किसी के पास एक अच्छा संसाधन है या एक FileInfoसरणी के लिए C # में प्राकृतिक क्रम क्रम का एक नमूना प्रदान करता है ? मैं IComparerअपनी तरह से इंटरफ़ेस लागू कर रहा हूं।
किसी के पास एक अच्छा संसाधन है या एक FileInfoसरणी के लिए C # में प्राकृतिक क्रम क्रम का एक नमूना प्रदान करता है ? मैं IComparerअपनी तरह से इंटरफ़ेस लागू कर रहा हूं।
जवाबों:
सबसे आसान काम यह है कि विंडोज में बिल्ट-इन फंक्शन को P / Invoke करें और इसे अपने फंक्शन की तुलना फंक्शन के रूप में करें IComparer।
[DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
private static extern int StrCmpLogicalW(string psz1, string psz2);माइकल कापलान के कुछ उदाहरण हैं कि यह कार्य यहां कैसे काम करता है , और विस्टा के लिए जो बदलाव किए गए थे, वे इसे अधिक सहजता से काम करते हैं। इस फ़ंक्शन का प्लस पक्ष यह है कि इसमें विंडोज के संस्करण के समान ही व्यवहार होगा, हालांकि इसका मतलब यह है कि यह विंडोज के संस्करणों के बीच भिन्न है, इसलिए आपको यह विचार करने की आवश्यकता है कि क्या यह आपके लिए एक समस्या है।
तो एक पूर्ण कार्यान्वयन कुछ इस तरह होगा:
[SuppressUnmanagedCodeSecurity]
internal static class SafeNativeMethods
{
[DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
public static extern int StrCmpLogicalW(string psz1, string psz2);
}
public sealed class NaturalStringComparer : IComparer<string>
{
public int Compare(string a, string b)
{
return SafeNativeMethods.StrCmpLogicalW(a, b);
}
}
public sealed class NaturalFileInfoNameComparer : IComparer<FileInfo>
{
public int Compare(FileInfo a, FileInfo b)
{
return SafeNativeMethods.StrCmpLogicalW(a.Name, b.Name);
}
}Comparer<T>लागू करने के बजाय से विरासत में मिला है, तो आपको उस API के उपयोग IComparer<T>के लिए IComparer(गैर-जेनेरिक) इंटरफ़ेस का अंतर्निहित कार्यान्वयन प्राप्त होता है , जो इसके बजाय उपयोग करने वाले API में उपयोग करता है। यह मूल रूप से भी करने के लिए स्वतंत्र है: बस "मैं" को हटा दें और बदल public int Compare(...)दें public override int Compare(...)। के लिए IEqualityComparer<T>और EqualityComparer<T>।
बस मैंने सोचा कि मैं इसे जोड़ूंगा (सबसे संक्षिप्त समाधान के साथ मैं पा सकता हूं):
public static IOrderedEnumerable<T> OrderByAlphaNumeric<T>(this IEnumerable<T> source, Func<T, string> selector)
{
int max = source
.SelectMany(i => Regex.Matches(selector(i), @"\d+").Cast<Match>().Select(m => (int?)m.Value.Length))
.Max() ?? 0;
return source.OrderBy(i => Regex.Replace(selector(i), @"\d+", m => m.Value.PadLeft(max, '0')));
}उपरोक्त सभी स्ट्रिंग में सभी नंबरों की अधिकतम लंबाई के लिए स्ट्रिंग में किसी भी संख्या को पैड करता है और सॉर्ट करने के लिए परिणामस्वरूप स्ट्रिंग का उपयोग करता है।
कास्ट ( int?) को बिना किसी संख्या के स्ट्रिंग्स के संग्रह के लिए अनुमति देना है ( .Max()एक खाली गणना पर फेंकता है InvalidOperationException)।
.DefaultIfEmpty().Max()कास्ट करने के बजाय इस्तेमाल कर सकते हैं int?। इसके अलावा, यह करने योग्य है कि source.ToList()गणना करने वाले को फिर से एन्यूमरेट करने से बचें।
मौजूदा कार्यान्वयन में से कोई भी बहुत अच्छा नहीं लगा इसलिए मैंने अपना लिखा। परिणाम विंडोज एक्सप्लोरर (विंडोज 7/8) के आधुनिक संस्करणों द्वारा उपयोग किए जाने वाले सॉर्टिंग के लगभग समान हैं। केवल अंतर जो मैंने देखा है वे 1 हैं) हालांकि Windows किसी भी लंबाई की संख्या (जैसे XP) का उपयोग करता है, अब यह 19 अंकों तक सीमित है - मेरा असीमित है, 2) विंडोज यूनिकोड अंकों के कुछ सेटों के साथ असंगत परिणाम देता है - मेरा काम करता है ठीक है (हालांकि यह सरोगेट जोड़े से अंकों की तुलना नहीं करता है; न ही विंडोज), और 3) मेरा अलग-अलग प्रकार के गैर-प्राथमिक प्रकार के वज़न को अलग-अलग वर्गों में होने पर अलग नहीं कर सकता है (उदाहरण के लिए "e-1é" बनाम " é1e- "- संख्या के पहले और बाद के वर्गों में डायक्रिटिक और विराम चिह्न वजन अंतर हैं)।
public static int CompareNatural(string strA, string strB) {
return CompareNatural(strA, strB, CultureInfo.CurrentCulture, CompareOptions.IgnoreCase);
}
public static int CompareNatural(string strA, string strB, CultureInfo culture, CompareOptions options) {
CompareInfo cmp = culture.CompareInfo;
int iA = 0;
int iB = 0;
int softResult = 0;
int softResultWeight = 0;
while (iA < strA.Length && iB < strB.Length) {
bool isDigitA = Char.IsDigit(strA[iA]);
bool isDigitB = Char.IsDigit(strB[iB]);
if (isDigitA != isDigitB) {
return cmp.Compare(strA, iA, strB, iB, options);
}
else if (!isDigitA && !isDigitB) {
int jA = iA + 1;
int jB = iB + 1;
while (jA < strA.Length && !Char.IsDigit(strA[jA])) jA++;
while (jB < strB.Length && !Char.IsDigit(strB[jB])) jB++;
int cmpResult = cmp.Compare(strA, iA, jA - iA, strB, iB, jB - iB, options);
if (cmpResult != 0) {
// Certain strings may be considered different due to "soft" differences that are
// ignored if more significant differences follow, e.g. a hyphen only affects the
// comparison if no other differences follow
string sectionA = strA.Substring(iA, jA - iA);
string sectionB = strB.Substring(iB, jB - iB);
if (cmp.Compare(sectionA + "1", sectionB + "2", options) ==
cmp.Compare(sectionA + "2", sectionB + "1", options))
{
return cmp.Compare(strA, iA, strB, iB, options);
}
else if (softResultWeight < 1) {
softResult = cmpResult;
softResultWeight = 1;
}
}
iA = jA;
iB = jB;
}
else {
char zeroA = (char)(strA[iA] - (int)Char.GetNumericValue(strA[iA]));
char zeroB = (char)(strB[iB] - (int)Char.GetNumericValue(strB[iB]));
int jA = iA;
int jB = iB;
while (jA < strA.Length && strA[jA] == zeroA) jA++;
while (jB < strB.Length && strB[jB] == zeroB) jB++;
int resultIfSameLength = 0;
do {
isDigitA = jA < strA.Length && Char.IsDigit(strA[jA]);
isDigitB = jB < strB.Length && Char.IsDigit(strB[jB]);
int numA = isDigitA ? (int)Char.GetNumericValue(strA[jA]) : 0;
int numB = isDigitB ? (int)Char.GetNumericValue(strB[jB]) : 0;
if (isDigitA && (char)(strA[jA] - numA) != zeroA) isDigitA = false;
if (isDigitB && (char)(strB[jB] - numB) != zeroB) isDigitB = false;
if (isDigitA && isDigitB) {
if (numA != numB && resultIfSameLength == 0) {
resultIfSameLength = numA < numB ? -1 : 1;
}
jA++;
jB++;
}
}
while (isDigitA && isDigitB);
if (isDigitA != isDigitB) {
// One number has more digits than the other (ignoring leading zeros) - the longer
// number must be larger
return isDigitA ? 1 : -1;
}
else if (resultIfSameLength != 0) {
// Both numbers are the same length (ignoring leading zeros) and at least one of
// the digits differed - the first difference determines the result
return resultIfSameLength;
}
int lA = jA - iA;
int lB = jB - iB;
if (lA != lB) {
// Both numbers are equivalent but one has more leading zeros
return lA > lB ? -1 : 1;
}
else if (zeroA != zeroB && softResultWeight < 2) {
softResult = cmp.Compare(strA, iA, 1, strB, iB, 1, options);
softResultWeight = 2;
}
iA = jA;
iB = jB;
}
}
if (iA < strA.Length || iB < strB.Length) {
return iA < strA.Length ? 1 : -1;
}
else if (softResult != 0) {
return softResult;
}
return 0;
}हस्ताक्षर Comparison<string>प्रतिनिधि से मेल खाते हैं :
string[] files = Directory.GetFiles(@"C:\");
Array.Sort(files, CompareNatural);यहाँ IComparer<string>निम्न के लिए एक आवरण वर्ग है :
public class CustomComparer<T> : IComparer<T> {
private Comparison<T> _comparison;
public CustomComparer(Comparison<T> comparison) {
_comparison = comparison;
}
public int Compare(T x, T y) {
return _comparison(x, y);
}
}उदाहरण:
string[] files = Directory.EnumerateFiles(@"C:\")
.OrderBy(f => f, new CustomComparer<string>(CompareNatural))
.ToArray();यहाँ परीक्षण के लिए उपयोग किए जाने वाले फ़ाइलनाम का एक अच्छा सेट है:
Func<string, string> expand = (s) => { int o; while ((o = s.IndexOf('\\')) != -1) { int p = o + 1;
int z = 1; while (s[p] == '0') { z++; p++; } int c = Int32.Parse(s.Substring(p, z));
s = s.Substring(0, o) + new string(s[o - 1], c) + s.Substring(p + z); } return s; };
string encodedFileNames =
"KDEqLW4xMiotbjEzKjAwMDFcMDY2KjAwMlwwMTcqMDA5XDAxNyowMlwwMTcqMDlcMDE3KjEhKjEtISox" +
"LWEqMS4yNT8xLjI1KjEuNT8xLjUqMSoxXDAxNyoxXDAxOCoxXDAxOSoxXDA2NioxXDA2NyoxYSoyXDAx" +
"NyoyXDAxOCo5XDAxNyo5XDAxOCo5XDA2Nio9MSphMDAxdGVzdDAxKmEwMDF0ZXN0aW5nYTBcMzEqYTAw" +
"Mj9hMDAyIGE/YTAwMiBhKmEwMDIqYTAwMmE/YTAwMmEqYTAxdGVzdGluZ2EwMDEqYTAxdnNmcyphMSph" +
"MWEqYTF6KmEyKmIwMDAzcTYqYjAwM3E0KmIwM3E1KmMtZSpjZCpjZipmIDEqZipnP2cgMT9oLW4qaG8t" +
"bipJKmljZS1jcmVhbT9pY2VjcmVhbT9pY2VjcmVhbS0/ajBcNDE/ajAwMWE/ajAxP2shKmsnKmstKmsx" +
"KmthKmxpc3QqbTAwMDNhMDA1YSptMDAzYTAwMDVhKm0wMDNhMDA1Km0wMDNhMDA1YSpuMTIqbjEzKm8t" +
"bjAxMypvLW4xMipvLW40P28tbjQhP28tbjR6P28tbjlhLWI1Km8tbjlhYjUqb24wMTMqb24xMipvbjQ/" +
"b240IT9vbjR6P29uOWEtYjUqb245YWI1Km/CrW4wMTMqb8KtbjEyKnAwMCpwMDEqcDAxwr0hKnAwMcK9" +
"KnAwMcK9YSpwMDHCvcK+KnAwMipwMMK9KnEtbjAxMypxLW4xMipxbjAxMypxbjEyKnItMDAhKnItMDAh" +
"NSpyLTAwIe+8lSpyLTAwYSpyLe+8kFwxIS01KnIt77yQXDEhLe+8lSpyLe+8kFwxISpyLe+8kFwxITUq" +
"ci3vvJBcMSHvvJUqci3vvJBcMWEqci3vvJBcMyE1KnIwMCEqcjAwLTUqcjAwLjUqcjAwNSpyMDBhKnIw" +
"NSpyMDYqcjQqcjUqctmg2aYqctmkKnLZpSpy27Dbtipy27Qqctu1KnLfgN+GKnLfhCpy34UqcuClpuCl" +
"rCpy4KWqKnLgpasqcuCnpuCnrCpy4KeqKnLgp6sqcuCppuCprCpy4KmqKnLgqasqcuCrpuCrrCpy4Kuq" +
"KnLgq6sqcuCtpuCtrCpy4K2qKnLgrasqcuCvpuCvrCpy4K+qKnLgr6sqcuCxpuCxrCpy4LGqKnLgsasq" +
"cuCzpuCzrCpy4LOqKnLgs6sqcuC1puC1rCpy4LWqKnLgtasqcuC5kOC5lipy4LmUKnLguZUqcuC7kOC7" +
"lipy4LuUKnLgu5UqcuC8oOC8pipy4LykKnLgvKUqcuGBgOGBhipy4YGEKnLhgYUqcuGCkOGClipy4YKU" +
"KnLhgpUqcuGfoOGfpipy4Z+kKnLhn6UqcuGgkOGglipy4aCUKnLhoJUqcuGlhuGljCpy4aWKKnLhpYsq" +
"cuGnkOGnlipy4aeUKnLhp5UqcuGtkOGtlipy4a2UKnLhrZUqcuGusOGutipy4a60KnLhrrUqcuGxgOGx" +
"hipy4bGEKnLhsYUqcuGxkOGxlipy4bGUKnLhsZUqcuqYoFwx6pilKnLqmKDqmKUqcuqYoOqYpipy6pik" +
"KnLqmKUqcuqjkOqjlipy6qOUKnLqo5UqcuqkgOqkhipy6qSEKnLqpIUqcuqpkOqplipy6qmUKnLqqZUq" +
"cvCQkqAqcvCQkqUqcvCdn5gqcvCdn50qcu+8kFwxISpy77yQXDEt77yVKnLvvJBcMS7vvJUqcu+8kFwx" +
"YSpy77yQXDHqmKUqcu+8kFwx77yO77yVKnLvvJBcMe+8lSpy77yQ77yVKnLvvJDvvJYqcu+8lCpy77yV" +
"KnNpKnPEsSp0ZXN02aIqdGVzdNmi2aAqdGVzdNmjKnVBZS0qdWFlKnViZS0qdUJlKnVjZS0xw6kqdWNl" +
"McOpLSp1Y2Uxw6kqdWPDqS0xZSp1Y8OpMWUtKnVjw6kxZSp3ZWlhMSp3ZWlhMip3ZWlzczEqd2Vpc3My" +
"KndlaXoxKndlaXoyKndlacOfMSp3ZWnDnzIqeSBhMyp5IGE0KnknYTMqeSdhNCp5K2EzKnkrYTQqeS1h" +
"Myp5LWE0KnlhMyp5YTQqej96IDA1MD96IDIxP3ohMjE/ejIwP3oyMj96YTIxP3rCqTIxP1sxKl8xKsKt" +
"bjEyKsKtbjEzKsSwKg==";
string[] fileNames = Encoding.UTF8.GetString(Convert.FromBase64String(encodedFileNames))
.Replace("*", ".txt?").Split(new[] { "?" }, StringSplitOptions.RemoveEmptyEntries)
.Select(n => expand(n)).ToArray();शुद्ध सी # लाइनक ऑर्डर के लिए समाधान:
http://zootfroot.blogspot.com/2009/09/natural-sort-compare-with-linq-orderby.html
public class NaturalSortComparer<T> : IComparer<string>, IDisposable
{
private bool isAscending;
public NaturalSortComparer(bool inAscendingOrder = true)
{
this.isAscending = inAscendingOrder;
}
#region IComparer<string> Members
public int Compare(string x, string y)
{
throw new NotImplementedException();
}
#endregion
#region IComparer<string> Members
int IComparer<string>.Compare(string x, string y)
{
if (x == y)
return 0;
string[] x1, y1;
if (!table.TryGetValue(x, out x1))
{
x1 = Regex.Split(x.Replace(" ", ""), "([0-9]+)");
table.Add(x, x1);
}
if (!table.TryGetValue(y, out y1))
{
y1 = Regex.Split(y.Replace(" ", ""), "([0-9]+)");
table.Add(y, y1);
}
int returnVal;
for (int i = 0; i < x1.Length && i < y1.Length; i++)
{
if (x1[i] != y1[i])
{
returnVal = PartCompare(x1[i], y1[i]);
return isAscending ? returnVal : -returnVal;
}
}
if (y1.Length > x1.Length)
{
returnVal = 1;
}
else if (x1.Length > y1.Length)
{
returnVal = -1;
}
else
{
returnVal = 0;
}
return isAscending ? returnVal : -returnVal;
}
private static int PartCompare(string left, string right)
{
int x, y;
if (!int.TryParse(left, out x))
return left.CompareTo(right);
if (!int.TryParse(right, out y))
return left.CompareTo(right);
return x.CompareTo(y);
}
#endregion
private Dictionary<string, string[]> table = new Dictionary<string, string[]>();
public void Dispose()
{
table.Clear();
table = null;
}
}मैथ्यू हॉर्सलेज़ का उत्तर सबसे तेज़ तरीका है जो व्यवहार को परिवर्तित नहीं करता है जिसके आधार पर आपके प्रोग्राम के विंडोज़ का संस्करण चल रहा है। हालाँकि, यह एक बार regex बनाकर और RegexOptions.Compiled का उपयोग करके और भी तेज़ हो सकता है। मैंने एक स्ट्रिंग तुलनित्र डालने का विकल्प भी जोड़ा ताकि आप यदि आवश्यक हो तो मामले को अनदेखा कर सकें, और पठनीयता में थोड़ा सुधार कर सकें।
public static IEnumerable<T> OrderByNatural<T>(this IEnumerable<T> items, Func<T, string> selector, StringComparer stringComparer = null)
{
var regex = new Regex(@"\d+", RegexOptions.Compiled);
int maxDigits = items
.SelectMany(i => regex.Matches(selector(i)).Cast<Match>().Select(digitChunk => (int?)digitChunk.Value.Length))
.Max() ?? 0;
return items.OrderBy(i => regex.Replace(selector(i), match => match.Value.PadLeft(maxDigits, '0')), stringComparer ?? StringComparer.CurrentCulture);
}द्वारा उपयोग
var sortedEmployees = employees.OrderByNatural(emp => emp.Name);यह डिफ़ॉल्ट .net स्ट्रिंग तुलना के लिए 300ms की तुलना में 100,000 स्ट्रिंग्स को सॉर्ट करने के लिए 450ms लेता है - बहुत तेज़!
मेरा समाधान:
void Main()
{
new[] {"a4","a3","a2","a10","b5","b4","b400","1","C1d","c1d2"}.OrderBy(x => x, new NaturalStringComparer()).Dump();
}
public class NaturalStringComparer : IComparer<string>
{
private static readonly Regex _re = new Regex(@"(?<=\D)(?=\d)|(?<=\d)(?=\D)", RegexOptions.Compiled);
public int Compare(string x, string y)
{
x = x.ToLower();
y = y.ToLower();
if(string.Compare(x, 0, y, 0, Math.Min(x.Length, y.Length)) == 0)
{
if(x.Length == y.Length) return 0;
return x.Length < y.Length ? -1 : 1;
}
var a = _re.Split(x);
var b = _re.Split(y);
int i = 0;
while(true)
{
int r = PartCompare(a[i], b[i]);
if(r != 0) return r;
++i;
}
}
private static int PartCompare(string x, string y)
{
int a, b;
if(int.TryParse(x, out a) && int.TryParse(y, out b))
return a.CompareTo(b);
return x.CompareTo(y);
}
}परिणाम:
1
a2
a3
a4
a10
b4
b5
b400
C1d
c1d2आपको सावधान रहने की आवश्यकता है - मैं जोर से पढ़कर याद करता हूं कि StrCmpLogicalW, या ऐसा कुछ, सख्ती से सकर्मक नहीं था, और मैंने देखा है कि .NET के सॉर्ट तरीके कभी-कभी अनंत छोरों में फंस जाते हैं यदि तुलनात्मक फ़ंक्शन उस नियम को तोड़ता है।
एक सकर्मक तुलना हमेशा रिपोर्ट करेगी कि एक <c अगर एक <b और b <c। एक ऐसा फ़ंक्शन मौजूद है जो एक प्राकृतिक क्रम क्रम तुलना करता है जो हमेशा उस मानदंड को पूरा नहीं करता है, लेकिन मुझे याद नहीं है कि यह StrCmpLogicalW है या कुछ और है।
CultureInfoएक संपत्ति है CompareInfo, और यह जो वस्तु देता है वह आपको SortKeyवस्तुओं के साथ आपूर्ति कर सकता है । बदले में, इनकी तुलना की जा सकती है और पारगम्यता की गारंटी दी जा सकती है।
अल्फा और न्यूमेरिक दोनों प्रकार के अक्षर वाले स्ट्रिंग को सॉर्ट करने के लिए यह मेरा कोड है।
सबसे पहले, यह विस्तार विधि:
public static IEnumerable<string> AlphanumericSort(this IEnumerable<string> me)
{
return me.OrderBy(x => Regex.Replace(x, @"\d+", m => m.Value.PadLeft(50, '0')));
}फिर, इसे अपने कोड में कहीं भी इस तरह उपयोग करें:
List<string> test = new List<string>() { "The 1st", "The 12th", "The 2nd" };
test = test.AlphanumericSort();यह कैसे काम करता है ? शून्य के साथ प्रतिस्थापित करके:
Original | Regex Replace | The | Returned
List | Apply PadLeft | Sorting | List
| | |
"The 1st" | "The 001st" | "The 001st" | "The 1st"
"The 12th" | "The 012th" | "The 002nd" | "The 2nd"
"The 2nd" | "The 002nd" | "The 012th" | "The 12th"गुणक संख्याओं के साथ काम करता है:
Alphabetical Sorting | Alphanumeric Sorting
|
"Page 21, Line 42" | "Page 3, Line 7"
"Page 21, Line 5" | "Page 3, Line 32"
"Page 3, Line 32" | "Page 21, Line 5"
"Page 3, Line 7" | "Page 21, Line 42"उम्मीद है कि मदद मिलेगी।
को जोड़ना ग्रेग बीच का जवाब (क्योंकि मैं सिर्फ इतना है कि के लिए खोज कर रहा है), तो आप Linq से उपयोग करने के लिए आप उपयोग कर सकते हैं चाहते हैं OrderByकि एक लेता है IComparer। उदाहरण के लिए:
var items = new List<MyItem>();
// fill items
var sorted = items.OrderBy(item => item.Name, new NaturalStringComparer());यहाँ एक अपेक्षाकृत सरल उदाहरण है जो P / Invoke का उपयोग नहीं करता है और निष्पादन के दौरान किसी भी आवंटन से बचा जाता है।
internal sealed class NumericStringComparer : IComparer<string>
{
public static NumericStringComparer Instance { get; } = new NumericStringComparer();
public int Compare(string x, string y)
{
// sort nulls to the start
if (x == null)
return y == null ? 0 : -1;
if (y == null)
return 1;
var ix = 0;
var iy = 0;
while (true)
{
// sort shorter strings to the start
if (ix >= x.Length)
return iy >= y.Length ? 0 : -1;
if (iy >= y.Length)
return 1;
var cx = x[ix];
var cy = y[iy];
int result;
if (char.IsDigit(cx) && char.IsDigit(cy))
result = CompareInteger(x, y, ref ix, ref iy);
else
result = cx.CompareTo(y[iy]);
if (result != 0)
return result;
ix++;
iy++;
}
}
private static int CompareInteger(string x, string y, ref int ix, ref int iy)
{
var lx = GetNumLength(x, ix);
var ly = GetNumLength(y, iy);
// shorter number first (note, doesn't handle leading zeroes)
if (lx != ly)
return lx.CompareTo(ly);
for (var i = 0; i < lx; i++)
{
var result = x[ix++].CompareTo(y[iy++]);
if (result != 0)
return result;
}
return 0;
}
private static int GetNumLength(string s, int i)
{
var length = 0;
while (i < s.Length && char.IsDigit(s[i++]))
length++;
return length;
}
}यह अग्रणी शून्य को अनदेखा नहीं करता है, इसलिए 01बाद में आता है 2।
अनुरूप इकाई परीक्षण:
public class NumericStringComparerTests
{
[Fact]
public void OrdersCorrectly()
{
AssertEqual("", "");
AssertEqual(null, null);
AssertEqual("Hello", "Hello");
AssertEqual("Hello123", "Hello123");
AssertEqual("123", "123");
AssertEqual("123Hello", "123Hello");
AssertOrdered("", "Hello");
AssertOrdered(null, "Hello");
AssertOrdered("Hello", "Hello1");
AssertOrdered("Hello123", "Hello124");
AssertOrdered("Hello123", "Hello133");
AssertOrdered("Hello123", "Hello223");
AssertOrdered("123", "124");
AssertOrdered("123", "133");
AssertOrdered("123", "223");
AssertOrdered("123", "1234");
AssertOrdered("123", "2345");
AssertOrdered("0", "1");
AssertOrdered("123Hello", "124Hello");
AssertOrdered("123Hello", "133Hello");
AssertOrdered("123Hello", "223Hello");
AssertOrdered("123Hello", "1234Hello");
}
private static void AssertEqual(string x, string y)
{
Assert.Equal(0, NumericStringComparer.Instance.Compare(x, y));
Assert.Equal(0, NumericStringComparer.Instance.Compare(y, x));
}
private static void AssertOrdered(string x, string y)
{
Assert.Equal(-1, NumericStringComparer.Instance.Compare(x, y));
Assert.Equal( 1, NumericStringComparer.Instance.Compare(y, x));
}
}मैंने वास्तव में इसे एक विस्तार विधि के रूप में लागू किया है StringComparerताकि आप उदाहरण के लिए कर सकें:
StringComparer.CurrentCulture.WithNaturalSort() याStringComparer.OrdinalIgnoreCase.WithNaturalSort()।जिसके परिणामस्वरूप IComparer<string>चाहते सभी स्थानों में इस्तेमाल किया जा सकता OrderBy, OrderByDescending, ThenBy, ThenByDescending, SortedSet<string>, आदि और आप कर सकते हैं अभी भी आसानी से ट्वीक केस संवेदनशीलता, संस्कृति, आदि
कार्यान्वयन काफी तुच्छ है और इसे बड़े दृश्यों पर भी काफी अच्छा प्रदर्शन करना चाहिए।
मैंने इसे एक छोटे नुगेट पैकेज के रूप में भी प्रकाशित किया है , ताकि आप बस कर सकें:
Install-Package NaturalSort.ExtensionXML प्रलेखन टिप्पणियों और परीक्षणों के सूट सहित कोड NaturalSort.Extension GitHub भंडार में उपलब्ध है ।
पूरा कोड यह है (यदि आप अभी तक C # 7 का उपयोग नहीं कर सकते हैं, बस NuGet पैकेज स्थापित करें):
public static class StringComparerNaturalSortExtension
{
public static IComparer<string> WithNaturalSort(this StringComparer stringComparer) => new NaturalSortComparer(stringComparer);
private class NaturalSortComparer : IComparer<string>
{
public NaturalSortComparer(StringComparer stringComparer)
{
_stringComparer = stringComparer;
}
private readonly StringComparer _stringComparer;
private static readonly Regex NumberSequenceRegex = new Regex(@"(\d+)", RegexOptions.Compiled | RegexOptions.CultureInvariant);
private static string[] Tokenize(string s) => s == null ? new string[] { } : NumberSequenceRegex.Split(s);
private static ulong ParseNumberOrZero(string s) => ulong.TryParse(s, NumberStyles.None, CultureInfo.InvariantCulture, out var result) ? result : 0;
public int Compare(string s1, string s2)
{
var tokens1 = Tokenize(s1);
var tokens2 = Tokenize(s2);
var zipCompare = tokens1.Zip(tokens2, TokenCompare).FirstOrDefault(x => x != 0);
if (zipCompare != 0)
return zipCompare;
var lengthCompare = tokens1.Length.CompareTo(tokens2.Length);
return lengthCompare;
}
private int TokenCompare(string token1, string token2)
{
var number1 = ParseNumberOrZero(token1);
var number2 = ParseNumberOrZero(token2);
var numberCompare = number1.CompareTo(number2);
if (numberCompare != 0)
return numberCompare;
var stringCompare = _stringComparer.Compare(token1, token2);
return stringCompare;
}
}
}यहाँ एक भोली एक लाइन रेगेक्स-कम LINQ तरीका है (अजगर से उधार)
var alphaStrings = new List<string>() { "10","2","3","4","50","11","100","a12","b12" };
var orderedString = alphaStrings.OrderBy(g => new Tuple<int, string>(g.ToCharArray().All(char.IsDigit)? int.Parse(g) : int.MaxValue, g));
// Order Now: ["2","3","4","10","11","50","100","a12","b12"]Dump()। इशारा करने के लिए धन्यवाद।
पिछले उत्तरों के एक जोड़े पर विस्तार करना और विस्तार विधियों का उपयोग करना, मैं निम्नलिखित के साथ आया था जिसमें संभावित बहुसंकेतन गणन, या प्रदर्शन के मुद्दे नहीं हैं, जो कई regex ऑब्जेक्ट्स का उपयोग करने के साथ संबंधित हैं, या निरर्थक रूप से कॉल कर रहे हैं, कहा जा रहा है, यह ToList () का उपयोग करता है, जो बड़े संग्रहों में लाभ को नकार सकता है।
चयनकर्ता किसी भी प्रतिनिधि को असाइन करने की अनुमति देने के लिए जेनेरिक टाइपिंग का समर्थन करता है, स्रोत संग्रह में तत्वों को चयनकर्ता द्वारा उत्परिवर्तित किया जाता है, फिर ट्रेसिंग () के साथ तार में परिवर्तित किया जाता है।
private static readonly Regex _NaturalOrderExpr = new Regex(@"\d+", RegexOptions.Compiled);
public static IEnumerable<TSource> OrderByNatural<TSource, TKey>(
this IEnumerable<TSource> source, Func<TSource, TKey> selector)
{
int max = 0;
var selection = source.Select(
o =>
{
var v = selector(o);
var s = v != null ? v.ToString() : String.Empty;
if (!String.IsNullOrWhiteSpace(s))
{
var mc = _NaturalOrderExpr.Matches(s);
if (mc.Count > 0)
{
max = Math.Max(max, mc.Cast<Match>().Max(m => m.Value.Length));
}
}
return new
{
Key = o,
Value = s
};
}).ToList();
return
selection.OrderBy(
o =>
String.IsNullOrWhiteSpace(o.Value) ? o.Value : _NaturalOrderExpr.Replace(o.Value, m => m.Value.PadLeft(max, '0')))
.Select(o => o.Key);
}
public static IEnumerable<TSource> OrderByDescendingNatural<TSource, TKey>(
this IEnumerable<TSource> source, Func<TSource, TKey> selector)
{
int max = 0;
var selection = source.Select(
o =>
{
var v = selector(o);
var s = v != null ? v.ToString() : String.Empty;
if (!String.IsNullOrWhiteSpace(s))
{
var mc = _NaturalOrderExpr.Matches(s);
if (mc.Count > 0)
{
max = Math.Max(max, mc.Cast<Match>().Max(m => m.Value.Length));
}
}
return new
{
Key = o,
Value = s
};
}).ToList();
return
selection.OrderByDescending(
o =>
String.IsNullOrWhiteSpace(o.Value) ? o.Value : _NaturalOrderExpr.Replace(o.Value, m => m.Value.PadLeft(max, '0')))
.Select(o => o.Key);
}माइकल पार्कर के समाधान से प्रेरित, यहाँ एक IComparerकार्यान्वयन है जिसे आप किसी भी लाइनक ऑर्डर करने के तरीकों में छोड़ सकते हैं:
private class NaturalStringComparer : IComparer<string>
{
public int Compare(string left, string right)
{
int max = new[] { left, right }
.SelectMany(x => Regex.Matches(x, @"\d+").Cast<Match>().Select(y => (int?)y.Value.Length))
.Max() ?? 0;
var leftPadded = Regex.Replace(left, @"\d+", m => m.Value.PadLeft(max, '0'));
var rightPadded = Regex.Replace(right, @"\d+", m => m.Value.PadLeft(max, '0'));
return string.Compare(leftPadded, rightPadded);
}
}हमें निम्नलिखित पैटर्न के साथ पाठ से निपटने के लिए एक प्राकृतिक प्रकार की आवश्यकता थी:
"Test 1-1-1 something"
"Test 1-2-3 something"
...किसी कारण से जब मैंने पहली बार एसओ को देखा, तो मुझे यह पोस्ट नहीं मिली और हमने खुद को लागू किया। यहां प्रस्तुत कुछ समाधानों की तुलना में, जबकि अवधारणा में समान है, यह शायद सरल और समझने में आसान होने का लाभ हो सकता है। हालाँकि, जब मैंने प्रदर्शन की अड़चनों को देखने की कोशिश की, यह अभी भी डिफ़ॉल्ट की तुलना में बहुत धीमी गति से क्रियान्वयन है OrderBy()।
यहां विस्तार विधि है जिसे मैं लागू करता हूं:
public static class EnumerableExtensions
{
// set up the regex parser once and for all
private static readonly Regex Regex = new Regex(@"\d+|\D+", RegexOptions.Compiled | RegexOptions.Singleline);
// stateless comparer can be built once
private static readonly AggregateComparer Comparer = new AggregateComparer();
public static IEnumerable<T> OrderByNatural<T>(this IEnumerable<T> source, Func<T, string> selector)
{
// first extract string from object using selector
// then extract digit and non-digit groups
Func<T, IEnumerable<IComparable>> splitter =
s => Regex.Matches(selector(s))
.Cast<Match>()
.Select(m => Char.IsDigit(m.Value[0]) ? (IComparable) int.Parse(m.Value) : m.Value);
return source.OrderBy(splitter, Comparer);
}
/// <summary>
/// This comparer will compare two lists of objects against each other
/// </summary>
/// <remarks>Objects in each list are compare to their corresponding elements in the other
/// list until a difference is found.</remarks>
private class AggregateComparer : IComparer<IEnumerable<IComparable>>
{
public int Compare(IEnumerable<IComparable> x, IEnumerable<IComparable> y)
{
return
x.Zip(y, (a, b) => new {a, b}) // walk both lists
.Select(pair => pair.a.CompareTo(pair.b)) // compare each object
.FirstOrDefault(result => result != 0); // until a difference is found
}
}
}विचार मूल तारों को अंकों और गैर-अंकों ( "\d+|\D+") के ब्लॉक में विभाजित करना है । चूंकि यह एक संभावित महंगा कार्य है, यह केवल एक बार प्रविष्टि के अनुसार किया जाता है। हम तब तुलनीय वस्तुओं की तुलना करते हैं (क्षमा करें, मुझे यह कहने का अधिक उचित तरीका नहीं मिल सकता है)। यह प्रत्येक ब्लॉक की तुलना दूसरे स्ट्रिंग में इसके संबंधित ब्लॉक से करता है।
मैं इस पर प्रतिक्रिया चाहूंगा कि इसमें कैसे सुधार किया जा सकता है और प्रमुख दोष क्या हैं। ध्यान दें कि इस बिंदु पर स्थिरता हमारे लिए महत्वपूर्ण है और हम वर्तमान में अत्यंत बड़े डेटा सेटों में इसका उपयोग नहीं कर रहे हैं।
एक संस्करण जो पढ़ने / बनाए रखने में आसान है।
public class NaturalStringComparer : IComparer<string>
{
public static NaturalStringComparer Instance { get; } = new NaturalStringComparer();
public int Compare(string x, string y) {
const int LeftIsSmaller = -1;
const int RightIsSmaller = 1;
const int Equal = 0;
var leftString = x;
var rightString = y;
var stringComparer = CultureInfo.CurrentCulture.CompareInfo;
int rightIndex;
int leftIndex;
for (leftIndex = 0, rightIndex = 0;
leftIndex < leftString.Length && rightIndex < rightString.Length;
leftIndex++, rightIndex++) {
var leftChar = leftString[leftIndex];
var rightChar = rightString[leftIndex];
var leftIsNumber = char.IsNumber(leftChar);
var rightIsNumber = char.IsNumber(rightChar);
if (!leftIsNumber && !rightIsNumber) {
var result = stringComparer.Compare(leftString, leftIndex, 1, rightString, leftIndex, 1);
if (result != 0) return result;
} else if (leftIsNumber && !rightIsNumber) {
return LeftIsSmaller;
} else if (!leftIsNumber && rightIsNumber) {
return RightIsSmaller;
} else {
var leftNumberLength = NumberLength(leftString, leftIndex, out var leftNumber);
var rightNumberLength = NumberLength(rightString, rightIndex, out var rightNumber);
if (leftNumberLength < rightNumberLength) {
return LeftIsSmaller;
} else if (leftNumberLength > rightNumberLength) {
return RightIsSmaller;
} else {
if(leftNumber < rightNumber) {
return LeftIsSmaller;
} else if(leftNumber > rightNumber) {
return RightIsSmaller;
}
}
}
}
if (leftString.Length < rightString.Length) {
return LeftIsSmaller;
} else if(leftString.Length > rightString.Length) {
return RightIsSmaller;
}
return Equal;
}
public int NumberLength(string str, int offset, out int number) {
if (string.IsNullOrWhiteSpace(str)) throw new ArgumentNullException(nameof(str));
if (offset >= str.Length) throw new ArgumentOutOfRangeException(nameof(offset), offset, "Offset must be less than the length of the string.");
var currentOffset = offset;
var curChar = str[currentOffset];
if (!char.IsNumber(curChar))
throw new ArgumentException($"'{curChar}' is not a number.", nameof(offset));
int length = 1;
var numberString = string.Empty;
for (currentOffset = offset + 1;
currentOffset < str.Length;
currentOffset++, length++) {
curChar = str[currentOffset];
numberString += curChar;
if (!char.IsNumber(curChar)) {
number = int.Parse(numberString);
return length;
}
}
number = int.Parse(numberString);
return length;
}
}मुझे अपनी समस्या बताएं और मैं इसे हल करने में कैसे सक्षम था।
समस्या: - फाइलइन्फो ऑब्जेक्ट्स से फाइलनेम पर आधारित फाइल्स को सॉर्ट करें जो एक डायरेक्टरी से रिकवर की जाती हैं।
समाधान: - मैंने FileInfo से फ़ाइल नामों का चयन किया और फ़ाइल नाम के ".png" भाग को ट्रिम किया। अब, बस List.Sort () करें, जो फ़ाइल नाम को प्राकृतिक क्रमबद्ध क्रम में क्रमबद्ध करता है। मेरे परीक्षण के आधार पर मैंने पाया कि। Png मेसेजिंग क्रम को गड़बड़ करता है। नीचे दिए गए कोड पर एक नज़र है
var imageNameList = new DirectoryInfo(@"C:\Temp\Images").GetFiles("*.png").Select(x =>x.Name.Substring(0, x.Name.Length - 4)).ToList();
imageNameList.Sort();