Code improvements

Author: NikolayIT

Source/GenCode128/Code128Code.cs

@@ -35,30 +35,30 @@ public enum CodeSetAllowed
         /// </summary>
         /// <param name="charAscii">The ASCII value of the character to translate</param>
         /// <param name="lookAheadAscii">The next character in sequence (or -1 if none)</param>
-        /// <param name="currCodeSet">The current codeset, that the returned codes need to follow;
+        /// <param name="currentCodeSet">The current codeset, that the returned codes need to follow;
         /// if the returned codes change that, then this value will be changed to reflect it</param>
         /// <returns>An array of integers representing the codes that need to be output to produce the 
         /// given character</returns>
-        public static int[] CodesForChar(int charAscii, int lookAheadAscii, ref CodeSet currCodeSet)
+        public static int[] CodesForChar(int charAscii, int lookAheadAscii, ref CodeSet currentCodeSet)
         {
             int[] result;
-            int shifter = -1;
+            var shifter = -1;
 
-            if (!CharCompatibleWithCodeset(charAscii, currCodeSet))
+            if (!CharCompatibleWithCodeset(charAscii, currentCodeSet))
             {
                 // if we have a lookahead character AND if the next character is ALSO not compatible
-                if ((lookAheadAscii != -1) && !CharCompatibleWithCodeset(lookAheadAscii, currCodeSet))
+                if ((lookAheadAscii != -1) && !CharCompatibleWithCodeset(lookAheadAscii, currentCodeSet))
                 {
                     // we need to switch code sets
-                    switch (currCodeSet)
+                    switch (currentCodeSet)
                     {
                         case CodeSet.CodeA:
                             shifter = CCodeB;
-                            currCodeSet = CodeSet.CodeB;
+                            currentCodeSet = CodeSet.CodeB;
                             break;
                         case CodeSet.CodeB:
                             shifter = CCodeA;
-                            currCodeSet = CodeSet.CodeA;
+                            currentCodeSet = CodeSet.CodeA;
                             break;
                     }
                 }
@@ -97,21 +97,21 @@ public static CodeSetAllowed CodesetAllowedForChar(int charAscii)
             }
             else
             {
-                return (charAscii < 32) ? CodeSetAllowed.CodeA : CodeSetAllowed.CodeB;
+                return charAscii < 32 ? CodeSetAllowed.CodeA : CodeSetAllowed.CodeB;
             }
         }
 
         /// <summary>
         /// Determine if a character can be represented in a given codeset
         /// </summary>
         /// <param name="charAscii">character to check for</param>
-        /// <param name="currcs">codeset context to test</param>
+        /// <param name="currentCodeSet">codeset context to test</param>
         /// <returns>true if the codeset contains a representation for the ASCII character</returns>
-        public static bool CharCompatibleWithCodeset(int charAscii, CodeSet currcs)
+        public static bool CharCompatibleWithCodeset(int charAscii, CodeSet currentCodeSet)
         {
-            CodeSetAllowed csa = CodesetAllowedForChar(charAscii);
-            return csa == CodeSetAllowed.CodeAorB || (csa == CodeSetAllowed.CodeA && currcs == CodeSet.CodeA)
-                   || (csa == CodeSetAllowed.CodeB && currcs == CodeSet.CodeB);
+            var csa = CodesetAllowedForChar(charAscii);
+            return csa == CodeSetAllowed.CodeAorB || (csa == CodeSetAllowed.CodeA && currentCodeSet == CodeSet.CodeA)
+                   || (csa == CodeSetAllowed.CodeB && currentCodeSet == CodeSet.CodeB);
         }
 
         /// <summary>
@@ -121,7 +121,7 @@ public static bool CharCompatibleWithCodeset(int charAscii, CodeSet currcs)
         /// <returns>code128 symbol value for the character</returns>
         public static int CodeValueForChar(int charAscii)
         {
-            return (charAscii >= 32) ? charAscii - 32 : charAscii + 64;
+            return charAscii >= 32 ? charAscii - 32 : charAscii + 64;
         }
 
         /// <summary>

Source/GenCode128/Code128Content.cs

@@ -1,33 +1,26 @@
 namespace GenCode128
 {
+    using System.Collections;
     using System.Text;
 
     /// <summary>
     /// Represent the set of code values to be output into barcode form
     /// </summary>
     public class Code128Content
     {
-        private readonly int[] codeList;
-
         /// <summary>
         /// Create content based on a string of ASCII data
         /// </summary>
         /// <param name="asciiData">the string that should be represented</param>
         public Code128Content(string asciiData)
         {
-            this.codeList = this.StringToCode128(asciiData);
+            this.Codes = this.StringToCode128(asciiData);
         }
 
         /// <summary>
         /// Provides the Code128 code values representing the object's string
         /// </summary>
-        public int[] Codes
-        {
-            get
-            {
-                return this.codeList;
-            }
-        }
+        public int[] Codes { get; }
 
         /// <summary>
         /// Transform the string into integers representing the Code128 codes
@@ -38,35 +31,33 @@ public int[] Codes
         private int[] StringToCode128(string asciiData)
         {
             // turn the string into ascii byte data
-            byte[] asciiBytes = Encoding.ASCII.GetBytes(asciiData);
+            var asciiBytes = Encoding.ASCII.GetBytes(asciiData);
 
             // decide which codeset to start with
-            Code128Code.CodeSetAllowed csa1 = asciiBytes.Length > 0
-                                                  ? Code128Code.CodesetAllowedForChar(asciiBytes[0])
-                                                  : Code128Code.CodeSetAllowed.CodeAorB;
-            Code128Code.CodeSetAllowed csa2 = asciiBytes.Length > 0
-                                                  ? Code128Code.CodesetAllowedForChar(asciiBytes[1])
-                                                  : Code128Code.CodeSetAllowed.CodeAorB;
-            CodeSet currcs = this.GetBestStartSet(csa1, csa2);
+            var csa1 = asciiBytes.Length > 0
+                           ? Code128Code.CodesetAllowedForChar(asciiBytes[0])
+                           : Code128Code.CodeSetAllowed.CodeAorB;
+            var csa2 = asciiBytes.Length > 0
+                           ? Code128Code.CodesetAllowedForChar(asciiBytes[1])
+                           : Code128Code.CodeSetAllowed.CodeAorB;
+            var currentCodeSet = this.GetBestStartSet(csa1, csa2);
 
             // set up the beginning of the barcode
-            System.Collections.ArrayList codes = new System.Collections.ArrayList(asciiBytes.Length + 3);
-            
             // assume no codeset changes, account for start, checksum, and stop
-            codes.Add(Code128Code.StartCodeForCodeSet(currcs));
-
+            var codes = new ArrayList(asciiBytes.Length + 3) { Code128Code.StartCodeForCodeSet(currentCodeSet) };
+            
             // add the codes for each character in the string
-            for (int i = 0; i < asciiBytes.Length; i++)
+            for (var i = 0; i < asciiBytes.Length; i++)
             {
                 int thischar = asciiBytes[i];
-                int nextchar = asciiBytes.Length > (i + 1) ? asciiBytes[i + 1] : -1;
+                var nextchar = asciiBytes.Length > i + 1 ? asciiBytes[i + 1] : -1;
 
-                codes.AddRange(Code128Code.CodesForChar(thischar, nextchar, ref currcs));
+                codes.AddRange(Code128Code.CodesForChar(thischar, nextchar, ref currentCodeSet));
             }
 
             // calculate the check digit
-            int checksum = (int)codes[0];
-            for (int i = 1; i < codes.Count; i++)
+            var checksum = (int)codes[0];
+            for (var i = 1; i < codes.Count; i++)
             {
                 checksum += i * (int)codes[i];
             }
@@ -75,7 +66,7 @@ private int[] StringToCode128(string asciiData)
 
             codes.Add(Code128Code.StopCode());
 
-            int[] result = codes.ToArray(typeof(int)) as int[];
+            var result = codes.ToArray(typeof(int)) as int[];
             return result;
         }
 
@@ -88,14 +79,14 @@ private int[] StringToCode128(string asciiData)
         /// <returns>The codeset determined to be best to start with</returns>
         private CodeSet GetBestStartSet(Code128Code.CodeSetAllowed csa1, Code128Code.CodeSetAllowed csa2)
         {
-            int vote = 0;
+            var vote = 0;
 
-            vote += (csa1 == Code128Code.CodeSetAllowed.CodeA) ? 1 : 0;
-            vote += (csa1 == Code128Code.CodeSetAllowed.CodeB) ? -1 : 0;
-            vote += (csa2 == Code128Code.CodeSetAllowed.CodeA) ? 1 : 0;
-            vote += (csa2 == Code128Code.CodeSetAllowed.CodeB) ? -1 : 0;
+            vote += csa1 == Code128Code.CodeSetAllowed.CodeA ? 1 : 0;
+            vote += csa1 == Code128Code.CodeSetAllowed.CodeB ? -1 : 0;
+            vote += csa2 == Code128Code.CodeSetAllowed.CodeA ? 1 : 0;
+            vote += csa2 == Code128Code.CodeSetAllowed.CodeB ? -1 : 0;
 
-            return (vote > 0) ? CodeSet.CodeA : CodeSet.CodeB; // ties go to codeB due to my own prejudices
+            return vote > 0 ? CodeSet.CodeA : CodeSet.CodeB; // ties go to codeB due to my own prejudices
         }
     }
 }

Source/GenCode128/Code128Rendering.cs

@@ -131,59 +131,58 @@ public static class Code128Rendering
         /// </summary>
         /// <param name="inputData">Message to be encoded</param>
         /// <param name="barWeight">Base thickness for bar width (1 or 2 works well)</param>
-        /// <param name="addQuietZone">Add required horiz margins (use if output is tight)</param>
+        /// <param name="addQuietZone">Add required horizontal margins (use if output is tight)</param>
         /// <returns>An Image of the Code128 barcode representing the message</returns>
         public static Image MakeBarcodeImage(string inputData, int barWeight, bool addQuietZone)
         {
             // get the Code128 codes to represent the message
-            Code128Content content = new Code128Content(inputData);
-            int[] codes = content.Codes;
+            var content = new Code128Content(inputData);
+            var codes = content.Codes;
 
-            int width, height;
-            width = (((codes.Length - 3) * 11) + 35) * barWeight;
-            height = Convert.ToInt32(System.Math.Ceiling(Convert.ToSingle(width) * .15F));
+            var width = (((codes.Length - 3) * 11) + 35) * barWeight;
+            var height = Convert.ToInt32(Math.Ceiling(Convert.ToSingle(width) * .15F));
 
             if (addQuietZone)
             {
                 width += 2 * CQuietWidth * barWeight; // on both sides
             }
 
             // get surface to draw on
-            Image myimg = new System.Drawing.Bitmap(width, height);
-            using (Graphics gr = Graphics.FromImage(myimg))
+            Image myImage = new Bitmap(width, height);
+            using (var gr = Graphics.FromImage(myImage))
             {
                 // set to white so we don't have to fill the spaces with white
-                gr.FillRectangle(System.Drawing.Brushes.White, 0, 0, width, height);
+                gr.FillRectangle(Brushes.White, 0, 0, width, height);
 
                 // skip quiet zone
-                int cursor = addQuietZone ? CQuietWidth * barWeight : 0;
+                var cursor = addQuietZone ? CQuietWidth * barWeight : 0;
 
-                for (int codeidx = 0; codeidx < codes.Length; codeidx++)
+                for (var codeIdx = 0; codeIdx < codes.Length; codeIdx++)
                 {
-                    int code = codes[codeidx];
+                    var code = codes[codeIdx];
 
                     // take the bars two at a time: a black and a white
-                    for (int bar = 0; bar < 8; bar += 2)
+                    for (var bar = 0; bar < 8; bar += 2)
                     {
-                        int barwidth = CPatterns[code, bar] * barWeight;
-                        int spcwidth = CPatterns[code, bar + 1] * barWeight;
+                        var barWidth = CPatterns[code, bar] * barWeight;
+                        var spcWidth = CPatterns[code, bar + 1] * barWeight;
 
                         // if width is zero, don't try to draw it
-                        if (barwidth > 0)
+                        if (barWidth > 0)
                         {
-                            gr.FillRectangle(System.Drawing.Brushes.Black, cursor, 0, barwidth, height);
+                            gr.FillRectangle(Brushes.Black, cursor, 0, barWidth, height);
                         }
 
                         // note that we never need to draw the space, since we 
                         // initialized the graphics to all white
 
                         // advance cursor beyond this pair
-                        cursor += barwidth + spcwidth;
+                        cursor += barWidth + spcWidth;
                     }
                 }
             }
 
-            return myimg;
+            return myImage;
         }
     }
 }