C#バーコード生成(一)----インタフェース、Code 128基礎データ、列挙


インタフェース、このようなインタフェースは各種の1次元、2次元コードに応用することができる
    /// <summary>
    ///      
    /// </summary>
    public interface IBarCode
    {
        string RawData { get; }
        /// <summary>
        ///         
        /// </summary>
        string EncodedData { get; }
        /// <summary>
        ///        
        /// </summary>
        string BarCodeType { get; }

        /// <summary>
        ///           
        /// </summary>
        /// <returns></returns>
        Image GetBarCodeImage();
    }

Code 128静的クラス、いくつかのCode 128の基礎の情報と共通の方法を格納します
/// <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>
        /// <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;
        }
    }

Code 128文字セット列挙クラス
    /// <summary>
    /// Code128   
    /// </summary>
    internal enum CharacterSet
    {
        A,
        B,
        C
    }