/// <summary> /// ... /// </summary> public ListViewItemComparer() { m_UseTagObject = false; m_SortColumn = 0; m_SortOrder = SortOrder.None; m_Comparer = new CaseInsensitiveComparer(); }
public static void TestCtor_CultureInfo_Compare(object a, object b, int expected) { var cultureNames = new string[] { "cs-CZ","da-DK","de-DE","el-GR","en-US", "es-ES","fi-FI","fr-FR","hu-HU","it-IT", "ja-JP","ko-KR","nb-NO","nl-NL","pl-PL", "pt-BR","pt-PT","ru-RU","sv-SE","tr-TR", "zh-CN","zh-HK","zh-TW" }; foreach (string cultureName in cultureNames) { CultureInfo culture; try { culture = new CultureInfo(cultureName); } catch (CultureNotFoundException) { continue; } var comparer = new CaseInsensitiveComparer(culture); Assert.Equal(expected, Helpers.NormalizeCompare(comparer.Compare(a, b))); } }
public ListViewColumnSorter() { ColumnToSort = 0; OrderOfSort = SortOrder.None; ObjectCompare = new CaseInsensitiveComparer(); }
public bool runTest() { Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer); String strLoc = "Loc_000oo"; String strValue = String.Empty; int iCountErrors = 0; int iCountTestcases = 0; CaseInsensitiveComparer comparer; try { strLoc = "Loc_384sdg"; iCountTestcases++; comparer = new CaseInsensitiveComparer(); if(comparer.Compare("hello", "HELLO")!=0) { iCountErrors++; Console.WriteLine( "Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "HELLO")); } if(comparer.Compare("hello", "hello")!=0) { iCountErrors++; Console.WriteLine( "Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "hello")); } if(comparer.Compare("hello", "mello")==0) { iCountErrors++; Console.WriteLine( "Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "mello")); } iCountTestcases++; if(comparer.Compare(5, 5)!=0) { iCountErrors++; Console.WriteLine( "Err_347tsfg! wrong value returned"); } if(comparer.Compare(5, 10)==0) { iCountErrors++; Console.WriteLine( "Err_973425sdg! wrong value returned"); } } catch (Exception exc_general ) { ++iCountErrors; Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy! strLoc=="+ strLoc +", exc_general=="+exc_general.ToString()); } if ( iCountErrors == 0 ) { Console.WriteLine( "paSs. "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString()); return true; } else { Console.WriteLine("FAiL! "+s_strTFName+" ,inCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums ); return false; } }
/// <summary> /// Class constructor. Initializes various elements /// </summary> public ListViewColumnSorter() { // Initialize the column to '0' ColumnToSort = 0; // Initialize the sort order to 'none' OrderOfSort = SortOrder.None; // Initialize the CaseInsensitiveComparer object ObjectCompare = new CaseInsensitiveComparer(); }
public IEnumerable<string> GetForAutocomplete(string prefixText, int count) { var comparer = new CaseInsensitiveComparer(); var remaining = count; var locations = _context.Locations.Where(p => p.Description.Contains(prefixText)) .OrderBy(p => p.Description.ToLower().IndexOf(prefixText.ToLower())) .Take(remaining).Select(p => p.Description).ToList().Distinct(comparer); var list = locations.OrderBy(p => p.ToLower().IndexOf(prefixText.ToLower())).Distinct(comparer).ToList(); if (locations.Count() == remaining) return list; remaining -= locations.Count(); var regions = _context.Regions.Where(p => p.Description.Contains(prefixText)) .OrderBy(p => p.Description.ToLower().IndexOf(prefixText.ToLower())) .Take(remaining).Select(p => p.Description).ToList().Distinct(comparer); list = list.Concat(regions).OrderBy(p => p.ToLower().IndexOf(prefixText.ToLower())).Distinct(comparer).ToList(); return list; }
public myCultureComparer(CultureInfo myCulture) { myComparer = new CaseInsensitiveComparer(myCulture); }
public ListViewColumnSorter() { _intColumnToSort = 0; _objOrderOfSort = SortOrder.None; _objObjectCompare = new CaseInsensitiveComparer(); }
public bool runTest() { //////////// Global Variables used for all tests int iCountErrors = 0; int iCountTestcases = 0; CaseInsensitiveComparer comparer; try { ///////////////////////// START TESTS //////////////////////////// /////////////////////////////////////////////////////////////////// //[]vanilla - the ctor simply sets the CompareInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo //There is no easy way to test this other than make sure that string comparison is case insensitive iCountTestcases++; iCountTestcases++; iCountTestcases++; var somePopularCultureNames = new string[] { "cs-CZ", "da-DK", "de-DE", "el-GR", "en-US", "es-ES", "fi-FI", "fr-FR", "hu-HU", "it-IT", "ja-JP", "ko-KR", "nb-NO", "nl-NL", "pl-PL", "pt-BR", "pt-PT", "ru-RU", "sv-SE", "tr-TR", "zh-CN", "zh-HK", "zh-TW" }; foreach (string cultureName in somePopularCultureNames) { CultureInfo culture = new CultureInfo(cultureName); if (culture == null) { continue; } comparer = new CaseInsensitiveComparer(culture); if (comparer.Compare("hello", "HELLO") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("hello", "HELLO"), culture.Name); } //same strings should work ok if (comparer.Compare("hello", "hello") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("hello", "hello"), culture.Name); } //different strings should return false if (comparer.Compare("hello", "mello") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", "non-zero", comparer.Compare("hello", "mello"), culture.Name); } // "tr-TR" = "Turkish (Turkey)" // Turkish has lower-case and upper-case version of the dotted "i", so the upper case of "i" (U+0069) isn't "I" (U+0049), but rather "İ" (U+0130). if (culture.Name != "tr-TR") { if (comparer.Compare("file", "FILE") != 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("file", "FILE"), culture.Name); } } else { if (comparer.Compare("file", "FILE") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", "non-zero", comparer.Compare("file", "FILE"), culture.Name); } } //[]Other data types should work as is iCountTestcases++; if (comparer.Compare(5, 5) != 0) { iCountErrors++; Console.WriteLine("Err_347tsfg! wrong value returned"); } if (comparer.Compare(5, 10) == 0) { iCountErrors++; Console.WriteLine("Err_973425sdg! wrong value returned"); } } //[]parm test iCountTestcases++; try { comparer = new CaseInsensitiveComparer(null); iCountErrors++; Console.WriteLine("Err_9745sdg! Exception not thrown"); } catch (ArgumentNullException) { } catch (Exception ex) { iCountErrors++; Console.WriteLine("Err_9745sdg! Unexpected exception thrown, " + ex.GetType().Name); } /////////////////////////////////////////////////////////////////// /////////////////////////// END TESTS ///////////////////////////// } catch (Exception exc_general) { ++iCountErrors; Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString()); } //// Finish Diagnostics if (iCountErrors == 0) { return(true); } else { return(false); } }
/// <summary> /// Class constructor. Initializes various elements /// </summary> public ListViewColumnSorter() { SortColumn = 0; Order = SortOrder.None; _objectCompare = new CaseInsensitiveComparer(); }
public ListViewColumnSorter() { ColumnToSort = 0; OrderOfSort = SortOrder.None; ciCompare = new CaseInsensitiveComparer(); }
/// <summary> /// Constructor /// </summary> public ListViewColumnSorter() { ColumnToSort = 0; OrderOfSort = SortOrder.Ascending; ObjectCompare = new CaseInsensitiveComparer(); }
public static void Ctor_Empty_Compare(object a, object b, int expected) { CaseInsensitiveComparer comparer = new CaseInsensitiveComparer(); Assert.Equal(expected, Math.Sign(comparer.Compare(a, b))); }
public static void TestCtor_CultureInfo_Compare_TurkishI() { var cultureNames = new string[] { "cs-CZ","da-DK","de-DE","el-GR","en-US", "es-ES","fi-FI","fr-FR","hu-HU","it-IT", "ja-JP","ko-KR","nb-NO","nl-NL","pl-PL", "pt-BR","pt-PT","ru-RU","sv-SE","tr-TR", "zh-CN","zh-HK","zh-TW" }; foreach (string cultureName in cultureNames) { CultureInfo culture; try { culture = new CultureInfo(cultureName); } catch (CultureNotFoundException) { continue; } var comparer = new CaseInsensitiveComparer(culture); // Turkish has lower-case and upper-case version of the dotted "i", so the upper case of "i" (U+0069) isn't "I" (U+0049) // but rather "İ" (U+0130) if (culture.Name == "tr-TR") { Assert.Equal(1, comparer.Compare("file", "FILE")); } else { Assert.Equal(0, comparer.Compare("file", "FILE")); } } }
public MachineRecordComparer() { ColumnToSort = 0; OrderOfSort = SortOrder.None; ObjectCompare = new CaseInsensitiveComparer(); }
public static void TestCtor_Empty_Compare(object a, object b, int expected) { CaseInsensitiveComparer comparer = new CaseInsensitiveComparer(); Assert.Equal(expected, Helpers.NormalizeCompare(comparer.Compare(a, b))); }
public int Compare(string x, string y) { CaseInsensitiveComparer comparer = new CaseInsensitiveComparer(); return(comparer.Compare(x, y)); }
public bool runTest() { Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer); String strLoc = "Loc_000oo"; String strValue = String.Empty; int iCountErrors = 0; int iCountTestcases = 0; CaseInsensitiveComparer comparer; CultureInfo[] cultures; try { strLoc = "Loc_384sdg"; iCountTestcases++; iCountTestcases++; iCountTestcases++; cultures = CultureInfo.GetCultures(CultureTypes.AllCultures); for(int i=0; i<cultures.Length; i++) { comparer = new CaseInsensitiveComparer(cultures[i]); if(comparer.Compare("hello", "HELLO")!=0) { iCountErrors++; Console.WriteLine( "Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "HELLO")); } if(comparer.Compare("hello", "hello")!=0) { iCountErrors++; Console.WriteLine( "Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "hello")); } if(comparer.Compare("hello", "mello")==0) { iCountErrors++; Console.WriteLine( "Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "mello")); } iCountTestcases++; if(comparer.Compare(5, 5)!=0) { iCountErrors++; Console.WriteLine( "Err_347tsfg! wrong value returned"); } if(comparer.Compare(5, 10)==0) { iCountErrors++; Console.WriteLine( "Err_973425sdg! wrong value returned"); } } strLoc = "Loc_dfyusg"; iCountTestcases++; try { comparer = new CaseInsensitiveComparer(null); iCountErrors++; Console.WriteLine( "Err_9745sdg! Exception not thrown"); } catch(ArgumentNullException) { } catch(Exception ex) { iCountErrors++; Console.WriteLine( "Err_9745sdg! Unexpected exception thrown, " + ex.GetType().Name); } } catch (Exception exc_general ) { ++iCountErrors; Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy! strLoc=="+ strLoc +", exc_general=="+exc_general.ToString()); } if ( iCountErrors == 0 ) { Console.WriteLine( "paSs. "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString()); return true; } else { Console.WriteLine("FAiL! "+s_strTFName+" ,inCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums ); return false; } }
public ListViewColumnSorter() { this.ColumnToSort = 0; this.ObjectCompare = new CaseInsensitiveComparer(); }
public ListViewItemComparer() { ColumnaAOrdenar = 0; Orden = SortOrder.None; ObjectCompare = new CaseInsensitiveComparer(); }
public void SortByColumn(int column, SortOrder sortOrder, bool isNumeric) { // Do nothing if column is outside bounds if (column < 0 || column >= Columns.Count) { return; } if (!colComparer.ContainsKey(column)) { if (isNumeric) { colComparer.Add(column, new ListViewColumnSorterNumeric()); } else { colComparer.Add(column, new CaseInsensitiveComparer()); } } else { if (isNumeric && colComparer[column] is CaseInsensitiveComparer) { colComparer[column] = new ListViewColumnSorterNumeric(); } else if (!isNumeric && colComparer[column] is ListViewColumnSorterNumeric) { colComparer[column] = new CaseInsensitiveComparer(); } } colSorter.Comparer = colComparer[column]; // Determine if clicked column is already the column that is being sorted. if (column == colSorter.SortColumn) { // If not selected sort order then order like if clicked on the column if (sortOrder == SortOrder.None) { // Reverse the current sort direction for this column. if (colSorter.Order == SortOrder.Ascending) { colSorter.Order = SortOrder.Descending; } else { colSorter.Order = SortOrder.Ascending; } } else { colSorter.Order = sortOrder; } } else { // Set the column number that is to be sorted; default to ascending. colSorter.SortColumn = column; colSorter.Order = sortOrder == SortOrder.None ? SortOrder.Ascending : sortOrder; } // Perform the sort with these new sort options. this.Sort(); }
public ListViewItemComparer(int column) { col = column; OrderOfSort = SortOrder.None; ObjectCompare = new CaseInsensitiveComparer(); }
int IComparer <ListItem> .Compare(ListItem x, ListItem y) { CaseInsensitiveComparer c = new CaseInsensitiveComparer(); return(c.Compare(x.Text, y.Text)); }
public bool runTest() { Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer); String strLoc = "Loc_000oo"; String strValue = String.Empty; int iCountErrors = 0; int iCountTestcases = 0; CaseInsensitiveComparer comparer; CaseInsensitiveComparer defaultComparer; CultureInfo[] cultures; try { strLoc = "Loc_384sdg"; iCountTestcases++; iCountTestcases++; cultures = CultureInfo.GetCultures(CultureTypes.AllCultures); for (int i = 0; i < cultures.Length; i++) { comparer = new CaseInsensitiveComparer(cultures[i]); defaultComparer = CaseInsensitiveComparer.Default; if (defaultComparer.Compare("hello", "HELLO") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "HELLO")); } if (defaultComparer.Compare("hello", "hello") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "hello")); } if (defaultComparer.Compare("hello", "mello") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "mello")); } iCountTestcases++; if (defaultComparer.Compare(5, 5) != 0) { iCountErrors++; Console.WriteLine("Err_347tsfg! wrong value returned"); } if (defaultComparer.Compare(5, 10) == 0) { iCountErrors++; Console.WriteLine("Err_973425sdg! wrong value returned"); } } } catch (Exception exc_general) { ++iCountErrors; Console.WriteLine(s_strTFAbbrev + " : Error Err_8888yyy! strLoc==" + strLoc + ", exc_general==" + exc_general.ToString()); } if (iCountErrors == 0) { Console.WriteLine("paSs. " + s_strTFName + " ,iCountTestcases==" + iCountTestcases.ToString()); return(true); } else { Console.WriteLine("FAiL! " + s_strTFName + " ,inCountErrors==" + iCountErrors.ToString() + " , BugNums?: " + s_strActiveBugNums); return(false); } }
public bool runTest() { //////////// Global Variables used for all tests int iCountErrors = 0; int iCountTestcases = 0; CaseInsensitiveComparer comparer; try { ///////////////////////// START TESTS //////////////////////////// //[]vanila - the ctor simply sets the ComapreInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo //There is no easy way to test this other than make sure that string comparison is case insenstive iCountTestcases++; comparer = new CaseInsensitiveComparer(); if (comparer.Compare("hello", "HELLO") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "HELLO")); } //same strings should work ok if (comparer.Compare("hello", "hello") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "hello")); } //different strings should return false if (comparer.Compare("hello", "mello") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "mello")); } //[]Other data types should work as is iCountTestcases++; if (comparer.Compare(5, 5) != 0) { iCountErrors++; Console.WriteLine("Err_347tsfg! wrong value returned"); } if (comparer.Compare(5, 10) == 0) { iCountErrors++; Console.WriteLine("Err_973425sdg! wrong value returned"); } /////////////////////////////////////////////////////////////////// /////////////////////////// END TESTS ///////////////////////////// } catch (Exception exc_general) { ++iCountErrors; Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString()); } //// Finish Diagnostics if (iCountErrors == 0) { return(true); } else { return(false); } }
private static void InitHash() { #if NET_2_0 StringComparer comparer = StringComparer.InvariantCultureIgnoreCase; directivesHash = new Hashtable(comparer); #else CaseInsensitiveHashCodeProvider provider = new CaseInsensitiveHashCodeProvider(CultureInfo.InvariantCulture); CaseInsensitiveComparer comparer = new CaseInsensitiveComparer(CultureInfo.InvariantCulture); directivesHash = new Hashtable(provider, comparer); #endif // Use Hashtable 'cause is O(1) in Contains (ArrayList is O(n)) #if NET_2_0 Hashtable valid_attributes = new Hashtable(comparer); #else Hashtable valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in page_atts) { valid_attributes.Add(att, null); } directivesHash.Add("PAGE", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in control_atts) { valid_attributes.Add(att, null); } directivesHash.Add("CONTROL", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in import_atts) { valid_attributes.Add(att, null); } directivesHash.Add("IMPORT", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in implements_atts) { valid_attributes.Add(att, null); } directivesHash.Add("IMPLEMENTS", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in register_atts) { valid_attributes.Add(att, null); } directivesHash.Add("REGISTER", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in assembly_atts) { valid_attributes.Add(att, null); } directivesHash.Add("ASSEMBLY", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in outputcache_atts) { valid_attributes.Add(att, null); } directivesHash.Add("OUTPUTCACHE", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in reference_atts) { valid_attributes.Add(att, null); } directivesHash.Add("REFERENCE", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in webservice_atts) { valid_attributes.Add(att, null); } directivesHash.Add("WEBSERVICE", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif // same attributes as webservice foreach (string att in webservice_atts) { valid_attributes.Add(att, null); } directivesHash.Add("WEBHANDLER", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); #else valid_attributes = new Hashtable(provider, comparer); #endif foreach (string att in application_atts) { valid_attributes.Add(att, null); } directivesHash.Add("APPLICATION", valid_attributes); valid_attributes = new Hashtable(provider, comparer); foreach (string att in session_atts) { valid_attributes.Add(att, null); } directivesHash.Add("SESSION", valid_attributes); #if NET_2_0 valid_attributes = new Hashtable(comparer); foreach (string att in mastertype_atts) { valid_attributes.Add(att, null); } directivesHash.Add("MASTERTYPE", valid_attributes); valid_attributes = new Hashtable(comparer); foreach (string att in control_atts) { valid_attributes.Add(att, null); } directivesHash.Add("MASTER", valid_attributes); valid_attributes = new Hashtable(comparer); foreach (string att in previouspagetype_atts) { valid_attributes.Add(att, null); } directivesHash.Add("PREVIOUSPAGETYPE", valid_attributes); #endif }
public ListViewItemComparer() { m_columnToSort = 0; m_orderOfSort = SortOrder.None; m_objectCompare = new CaseInsensitiveComparer(); }
/// <summary> /// Initializes a new instance of the <see cref="ListBoxItem"/> class. /// </summary> public ListBoxItem() { // Initialize the CaseInsensitiveComparer object objectCompare = new CaseInsensitiveComparer(Thread.CurrentThread.CurrentCulture); }
/// <summary> /// Arranges a variable's contents in alphabetical, numerical, or random order optionally removing duplicates. /// </summary> /// <param name="input">The variable whose contents to use as the input.</param> /// <param name="options">See the remarks.</param> /// <remarks> /// <list type="table"> /// <listheader> /// <term>Name</term> /// <description>Description</description> /// </listheader> /// <item> /// <term>C</term> /// <description>Case sensitive.</description> /// </item> /// <item> /// <term>CL</term> /// <description>Case sensitive based on current user's locale.</description> /// </item> /// <item> /// <term>D<c>x</c></term> /// <description>Specifies <c>x</c> as the delimiter character which is <c>`n</c> by default.</description> /// </item> /// <item> /// <term>F <c>name</c></term> /// <description>Use the return value of the specified function for comparing two items.</description> /// </item> /// <item> /// <term>N</term> /// <description>Numeric sorting.</description> /// </item> /// <item> /// <term>P<c>n</c></term> /// <description>Sorts items based on character position <c>n</c>.</description> /// </item> /// <item> /// <term>R</term> /// <description>Sort in reverse order.</description> /// </item> /// <item> /// <term>Random</term> /// <description>Sort in random order.</description> /// </item> /// <item> /// <term>U</term> /// <description>Remove any duplicate items.</description> /// </item> /// <item> /// <term>Z</term> /// <description>Considers a trailing delimiter as a boundary which otherwise would be ignored.</description> /// </item> /// <item> /// <term>\</term> /// <description>File path sorting.</description> /// </item> /// </list> /// </remarks> public static void Sort(ref string input, params string[] options) { var opts = KeyValues(string.Join(",", options), true, new[] { 'f' }); MethodInfo function = null; if (opts.ContainsKey('f')) { function = FindLocalRoutine(opts['f']); if (function == null) { return; } } char split = '\n'; if (opts.ContainsKey('d')) { string s = opts['d']; if (s.Length == 1) { split = s[0]; } opts.Remove('d'); } string[] list = input.Split(new[] { split }, StringSplitOptions.RemoveEmptyEntries); if (split == '\n') { for (int i = 0; i < list.Length; i++) { int x = list[i].Length - 1; if (list[i][x] == '\r') { list[i] = list[i].Substring(0, x); } } } if (opts.ContainsKey('z') && input[input.Length - 1] == split) { Array.Resize(ref list, list.Length + 1); list[list.Length - 1] = string.Empty; opts.Remove('z'); } bool withcase = false; if (opts.ContainsKey('c')) { string mode = opts['c']; if (mode == "l" || mode == "L") { withcase = false; } else { withcase = true; } opts.Remove('c'); } bool numeric = false; if (opts.ContainsKey('n')) { numeric = true; opts.Remove('n'); } int sortAt = 1; if (opts.ContainsKey('p')) { if (!int.TryParse(opts['p'], out sortAt)) { sortAt = 1; } opts.Remove('p'); } bool reverse = false, random = false; if (opts.ContainsKey(Keyword_Random[0])) { if (opts[Keyword_Random[0]].Equals(Keyword_Random.Substring(1), StringComparison.OrdinalIgnoreCase)) // Random { random = true; } else { reverse = true; } opts.Remove(Keyword_Random[0]); } bool unique = false; if (opts.ContainsKey('u')) { unique = true; opts.Remove('u'); } bool slash = false; if (opts.ContainsKey('\\')) { slash = true; opts.Remove('\\'); } var comp = new CaseInsensitiveComparer(); var rand = new Random(); Array.Sort(list, delegate(string x, string y) { if (function != null) { object value = null; try { value = function.Invoke(null, new object[] { new object[] { x, y } }); } catch (Exception) { } int result; if (value is string && int.TryParse((string)value, out result)) { return(result); } return(0); } else if (x == y) { return(0); } else if (random) { return(rand.Next(-1, 2)); } else if (numeric) { int a, b; return(int.TryParse(x, out a) && int.TryParse(y, out b) ? a.CompareTo(b) : x.CompareTo(y)); } else { if (slash) { int z = x.LastIndexOf('\\'); if (z != -1) { x = x.Substring(z + 1); } z = y.LastIndexOf('\\'); if (z != -1) { y = y.Substring(z + 1); } if (x == y) { return(0); } } return(withcase ? x.CompareTo(y) : comp.Compare(x, y)); } }); if (unique) { int error = 0; var ulist = new List <string>(list.Length); foreach (var item in list) { if (!ulist.Contains(item)) { ulist.Add(item); } else { error++; } } ErrorLevel = error; list = ulist.ToArray(); } if (reverse) { Array.Reverse(list); } input = string.Join(split.ToString(), list); }
/// <summary> /// コンストラクタ /// </summary> public Class_ListViewColumnSorter() { _orderOfSort = SortOrder.None; _objectCompare = new CaseInsensitiveComparer(CultureInfo.CurrentUICulture); }
public void Ctor_Empty_Compare(object a, object b, int expected) { CaseInsensitiveComparer comparer = new CaseInsensitiveComparer(); Assert.Equal(expected, Math.Sign(comparer.Compare(a, b))); }
public ListViewColumnSorter() { _objObjectCompare = new CaseInsensitiveComparer(); }
public bool runTest() { //////////// Global Variables used for all tests int iCountErrors = 0; int iCountTestcases = 0; CaseInsensitiveComparer comparer; String str1; String str2; try { ///////////////////////// START TESTS //////////////////////////// /////////////////////////////////////////////////////////////////// //[]vanilla - the ctor simply sets the CompareInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo //There is no easy way to test this other than make sure that string comparison is case insensitive iCountTestcases++; comparer = new CaseInsensitiveComparer(); if (comparer.Compare("hello", "HELLO") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "HELLO")); } //same strings should work ok if (comparer.Compare("hello", "hello") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "hello")); } //different strings should return false if (comparer.Compare("hello", "mello") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "mello")); } //[]Other data types should work as is iCountTestcases++; if (comparer.Compare(5, 5) != 0) { iCountErrors++; Console.WriteLine("Err_347tsfg! wrong value returned"); } if (comparer.Compare(5, 10) == 0) { iCountErrors++; Console.WriteLine("Err_973425sdg! wrong value returned"); } //[]we will consider nulls iCountTestcases++; if (comparer.Compare(5, null) <= 0) { iCountErrors++; Console.WriteLine("Err_83sdg! wrong value returned, " + comparer.Compare(5, null)); } if (comparer.Compare(null, 5) >= 0) { iCountErrors++; Console.WriteLine("Err_94375sdg! wrong value returned, " + comparer.Compare(null, 5)); } if (comparer.Compare(null, null) != 0) { iCountErrors++; Console.WriteLine("Err_94375sdg! wrong value returned, " + comparer.Compare(null, null)); } //[]we will consider nulls with Strings iCountTestcases++; str1 = "Hello"; str2 = null; if (comparer.Compare(str1, str2) <= 0) { iCountErrors++; Console.WriteLine("Err_948732dsg! wrong value returned, " + comparer.Compare(str1, str2)); } str1 = null; str2 = "Hello"; if (comparer.Compare(str1, str2) >= 0) { iCountErrors++; Console.WriteLine("Err_948732dsg! wrong value returned, " + comparer.Compare(str1, str2)); } str1 = null; str2 = null; if (comparer.Compare(str1, str2) != 0) { iCountErrors++; Console.WriteLine("Err_948732dsg! wrong value returned, " + comparer.Compare(str1, str2)); } /////////////////////////////////////////////////////////////////// /////////////////////////// END TESTS ///////////////////////////// } catch (Exception exc_general) { ++iCountErrors; Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString()); } //// Finish Diagnostics if (iCountErrors == 0) { return true; } else { return false; } }
public myCultureComparer() { myComparer = CaseInsensitiveComparer.DefaultInvariant; }
public ListViewSorter() { this.ColumnToSort = 0; this.Comparer = new CaseInsensitiveComparer(); this.OrderOfSort = SortOrder.None; }
private readonly CaseInsensitiveComparer objectCompare; // Case insensitive comparer object /// <summary> /// sort the listview by column /// http://support.microsoft.com/kb/319401 /// </summary> public ListviewSort() // Class constructor. Initializes various elements { columnToSort = 0; orderOfSort = SortOrder.None; objectCompare = new CaseInsensitiveComparer(); }
private CaseInsensitiveComparer ObjectCompare; // 声明CaseInsensitiveComparer类对象, public ListViewColumnSorter() // 构造函数 { ColumnToSort = 0; // 默认按第一列排序 OrderOfSort = SortOrder.None; // 排序方式为不排序 ObjectCompare = new CaseInsensitiveComparer(); // 初始化CaseInsensitiveComparer类对象 }
public bool runTest() { //////////// Global Variables used for all tests int iCountErrors = 0; int iCountTestcases = 0; CaseInsensitiveComparer comparer; CaseInsensitiveComparer defaultInvComparer; try { ///////////////////////// START TESTS //////////////////////////// /////////////////////////////////////////////////////////////////// //[]vanilla - Default sets the CompareInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo //There is no easy way to test this other than make sure that string comparison is case insensitive iCountTestcases++; iCountTestcases++; var somePopularCultureNames = new string[] { "cs-CZ","da-DK","de-DE","el-GR","en-US", "es-ES","fi-FI","fr-FR","hu-HU","it-IT", "ja-JP","ko-KR","nb-NO","nl-NL","pl-PL", "pt-BR","pt-PT","ru-RU","sv-SE","tr-TR", "zh-CN","zh-HK","zh-TW" }; foreach (string cultureName in somePopularCultureNames) { CultureInfo culture = new CultureInfo(cultureName); if (culture == null) { continue; } comparer = new CaseInsensitiveComparer(culture); defaultInvComparer = CaseInsensitiveComparer.DefaultInvariant; if (defaultInvComparer.Compare("hello", "HELLO") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultInvComparer.Compare("hello", "HELLO")); } //same strings should work ok if (defaultInvComparer.Compare("hello", "hello") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultInvComparer.Compare("hello", "hello")); } //different strings should return false if (defaultInvComparer.Compare("hello", "mello") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultInvComparer.Compare("hello", "mello")); } //What would turkey do? - Since we are comparing with the invariant culture, this will pass if (defaultInvComparer.Compare("file", "FILE") != 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultInvComparer.Compare("file", "FILE")); } //[]Other data types should work as is iCountTestcases++; if (defaultInvComparer.Compare(5, 5) != 0) { iCountErrors++; Console.WriteLine("Err_347tsfg! wrong value returned"); } if (defaultInvComparer.Compare(5, 10) == 0) { iCountErrors++; Console.WriteLine("Err_973425sdg! wrong value returned"); } } /////////////////////////////////////////////////////////////////// /////////////////////////// END TESTS ///////////////////////////// } catch (Exception exc_general) { ++iCountErrors; Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString()); } //// Finish Diagnostics if (iCountErrors == 0) { return true; } else { return false; } }
public ColumnSorterAsc() { ColumnToSort = 0; sensComparer = new CaseInsensitiveComparer(); }
public ListViewColumnSorter() { _columnToSort = 0; _sortOrder = SortOrder.None; _comparer = new CaseInsensitiveComparer(); }
public bool runTest() { //////////// Global Variables used for all tests int iCountErrors = 0; int iCountTestcases = 0; CaseInsensitiveComparer comparer; CaseInsensitiveComparer defaultComparer; try { ///////////////////////// START TESTS //////////////////////////// /////////////////////////////////////////////////////////////////// //[]vanila - Default sets the ComapreInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo //There is no easy way to test this other than make sure that string comparison is case insenstive iCountTestcases++; iCountTestcases++; var somePopularCultureNames = new string[] { "cs-CZ", "da-DK", "de-DE", "el-GR", "en-US", "es-ES", "fi-FI", "fr-FR", "hu-HU", "it-IT", "ja-JP", "ko-KR", "nb-NO", "nl-NL", "pl-PL", "pt-BR", "pt-PT", "ru-RU", "sv-SE", "tr-TR", "zh-CN", "zh-HK", "zh-TW" }; foreach (string cultureName in somePopularCultureNames) { CultureInfo culture = new CultureInfo(cultureName); if (culture == null) { continue; } comparer = new CaseInsensitiveComparer(culture); defaultComparer = CaseInsensitiveComparer.Default; if (defaultComparer.Compare("hello", "HELLO") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "HELLO")); } //same strings should work ok if (defaultComparer.Compare("hello", "hello") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "hello")); } //different strings should return false if (defaultComparer.Compare("hello", "mello") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "mello")); } //What would turkey do? - Since we are comparing with the default culture, unless this is run on a turkish machine, this will pass if (CultureInfo.CurrentCulture.Name != "tr-TR") { if (defaultComparer.Compare("file", "FILE") != 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("file", "FILE")); } } else { if (defaultComparer.Compare("file", "FILE") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("file", "FILE")); } } //[]Other data types should work as is iCountTestcases++; if (defaultComparer.Compare(5, 5) != 0) { iCountErrors++; Console.WriteLine("Err_347tsfg! wrong value returned"); } if (defaultComparer.Compare(5, 10) == 0) { iCountErrors++; Console.WriteLine("Err_973425sdg! wrong value returned"); } } /////////////////////////////////////////////////////////////////// /////////////////////////// END TESTS ///////////////////////////// } catch (Exception exc_general) { ++iCountErrors; Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString()); } //// Finish Diagnostics if (iCountErrors == 0) { return(true); } else { return(false); } }
public bool runTest() { //////////// Global Variables used for all tests int iCountErrors = 0; int iCountTestcases = 0; CaseInsensitiveComparer comparer; try { ///////////////////////// START TESTS //////////////////////////// /////////////////////////////////////////////////////////////////// //[]vanilla - the ctor simply sets the CompareInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo //There is no easy way to test this other than make sure that string comparison is case insensitive iCountTestcases++; iCountTestcases++; iCountTestcases++; var somePopularCultureNames = new string[] { "cs-CZ","da-DK","de-DE","el-GR","en-US", "es-ES","fi-FI","fr-FR","hu-HU","it-IT", "ja-JP","ko-KR","nb-NO","nl-NL","pl-PL", "pt-BR","pt-PT","ru-RU","sv-SE","tr-TR", "zh-CN","zh-HK","zh-TW" }; foreach (string cultureName in somePopularCultureNames) { CultureInfo culture = new CultureInfo(cultureName); if (culture == null) { continue; } comparer = new CaseInsensitiveComparer(culture); if (comparer.Compare("hello", "HELLO") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("hello", "HELLO"), culture.Name); } //same strings should work ok if (comparer.Compare("hello", "hello") != 0) { iCountErrors++; Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("hello", "hello"), culture.Name); } //different strings should return false if (comparer.Compare("hello", "mello") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", "non-zero", comparer.Compare("hello", "mello"), culture.Name); } // "tr-TR" = "Turkish (Turkey)" // Turkish has lower-case and upper-case version of the dotted "i", so the upper case of "i" (U+0069) isn't "I" (U+0049), but rather "İ" (U+0130). if (culture.Name != "tr-TR") { if (comparer.Compare("file", "FILE") != 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("file", "FILE"), culture.Name); } } else { if (comparer.Compare("file", "FILE") == 0) { iCountErrors++; Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", "non-zero", comparer.Compare("file", "FILE"), culture.Name); } } //[]Other data types should work as is iCountTestcases++; if (comparer.Compare(5, 5) != 0) { iCountErrors++; Console.WriteLine("Err_347tsfg! wrong value returned"); } if (comparer.Compare(5, 10) == 0) { iCountErrors++; Console.WriteLine("Err_973425sdg! wrong value returned"); } } //[]parm test iCountTestcases++; try { comparer = new CaseInsensitiveComparer(null); iCountErrors++; Console.WriteLine("Err_9745sdg! Exception not thrown"); } catch (ArgumentNullException) { } catch (Exception ex) { iCountErrors++; Console.WriteLine("Err_9745sdg! Unexpected exception thrown, " + ex.GetType().Name); } /////////////////////////////////////////////////////////////////// /////////////////////////// END TESTS ///////////////////////////// } catch (Exception exc_general) { ++iCountErrors; Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString()); } //// Finish Diagnostics if (iCountErrors == 0) { return true; } else { return false; } }
/// <summary> /// Class constructor. Initializes various elements /// </summary> public ListViewColumnSorter() { SortColumn = 0; // Initialize the column to '0' Order = SortOrder.None; // Initialize the sort order to 'none' ObjectCompare = new CaseInsensitiveComparer(); // Initialize the CaseInsensitiveComparer object }