Come utilizzare il metodo di estensione Join()?

Question

Riesco a capire la stringa.Join( )

  var stringies1 =new [] {"Blood", "is", "Thicker", "Than", "Water" };
  var zoin = string.Join("|", stringies1);

In cosa differisce dal metodo di estensione Join() ?

I mean stringies1.Join(IEnumerable<T Result......)

Answer 1

Il metodo di estensione a cui ti riferisci, Enumerabile. Partecipa serve per unire le raccolte, il che significa che le metti una accanto all'altra e provi ad abbinare elementi con elementi, producendo risultati.Immagina di abbinare la rubrica con l'elenco dei nomi di una festa, per trovare il numero di telefono di tutti i nomi che hai nell'elenco.

Quindi no, il metodo di estensione Join non può essere utilizzato per posizionarli uno dopo l'altro e combinarli in un unico array lungo.

Esiste tuttavia un'alternativa, puoi utilizzare il metodo di estensione Enumerabile.Concat nella stessa classe.

Questo metodo non funziona solo su/con gli array, ma su tutti i tipi di raccolta che implementano IEnumerable<T>, e ne produrrà così anche un altro IEnumerable<T> come suo risultato.Questo risultato può quindi essere convertito in un array utilizzando Enumerabile.ToArray.

Pertanto, utilizzeresti il ​​seguente codice:

var stringies1 = new [] {"Blood", "is", "Thicker", "Than", "Water" };
var stringies2 = new [] { "and", "so", "is", "wine" };

var stringies3 = stringies1.Concat(stringies2).ToArray();
// stringies3 now contains "Blood", "is", ... and "and", "so", "is", ...

Ciò presuppone che tu stia utilizzando .NET 3.5 e che nell'elenco di utilizzo nella parte superiore del file sia presente quanto segue:

using System.Linq;

Se, d'altra parte, tu (o qualcun altro che trova questa risposta) non utilizzi .NET 3.5, hai bisogno di un codice manuale.Ecco un semplice metodo generico (presuppone .NET 2.0) che può aiutarti:

public static T[] Concat<T>(T[] firstSource, T[] secondSource,
    params T[] restOfSources)
{
    // omitted validation of non-null arguments, etc.

    Int32 totalLength = firstSource.Length + secondSource.Length;
    foreach (T[] source in restOfSources)
        totalLength += source.Length;

    T[] result = new T[totalLength];
    Int32 currentIndex = 0;

    Array.Copy(firstSource, 0, result, currentIndex, firstSource.Length);
    currentIndex += firstSource.Length;

    Array.Copy(secondSource, 0, result, currentIndex, secondSource.Length);
    currentIndex += secondSource.Length;

    foreach (T[] source in restOfSources)
    {
        Array.Copy(source, 0, result, currentIndex, source.Length);
        currentIndex += source.Length;
    }

    return result;
}

Questo può essere usato in questo modo:

var stringies1 = ...
var stringies2 = ...

var stringies3 = YourClass.Concat(stringies1, stringies2);

Answer 2

Suppongo che con il metodo di estensione ti riferisci al metodo Enumerable.Join? string.Join un IEnumerable.Join sono due metodi piuttosto diversi:

• <=> prenderà una serie di stringhe, le unirà insieme usando un separatore e restituirà la stringa risultante.
• <=> agirà su due raccolte molto nel allo stesso modo di un'operazione JOIN in SQL

Answer 3

Stessa funzione approccio diverso per leggibilità e meno codice quando appropriato.