public void resolve_returns_exception()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var ex = exceptionHelper.Resolve("valid");
Assert.True(ex is InvalidOperationException);
Assert.Equal("Here is the message.", ex.Message);
}
public void resolve_allows_inner_exception_to_be_provided()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var inner = new ArgumentException();
var ex = exceptionHelper.Resolve("valid", inner);
Assert.NotNull(ex.InnerException);
Assert.Same(inner, ex.InnerException);
}
public void resolve_allows_custom_constructor_and_message_formatting_in_tandem()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var ex = exceptionHelper.Resolve("withConstructorAndMessageArgs", new object[] { 1, 2, "more info" }, "param1") as TestException;
Assert.NotNull(ex);
Assert.Equal("My message with a parameter: 'param1'", ex.Message);
Assert.Equal(1, ex.Num1);
Assert.Equal(2, ex.Num2);
Assert.Equal("more info", ex.Info);
}
public LocalizedArgumentOutOfRangeException(string argument, object min, object max, string key = "Exceptions.ArgumentOutOfRangeException", string defaultMessage = null, object parameters = null, Exception innerException = null)
: base(defaultMessage, innerException)
{
if (defaultMessage == null)
{
defaultMessage = "Value must be in the range {0} to {1}";
}
Localization = new ExceptionHelper(this, key, defaultMessage, parameters);
Localization.AddParameter("Minimum", min).AddParameter("Maximum", max);
}
public void resolve_allows_custom_constructor_to_be_called()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var ex = exceptionHelper.Resolve("withConstructorArgs", new object[] { 1, 2, "more info" }, (Exception)null) as TestException;
Assert.NotNull(ex);
Assert.Equal("A message.", ex.Message);
Assert.Equal(1, ex.Num1);
Assert.Equal(2, ex.Num2);
Assert.Equal("more info", ex.Info);
}
public void exception_helper_resource_can_be_in_custom_location()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture), "Kent.Boogaart.HelperTrinity.UnitTests.ExceptionHelper.Subfolder.CustomExceptionHelperResource.xml");
var ex = Assert.Throws<InvalidOperationException>(() => exceptionHelper.ResolveAndThrowIf(true, "anException"));
Assert.Equal("Here is the message.", ex.Message);
}
public void resolve_throws_if_type_is_not_an_exception()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var ex = Assert.Throws<InvalidOperationException>(() => exceptionHelper.Resolve("typeNotException"));
Assert.Equal("Type 'System.DateTime' for exception with key 'typeNotException' does not inherit from 'System.Exception'", ex.Message);
}
/// <summary>
/// Gets an object that can iterate through information of substrings in this string (or a part of this string)
/// that are delimited by the specified separator.
/// </summary>
/// <param name="str">This string instance.</param>
/// <param name="separator">A string instance that delimits the substrings in the current string instance.</param>
/// <param name="startIndex">The zero-based position indicating where the search for separators starts.</param>
/// <param name="removeEmptyEntries"><c>true</c> if the returned enumerator should ignore empty substrings; otherwise <c>false</c>.</param>
/// <param name="trim">Indicates whether the returned substrings are trimmed.
/// <para>NOTE that if <paramref name="removeEmptyEntries" /> is set <c>true</c>, then a substring containing only white spaces will not be returned;
/// for example, in this case "ab,, ,,cd" split by dual-comma ",," is "ab" and "cd".</para></param>
/// <returns>
/// An object that can iterate through information of substrings in the current string instance (or a part of the current string instance)
/// that are delimited by the specified separator.
/// </returns>
public static IEnumerator <StringSplitResult> GetSplitEnumeratorEx(this string str, string separator, int startIndex = 0, bool removeEmptyEntries = false, bool trim = false)
{
ExceptionHelper.NonNegativeArgumentRequired("startIndex", startIndex);
return(_innerGetSplitEnumeratorEx(str, separator, startIndex, str.Length, removeEmptyEntries, trim));
}
public LocalizedFileNotFoundException(string filename, string key = "Exceptions.FileNotFoundException", string defaultMessage = null, object parameters = null, Exception innerException = null)
: base(defaultMessage, innerException)
{
Localization = new ExceptionHelper(this, key, defaultMessage, parameters);
Localization.AddParameter("FileName", filename);
}
public void resolve_throws_if_key_is_not_found()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var ex = Assert.Throws<InvalidOperationException>(() => exceptionHelper.Resolve("invalidKey"));
Assert.Equal("The exception details for key 'invalidKey' could not be found at /exceptionHelper/exceptionGroup[@type'Kent.Boogaart.HelperTrinity.UnitTests.ExceptionHelperFixture']/exception[@key='invalidKey'].", ex.Message);
}
/// <summary>
/// Gets an object that can iterate through groups of substrings in this string instance (or a part of the current string instance according to <paramref name="startIndex"/> and <paramref name="length"/>) that are delimited by the primary and secondary Unicode separators outside quotes.
/// </summary>
/// <param name="str">This string instance.</param>
/// <param name="primarySeparator">A primary spearator delimits substring groups, for example, in "123,456;abc,def" which represent substring arrays { {"123", "456"}, {"abc", "def"} }, the semi-comma ';' is the primary separator.</param>
/// <param name="secondarySeparator">A secondary separator delimits substrings in a group, for example, in "123,456;abc,def" which represent substring arrays { {"123", "456"}, {"abc", "def"} }, the comma ',' is the secondary separator.</param>
/// <param name="startIndex">The zero-based position indicating where the search for separators starts.</param>
/// <param name="length">A positive value indicating the number of characters to search starting from the position specified by <paramref name="startIndex" />.</param>
/// <param name="leftQuotes">Specifies an array of Unicode characters as the left quotes.
/// A left quote of an index of this array corresponds to the right quote of that index of the array specified by <paramref name="rightQuotes" />.</param>
/// <param name="rightQuotes">Specifies an array of Unicode characters as the right quotes.
/// A right quote of an index of this array corresponds to the left quote of that index of the array specified by <paramref name="leftQuotes" />.</param>
/// <param name="removeEmptyEntries"><c>true</c> if empty strings should be ignored; otherwise <c>false</c>.</param>
/// <param name="removeEmptyGroups"><c>true</c> if empty substring groups should be ignored by the returned enumerator; otherwise, <c>false</c>.</param>
/// <param name="trim">Indicates whether the returned substrings are trimmed.
/// <para>NOTE that if <paramref name="removeEmptyEntries" /> is set <c>true</c>, then a substring containing only white spaces will be ignored by the returned enumerator;
/// for example, in this case "ab, ,cd" split by comma ',' is "ab" and "cd".</para></param>
/// <param name="keepQuotes"><c>true</c> if the quotes should be included in each returned substring; otherwise, <c>false</c>.</param>
/// <returns>An object that can iterate through groups of substrings in this string instance (or a part of the current string instance) that are delimited by the primary and secondary separators.</returns>
public static IEnumerator <string[]> GetDoubleSplitEnumeratorWithQuotes(this string str, char primarySeparator, char secondarySeparator, int startIndex, int length, char[] leftQuotes, char[] rightQuotes, bool removeEmptyEntries = false, bool removeEmptyGroups = false, bool trim = false, bool keepQuotes = true)
{
ExceptionHelper.ForwardCheckStartIndexAndLength(startIndex, length, str.Length);
return(new _innerDoubleSplitEnumerator02(str, startIndex, str.Length, c1 => c1 == primarySeparator, c2 => c2 == secondarySeparator, leftQuotes, rightQuotes, removeEmptyEntries, removeEmptyGroups, trim, keepQuotes));
}
/// <summary>
/// Gets an object that can iterate through groups of substrings in this string instance (or a part of the current string instance according to <paramref name="startIndex"/> and <paramref name="length"/>) that are delimited by Unicode characters outside quotes and satisfying the specified primary predicate and secondary predicate.
/// </summary>
/// <param name="str">This string instance.</param>
/// <param name="primaryPredicate">A function used to test each Unicode character of the current string. If a character passes this predicate, it returns a non-negative integer as the separator's index; otherwise, this function must return -1. Any character satisfying this predicate will be used as the primary separator. A primary spearator delimits substring arrays, for example, in "123,456;abc,def" which represent substring arrays { {"123", "456"}, {"abc", "def"} }, the semi-comma ';' is the primary separator.</param>
/// <param name="secondaryPredicate">A function used to test each Unicode character of the current string. If a character passes this predicate, it returns a non-negative integer as the separator's index; otherwise, this function must return -1. Any character satisfying this predicate will be used as the secondary separator. A secondary separator delimits substrings in an array, for example, in "123,456;abc,def" which represent substring arrays { {"123", "456"}, {"abc", "def"} }, the comma ',' is the secondary separator.</param>
/// <param name="startIndex">The zero-based position indicating where the search for separators starts.</param>
/// <param name="length">A positive value indicating the number of characters to search starting from the position specified by <paramref name="startIndex" />.</param>
/// <param name="leftQuotes">Specifies an array of Unicode characters as the left quotes.
/// A left quote of an index of this array corresponds to the right quote of that index of the array specified by <paramref name="rightQuotes" />.</param>
/// <param name="rightQuotes">Specifies an array of Unicode characters as the right quotes.
/// A right quote of an index of this array corresponds to the left quote of that index of the array specified by <paramref name="leftQuotes" />.</param>
/// <param name="removeEmptyEntries"><c>true</c> if empty strings should be ignored; otherwise <c>false</c>.</param>
/// <param name="removeEmptyGroups"><c>true</c> if empty substring groups should be ignored by the returned enumerator; otherwise, <c>false</c>.</param>
/// <param name="trim">Indicates whether the returned substrings are trimmed.
/// <para>NOTE that if <paramref name="removeEmptyEntries" /> is set <c>true</c>, then a substring containing only white spaces will be ignored by the returned enumerator;
/// for example, in this case "ab, ,cd" split by comma ',' is "ab" and "cd".</para></param>
/// <param name="keepQuotes"><c>true</c> if the quotes should be included in each returned substring; otherwise, <c>false</c>.</param>
/// <returns>An object that can iterate through groups of substrings in this string instance (or a part of the current string instance) that are delimited by Unicode characters satisfying the specified two predicates.</returns>
public static IEnumerator <string[]> GetDoubleSplitEnumeratorWithQuotes(this string str, Func <char, bool> primaryPredicate, Func <char, bool> secondaryPredicate, int startIndex, int length, char[] leftQuotes, char[] rightQuotes, bool removeEmptyEntries = false, bool removeEmptyGroups = false, bool trim = false, bool keepQuotes = true)
{
var endIndex = ExceptionHelper.ForwardCheckStartIndexAndLength(startIndex, length, str.Length);
return(new _innerDoubleSplitEnumerator02(str, startIndex, endIndex, primaryPredicate, secondaryPredicate, leftQuotes, rightQuotes, removeEmptyEntries, removeEmptyGroups, trim, keepQuotes));
}
/// <summary>
/// Gets an object that can iterate through groups of substrings in this string instance (or a part of the current string instance according to <paramref name="startIndex"/>) that are delimited by Unicode characters outside quotes and satisfying the specified primary predicate and secondary predicate.
/// </summary>
/// <param name="str">This string instance.</param>
/// <param name="primaryPredicate">A function used to test each Unicode character of the current string. If a character passes this predicate, it returns a non-negative integer as the separator's index; otherwise, this function must return -1. Any character satisfying this predicate will be used as the primary separator. A primary spearator delimits substring arrays, for example, in "123,456;abc,def" which represent substring arrays { {"123", "456"}, {"abc", "def"} }, the semi-comma ';' is the primary separator.</param>
/// <param name="secondaryPredicate">A function used to test each Unicode character of the current string. If a character passes this predicate, it returns a non-negative integer as the separator's index; otherwise, this function must return -1. Any character satisfying this predicate will be used as the secondary separator. A secondary separator delimits substrings in an array, for example, in "123,456;abc,def" which represent substring arrays { {"123", "456"}, {"abc", "def"} }, the comma ',' is the secondary separator.</param>
/// <param name="startIndex">The zero-based position indicating where the search for separators starts.</param>
/// <param name="leftQuote">The left quote paired by <paramref name="rightQuote"/> to escape separators.</param>
/// <param name="rightQuote">The right quote paired by <paramref name="leftQuote"/> to escape separators.</param>
/// <param name="removeEmptyEntries"><c>true</c> if empty strings should be ignored; otherwise <c>false</c>.</param>
/// <param name="removeEmptyGroups"><c>true</c> if empty substring groups should be ignored by the returned enumerator; otherwise, <c>false</c>.</param>
/// <param name="trim">Indicates whether the returned substrings are trimmed.
/// <para>NOTE that if <paramref name="removeEmptyEntries" /> is set <c>true</c>, then a substring containing only white spaces will be ignored by the returned enumerator;
/// for example, in this case "ab, ,cd" split by comma ',' is "ab" and "cd".</para></param>
/// <param name="keepQuotes"><c>true</c> if the quotes should be included in each returned substring; otherwise, <c>false</c>.</param>
/// <returns>An object that can iterate through groups of substrings in this string instance (or a part of the current string instance) that are delimited by Unicode characters satisfying the specified two predicates.</returns>
public static IEnumerator <string[]> GetDoubleSplitEnumeratorWithQuotes(this string str, Func <char, bool> primaryPredicate, Func <char, bool> secondaryPredicate, int startIndex, char leftQuote = '{', char rightQuote = '}', bool removeEmptyEntries = false, bool removeEmptyGroups = false, bool trim = false, bool keepQuotes = true)
{
ExceptionHelper.NonNegativeArgumentRequired("startIndex", startIndex);
return(new _innerDoubleSplitEnumerator01(str, startIndex, str.Length, primaryPredicate, secondaryPredicate, leftQuote, rightQuote, removeEmptyEntries, removeEmptyGroups, trim, keepQuotes));
}
static void Main(string[] args)
{
#region Using static - ex1
EncryptUtil.EncryptFiles();
#endregion
#region nameOf - ex1
//var customer = new Customer("John D.");
//customer.FullName = "John Denver";
//customer.FullName = "Bob C.";
#endregion
#region nameOf - ex2
// WpfApp1
#endregion
#region String Interpolation - ex1
// 1. -> PersonUnitTests.cs
#endregion
#region String Interpolation - ex2
var p = new Person("", "John");
Console.WriteLine($"p.FullName: {p.FullName}");
#endregion
#region Null Conditional Operator - ex1 FooBar
FooBar nullSample = null;
#region 1
if (nullSample != null && nullSample.Foo != null && nullSample.Foo.Bar != null)
{
nullSample.Foo.Bar.SayBar();
}
#endregion
#region 2
nullSample?.Foo?.Bar?.SayBar();
#endregion
#endregion
#region Null Conditional Operator - ex2
// Customer.cs - Null-Cond Operator - ex2
#endregion
#region Null Conditional Operator - ex3
var points = new[]
{
new Point() {X = 3100, Y = 3200 },
null
};
//Console.WriteLine(points[0]?.ToString());
//Console.WriteLine(points[1]?.ToString());
#endregion
#region Null Conditional Operator - ex 4
//Point[] points2 = null;
//Point[] points3 = new Point[] { }; // !
//Console.WriteLine(points2[0]?.ToString());
#endregion
#region AutoProperty - ex1
//var company1 = Company.NewCompany1;
#endregion
#region Expression Bodied Methods - ex1
//var company2 = Company.NewCompany2();
#endregion
#region Expression Bodied Methods - ex2
//var company3 = new Company("Coca-Cola", "Iasi");
//Console.WriteLine(company3.ToString());
#endregion
#region Expression Bodied Methods - ex3 companes
var companies = new Companies();
companies.Add(new Company("c1", "Iasi"));
companies.Add(new Company("c2", "Cluj"));
companies.Add(new Company("c3", "Bucuresti"));
//Console.WriteLine($"expression bodied methods - ex3, company: {companies["c3"]}");
#endregion
#region DictionaryInitializer - ex1
var dicHelper = new DictionaryHelper();
#endregion
#region DictionaryInitializer - ex3
var dic = dicHelper.Ex3();
//Console.WriteLine("ex3 - dictionary initializer");
//Console.WriteLine(dic[10]);
// ! Console.WriteLine(dic[2]);
#endregion
#region DictionaryInitializer - ex4
var list = dicHelper.Ex4();
Console.WriteLine(list[4]);
#endregion
#region ExceptionImprov - ex1
var wHandler = new ExceptionHelper();
wHandler.ReadDataFromGoogle();
#endregion
#region ExceptionImprov - ex2 await
var wHandler2 = new ExceptionHelper();
//wHandler2.ReadDataFromGoogle2();
#endregion
#region ExceptionImprov - ex3
//wHandler.ShowCompanyDetails();
#endregion
Console.WriteLine("");
}
public LocalizedArgumentNullException(string paramName, string key = "Exceptions.ArgumentNullException", string defaultMessage = null, object parameters = null, Exception innerException = null)
: base(paramName, defaultMessage)
{
Localization = new ExceptionHelper(this, key, defaultMessage, parameters);
Localization.AddParameter("ParamName", paramName);
}
/// <summary>
/// Reports the zero-based index of the last occurrence of the specified <paramref name="value" /> outside quotes in this string. The search starts from <pararef name="startIndex" /> and advances towards the beginning of the current string.
/// </summary>
/// <param name="str">This string instance.</param>
/// <param name="value">The substring to seek.</param>
/// <param name="startIndex">The search starting position.</param>
/// <param name="primaryLeftQuotes">Specifies an array of Unicode characters as the primary left quotes. A left quote of an index of this array corresponds to the right quote of that index of the array specified by <paramref name="primaryRightQuote" />.</param>
/// <param name="primaryRightQuotes">Specifies an array of Unicode characters as the primary right quotes. A right quote of an index of this array corresponds to the left quote of that index of the array specified by <paramref name="primaryLeftQuote" />.</param>
/// <param name="secondaryLeftQuotes">Specifies an array of Unicode characters as the secondary left quotes. A left quote of an index of this array corresponds to the right quote of that index of the array specified by <paramref name="secondaryRightQuotes" />. Secondary quotes are escaped when they are inside a pair of primary quotes.</param>
/// <param name="secondaryRightQuotes">Specifies an array of Unicode characters as the secondary right quotes. A right quote of an index of this array corresponds to the left quote of that index of the array specified by <paramref name="secondaryLeftQuotes" />. Secondary quotes are escaped when they are inside a pair of primary quotes.</param>
/// <param name="comparisonType">One of the enumeration values that specifies the rules for the search of <paramref name="value" />.</param>
/// <returns>
/// The zero-based index position of the last occurrence of <paramref name="value" /> if it is found outside quotes, or -1 if it is not.
/// </returns>
/// <exception cref="System.FormatException">Occurs when there is quote mismatch in the string instance.</exception>
public static int LastIndexOfWithQuotes(this string str, string value, int startIndex, char[] primaryLeftQuotes, char[] primaryRightQuotes, char[] secondaryLeftQuotes, char[] secondaryRightQuotes,
StringComparison comparisonType = StringComparison.Ordinal)
{
ExceptionHelper.ArgumentRangeRequired("startIndex", startIndex, 0, true, str.Length - 1, true);
return(_innerLastIndexOfWithQuotes(str, value, startIndex, -1, primaryLeftQuotes, primaryRightQuotes, secondaryLeftQuotes, secondaryRightQuotes, comparisonType));
}
public void resolve_allows_formatting_of_exception_message()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var ex = exceptionHelper.Resolve("withMessageArgs", "hello", 12);
Assert.Equal("Here is the message with argument (hello) or two (12).", ex.Message);
}
/// <summary>
/// Gets an object that can iterate through groups of substrings in this string instance (or a part of the current string instance according to <paramref name="startIndex"/>) that are delimited by the primary and secondary Unicode separators outside quotes.
/// </summary>
/// <param name="str">This string instance.</param>
/// <param name="primarySeparator">A primary spearator delimits substring groups, for example, in "123,456;abc,def" which represent substring arrays { {"123", "456"}, {"abc", "def"} }, the semi-comma ';' is the primary separator.</param>
/// <param name="secondarySeparator">A secondary separator delimits substrings in a group, for example, in "123,456;abc,def" which represent substring arrays { {"123", "456"}, {"abc", "def"} }, the comma ',' is the secondary separator.</param>
/// <param name="startIndex">The zero-based position indicating where the search for separators starts.</param>
/// <param name="leftQuotes">Specifies an array of Unicode characters as the left quotes.
/// A left quote of an index of this array corresponds to the right quote of that index of the array specified by <paramref name="rightQuotes" />.</param>
/// <param name="rightQuotes">Specifies an array of Unicode characters as the right quotes.
/// A right quote of an index of this array corresponds to the left quote of that index of the array specified by <paramref name="leftQuotes" />.</param>
/// <param name="removeEmptyEntries"><c>true</c> if empty strings should be ignored; otherwise <c>false</c>.</param>
/// <param name="removeEmptyGroups"><c>true</c> if empty substring groups should be ignored by the returned enumerator; otherwise, <c>false</c>.</param>
/// <param name="trim">Indicates whether the returned substrings are trimmed.
/// <para>NOTE that if <paramref name="removeEmptyEntries" /> is set <c>true</c>, then a substring containing only white spaces will be ignored by the returned enumerator;
/// for example, in this case "ab, ,cd" split by comma ',' is "ab" and "cd".</para></param>
/// <param name="keepQuotes"><c>true</c> if the quotes should be included in each returned substring; otherwise, <c>false</c>.</param>
/// <returns>An object that can iterate through groups of substrings in this string instance (or a part of the current string instance) that are delimited by the primary and secondary separators.</returns>
public static IEnumerator <string[]> GetDoubleSplitEnumeratorWithQuotes(this string str, char primarySeparator, char secondarySeparator, int startIndex, char[] leftQuotes, char[] rightQuotes, bool removeEmptyEntries = false, bool removeEmptyGroups = false, bool trim = false, bool keepQuotes = true)
{
ExceptionHelper.NonNegativeArgumentRequired("startIndex", startIndex);
return(new _innerDoubleSplitEnumerator02(str, startIndex, str.Length, c1 => c1 == primarySeparator, c2 => c2 == secondarySeparator, leftQuotes, rightQuotes, removeEmptyEntries, removeEmptyGroups, trim, keepQuotes));
}
public InnerParserException(string construct, int pos, string key, string defaultMessage, object parameters)
{
Localization = new ExceptionHelper(this, key, defaultMessage, parameters);
Pos = pos;
Construct = construct;
}
public void resolve_throws_if_type_attribute_is_not_found()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var ex = Assert.Throws<InvalidOperationException>(() => exceptionHelper.Resolve("noTypeAttribute"));
Assert.Equal("The 'type' attribute could not be found for exception with key 'noTypeAttribute'", ex.Message);
}
public void resolve_throws_if_no_constructor_could_be_found()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var ex = Assert.Throws<InvalidOperationException>(() => exceptionHelper.Resolve("noConstructorFound"));
Assert.Equal("An appropriate constructor could not be found for exception type 'Kent.Boogaart.HelperTrinity.UnitTests.ExceptionHelperFixture+TestException, for exception with key 'noConstructorFound'", ex.Message);
}
public void resolve_throws_if_type_could_not_be_loaded()
{
var exceptionHelper = new ExceptionHelper(typeof(ExceptionHelperFixture));
var ex = Assert.Throws<InvalidOperationException>(() => exceptionHelper.Resolve("typeCouldNotBeLoaded"));
Assert.Equal("Type 'Foo.Bar.Wont.Load, Anywhere' could not be loaded for exception with key 'typeCouldNotBeLoaded'", ex.Message);
}
public LocalizedKeyNotFoundException(string key = "Exceptions.KeyNotFoundException", string defaultMessage = null, object parameters = null, Exception innerException = null)
: base(defaultMessage, innerException)
{
Localization = new ExceptionHelper(this, key, defaultMessage, parameters);
}
/// <summary>
/// Gets an object that can iterate through information of substrings in this string (or a part of this string)
/// that are delimited by the specified separator.
/// </summary>
/// <param name="str">This string instance.</param>
/// <param name="separator">A string instance that delimits the substrings in the current string instance.</param>
/// <param name="startIndex">The zero-based position indicating where the search for separators starts.</param>
/// <param name="length">A positive value indicating the number of characters to search starting from the position specified by <paramref name="startIndex" />.</param>
/// <param name="removeEmptyEntries"><c>true</c> if the returned enumerator should ignore empty substrings; otherwise <c>false</c>.</param>
/// <param name="trim">Indicates whether the returned substrings are trimmed.
/// <para>NOTE that if <paramref name="removeEmptyEntries" /> is set <c>true</c>, then a substring containing only white spaces will not be returned;
/// for example, in this case "ab,, ,,cd" split by dual-comma ",," is "ab" and "cd".</para></param>
/// <returns>
/// An object that can iterate through information of substrings in the current string instance (or a part of the current string instance)
/// that are delimited by the specified separator.
/// </returns>
public static IEnumerator <StringSplitResult> GetSplitEnumeratorEx(this string str, string separator, int startIndex, int length, bool removeEmptyEntries = false, bool trim = false)
{
var endIndex = ExceptionHelper.ForwardCheckStartIndexAndLength(startIndex, length, str.Length);
return(_innerGetSplitEnumeratorEx(str, separator, startIndex, endIndex, removeEmptyEntries, trim));
}
