本文主要介绍了C#实现的四种常用数据校验方法小结(CRC校验，LRC校验，密件抄送校验，累加和校验),文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

循环冗余检验即循环冗余校验码（循环冗余校验):是数据通信领域中最常用的一种查错校验码，其特征是信息字段和校验字段的长度可以任意选定。循环冗余检查（儿童权利委员会)是一种数据传输检错功能，对数据进行多项式计算，并将得到的结果附在帧的后面，接收设备也执行类似的算法，以保证数据传输的正确性和完整性。

CRC算法参数模型解释：

名称：参数模型名称宽度：宽度，即循环冗余检验比特数聚：生成项的简写，以16进制表示。例如：CRC-32即是0x04C11DB7，忽略了最高位的'1',即完整的生成项是0x104C11DB7。初始化：这是算法开始时寄存器（儿童权利委员会)的初始化预置值，十六进制表示REFIN:待测数据的每个字节是否按位反转，真的或错误。REFOUT:在计算后之后，异或输出之前，整个数据是否按位反转，真的或错误。XOROUT:计算结果与此参数异或后得到最终的循环冗余检验值。

///**********************************************************************

///名称：CRC-4/ITU x4 x 1

///Poly:0x03

///Init:0x00

///Refin: true

///Refout: true

///Xorout:0x00

///*************************************************************************

公共静态字节[] Crc1(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节CRC=0；//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc 1) 0)

crc=(字节)((CRC 1)^0x0c)；//0x0C=(反向0x03)(8-4)

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[]{ CRC }；

}

///**********************************************************************

///名称：CRC-5/EPC x5 x3 1

///Poly:0x09

///Init:0x09

///Refin: false

///Refout: false

///Xorout:0x00

///*************************************************************************

公共静态字节[] Crc2(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节crc=0x48//初始值：0x48=0x09(8-5)

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc0x80) 0)

crc=(字节)((华润1)^0x 48)；//0x48=0x09(8-5)

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[] {(字节)(CRC 3)}；

}

///**********************************************************************

///名称：CRC-5/ITU x5 x4 x2 1

///Poly:0x15

///Init:0x00

///Refin: true

///Refout: true

///Xorout:0x00

///*************************************************************************

公共静态字节[] Crc3(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节CRC=0；//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc 1) 0)

crc=(字节)((华润1)^0x 15)；//0x15=(反向0x15)(8-5)

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[]{ CRC }；

}

///**********************************************************************

///名称：CRC-5/USB x5 x2 1

///Poly:0x05

///Init:0x1F

///Refin: true

///Refout: true

///Xorout:0x1F

///*************************************************************************

公共静态字节[]铬c4(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节crc=0x1F//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc 1) 0)

crc=(字节)((CRC 1)^0x 14)；//0x14=(反向0x05)(8-5)

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[] {(字节)(CRC ^0x1f)}；

}

///**********************************************************************

///名称：CRC-6/ITU x6 x 1

///Poly:0x03

///Init:0x00

///Refin: true

///Refout: true

///Xorout:0x00

///*************************************************************************

公共静态字节[] Crc5(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节CRC=0；//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc 1) 0)

crc=(字节)((华润1)^0x 30)；//0x30=(反向0x03)(8-6)

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[]{ CRC }；

}

///**********************************************************************

///名称：CRC-7/MMC x7 x3 1

///Poly:0x09

///Init:0x00

///Refin: false

///Refout: false

///Xorout:0x00

///*************************************************************************

公共静态字节[] Crc6(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节CRC=0；//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc0x80) 0)

crc=(字节)((华润1)^0x 12)；//0x12=0x09(8-7)

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[] {(字节)(CRC 1)}；

}

///**********************************************************************

///名称：CRC8 x8 x2 x 1

///Poly:0x07

///Init:0x00

///Refin: false

///Refout: false

///Xorout:0x00

///*************************************************************************

公共静态字节[] Crc7(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节CRC=0；//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc0x80) 0)

crc=(字节)((CRC 1)^0x 07)；

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[]{ CRC }；

}

///**********************************************************************

///名称：CRC-8/ITU x8 x2 x 1

///Poly:0x07

///Init:0x00

///Refin: false

///Refout: false

///Xorout:0x55

///*************************************************************************

公共静态字节[] Crc8(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节CRC=0；//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc0x80) 0)

crc=(字节)((CRC 1)^0x 07)；

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[] {(字节)(CRC ^0x 55)}；

}

///**********************************************************************

///名称：CRC-8/MAXIM x8 x5 x4 1

///Poly:0x31

///Init:0x00

///Refin: true

///Refout: true

///Xorout:0x00

///*************************************************************************

公共静态字节[] Crc9(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节CRC=0；//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc 1) 0)

crc=(字节)((CRC 1)^0x8c)；//0x8C=反向0x31

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[]{ CRC }；

}

///**********************************************************************

///名称：CRC-8/ROHC x8 x2 x 1

///Poly:0x07

///Init:0xFF

///Refin: true

///Refout: true

///Xorout:0x00

///*************************************************************************

公共静态字节[] Crc10(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

字节crc=0xFF//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc 1) 0)

crc=(字节)((CRC 1)^0x E0)；//0xE0=反向0x07

其他

crc=(字节)(CRC 1)；

}

}

返回新字节[]{ CRC }；

}

///Z1协议校验码计算

静态字节[] table={0x00，0x1C，0x38，0x24，0x70，0x6C，0x48，0x54，0xE0，0xFC，

0xD8、0xC4、0x90、0x8C、0xA8、0xB4、0xDC、0xC0、0xE4、0xF8、

0xAC、0xB0、0x94、0x88、0x3C、0x20、0x04、0x18、0x4C、0x50、

0x74、0x68、0xA4、0xB8、0x9C、0x80、0xD4、0xC8、0xEC、0xF0、

0x44，0x58，0x7C，0x60，0x34，0x28，0x0C，0x10，0x78，0x64，

0x40、0x5C、0x08、0x14、0x30、0x2C、0x98、0x84、0xA0、0xBC、

0xE8、0xF4、0xD0、0xCC、0x54、0x48、0x6C、0x70、0x24、0x38、

0x1C、0x00、0xB4、0xA8、0x8C、0x90、0xC4、0xD8、0xFC、0xE0、

0x88、0x94、0xB0、0xAC、0xF8、0xE4、0xC0、0xDC、0x68、0x74、

0x50、0x4C、0x18、0x04、0x20、0x3C、0xF0、0xEC、0xC8、0xD4、

0x80、0x9C、0xB8、0xA4、0x10、0x0C、0x28、0x34、0x60、0x7C、

0x58，0x44，0x2C，0x30，0x14，0x08，0x5C，0x40，0x64，0x78，

0xCC、0xD0、0xF4、0xE8、0xBC、0xA0、0x84、0x98、0xA8、0xB4、

0x90、0x8C、0xD8、0xC4、0xE0、0xFC、0x48、0x54、0x70、0x6C、

0x38、0x24、0x00、0x1C、0x74、0x68、0x4C、0x50、0x04、0x18、

0x3C，0x20，0x94，0x88，0xAC，0xB0，0xE4，0xF8，0xDC，0xC0，

0x0C，0x10，0x34，0x28，0x7C，0x60，0x44，0x58，0xEC，0xF0，

0xD4、0xC8、0x9C、0x80、0xA4、0xB8、0xD0、0xCC、0xE8、0xF4、

0xA0，0xBC，0x98，0x84，0x30，0x2C，0x08，0x14，0x40，0x5C，

0x78、0x64、0xFC、0xE0、0xC4、0xD8、0x8C、0x90、0xB4、0xA8、

0x1C，0x00，0x24，0x38，0x6C，0x70，0x54，0x48，0x20，0x3C，

0x18、0x04、0x50、0x4C、0x68、0x74、0xC0、0xDC、0xF8、0xE4、

0xB0，0xAC，0x88，0x94，0x58，0x44，0x60，0x7C，0x28，0x34，

0x10，0x0C，0xB8，0xA4，0x80，0x9C，0xC8，0xD4，0xF0，0xEC，

0x84、0x98、0xBC、0xA0、0xF4、0xE8、0xCC、0xD0、0x64、0x78、

0x5C、0x40、0x14、0x08、0x2C、0x30

};

公共静态字节[] Crc11(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

int I；

字节crc=0x00

int表索引

for(I=start；我长度；我)

{

表索引=CRC ^(buffer[i]0x ff)；

CRC=table[表索引]；

}

返回新字节[]{ CRC }；

}

///**********************************************************************

///名称：CRC-12 x16 x12 x5 1

///Poly:0x80

///Init:0x0000

///Refin: true

///Refout: true

///Xorout:0x0000

///*************************************************************************

公共静态字节[] Crc12(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

u short CRC=0；//初始值

矮智商=0，iR=0；

for(int I=start；我长度；我)

{

//多项式除法

//如果该位为一

if ((buffer[i] (0x80 iR)) 0)

{

//则在余数尾部添一否则添0

crc |=0x01

}

//如果12位除数中的最高位为1,则够除

if (crc=0x1000)

{

华润^=0x 180d；

}

CRC=1；

iR；

if (8==iR)

{

iR=0；

智商；

}

}

//对后面添加的12个0做处理

for(int I=0；i 12我)

{

if (crc=0x1000)

{

华润^=0x 180d；

}

CRC=1；

}

CRC=1；

byte[] ret=BitConverter .GetBytes(CRC)；

数组。反转(ret)；

返回浸水使柔软

}

///**********************************************************************

///名称：CRC-16/CCITT x16 x12 x5 1

///Poly:0x1021

///Init:0x0000

///Refin: true

///Refout: true

///Xorout:0x0000

///*************************************************************************

公共静态字节[]氯化碳13(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

u short CRC=0；//初始值

for(int I=start；我长度；我)

{

crc ^=缓冲[I]；

for(int j=0；j 8；j)

{

if ((crc 1) 0)

CRC=(ushort)((CRC 1)^0x 8408)；//0x8408=反向0x1021

其他

CRC=(ushort)(CRC 1)；

}

}

byte[] ret=BitConverter .GetBytes(CRC)；

数组。反转(ret)；

返回浸水使柔软

}

///**********************************************************************

///名称：CRC-16/CCITT FALSE x16 x12 x5 1

///Poly:0x1021

///Init:0xFFFF

///Refin: false

///Refout: false

///Xorout:0x0000

///*************************************************************************

公共静态字节[]氯化碳14(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

if (len==0) len=buffer .长度-开始；

int长度=起始长度；

如果(长度缓冲3.5长度)返回空

ushort crc=0xFFFF//初始值

for(int I=start；我长度；我)

{

CRC ^=(ushort)(buffer[i]8)；

for(int j=0；j 8；j)

{

if ((crc0x8000) 0)

CRC=(ushort)((CRC 1)^0x 1021)；

其他

CRC=(ushort)(CRC 1)；

}

}

byte[] ret=BitConverter .GetBytes(CRC)；

数组。反转(ret)；

返回浸水使柔软

}

///**********************************************************************

///名称：CRC-16/DNP x16 x13 x12 X11 X10 x8 X6 X5 x2 1

///Poly:0x3D65

///Init:0x0000

///Refin: true

///Refout: true

///Xorout:0xFFFF

///*************************************************************************

公共静态字节[]氯化碳15(字节[]缓冲区，int start=0，int len=0)

{

if (buffer==null || buffer .长度==0)返回空

如果(从0开始)返回空

检验和(checksum)，在数据处理和数据通信领域中，用于校验目的地一组数据项的和。它通常是以十六进制为数制表示的形式。如果校验和的数值超过十六进制的FF,也就是255. 就要求其补码作为校验和。通常用来在通信中，尤其是远距离通信中保证数据的完整性和准确性。

到此这篇关于C#实现的4种常用数据校验方法小结(CRC校验,LRC校验,BCC校验,累加和校验)的文章就介绍到这了,更多相关C# 数据校验内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。