首先需要说明该部分代码虽然经过个人测试，也使用扫描枪测试，但本人不保证代码完全正确
其次代码没有遵循“先预定义长度后非定长”的原则，但遵循了非预定义长度字符串后都加入FNC1分隔符
最后虽然此部分代码遵循了 GBT 16986-2009 商品条码 应用标识符标准，但实际并未完全遵循，仅遵循了标识符长度和输入字母原则
补充：此部分代码用到了前面的Code128Auto的生成编码代码，所以将部分代码做了调整，以下是相关的代码
Code128
/// <summary>
/// Code128基础相关类
/// </summary>
internal static class Code128
{
/*
* 128 尺寸要求
* 最小模块宽度 x 最大1.016mm，最小0.250mm 一个系统中的x应为一恒定值 标准是1mm,放大系数0.25~1.2
* 左右侧空白区最小宽度为 10x
* 条高通常为32mm，实际可以根据具体要求
*
* 最大物理长度不应超过 165mm，可编码的最大数据字符数为48，其中包括应用标识符和作为分隔符使用的FNC1字符，但不包括辅助字符和校验符
*
* AI中FNC1同样作为分隔符使用
*
* ASCII
* 0~31 StartA 专有
* 96~127 StartB 专有
*
* EAN128不使用空格（ASCII码32）
*/
/// <summary>
/// Code128条空排列集合，1代表条b，0代表空s，Index对应符号字符值S
/// </summary>
internal static readonly List<string> BSList = new List<string>()
{
"212222" , "222122" , "222221" , "121223" , "121322" , "131222" , "122213" , "122312" , "132212" , "221213" ,
"221312" , "231212" , "112232" , "122132" , "122231" , "113222" , "123122" , "123221" , "223211" , "221132" ,
"221231" , "213212" , "223112" , "312131" , "311222" , "321122" , "321221" , "312212" , "322112" , "322211" ,
"212123" , "212321" , "232121" , "111323" , "131123" , "131321" , "112313" , "132113" , "132311" , "211313" ,
"231113" , "231311" , "112133" , "112331" , "132131" , "113123" , "113321" , "133121" , "313121" , "211331" ,
"231131" , "213113" , "213311" , "213131" , "311123" , "311321" , "331121" , "312113" , "312311" , "332111" ,
"314111" , "221411" , "431111" , "111224" , "111422" , "121124" , "121421" , "141122" , "141221" , "112214" ,
"112412" , "122114" , "122411" , "142112" , "142211" , "241211" , "221114" , "413111" , "241112" , "134111" ,
"111242" , "121142" , "121241" , "114212" , "124112" , "124211" , "411212" , "421112" , "421211" , "212141" ,
"214121" , "412121" , "111143" , "111341" , "131141" , "114113" , "114311" , "411113" , "411311" , "113141" ,
"114131" , "311141" , "411131" , "211412" , "211214" , "211232" , "2331112"
};
#region 条空排列集合
//{
// "11011001100" , "11001101100" , "11001100110" , "10010011000" , "10010001100" ,
// "10001001100" , "10011001000" , "10011000100" , "10001100100" , "11001001000" ,
// "11001000100" , "11000100100" , "10110011100" , "10011011100" , "10011001110" ,
// "10111001100" , "10011101100" , "10011100110" , "11001110010" , "11001011100" ,
// "11001001110" , "11011100100" , "11001110100" , "11101101110" , "11101001100" ,
// "11100101100" , "11100100110" , "11101100100" , "11100110100" , "11100110010" ,
// "11011011000" , "11011000110" , "11000110110" , "10100011000" , "10001011000" ,
// "10001000110" , "10110001000" , "10001101000" , "10001100010" , "11010001000" ,
// "11000101000" , "11000100010" , "10110111000" , "10110001110" , "10001101110" ,
// "10111011000" , "10111000110" , "10001110110" , "11101110110" , "11010001110" ,
// "11000101110" , "11011101000" , "11011100010" , "11011101110" , "11101011000" ,
// "11101000110" , "11100010110" , "11101101000" , "11101100010" , "11100011010" ,
// "11101111010" , "11001000010" , "11110001010" , "10100110000" , "10100001100" ,
// "10010110000" , "10010000110" , "10000101100" , "10000100110" , "10110010000" ,
// "10110000100" , "10011010000" , "10011000010" , "10000110100" , "10000110010" ,
// "11000010010" , "11001010000" , "11110111010" , "11000010100" , "10001111010" ,
// "10100111100" , "10010111100" , "10010011110" , "10111100100" , "10011110100" ,
// "10011110010" , "11110100100" , "11110010100" , "11110010010" , "11011011110" ,
// "11011110110" , "11110110110" , "10101111000" , "10100011110" , "10001011110" ,
// "10111101000" , "10111100010" , "11110101000" , "11110100010" , "10111011110" ,
// "10111101110" , "11101011110" , "11110101110" , "11010000100" , "11010010000" ,
// "11010011100" , "1100011101011"
//};
#endregion
internal const byte FNC3_AB = 96, FNC2_AB = 97, SHIFT_AB = 98, CODEC_AB = 99, CODEB_AC = 100, CODEA_BC = 101;
internal const byte FNC4_A = 101, FNC4_B = 100;
internal const byte FNC1 = 102, StartA = 103, StartB = 104, StartC = 105;
internal const byte Stop = 106;
/// <summary>
/// 获取字符在字符集A中对应的符号字符值S
/// </summary>
/// <param name="c"></param>
/// <returns></returns>
internal static byte GetSIndexFromA(char c)
{
byte sIndex = (byte)c;
//字符集A中 符号字符值S 若ASCII<32,则 S=ASCII+64 ,若95>=ASCII>=32,则S=ASCII-32
if (sIndex < 32)
{
sIndex += 64;
}
else if (sIndex < 96)
{
sIndex -= 32;
}
else
{
throw new NotImplementedException();
}
return sIndex;
}
/// <summary>
/// 获取字符在字符集B中对应的符号字符值S
/// </summary>
/// <param name="c"></param>
/// <returns></returns>
internal static byte GetSIndexFromB(char c)
{
byte sIndex = (byte)c;
if (sIndex > 31 && sIndex < 128)
{
sIndex -= 32;//字符集B中ASCII码 减去32后就等于符号字符值
}
else
{
throw new NotImplementedException();
}
return sIndex;
}
internal static byte GetSIndex(CharacterSet characterSet, char c)
{
switch (characterSet)
{
case CharacterSet.A:
return GetSIndexFromA(c);
case CharacterSet.B:
return GetSIndexFromB(c);
default:
throw new NotImplementedException();
}
}
/// <summary>
/// 判断指定字符是否仅属于指定字符集
/// </summary>
/// <param name="characterSet"></param>
/// <param name="c"></param>
/// <returns></returns>
internal static bool CharOnlyBelongsTo(CharacterSet characterSet, char c)
{
switch (characterSet)
{
case CharacterSet.A:
return (byte)c < 32;
case CharacterSet.B:
return (byte)c > 95 && (byte)c < 128;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// 判断指定字符是否不属于指定字符集
/// </summary>
/// <param name="characterSet"></param>
/// <param name="c"></param>
/// <returns></returns>
internal static bool CharNotBelongsTo(CharacterSet characterSet, char c)
{
switch (characterSet)
{
case CharacterSet.A:
return (byte)c > 95;
case CharacterSet.B:
return (byte)c < 32 && (byte)c > 127;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// 当编码转换时，获取相应的切换符对应的符号字符值
/// </summary>
/// <param name="newCharacterSet"></param>
/// <returns></returns>
internal static byte GetCodeXIndex(CharacterSet newCharacterSet)
{
switch (newCharacterSet)
{
case CharacterSet.A:
return CODEA_BC;
case CharacterSet.B:
return CODEB_AC;
default:
return CODEC_AB;
}
}
/// <summary>
/// 获取转换后的字符集
/// </summary>
/// <param name="characterSet"></param>
/// <returns></returns>
internal static CharacterSet GetShiftCharacterSet(CharacterSet characterSet)
{
switch (characterSet)
{
case CharacterSet.A:
return CharacterSet.B;
case CharacterSet.B:
return CharacterSet.A;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// 获取指定字符串应该采用的起始符对应的符号字符值
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
internal static byte GetStartIndex(string data, out CharacterSet startCharacterSet)
{
startCharacterSet = GetCharacterSet(data, 0);
switch (startCharacterSet)
{
case CharacterSet.A:
return StartA;
case CharacterSet.B:
return StartB;
default:
return StartC;
}
}
/// <summary>
/// 获取应采用的字符集
/// </summary>
/// <param name="data"></param>
/// <param name="startIndex">判断开始位置</param>
/// <returns></returns>
internal static CharacterSet GetCharacterSet(string data, int startIndex)
{
CharacterSet returnSet = CharacterSet.B;
if (Regex.IsMatch(data.Substring(startIndex), @"^\d{4,}"))
{
returnSet = CharacterSet.C;
}
else
{
byte byteC = GetProprietaryChar(data, startIndex);
returnSet = byteC < 32 ? CharacterSet.A : CharacterSet.B;
}
return returnSet;
}
/// <summary>
/// 从指定位置开始，返回第一个大于95(并且小于128)或小于32的字符对应的值
/// </summary>
/// <param name="data"></param>
/// <param name="startIndex"></param>
/// <returns>如果没有任何字符匹配，则返回255</returns>
internal static byte GetProprietaryChar(string data, int startIndex)
{
byte returnByte = byte.MaxValue;
for (int i = startIndex; i < data.Length; i++)
{
byte byteC = (byte)data[i];
if (byteC < 32 || byteC > 95 && byteC < 128)
{
returnByte = byteC;
break;
}
}
return returnByte;
}
/// <summary>
/// 获取字符串从指定位置开始连续出现数字的个数
/// </summary>
/// <param name="data"></param>
/// <param name="startIndex"></param>
/// <returns></returns>
internal static int GetDigitLength(string data, int startIndex)
{
int digitLength = data.Length - startIndex;//默认设定从起始位置开始至最后都是数字
for (int i = startIndex; i < data.Length; i++)
{
if (!char.IsDigit(data[i]))
{
digitLength = i - startIndex;
break;
}
}
return digitLength;
}
/// <summary>
/// 通用方法
/// </summary>
/// <param name="tempBuilder"></param>
/// <param name="sIndex"></param>
/// <param name="nowWeight"></param>
/// <param name="checkNum"></param>
internal static void EncodingCommon(StringBuilder tempBuilder, byte sIndex, ref int nowWeight, ref int checkNum)
{
tempBuilder.Append(BSList[sIndex]);
checkNum += nowWeight * sIndex;
nowWeight++;
}
/// <summary>
/// 获取原始数据对应的编码后数据(不包括起始符、特殊符(EAN128时)、检验符、终止符)
/// </summary>
/// <param name="rawData">编码对应的原始数据</param>
/// <param name="tempBuilder">编码数据容器</param>
/// <param name="nowCharacterSet">当前字符集</param>
/// <param name="i">字符串索引</param>
/// <param name="nowWeight">当前权值</param>
/// <param name="checkNum">当前检验值总和</param>
internal static void GetEncodedData(string rawData, StringBuilder tempBuilder, ref CharacterSet nowCharacterSet, ref int i, ref int nowWeight, ref int checkNum)
{//因为可能存在字符集C，所以i与nowWeight可能存在不一致关系，所以要分别定义
byte sIndex;
switch (nowCharacterSet)
{
case CharacterSet.A:
case CharacterSet.B:
for (; i < rawData.Length; i++)
{
if (char.IsDigit(rawData[i]))
{
//数字
int digitLength = GetDigitLength(rawData, i);
if (digitLength >= 4)
{
//转入CodeC
if (digitLength % 2 != 0)
{//奇数位数字，在第一个数字之后插入CodeC字符
sIndex = GetSIndex(nowCharacterSet, (rawData[i]));
EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
i++;
}
nowCharacterSet = CharacterSet.C;
sIndex = GetCodeXIndex(nowCharacterSet);//插入CodeC切换字符
EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
GetEncodedData(rawData, tempBuilder, ref nowCharacterSet, ref i, ref nowWeight, ref checkNum);
return;
}
else
{
//如果小于4位数字，则直接内部循环结束
for (int j = 0; j < digitLength; j++)
{
sIndex = GetSIndex(nowCharacterSet, (rawData[i]));
EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
i++;
}
i--;//因为上面循环结束后继续外部循环会导致i多加了1，所以要减去1
continue;
}
}
else if (CharNotBelongsTo(nowCharacterSet, rawData[i]))
{//当前字符不属于目前的字符集
byte tempByte = GetProprietaryChar(rawData, i + 1);//获取当前字符后第一个属于A,或B的字符集
CharacterSet tempCharacterSet = GetShiftCharacterSet(nowCharacterSet);
if (tempByte != byte.MaxValue && CharOnlyBelongsTo(nowCharacterSet, (char)tempByte))
{
//加入转换符
sIndex = SHIFT_AB;
EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
sIndex = GetSIndex(tempCharacterSet, rawData[i]);
EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
continue;
}
else
{
//加入切换符
nowCharacterSet = tempCharacterSet;
sIndex = GetCodeXIndex(nowCharacterSet);
EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
GetEncodedData(rawData, tempBuilder, ref nowCharacterSet, ref i, ref nowWeight, ref checkNum);
return;
}
}
else
{
sIndex = GetSIndex(nowCharacterSet, rawData[i]);
EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
}
}
break;
default:
for (; i < rawData.Length; i += 2)
{
if (i != rawData.Length - 1 && char.IsDigit(rawData, i) && char.IsDigit(rawData, i + 1))
{
sIndex = byte.Parse(rawData.Substring(i, 2));
EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
}
else
{
nowCharacterSet = GetCharacterSet(rawData, i);
//插入转换字符
sIndex = GetCodeXIndex(nowCharacterSet);
EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
GetEncodedData(rawData, tempBuilder, ref nowCharacterSet, ref i, ref nowWeight, ref checkNum);
return;
}
}
break;
}
}
}
/// <summary>
/// Code128字符集
/// </summary>
internal enum CharacterSet
{
A,
B,
C
}
AI相关
/// <summary>
/// 商品应用标识符标准 GBT 16986-2009
/// </summary>
internal static class AI
{
/// <summary>
/// GBT 16986-2009 定义的应用标识符集合
/// </summary>
public static readonly List<ApplicationIdentifier> AIList = new List<ApplicationIdentifier>()
{
//20系列货运包装箱代码
new ApplicationIdentifier("00", new List<DataFormat>(){ new DataFormat(new byte[]{18})}),
//01全球贸易项目代码
new ApplicationIdentifier("01", new List<DataFormat>(){ new DataFormat(new byte[]{14})}),
//02物流单元内贸易项目的GTIN
new ApplicationIdentifier("02", new List<DataFormat>(){ new DataFormat(new byte[]{14})}),
//10批号
new ApplicationIdentifier("10", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,20})}),
//11生产日期YYMMDD
new ApplicationIdentifier("11", new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//12付款截止日期YYMMDD
new ApplicationIdentifier("12", new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//13包装日期YYMMDD
new ApplicationIdentifier("13", new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//15保质期YYMMDD
new ApplicationIdentifier("15", new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//17有效期YYMMDD
new ApplicationIdentifier("17", new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//20产品变体
new ApplicationIdentifier("20", new List<DataFormat>(){ new DataFormat(new byte[]{2})}),
//21系列号
new ApplicationIdentifier("21", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,20})}),
//22医疗卫生行业产品二级数据
new ApplicationIdentifier("22", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,29})}),
//240附加产品标识
new ApplicationIdentifier("240", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//241客户方代码
new ApplicationIdentifier("241", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//242定制产品代码
new ApplicationIdentifier("242", new List<DataFormat>(){ new DataFormat(new byte[]{1,6})}),
//250二级系列号
new ApplicationIdentifier("250", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//251源实体参考代码
new ApplicationIdentifier("251", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//253全球文件/单证类型代码
new ApplicationIdentifier("253", new List<DataFormat>(){ new DataFormat(new byte[]{13}),new DataFormat(new byte[]{1,17})}),
//254GLN扩展部分代码
new ApplicationIdentifier("254", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,20})}),
//30可变数量
new ApplicationIdentifier("30", new List<DataFormat>(){ new DataFormat(new byte[]{1,8})}),
//31nn 贸易与物流量度
new ApplicationIdentifier("31", 4, new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//32nn 贸易与物流量度
new ApplicationIdentifier("32", 4, new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//33nn 贸易与物流量度
new ApplicationIdentifier("33", 4, new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//34nn 贸易与物流量度
new ApplicationIdentifier("34", 4, new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//35nn 贸易与物流量度
new ApplicationIdentifier("35", 4, new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//36nn 贸易与物流量度
new ApplicationIdentifier("36", 4, new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//37物流单元内贸易项目数量
new ApplicationIdentifier("37", new List<DataFormat>(){ new DataFormat(new byte[]{1,8})}),
//390n单一货币区内应付款金额
new ApplicationIdentifier("390", 4, new List<DataFormat>(){ new DataFormat(new byte[]{1,15})}),
//391n具有ISO货币代码的应付款金额
new ApplicationIdentifier("391", 4, new List<DataFormat>(){ new DataFormat(new byte[]{3}),new DataFormat(new byte[]{1,15})}),
//392n单一货币区内变量贸易项目应付款金额
new ApplicationIdentifier("392", 4, new List<DataFormat>(){ new DataFormat(new byte[]{1,15})}),
//393n具有ISO货币代码的变量贸易项目应付款金额
new ApplicationIdentifier("393", 4, new List<DataFormat>(){ new DataFormat(new byte[]{3}),new DataFormat(new byte[]{1,15})}),
//400客户订购单代码
new ApplicationIdentifier("400", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//401货物托运代码
new ApplicationIdentifier("401", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//402 装运标识代码
new ApplicationIdentifier("402", new List<DataFormat>(){ new DataFormat(new byte[]{17})}),
//403路径代码
new ApplicationIdentifier("403", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//410 交货地全球位置码
new ApplicationIdentifier("410", new List<DataFormat>(){ new DataFormat(new byte[]{13})}),
//411 受票方全球位置码
new ApplicationIdentifier("411", new List<DataFormat>(){ new DataFormat(new byte[]{13})}),
//412 最终目的地全球位置码
new ApplicationIdentifier("412", new List<DataFormat>(){ new DataFormat(new byte[]{13})}),
//413 交货地全球位置码
new ApplicationIdentifier("413", new List<DataFormat>(){ new DataFormat(new byte[]{13})}),
//414 标志物理位置的全球位置码
new ApplicationIdentifier("414", new List<DataFormat>(){ new DataFormat(new byte[]{13})}),
//415 开票方全球位置码
new ApplicationIdentifier("415", new List<DataFormat>(){ new DataFormat(new byte[]{13})}),
//420 同一邮政行政区域内交货地邮政编码
new ApplicationIdentifier("420", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//421 具有3位ISO国家(或地区)代码的交货地邮政编码
new ApplicationIdentifier("421", new List<DataFormat>(){ new DataFormat(new byte[]{3}),new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,9})}),
//422 贸易项目原产国(或地区)
new ApplicationIdentifier("422", new List<DataFormat>(){ new DataFormat(new byte[]{3})}),
//423 贸易项目初始加工国(或地区)
new ApplicationIdentifier("423", new List<DataFormat>(){ new DataFormat(new byte[]{3}),new DataFormat(new byte[]{1,12})}),
//424 贸易项目加工国(或地区)
new ApplicationIdentifier("424", new List<DataFormat>(){ new DataFormat(new byte[]{3})}),
//425 贸易项目拆分国(或地区)
new ApplicationIdentifier("425", new List<DataFormat>(){ new DataFormat(new byte[]{3})}),
//426 全程加工贸易项目的国家(或地区)
new ApplicationIdentifier("426", new List<DataFormat>(){ new DataFormat(new byte[]{3})}),
//7001 北约物资代码
new ApplicationIdentifier("7001", new List<DataFormat>(){ new DataFormat(new byte[]{13})}),
//7002 UN/ECE胴体肉与分割品分类
new ApplicationIdentifier("7002", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//7003 产品的有效日期和时间
new ApplicationIdentifier("7003", new List<DataFormat>(){ new DataFormat(new byte[]{8}),new DataFormat(new byte[]{1,2})}),
//703s 具有3位ISO国家(或地区)代码的加工者核准号码
new ApplicationIdentifier("703", new List<DataFormat>(){ new DataFormat(new byte[]{3}),new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,27})}),
//8001 卷装产品
new ApplicationIdentifier("8001", new List<DataFormat>(){ new DataFormat(new byte[]{14})}),
//8002 蜂窝移动电话标识符
new ApplicationIdentifier("8002", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,20})}),
//8003 全球可回收资产标识符
new ApplicationIdentifier("8003", new List<DataFormat>(){ new DataFormat(new byte[]{14}),new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,16})}),
//8004 全球单个资产标识符
new ApplicationIdentifier("8004", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//8005 单价
new ApplicationIdentifier("8005", new List<DataFormat>(){ new DataFormat(new byte[]{6})}),
//8006 贸易项目组件的标识符
new ApplicationIdentifier("8006", new List<DataFormat>(){ new DataFormat(new byte[]{14}),new DataFormat(new byte[]{2}),new DataFormat(new byte[]{2})}),
//8007 国际银行账号代码
new ApplicationIdentifier("8007", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//8008 产品生产的日期和时间
new ApplicationIdentifier("8008", new List<DataFormat>(){ new DataFormat(new byte[]{8}),new DataFormat(new byte[]{1,4})}),
//8018 全球服务关系代码
new ApplicationIdentifier("8018", new List<DataFormat>(){ new DataFormat(new byte[]{18})}),
//8020 付款单代码
new ApplicationIdentifier("8020", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,25})}),
//8100 GS1-128优惠券扩展代码-NSC+Offer Code
new ApplicationIdentifier("8100", new List<DataFormat>(){ new DataFormat(new byte[]{1}),new DataFormat(new byte[]{5})}),
//8101 GS1-128优惠券扩展代码-NSC+Offer Code + end of offer code
new ApplicationIdentifier("8101", new List<DataFormat>(){ new DataFormat(new byte[]{1}),new DataFormat(new byte[]{5}),new DataFormat(new byte[]{4})}),
//8102 GS1-128优惠券扩展代码-NSC
new ApplicationIdentifier("8102", new List<DataFormat>(){ new DataFormat(new byte[]{1}),new DataFormat(new byte[]{1})}),
//90 贸易伙伴之间相互约定的信息
new ApplicationIdentifier("90", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//91 公司内部信息
new ApplicationIdentifier("91", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//92 公司内部信息
new ApplicationIdentifier("92", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//93 公司内部信息
new ApplicationIdentifier("93", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//94 公司内部信息
new ApplicationIdentifier("94", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//95 公司内部信息
new ApplicationIdentifier("95", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//96 公司内部信息
new ApplicationIdentifier("96", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//97 公司内部信息
new ApplicationIdentifier("97", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//98 公司内部信息
new ApplicationIdentifier("98", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})}),
//99 公司内部信息
new ApplicationIdentifier("99", new List<DataFormat>(){ new DataFormat(AICharacter.a| AICharacter.n, new byte[]{1,30})})
};
/// <summary>
/// 需要遵循的预定义长度的应用标识符及其对应的总长度
/// </summary>
public static readonly List<KeyValuePair<string, byte>> PredefinedAILength = new List<KeyValuePair<string, byte>>()
{
new KeyValuePair<string,byte>("00",20),new KeyValuePair<string,byte>("01",16),new KeyValuePair<string,byte>("02",16),new KeyValuePair<string,byte>("03",16),
new KeyValuePair<string,byte>("04",18),new KeyValuePair<string,byte>("11",8),new KeyValuePair<string,byte>("12",8),new KeyValuePair<string,byte>("13",8),
new KeyValuePair<string,byte>("14",8),new KeyValuePair<string,byte>("15",8),new KeyValuePair<string,byte>("16",8),new KeyValuePair<string,byte>("17",8),
new KeyValuePair<string,byte>("18",8),new KeyValuePair<string,byte>("19",8),new KeyValuePair<string,byte>("20",4),new KeyValuePair<string,byte>("31",10),
new KeyValuePair<string,byte>("32",10),new KeyValuePair<string,byte>("33",10),new KeyValuePair<string,byte>("34",10),new KeyValuePair<string,byte>("35",10),
new KeyValuePair<string,byte>("36",10),new KeyValuePair<string,byte>("41",16)
};
/// <summary>
/// 获取字符串对应的 第一个 商品应用标识
/// </summary>
/// <param name="rawData"></param>
/// <returns></returns>
internal static ApplicationIdentifier GetAI(string rawData)
{
return AIList.Where(ai => rawData.StartsWith(ai.AI)).FirstOrDefault();
}
/// <summary>
/// 判断指定字符串是否是预定义长度应用标识符
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
internal static bool IsPredefinedAI(string data)
{
KeyValuePair<string, byte> temp = PredefinedAILength.Where(ai => data.StartsWith(ai.Key) && data.Length == ai.Value).FirstOrDefault();
return !string.IsNullOrEmpty(temp.Key);
}
/// <summary>
/// 判断指定字符串是否是符合指定应用标识规范
/// </summary>
/// <param name="ai"></param>
/// <param name="aiStr"></param>
/// <returns></returns>
internal static bool IsRight(ApplicationIdentifier ai, string aiStr)
{
//标识符部分，字符串必须以相同的AI开头
if (!aiStr.StartsWith(ai.AI) || aiStr.Length > ai.MaxLength || aiStr.Length < ai.MinLength)
{
return false;
}
//如果AILength与ai对应的AI长度不一致时，还需检验后续几个字符是否是数字
for (int i = ai.AI.Length; i < ai.AILength; i++)
{
if (!char.IsDigit(aiStr[i]))
{
return false;
}
}
int ptr = ai.AILength;
for (int i = 0; i < ai.DataWithoutAI.Count; i++)
{
DataFormat df = ai.DataWithoutAI[i];
for (int j = 0; j < df.Length[df.Length.Length - 1]; j++)
{
if ((df.Character == AICharacter.n && !char.IsDigit(aiStr[ptr])) || (byte)aiStr[ptr] < 33 || (byte)aiStr[ptr] > 126)
{
return false;
}
ptr++;
if (ptr >= aiStr.Length)
{
break;
}
}
}
return true;
}
}
/// <summary>
/// 商品标识符的数据类型范围
/// </summary>
[Flags]
internal enum AICharacter
{
/// <summary>
/// 数字
/// </summary>
n = 1,
/// <summary>
/// 字母
/// </summary>
a = 2
}
/// <summary>
/// 商品应用标识
/// </summary>
internal sealed class ApplicationIdentifier
{
private bool _isFixedLength;
private string _ai;
private byte _aiLength;
private List<DataFormat> _dataWithoutAI;
private byte _minLength;
private byte _maxLength;
public ApplicationIdentifier(string ai, List<DataFormat> dataWithoutAI)
: this(ai, (byte)ai.Length, dataWithoutAI)
{
}
public ApplicationIdentifier(string ai, byte aiLength, List<DataFormat> dataWithoutAI)
{
this._ai = ai;
this._aiLength = aiLength;
this._dataWithoutAI = dataWithoutAI;
this._minLength = aiLength;
this._maxLength = aiLength;
for (int i = 0; i < this._dataWithoutAI.Count; i++)
{
byte[] temp = this._dataWithoutAI[i].Length;
this._minLength += temp[0];
this._maxLength += temp[temp.Length - 1];
}
this._isFixedLength = this._minLength == this._maxLength;
}
/// <summary>
/// 商品应用标识符
/// </summary>
public string AI
{
get { return this._ai; }
}
/// <summary>
/// 标识符长度
/// </summary>
public byte AILength
{
get { return this._aiLength; }
}
/// <summary>
/// 排除标识符后字符串的数据格式
/// </summary>
public List<DataFormat> DataWithoutAI
{
get { return this._dataWithoutAI; }
}
/// <summary>
/// 是否定长
/// </summary>
public bool IsFixedLength
{
get { return this._isFixedLength; }
}
/// <summary>
/// 获取该商品应用标识允许的最小长度(包含AI)
/// </summary>
/// <returns></returns>
public byte MinLength
{
get { return this._minLength; }
}
/// <summary>
/// 获取该商品应用标识允许的最大长度(包含AI)
/// </summary>
/// <returns></returns>
public byte MaxLength
{
get { return this._maxLength; }
}
}
/// <summary>
/// 数据格式
/// </summary>
internal sealed class DataFormat
{
private AICharacter _character;
private byte[] _length;
/// <summary>
/// 默认数据格式为数字
/// </summary>
/// <param name="length"></param>
public DataFormat(byte[] length)
: this(AICharacter.n, length)
{
}
public DataFormat(AICharacter character, byte[] length)
{
this._character = character;
this._length = length;
}
/// <summary>
/// 数据类型
/// </summary>
public AICharacter Character
{ get { return this._character; } }
/// <summary>
/// 数据长度，数组长度为1时表示定长
/// </summary>
public byte[] Length
{ get { return this._length; } }
}
GS1-128
/// <summary>
/// GS1-128(UCC/EAN128)条形码，遵循标准GB/T 16986-2009
/// </summary>
public class GS1_128 : absCode128
{
private List<string> _aiList = new List<string>();//rawData分割后符合商品应用标识规范的字符串集合
/// <summary>
/// GS1-128(UCC/EAN128)条形码，非定长标识符后面必须跟空格，定长标识符带不带无所谓
/// </summary>
/// <param name="rawData">包含ASCII码表32~126，其中32对应的空格sp用来通知生成FNC1分割符</param>
public GS1_128(string rawData)
: base(rawData)
{
}
/// <summary>
/// 对应的ASCII码范围为32~126,其中32对应的空格sp用来通知生成FNC1分割符
/// </summary>
/// <returns></returns>
protected override bool RawDataCheck()
{
this._presentationData = string.Empty;
string[] tempArray = this._rawData.Split((char)32);//以空格为分隔符将字符串进行分割
foreach (string ts in tempArray)
{
int ptr = 0;
do
{
string tempStr;
ApplicationIdentifier ai = AI.GetAI(ts.Substring(ptr));
int residuelength = ts.Length - ptr;//剩余字符串长度
if (ai == null || residuelength < ai.MinLength || (!ai.IsFixedLength && residuelength > ai.MaxLength))
{//第三个判定条件：因为不定长，而且经过空格分割，所以此时如果出现剩余字符串长度超出标识符最大长度规定，则认为错误
return false;
}
else
{
int length = Math.Min(ai.MaxLength, residuelength);
tempStr = ts.Substring(ptr, length);
ptr += length;
}
if (!AI.IsRight(ai, tempStr))
{
return false;
}
//展示数据加上括号
this._presentationData += string.Format("({0}){1}", tempStr.Substring(0, ai.AILength), tempStr.Substring(ai.AILength));
#region 修改为遵循预定义长度的AI后面才不加上FNC1,而不是实际定长的就不加上FNC1
//if (!ai.IsFixedLength)
//{
// tempStr += (char)32;//为不定长AI加上空格，以便生成条形码时确认需要在此部分后面加入分隔符FNC1
//}
#endregion
this._aiList.Add(tempStr);
}
while (ptr < ts.Length);
}
//是否要将_aiList进行排序，将预定长的放在前面以符合 先定长后变长 原则
//如果修改，则需将展示数据部分重新处理
return true;
}
protected override string GetEncodedData()
{
StringBuilder tempBuilder = new StringBuilder();
CharacterSet nowCharacterSet;
//校验字符
int checkNum = Code128.GetStartIndex(this._aiList[0], out nowCharacterSet);
tempBuilder.Append(Code128.BSList[checkNum]);//加上起始符
tempBuilder.Append(Code128.BSList[Code128.FNC1]);//加上第一个FNC1表示当前是GS1-128
checkNum += Code128.FNC1;
int nowWeight = 2;//当前权值
for (int i = 0; i < this._aiList.Count; i++)
{
string tempStr = this._aiList[i];
int nowIndex = 0;
#region 修改为遵循预定义长度的AI后面才不加上FNC1,而不是实际定长的就不加上FNC1
//bool isEndWithSP = tempStr[tempStr.Length - 1] == (char)32;
//if (isEndWithSP)
//{
// tempStr = tempStr.Substring(0, tempStr.Length - 1);
//}
#endregion
Code128.GetEncodedData(tempStr, tempBuilder, ref nowCharacterSet, ref nowIndex, ref nowWeight, ref checkNum);
#region 修改为遵循预定义长度的AI后面才不加上FNC1,而不是实际定长的就不加上FNC1
//if (isEndWithSP && i != this._aiList.Count - 1)
//{
// //非定长标识符后面加上FNC1，此时FNC1作为分隔符存在
// Code128.EncodingCommon(tempBuilder, Code128.FNC1, ref nowWeight, ref checkNum);
//}
#endregion
if (!AI.IsPredefinedAI(tempStr) && i != this._aiList.Count - 1)
{
//非预定长标识符后面加上FNC1，此时FNC1作为分隔符存在
Code128.EncodingCommon(tempBuilder, Code128.FNC1, ref nowWeight, ref checkNum);
}
}
checkNum %= 103;
tempBuilder.Append(Code128.BSList[checkNum]);//加上校验符
tempBuilder.Append(Code128.BSList[Code128.Stop]);//加上结束符
return tempBuilder.ToString();
}
}
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
