C#条形码生成（四）----Code128Auto

最新推荐文章于 2024-04-19 19:54:33 发布
最新推荐文章于 2024-04-19 19:54:33 发布
阅读量1.1w 收藏 4
点赞数
分类专栏： C# 文章标签： c# codec byte string class c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/starfd/article/details/7168951
版权

 Code128Auto就是完全遵循GBT 18347-2001 128条码 上面的最小长度原则 编写的条形码

/// <summary>
    /// Code128Auto条形码，遵循长度最小原则
    /// </summary>
    public class Code128Auto : absCode128
    {
        public Code128Auto(string rawData)
            : base(rawData)
        {
        }

        protected override bool RawDataCheck()
        {
            //Code128对应的ASCII码范围是0~127
            foreach (char c in this._rawData)
            {
                if ((byte)c > 127)
                {
                    return false;
                }
            }
            return true;
        }

        protected override string GetEncodedData()
        {
            StringBuilder tempBuilder = new StringBuilder();

            CharacterSet nowCharacterSet = Code128.GetCharacterSet(this._rawData, 0);

            int checkNum;//校验字符
            switch (nowCharacterSet)
            {
                case CharacterSet.A:
                    tempBuilder.Append(Code128.BSList[Code128.StartA]);//加上起始符StartA
                    checkNum = Code128.StartA;
                    break;
                case CharacterSet.B:
                    tempBuilder.Append(Code128.BSList[Code128.StartB]);//加上起始符StartB
                    checkNum = Code128.StartB;
                    break;
                default:
                    tempBuilder.Append(Code128.BSList[Code128.StartC]);//加上起始符StartC
                    checkNum = Code128.StartC;
                    break;
            }
            int nowWeight = 1, nowIndex = 0;
            this.GetEncodedData(tempBuilder, nowCharacterSet, ref nowIndex, ref nowWeight, ref checkNum);

            checkNum %= 103;
            tempBuilder.Append(Code128.BSList[checkNum]);//加上校验符
            tempBuilder.Append(Code128.BSList[Code128.Stop]);//加上结束符
            return tempBuilder.ToString();
        }
        /// <summary>
        /// 通用方法
        /// </summary>
        /// <param name="tempBuilder"></param>
        /// <param name="sIndex"></param>
        /// <param name="nowWeight"></param>
        /// <param name="checkNum"></param>
        private void EncodingCommon(StringBuilder tempBuilder, byte sIndex, ref int nowWeight, ref int checkNum)
        {
            tempBuilder.Append(Code128.BSList[sIndex]);
            checkNum += nowWeight * sIndex;
            nowWeight++;
        }
        /// <summary>
        /// 获取编码后的数据
        /// </summary>
        /// <param name="tempBuilder">编码数据容器</param>
        /// <param name="nowCharacterSet">当前字符集</param>
        /// <param name="i">字符串索引</param>
        /// <param name="nowWeight">当前权值</param>
        /// <param name="checkNum">当前检验值总和</param>
        private void GetEncodedData(StringBuilder tempBuilder, 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 < this._rawData.Length; i++)
                    {
                        if (char.IsDigit(this._rawData[i]))
                        {
                            //数字
                            int digitLength = Code128.GetDigitLength(this._rawData, i);
                            if (digitLength >= 4)
                            {
                                //转入CodeC
                                if (digitLength % 2 != 0)
                                {//奇数位数字，在第一个数字之后插入CodeC字符
                                    sIndex = Code128.GetSIndex(nowCharacterSet, (this._rawData[i]));
                                    this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
                                    i++;
                                }
                                nowCharacterSet = CharacterSet.C;
                                sIndex = Code128.GetCodeXIndex(nowCharacterSet);//插入CodeC切换字符
                                this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
                                this.GetEncodedData(tempBuilder, nowCharacterSet, ref i, ref nowWeight, ref checkNum);
                                return;
                            }
                            else
                            {
                                //如果小于4位数字，则直接内部循环结束
                                for (int j = 0; j < digitLength; j++)
                                {
                                    sIndex = Code128.GetSIndex(nowCharacterSet, (this._rawData[i]));
                                    this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
                                    i++;
                                }
                                i--;//因为上面循环结束后继续外部循环会导致i多加了1，所以要减去1
                                continue;
                            }
                        }
                        else if (Code128.CharNotBelongsTo(nowCharacterSet, this._rawData[i]))
                        {//当前字符不属于目前的字符集
                            byte tempByte = Code128.GetProprietaryChar(this._rawData, i + 1);//获取当前字符后第一个属于A,或B的字符集
                            CharacterSet tempCharacterSet = Code128.GetShiftCharacterSet(nowCharacterSet);
                            if (tempByte != byte.MaxValue && Code128.CharOnlyBelongsTo(nowCharacterSet, (char)tempByte))
                            {
                                //加入转换符
                                sIndex = Code128.SHIFT_AB;
                                this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);

                                sIndex = Code128.GetSIndex(tempCharacterSet, this._rawData[i]);
                                this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
                                continue;
                            }
                            else
                            {
                                //加入切换符
                                nowCharacterSet = tempCharacterSet;
                                sIndex = Code128.GetCodeXIndex(nowCharacterSet);
                                this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
                                this.GetEncodedData(tempBuilder, nowCharacterSet, ref i, ref nowWeight, ref checkNum);
                                return;
                            }
                        }
                        else
                        {
                            sIndex = Code128.GetSIndex(nowCharacterSet, this._rawData[i]);
                            this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
                        }
                    }
                    break;
                default:
                    for (; i < this._rawData.Length; i += 2)
                    {
                        if (i != this._rawData.Length - 1 && char.IsDigit(this._rawData, i) && char.IsDigit(this._rawData, i + 1))
                        {
                            sIndex = byte.Parse(this._rawData.Substring(i, 2));
                            this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
                        }
                        else
                        {
                            nowCharacterSet = Code128.GetCharacterSet(this._rawData, i);
                            //插入转换字符
                            sIndex = Code128.GetCodeXIndex(nowCharacterSet);
                            this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
                            this.GetEncodedData(tempBuilder, nowCharacterSet, ref i, ref nowWeight, ref checkNum);
                            return;
                        }
                    }
                    break;
            }
        }

        #region 注销
        //private void GetEncodedData(StringBuilder tempBuilder, string data, CharacterSet nowCharacterSet, ref int nowWeight, ref int checkNum)
        //{
        //    byte sIndex, nowChar;
        //    switch (nowCharacterSet)
        //    {
        //        case CharacterSet.A:
        //            for (int i = 0; i < data.Length; i++)
        //            {
        //                nowChar = (byte)data[i];
        //                if (nowChar > 95)
        //                {
        //                    //字符集B
        //                    byte tempByte = Code128.GetProprietaryChar(data, i + 1);
        //                    if (tempByte < 32)
        //                    {
        //                        //加入转换符
        //                        sIndex = Code128.SHIFT_AB;
        //                        this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);

        //                        sIndex = Code128.GetSIndexFromB(data[i]);
        //                        this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                        continue;
        //                    }
        //                    else
        //                    {
        //                        //加入切换符
        //                        sIndex = Code128.CODEB_AC;
        //                        this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                        this.GetEncodedData(tempBuilder, data.Substring(i), CharacterSet.B, ref nowWeight, ref checkNum);
        //                        return;
        //                    }
        //                }
        //                else if (char.IsDigit(data[i]))
        //                {
        //                    //数字
        //                    int digitLength = Code128.GetDigitLength(data, i);
        //                    if (digitLength >= 4)
        //                    {
        //                        //转入CodeC
        //                        if (digitLength % 2 != 0)
        //                        {//奇数位数字，在第一个数字之后插入CodeC字符
        //                            sIndex = Code128.GetSIndexFromA(data[i]);
        //                            this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                            i++;
        //                        }
        //                        sIndex = Code128.CODEC_AB;//插入CodeC切换字符
        //                        this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                        this.GetEncodedData(tempBuilder, data.Substring(i), CharacterSet.C, ref nowWeight, ref checkNum);
        //                        return;
        //                    }
        //                    else
        //                    {
        //                        for (int j = 0; j < digitLength; j++)
        //                        {
        //                            sIndex = Code128.GetSIndexFromA(data[i]);
        //                            this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);i++;
        //                        }i--;
        //                        continue;
        //                    }
        //                }

        //                sIndex = Code128.GetSIndexFromA(data[i]);
        //                this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //            }
        //            break;
        //        case CharacterSet.B:
        //            for (int i = 0; i < data.Length; i++)
        //            {
        //                nowChar = (byte)data[i];
        //                if (nowChar < 32)
        //                {
        //                    //字符集A
        //                    byte tempByte = Code128.GetProprietaryChar(data, i + 1);
        //                    if (tempByte > 95)
        //                    {
        //                        //加入转换符
        //                        sIndex = Code128.SHIFT_AB;
        //                        this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);

        //                        sIndex = Code128.GetSIndexFromA(data[i]);
        //                        this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                        continue;
        //                    }
        //                    else
        //                    {
        //                        //加入切换符
        //                        sIndex = Code128.CODEA_BC;
        //                        this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                        this.GetEncodedData(tempBuilder, data.Substring(i), CharacterSet.B, ref nowWeight, ref checkNum);
        //                        return;
        //                    }
        //                }
        //                else if (char.IsDigit(data[i]))
        //                {
        //                    //数字
        //                    int digitLength = Code128.GetDigitLength(data, i);
        //                    if (digitLength >= 4)
        //                    {
        //                        //转入CodeC
        //                        if (digitLength % 2 != 0)
        //                        {//奇数位数字，在第一个数字之后插入CodeC字符
        //                            sIndex = Code128.GetSIndexFromB(data[i]);
        //                            this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                            i++;
        //                        }
        //                        sIndex = Code128.CODEC_AB;//插入CodeC切换字符
        //                        this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                        this.GetEncodedData(tempBuilder, data.Substring(i), CharacterSet.C, ref nowWeight, ref checkNum);
        //                        return;
        //                    }
        //                    else
        //                    {
        //                        for (int j = 0; j < digitLength; j++)
        //                        {
        //                            sIndex = Code128.GetSIndexFromB(data[i]);
        //                            this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);i++;
        //                        }i--;
        //                        continue;
        //                    }
        //                }

        //                sIndex = Code128.GetSIndexFromB(data[i]);
        //                this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //            }
        //            break;
        //        default:
        //            for (int i = 0; i < data.Length; i += 2)
        //            {
        //                if (i != data.Length - 1 && char.IsDigit(data, i) && char.IsDigit(data, i + 1))
        //                {
        //                    sIndex = byte.Parse(data.Substring(i, 2));
        //                    this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                }
        //                else
        //                {
        //                    nowCharacterSet = Code128.GetCharacterSet(data, i);
        //                    //插入转换字符
        //                    sIndex = Code128.GetCodeXIndex(nowCharacterSet);
        //                    this.EncodingCommon(tempBuilder, sIndex, ref nowWeight, ref checkNum);
        //                    this.GetEncodedData(tempBuilder, data.Substring(i), nowCharacterSet, ref nowWeight, ref checkNum);
        //                    return;
        //                }
        //            }
        //            break;
        //    }
        //}
        #endregion
    }


注销部分是一开始的获取编码的写法

娃都会打酱油了
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
c#--Code 128 Auto -21位纯数字条形码生成工具
04-26
一直找不到现成的Code128auto生成工具,无奈自己参考其他资源,写了个.纯数字的,默认是21位.
超级好用的Code128Auto编码 打印条码
05-07
Code128的Auto算法, 打印条码是可以最大程度缩短打印宽度
Code128A、B、C及Auto的区别
aldsot0997的博客
01-11 559
A字符集仅包含数字和大写字母，B字符集包含大小写字母和数字，C字符集仅包含从00-99的100个两位数数字。一般来说，如果条码内容是大写英文字母，用A用B是一样的，如果包含大小写字母，则要用B，如果条码是由纯数字构成的，要用C。 转载于:https://www.cnblogs.com/yangxuming/p/8267154.html...
CODE128Auto条码打印
04-23
自己编写的实现CODE128Auto一维条码的代码，欢迎各位使用和提出修改意见
C# 绘制Code128 auto条码
05-26
不到200行代码，实用的绘制Code128 auto条码程序，Code128 auto采用 A、B、C混合编码，将条码长度压缩到最短
vb.net 打印条形码code39、code128A、code128C、code128Auto（picturebox和打印机）封装类
superfans98的专栏
08-01 1815
调用该类的方法后，会返回形如bsbssbsssbbbssbbssbbss这样的字符串。然后您可以根据这串字符，指定位置和打印介质来打印到picturebox或者打印机。上面举的例子是使用code128auto来打印到图像框和打印机。类的工作是计算出哪个位置打线条，哪个位置不打。code128auto打印出来的条码即短，又不受条码位数限制。而code128C只能打印偶数位的条码。auto即，如果是奇数，那么前偶数个用128C打，最后一位，先改变编码再打印。具体规则，网上有，我就不搬了。.........
一维条形码CODE128编码及字符集CODE A、B、C解析
热门推荐
猪哥的专栏
07-21 2万+
在进行一维条形码打印的编程中知道了条形码有一种类型是code128，也是比较常用的，具体的字符集有3种，分别为A、B、C，这三种的说明如下： A格式：数字、大写字母和控制字符组成的字符串，如ABC、ABC123 B格式：数字、大小写字母和字符组成的字符串，如Abc123、a-123（B） C格式：双位数字组成的字符串，如1234、00008182。 一般来说，如果条幅内容是大写英文字母，用
C#条形码生成（六）----GS1-128条形码
sky 胡萝卜星星
01-10 1万+
首先需要说明该部分代码虽然经过个人测试，也使用扫描枪测试，但本人不保证代码完全正确 其次代码没有遵循“先预定义长度后非定长”的原则，但遵循了非预定义长度字符串后都加入FNC1分隔符 最后虽然此部分代码遵循了 GBT 16986-2009 商品条码 应用标识符标准，但实际并未完全遵循，仅遵循了标识符长度和输入字母原则 补充：此部分代码用到了前面的Code128Auto的生成编码代码，所以将部分
C#条形码生成（一）----接口、Code128基础数据、枚举
sky 胡萝卜星星
12-31 8664
接口，这样的接口能够应用到各种的一维，二维码 /// /// 条形码接口 /// public interface IBarCode { string RawData { get; } /// /// 条形码对应的数据 /// string Encod
带你人工识别C#开源库BarcodeLib生成的一维码Code128
zxy13826134783的博客
11-02 673
1 先把数字如：6986081进行编码，两个数字作为一组进行编码，这里数字69一组，86一组，08一组，剩下一个1就比较特别，源码看得不是很懂，有特殊的规则进行编码。3 通过C#的绘图类Graphics的画线方法.DrawLine进行绘制线，如要绘制10110010000编码，碰到1就纵向绘制一定宽度的直线，碰到0就不绘制直线。通过编码10011100110 查找本文后面的编码表得到的数值为17，但前面有一个CODE_A，应该编码为1。2 把两位数字通过查表法进行编码，编码为11位的0或1数字。
CODE128AUTO纯PB原代码实现
12-16
采用pb11.5 编写，CODE128AUTO纯PB原代码实现，没有OCX、DLL等第三方控件。
.NET Code128 Auto生成条形码
07-03
网上大部分都是如何生成CodeA,B,C这样的代码，这个是真正生成Auto的代码
Code128Auto实例
12-14
Code128Auto使用实例,前面一个不Code128Auto类不会用的请直接下载这个。
生成QR-Code和Data-Matrix的二维码（库）
05-10
生成QR-Code格式的二维码 bool QR_Code(char *QR_text, char *bmpSavedPath, QRecLevel level, QRencodeMode hint); 生成Data-Matrix格式的二维码 bool Data_Matrix(char *DM_text, char *bmpSavedPath); 资源包附赠...
C#-code128码-ABC-带Auto实现方式-源代码-非输入法转条码-通过方法实现各种绘图软件实现自画
11-29
C#-code128码-ABC-带Auto实现方式-源代码-非输入法转条码-通过方法实现各种绘图软件实现自画可以实现 code128-A code128-B code128-C code128-Auto EAN128通过以上源代码，可以实现CAD/CATIA等软件的自画128条码操作...
C#生成code128条形码的方法
09-04
主要介绍了C#生成code128条形码的方法,是C#程序设计中一个很实用的技巧,需要的朋友可以参考下
GenCode128-Code128条码生成器
04-08
为WinForms或ASP.NET创建Code128条码。
ASP.NET基于WEB的工作计划流程管理系统的设计与实现
大叔_爱编程 的博客
04-19 1475
本设计着重解决了三方面的问题：（1）、根据人员的权限实现对工作计划的创建；（2）、根据人员的权限实现对工作完成情况的录入；（3）、根据人员的权限实现对工作的审查。工作计划流程管理系统主要分为工作计划的创建区、工作人员的工作区与工作的审查区三个模块，其中工作区是整个工作计划流程管理系统的核心。 本文共五章，第一章对当前背景与国内外现状进行分析；第二章对数据库技术、面向对象的技术进行简单介绍；第三章对当前单位、企业进行了需求分析并提出解决方案；第四章根据解决方案对系统进行设计；第五章对工作计划流程管理系统进行测
C#中的Task：异步编程的瑞士军刀
最新发布
qq_35320456的博客
04-19 1490
C#中的Task：异步编程的瑞士军刀
C#语言随机生成1-100随机数
07-14
您可以使用C#的Random类来生成1-100之间的随机数。以下是一个示例代码： ```csharp using System; class Program { static void Main() { Random random = new Random(); int randomNumber = random.Next(1, 101); // 生成1-100之间的随机数 Console.WriteLine(randomNumber); } } ``` 在上述代码中，我们使用Random类创建了一个名为random的对象。然后，使用random.Next(1, 101)方法生成1-100之间的随机数，并将结果存储在randomNumber变量中。最后，我们使用Console.WriteLine输出随机数的值。 希望能帮到您！如果您还有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值