Qual è il modo più breve in .NET per ordinare le stringhe che iniziano con 1, 10 e 2 e rispettare l'ordinamento dei numeri?

Question

Ho bisogno di ordinare i nomi dei file come segue: 1.Accedere, 2.log, 10.log

Ma quando uso OrderBy (fn => fn) li fascicolerà come: 1.Accedere, 10. log, 2.log

Ovviamente so che questo potrebbe essere fatto scrivendo un altro comparatore, ma c'è un modo più semplice per passare dall'ordine lessicografico all'ordinamento naturale?

Modifica: l'obiettivo è ottenere lo stesso ordinamento di quando si seleziona "ordina per nome" in Esplora risorse.

Answer 1

È possibile utilizzare la funzione Win32 CompareStringEx. Su Windows 7 supporta l'ordinamento di cui hai bisogno. Avrete uso P/Invoke:

static readonly Int32 NORM_IGNORECASE = 0x00000001; 
static readonly Int32 NORM_IGNORENONSPACE = 0x00000002; 
static readonly Int32 NORM_IGNORESYMBOLS = 0x00000004; 
static readonly Int32 LINGUISTIC_IGNORECASE = 0x00000010; 
static readonly Int32 LINGUISTIC_IGNOREDIACRITIC = 0x00000020; 
static readonly Int32 NORM_IGNOREKANATYPE = 0x00010000; 
static readonly Int32 NORM_IGNOREWIDTH = 0x00020000; 
static readonly Int32 NORM_LINGUISTIC_CASING = 0x08000000; 
static readonly Int32 SORT_STRINGSORT = 0x00001000; 
static readonly Int32 SORT_DIGITSASNUMBERS = 0x00000008; 

static readonly String LOCALE_NAME_USER_DEFAULT = null; 
static readonly String LOCALE_NAME_INVARIANT = String.Empty; 
static readonly String LOCALE_NAME_SYSTEM_DEFAULT = "!sys-default-locale"; 

[DllImport("kernel32.dll", CharSet = CharSet.Unicode)] 
static extern Int32 CompareStringEx(
    String localeName, 
    Int32 flags, 
    String str1, 
    Int32 count1, 
    String str2, 
    Int32 count2, 
    IntPtr versionInformation, 
    IntPtr reserved, 
    Int32 param 
); 

È possibile quindi creare un IComparer che utilizza il flag SORT_DIGITSASNUMBERS:

class LexicographicalComparer : IComparer<String> { 

    readonly String locale; 

    public LexicographicalComparer() : this(CultureInfo.CurrentCulture) { } 

    public LexicographicalComparer(CultureInfo cultureInfo) { 
    if (cultureInfo.IsNeutralCulture) 
     this.locale = LOCALE_NAME_INVARIANT; 
    else 
     this.locale = cultureInfo.Name; 
    } 

    public Int32 Compare(String x, String y) { 
    // CompareStringEx return 1, 2, or 3. Subtract 2 to get the return value. 
    return CompareStringEx( 
     this.locale, 
     SORT_DIGITSASNUMBERS, // Add other flags if required. 
     x, 
     x.Length, 
     y, 
     y.Length, 
     IntPtr.Zero, 
     IntPtr.Zero, 
     0) - 2; 
    } 

} 

è quindi possibile utilizzare il IComparer in vari ordinamento API:

var names = new [] { "2.log", "10.log", "1.log" }; 
var sortedNames = names.OrderBy(s => s, new LexicographicalComparer()); 

È inoltre possibile utilizzare StrCmpLogicalW, che è la funzione utilizzata da Esplora risorse. È disponibile da Windows XP:

[DllImport("shlwapi.dll", CharSet = CharSet.Unicode)] 
static extern Int32 StrCmpLogical(String x, String y); 

class LexicographicalComparer : IComparer<String> { 

    public Int32 Compare(String x, String y) { 
    return StrCmpLogical(x, y); 
    } 

} 

Più semplice, ma si ha meno controllo sul confronto.

Answer 2

Sarebbe più facile se fosse un ordine lessicografico.

Il confronto delle stringhe è sempre lettera per lettera.

Come si vuole gestire questo senza guardare l'intero numero?

No, un unico comparatore è l'unica soluzione.

Answer 3

Si potrebbe semplicemente rimuovere tutti i caratteri non numerici, analizzare a int e poi scegli:

Regex r = new Regex(@"[^\d]"); 
OrderBy(fn => int.Parse(r.Replace(fn, ""))); 

Answer 4

no io non la penso così - credo che si deve scrivere da soli il tempo che i vostri dati sono solo una stringa. se fate i vostri dati in qualcosa di simile

struct LogDescription 
{ 
    public int LogBase { get; set; } 
    public override ToString() 
    { return string.Format("{0}.log", LogBase); } 
} 

è possibile ordinare tramite logbase-Field

Answer 5

Il modo più semplice (non necessariamente più veloce/ottimale) sarebbe IMHO a tutti loro sinistra-pad in una certa lunghezza massima predefinita con zeri. Cioè

var data = new[] { "1.log", "10.log", "2.log" }; 
data.OrderBy(x => x.PadLeft(10, '0')).Dump(); 

Answer 6

Si può fare qualcosa di simile quando si può assicurare il formato dei vostri nomi sono NUMBER.VALUE:

var q = strings.Select(s => s.Split(new[] {'.'}, 2)) 
    .Select(s => new 
         { 
          Number = Convert.ToInt32(s[0]), 
          Name = s[1] 
         }) 
    .OrderBy(s => s.Number) 
    .Select(s => string.Format("{0}.{1}", s.Number, s.Name)); 

Answer 7

Se i nomi di file sempre consistono solo in cifre, è possibile utilizzare Path.GetFileNameWithoutExtension() scartare l'estensione del file e Convert.ToInt32() (o simile) per convertire i nomi di file di numeri interi a scopo di confronto:

var ordered = yourFileNames.OrderBy(
    fn => Convert.ToInt32(Path.GetFileNameWithoutExtension(fn))); 

Nel caso generale, o se siete l Per ottenere un modo più "standard" per farlo, è possibile p/invocare StrCmpLogicalW(), che Explorer utilizza per ordinare i nomi dei file nelle sue viste. Tuttavia, facendo ciò ti costringerà ad implementare un IComparer<string> se si desidera utilizzare OrderBy().

Answer 8

Si dovrebbe prendere uno di questi

• http://www.interact-sw.co.uk/iangblog/2007/12/13/natural-sorting
• http://www.davekoelle.com/alphanum.html