添加项目文件。

zxing.core/zxing.core/SupportClass.cs

@@ -0,0 +1,185 @@
+//
+// In order to convert some functionality to Visual C#, the Java Language Conversion Assistant
+// creates "support classes" that duplicate the original functionality.  
+//
+// Support classes replicate the functionality of the original code, but in some cases they are 
+// substantially different architecturally. Although every effort is made to preserve the 
+// original architecture of the application in the converted project, the user should be aware that 
+// the primary goal of these support classes is to replicate functionality, and that at times 
+// the architecture of the resulting solution may differ somewhat.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ZXing
+{
+    /// <summary>
+    /// Contains conversion support elements such as classes, interfaces and static methods.
+    /// </summary>
+    public static class SupportClass
+    {
+        /*******************************/
+        /// <summary>
+        /// Copies an array of chars obtained from a String into a specified array of chars
+        /// </summary>
+        /// <param name="sourceString">The String to get the chars from</param>
+        /// <param name="sourceStart">Position of the String to start getting the chars</param>
+        /// <param name="sourceEnd">Position of the String to end getting the chars</param>
+        /// <param name="destinationArray">Array to return the chars</param>
+        /// <param name="destinationStart">Position of the destination array of chars to start storing the chars</param>
+        /// <returns>An array of chars</returns>
+        public static void GetCharsFromString(System.String sourceString, int sourceStart, int sourceEnd, char[] destinationArray, int destinationStart)
+        {
+            int sourceCounter = sourceStart;
+            int destinationCounter = destinationStart;
+            while (sourceCounter < sourceEnd)
+            {
+                destinationArray[destinationCounter] = (char)sourceString[sourceCounter];
+                sourceCounter++;
+                destinationCounter++;
+            }
+        }
+
+        /*******************************/
+        /// <summary>
+        /// Sets the capacity for the specified List
+        /// </summary>
+        /// <param name="vector">The List which capacity will be set</param>
+        /// <param name="newCapacity">The new capacity value</param>
+        public static void SetCapacity<T>(System.Collections.Generic.IList<T> vector, int newCapacity) where T : new()
+        {
+            while (newCapacity > vector.Count)
+                vector.Add(new T());
+            while (newCapacity < vector.Count)
+                vector.RemoveAt(vector.Count - 1);
+        }
+
+        /// <summary>
+        /// Converts a string-Collection to an array
+        /// </summary>
+        /// <param name="strings">The strings.</param>
+        /// <returns></returns>
+        public static String[] toStringArray(ICollection<string> strings)
+        {
+            var result = new String[strings.Count];
+            strings.CopyTo(result, 0);
+            return result;
+        }
+
+        /// <summary>
+        /// Joins all elements to one string.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="separator">The separator.</param>
+        /// <param name="values">The values.</param>
+        /// <returns></returns>
+        public static string Join<T>(string separator, IEnumerable<T> values)
+        {
+            var builder = new StringBuilder();
+            separator = separator ?? String.Empty;
+            if (values != null)
+            {
+                foreach (var value in values)
+                {
+                    builder.Append(value);
+                    builder.Append(separator);
+                }
+                if (builder.Length > 0)
+                    builder.Length -= separator.Length;
+            }
+
+            return builder.ToString();
+        }
+
+        /// <summary>
+        /// Fills the specified array.
+        /// (can't use extension method because of .Net 2.0 support)
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="array">The array.</param>
+        /// <param name="value">The value.</param>
+        public static void Fill<T>(T[] array, T value)
+        {
+            for (int i = 0; i < array.Length; i++)
+            {
+                array[i] = value;
+            }
+        }
+
+        /// <summary>
+        /// Fills the specified array.
+        /// (can't use extension method because of .Net 2.0 support)
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="array">The array.</param>
+        /// <param name="startIndex">The start index.</param>
+        /// <param name="endIndex">The end index.</param>
+        /// <param name="value">The value.</param>
+        public static void Fill<T>(T[] array, int startIndex, int endIndex, T value)
+        {
+            for (int i = startIndex; i < endIndex; i++)
+            {
+                array[i] = value;
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="x"></param>
+        /// <returns></returns>
+        public static string ToBinaryString(int x)
+        {
+            char[] bits = new char[32];
+            int i = 0;
+
+            while (x != 0)
+            {
+                bits[i++] = (x & 1) == 1 ? '1' : '0';
+                x >>= 1;
+            }
+
+            Array.Reverse(bits, 0, i);
+            return new string(bits);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="n"></param>
+        /// <returns></returns>
+        public static int bitCount(int n)
+        {
+            int ret = 0;
+            while (n != 0)
+            {
+                n &= (n - 1);
+                ret++;
+            }
+            return ret;
+        }
+
+        /// <summary>
+        /// Savely gets the value of a decoding hint
+        /// if hints is null the default is returned
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="hints">The hints.</param>
+        /// <param name="hintType">Type of the hint.</param>
+        /// <param name="default">The @default.</param>
+        /// <returns></returns>
+        public static T GetValue<T>(IDictionary<DecodeHintType, object> hints, DecodeHintType hintType, T @default)
+        {
+            // can't use extension method because of .Net 2.0 support
+
+            if (hints == null)
+                return @default;
+            if (!hints.ContainsKey(hintType))
+                return @default;
+
+            return (T)hints[hintType];
+        }
+    }
+}