public static string[] Split(string str, char[] separators, int maxComponents, StringSplitOptions options)
        {
            ContractUtils.RequiresNotNull(str, "str");
            #if SILVERLIGHT || WP75
            if (separators == null) return SplitOnWhiteSpace(str, maxComponents, options);

            bool keep_empty = (options & StringSplitOptions.RemoveEmptyEntries) != StringSplitOptions.RemoveEmptyEntries;

            List<string> result = new List<string>(maxComponents == Int32.MaxValue ? 1 : maxComponents + 1);

            int i = 0;
            int next;
            while (maxComponents > 1 && i < str.Length && (next = str.IndexOfAny(separators, i)) != -1) {

                if (next > i || keep_empty) {
                    result.Add(str.Substring(i, next - i));
                    maxComponents--;
                }

                i = next + 1;
            }

            if (i < str.Length || keep_empty) {
                result.Add(str.Substring(i));
            }

            return result.ToArray();
            #else
            return str.Split(separators, maxComponents, options);
            #endif
        }

        public static string[] Split(string str, string separator, int maxComponents, StringSplitOptions options) {
            ContractUtils.RequiresNotNull(str, "str");
#if SILVERLIGHT || WP75
            if (string.IsNullOrEmpty(separator)) throw new ArgumentNullException("separator");

            bool keep_empty = (options & StringSplitOptions.RemoveEmptyEntries) != StringSplitOptions.RemoveEmptyEntries;

            List<string> result = new List<string>(maxComponents == Int32.MaxValue ? 1 : maxComponents + 1);

            int i = 0;
            int next;
            while (maxComponents > 1 && i < str.Length && (next = str.IndexOf(separator, i)) != -1) {

                if (next > i || keep_empty) {
                    result.Add(str.Substring(i, next - i));
                    maxComponents--;
                }

                i = next + separator.Length;
            }

            if (i < str.Length || keep_empty) {
                result.Add(str.Substring(i));
            }

            return result.ToArray();
#else
            return str.Split(new string[] { separator }, maxComponents, options);
#endif
        }

 public static string[] Split(string str, string[] delimeters, StringSplitOptions options = StringSplitOptions.None)
 {
     StringTokenizer.options = options;
     StringTokenizer.delimeters = delimeters;
     StringTokenizer.str = str;
     List<string> list = new List<string>();
     string cur = "";
     for (int i = 0; i <= str.Length; i++)
     {
         int d = getDelimeter(i);
         if (d == -1)
         {
             if (i < str.Length)
                 cur += str[i];
             else
             {
                 AddToList(list, cur);
                 cur = "";
             }
         }
         else
         {
             AddToList(list, cur);
             cur = "";
             AddToList(list, delimeters[d]);
             i += delimeters[d].Length - 1;
         }
     }
     return list.ToArray();
 }

        public static string[] SplitOnWhiteSpace(string str, int maxComponents, StringSplitOptions options) {
            ContractUtils.RequiresNotNull(str, "str");

            bool keep_empty = (options & StringSplitOptions.RemoveEmptyEntries) != StringSplitOptions.RemoveEmptyEntries;

            List<string> result = new List<string>(maxComponents == Int32.MaxValue ? 1 : maxComponents + 1);

            int i = 0;
            int next;
            while (maxComponents > 1 && i < str.Length && (next = IndexOfWhiteSpace(str, i)) != -1) {

                if (next > i || keep_empty) {
                    result.Add(str.Substring(i, next - i));
                    maxComponents--;
                }

                i = next + 1;
            }

            if (i < str.Length || keep_empty) {
                result.Add(str.Substring(i));
            }

            return result.ToArray();
        }

 public static string[] Split(string words, StringSplitOptions splitOptions, bool splitOnCaseDifference)
 {
     if (string.IsNullOrEmpty(words))
     {
         return new string[] { words };
     }
     string[] initial = words.Split(_separators, splitOptions);
     List<string> final = new List<string>();
     int finalIndex = 0;
     for (int i = 0; i < initial.Length; i++)
     {
         StringBuilder sb = new StringBuilder();
         string w = initial[i];
         bool isUpper = char.IsUpper(w[0]);
         sb.Append(w[0]);
         for (int c = 1; c < w.Length; c++)
         {
             if (splitOnCaseDifference && char.IsUpper(w[c]))
             {
                 final.Insert(finalIndex++, sb.ToString());
                 sb.Clear();
             }
             sb.Append(w[c]);
         }
         if (sb.Length > 0)
         {
             final.Insert(finalIndex++, sb.ToString());
             sb.Clear();
         }
     }
     return final.ToArray();
 }

        public static IEnumerable<KeyValuePair<string, string>> SplitWithSeparator(this string str, IEnumerable<string> separator,
			StringComparison comparisonType = StringComparison.CurrentCulture, StringSplitOptions options = StringSplitOptions.None)
        {
            IEnumerable<KeyValuePair<int, string>> indexes = new Dictionary<int, string>();
            indexes = separator.Aggregate(indexes, (current, s) => current.Union(str.IndexOfAll(s, comparisonType).ToDictionaryValue(i => str.Substring(i, s.Length))));
            int lastIndex = 0;
            var list = new List<KeyValuePair<string, string>>();
            foreach (KeyValuePair<int, string> kvp in indexes.OrderBy(a => a.Key))
            {
                string substring = str.Substring(lastIndex, kvp.Key - lastIndex);
                list.Add(new KeyValuePair<string, string>(substring, kvp.Value));
                lastIndex += substring.Length + kvp.Value.Length;
            }
            list.Add(new KeyValuePair<string, string>(str.Substring(lastIndex), null));
            return list.Where(a =>
            {
                switch (options)
                {
                    case StringSplitOptions.None:
                        return true;
                    case StringSplitOptions.RemoveEmptyEntries:
                        return a.Key != "";
                    default:
                        throw new NotSupportedException("unrecognized StringSplitOptions");
                }
            });
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="StringParser"/> class.
 /// </summary>
 /// <param name="value">The value.</param>
 /// <param name="separator">The separator.</param>
 /// <param name="splitOptions">The split options.</param>
 public StringParser(string value, string separator, StringSplitOptions splitOptions)
 {
     if (!string.IsNullOrWhiteSpace(value) && !string.IsNullOrEmpty(separator))
     {
         _tokens = value.Split(new string[] { separator }, splitOptions);
     }
 }

        /// <summary>
        /// Builds a polyline from a string. Optional : keep a subpart of the complete polyline.
        /// </summary>
        /// <param name="line">The input string, under the format [[x_1,y_1],...,[x_n,y_n]].</param>
        /// <param name="partToKeep">The percentage of the first part of the string to keep.</param>
        public Polyline(string line, double partToKeep = 1.1f)
        {
            StringSplitOptions sso = new StringSplitOptions();
            string[] arr = line.Split(new string[] { "[[" }, sso);
            string pl = arr[1];
            pl = pl.Replace("[", "");
            pl = pl.Replace("]", "");
            pl = pl.Replace("\"", "");
            List<string> elts = pl.Split(',').ToList();

            if (partToKeep < 1f)
            {
                int finalSize = (int)Math.Floor(elts.Count * partToKeep / 2 + 1) * 2;
                List<string> elts2 = new List<string>();
                for (int i = 0; i < finalSize; i++)
                    elts2.Add(elts[i]);
                elts = elts2;
            }

            _polylineX = new double[elts.Count / 2];
            _polylineY = new double[elts.Count / 2];

            for (int i = 0; i < _polylineX.Length; i++)
            {
                _polylineX[i] = Convert.ToDouble(elts[i * 2], CultureInfo.GetCultureInfo("en-US"));
                _polylineY[i] = Convert.ToDouble(elts[i * 2 + 1], CultureInfo.GetCultureInfo("en-US"));
            }
        }

        public static string[] split_safe(this string s, char[] separator, StringSplitOptions stringSplitOptions)
        {
            if (s == null)
            {
                return new string[0];
            }

            return s.Split(separator, stringSplitOptions);
        }

        public static string[] ToArray(this string input, StringSplitOptions option, params char[] delimiter)
        {
            if (input == null)
            {
                return null;
            }

            return input.Split(delimiter, option);
        }

 private static IEnumerable<string> GetAllSettingsAsString(
     IEnumerable<string> returns,
     char separator = ',',
     StringSplitOptions options = StringSplitOptions.RemoveEmptyEntries)
 {
     return CreateSubjectUnderTest(
         string.Join(separator.ToString(), returns))
         .GetAllSettingsAsString(Key, separator, options);
 }

        /// <summary>
        ///     Returns a string array that contains the substrings in this string that are
        ///     delimited by elements of a specified string array. A parameter specifies
        ///     whether to return empty array elements.
        /// </summary>
        /// <exception cref="ArgumentNullException">The string can not be null.</exception>
        /// <exception cref="ArgumentNullException">The separator can not be null.</exception>
        /// <param name="value">The string to split.</param>
        /// <param name="separators">
        ///     An array of strings that delimit the substrings in this string, an empty
        ///     array that contains no delimiters, or null.
        /// </param>
        /// <param name="stringSplitOption">
        ///     <see cref="System.StringSplitOptions.RemoveEmptyEntries" /> to omit empty array elements
        ///     from the array returned; or System.StringSplitOptions.None to include empty
        ///     array elements in the array returned.
        /// </param>
        /// <returns>
        ///     Returns an array whose elements contain the substrings in this string that are delimited
        ///     by one or more strings in separator.
        /// </returns>
        public static String[] Split( this String value,
                                      StringSplitOptions stringSplitOption,
                                      params String[] separators )
        {
            value.ThrowIfNull( nameof( value ) );
            separators.ThrowIfNull( nameof( separators ) );

            return value.Split( separators, stringSplitOption );
        }

        /// <summary>
        ///     Splits the given string at each line break (<see cref="Environment.NewLine" />).
        /// </summary>
        /// <example>value can not be null.</example>
        /// <param name="value">The string to split.</param>
        /// <param name="stringSplitOptions">
        ///     <see cref="System.StringSplitOptions.RemoveEmptyEntries" /> to omit empty array elements
        ///     from the array returned; or System.StringSplitOptions.None to include empty
        ///     array elements in the array returned.
        /// </param>
        /// <returns>
        ///     Returns an array whose elements contain the substrings in this string that are delimited by
        ///     <see cref="Environment.NewLine" />.
        /// </returns>
        public static String[] SplitLines( this String value, StringSplitOptions stringSplitOptions )
        {
            value.ThrowIfNull( nameof( value ) );

            return value.Split( new[]
            {
                Environment.NewLine
            },
                                stringSplitOptions );
        }

 /// <summary>
 /// Splits a given strings into elements by a given sperator.
 /// </summary>
 /// <param name="IEnumerator">An enumerator of strings.</param>
 /// <param name="IgnoreLines">A regular expression indicating which input strings should be ignored. Default: All lines starting with a '#'.</param>
 /// <param name="Seperators">An array of string used to split the input strings.</param>
 /// <param name="StringSplitOptions">Split options, e.g. remove empty entries.</param>
 /// <param name="ExpectedNumberOfColumns">If the CSV file had a schema, a specific number of columns can be expected. If instead it is a list of values no such value can be expected.</param>
 /// <param name="FailOnWrongNumberOfColumns">What to do when the current and expected number of columns do not match.</param>
 /// <param name="TrimColumns">Remove leading and trailing whitespaces.</param>
 /// <returns>An enumeration of string arrays.</returns>
 public static IEnumerable<String[]> CSVPipe(this IEnumerator<String> IEnumerator,
                                                  Regex               IgnoreLines                = null,
                                                  String[]            Seperators                 = null,
                                                  StringSplitOptions  StringSplitOptions         = StringSplitOptions.None,
                                                  UInt16?             ExpectedNumberOfColumns    = null,
                                                  Boolean             FailOnWrongNumberOfColumns = false,
                                                  Boolean             TrimColumns                = true)
 {
     return new CSVReaderPipe(IgnoreLines, Seperators, StringSplitOptions, ExpectedNumberOfColumns, FailOnWrongNumberOfColumns, TrimColumns, null, IEnumerator);
 }

        public static int[] stringToIntArray(string input, char[] separator, StringSplitOptions option)
        {
            string[] tempArray = input.Trim().Split(separator, option);
            int[] result = new int[tempArray.Length];
            for (int i = 0; i < tempArray.Length; i++)
            {
                result[i] = int.Parse(tempArray[i].Trim());
            }

            return result;
        }

        static void AssertTextEqual(string expected, string actual, string message, StringSplitOptions options = StringSplitOptions.RemoveEmptyEntries)
        {
            var eLines = expected.Split(new char[] { '\n', '\r' }, options);
            var aLines = actual.Split(new char[] { '\n', '\r' }, options);

            for (var i = 0; i < Math.Min(eLines.Length, aLines.Length); i++)
            {
                Assert.AreEqual(eLines[i], aLines[i], message);
            }

            Assert.AreEqual(eLines.Length, aLines.Length, message);
        }

 public void TestSplit(string words, StringSplitOptions splitOptions, bool splitOnCaseDifference, string[] expected)
 {
     var result = BaseRenameRule.Split(words, splitOptions, splitOnCaseDifference);
     Assert.AreEqual(expected.Length, result.Length);
     Console.WriteLine(result.Length);
     Console.WriteLine(result[0]);
     Console.WriteLine(result[1]);
     for (int i = 0; i < expected.Length; i++)
     {
         Assert.AreEqual(expected[i],result[i]);
     }
 }

        public static string[] Split(this string source, char[] spliter, int count, StringSplitOptions options)
        {
            var parts = source.Split(spliter, options);

            if (parts.Length <= count)
                return parts.ToArray();

            var partList = parts.Take(count - 1).ToList();
            partList.Add(string.Join(spliter[0].ToString(), parts, count - 1, parts.Length - count + 1));
            parts = partList.ToArray();
            return parts;
        }

        /// <summary>
        /// 将当前字符串对象按照指定的分隔符转换为字符串数组
        /// </summary>
        /// <param name="str">当前要转换的字符串对象</param>
        /// <param name="split">指定的分隔字符列表</param>
        /// <param name="opt">指定转换后的数组是否要包含为空的项，默认为不包含</param>
        /// <returns>如果当前字符串为空，返回NULL，否则返回转换后的数组对象</returns>
        public static string[] ToArray(this string str, string split = ",", StringSplitOptions opt = StringSplitOptions.RemoveEmptyEntries)
        {
            if (General.IsNullable(str))
                return null;

            string[] strArray = null;
            if (General.IsNullable(split) || str.IndexOf(split) == -1)
                strArray = new string[] { str };
            else
                strArray = str.Split(split.ToCharArray(), opt);

            return strArray;
        }

		/// <summary>
		/// Splits a <c>string</c> using a Unicode character, unless that character is contained between matching <paramref name="start"/> and <paramref name="end"/> Unicode characters.
		/// </summary>
		/// <param name="st">The <c>string</c> to split.</param>
		/// <param name="separator">Unicode <c>char</c> that delimits the substrings in this instance.</param>
		/// <param name="start">The starting (left) container character. EX: '('.</param>
		/// <param name="end">The ending (right) container character. EX: ')'.</param>
		/// <returns>Array of <c>string</c> objects that are the resulting substrings.</returns>
		public static string[] SplitUnlessBetweenDelimiters(this string st, char separator, char start, char end, StringSplitOptions options = StringSplitOptions.None) {
			List<string> results = new List<string>();
			int containerLevel = 0;
			StringBuilder current = new StringBuilder();
			foreach (char c in st) {
				if (c == start) {
					++containerLevel;
					if (containerLevel == 1) {
						continue;
					}
				}

				if (c == end) {
					--containerLevel;
					if (containerLevel == 0) {
						continue;
					}
				}

				if (containerLevel == 0) {
					if (c == separator) {
						switch (options) {
							case StringSplitOptions.RemoveEmptyEntries: {
								if (current.Length > 0) {
									results.Add(current.ToString());
								}
								current.Length = 0;
								break;
							}
							case StringSplitOptions.None: {
								results.Add(current.ToString());
								current.Length = 0;
								break;
							}
						}
					} else {
						current.Append(c);
					}
				} else {
					current.Append(c);
				}
			}

			if (current.Length > 0) {
				results.Add(current.ToString());
			}

			return results.ToArray<string>();
		}