Enumerable.Concat<TSource> Método

Definición

Espacio de nombres:

System.Linq

Ensamblado:

System.Linq.dll

Source:

Concat.cs

Concatena dos secuencias.

public:
generic <typename TSource>
[System::Runtime::CompilerServices::Extension]
 static System::Collections::Generic::IEnumerable<TSource> ^ Concat(System::Collections::Generic::IEnumerable<TSource> ^ first, System::Collections::Generic::IEnumerable<TSource> ^ second);

public static System.Collections.Generic.IEnumerable<TSource> Concat<TSource> (this System.Collections.Generic.IEnumerable<TSource> first, System.Collections.Generic.IEnumerable<TSource> second);

static member Concat : seq<'Source> * seq<'Source> -> seq<'Source>

<Extension()>
Public Function Concat(Of TSource) (first As IEnumerable(Of TSource), second As IEnumerable(Of TSource)) As IEnumerable(Of TSource)

Parámetros de tipo

TSource

Tipo de los elementos de las secuencias de entrada.

Parámetros

first

IEnumerable<TSource>

Primera secuencia que se va a concatenar.

second

IEnumerable<TSource>

Secuencia que se va a concatenar con la primera secuencia.

Devoluciones

IEnumerable<TSource>

IEnumerable<T> que contiene los elementos concatenados de las dos secuencias de entrada.

Excepciones

ArgumentNullException

first o second es null.

Ejemplos

En el ejemplo de código siguiente se muestra cómo usar Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) para concatenar dos secuencias.

class Pet
{
    public string Name { get; set; }
    public int Age { get; set; }
}

static Pet[] GetCats()
{
    Pet[] cats = { new Pet { Name="Barley", Age=8 },
                   new Pet { Name="Boots", Age=4 },
                   new Pet { Name="Whiskers", Age=1 } };
    return cats;
}

static Pet[] GetDogs()
{
    Pet[] dogs = { new Pet { Name="Bounder", Age=3 },
                   new Pet { Name="Snoopy", Age=14 },
                   new Pet { Name="Fido", Age=9 } };
    return dogs;
}

public static void ConcatEx1()
{
    Pet[] cats = GetCats();
    Pet[] dogs = GetDogs();

    IEnumerable<string> query =
        cats.Select(cat => cat.Name).Concat(dogs.Select(dog => dog.Name));

    foreach (string name in query)
    {
        Console.WriteLine(name);
    }
}

// This code produces the following output:
//
// Barley
// Boots
// Whiskers
// Bounder
// Snoopy
// Fido

Structure Pet
    Public Name As String
    Public Age As Integer
End Structure

' Returns an array of Pet objects.
Function GetCats() As Pet()
    Dim cats() As Pet = {New Pet With {.Name = "Barley", .Age = 8},
                 New Pet With {.Name = "Boots", .Age = 4},
                 New Pet With {.Name = "Whiskers", .Age = 1}}

    Return cats
End Function

' Returns an array of Pet objects.
Function GetDogs() As Pet()
    Dim dogs() As Pet = {New Pet With {.Name = "Bounder", .Age = 3},
                 New Pet With {.Name = "Snoopy", .Age = 14},
                 New Pet With {.Name = "Fido", .Age = 9}}
    Return dogs
End Function

Sub ConcatEx1()
    ' Create two arrays of Pet objects.
    Dim cats() As Pet = GetCats()
    Dim dogs() As Pet = GetDogs()

    ' Project the Name of each cat and concatenate
    ' the collection of cat name strings with a collection
    ' of dog name strings.
    Dim query As IEnumerable(Of String) =
cats _
.Select(Function(cat) cat.Name) _
.Concat(dogs.Select(Function(dog) dog.Name))

    Dim output As New System.Text.StringBuilder
    For Each name As String In query
        output.AppendLine(name)
    Next

    ' Display the output.
    Console.WriteLine(output.ToString())
End Sub

' This code produces the following output:
'
' Barley
' Boots
' Whiskers
' Bounder
' Snoopy
' Fido

Una forma alternativa de concatenar dos secuencias es construir una colección, por ejemplo, una matriz, de secuencias y, a continuación, aplicar el SelectMany método , pasarla a la función del selector de identidades. En el ejemplo siguiente se muestra este uso de SelectMany.

Pet[] cats = GetCats();
Pet[] dogs = GetDogs();

IEnumerable<string> query =
    new[] { cats.Select(cat => cat.Name), dogs.Select(dog => dog.Name) }
    .SelectMany(name => name);

foreach (string name in query)
{
    Console.WriteLine(name);
}

// This code produces the following output:
//
// Barley
// Boots
// Whiskers
// Bounder
// Snoopy
// Fido

    ' Create two arrays of Pet objects.
    Dim cats() As Pet = GetCats()
    Dim dogs() As Pet = GetDogs()

    ' Create an IEnumerable collection that contains two elements.
    ' Each element is an array of Pet objects.
    Dim animals() As IEnumerable(Of Pet) = {cats, dogs}

    Dim query As IEnumerable(Of String) =
(animals.SelectMany(Function(pets) _
                        pets.Select(Function(pet) pet.Name)))

    Dim output As New System.Text.StringBuilder
    For Each name As String In query
        output.AppendLine(name)
    Next

    ' Display the output.
    Console.WriteLine(output.ToString())

    ' This code produces the following output:
    '
    ' Barley
    ' Boots
    ' Whiskers
    ' Bounder
    ' Snoopy
    ' Fido

Comentarios

Este método se implementa mediante la ejecución diferida. El valor devuelto inmediato es un objeto que almacena toda la información necesaria para realizar la acción. La consulta representada por este método no se ejecuta hasta que el objeto se enumera llamando directamente a su GetEnumerator método o mediante foreach en C# o For Each en Visual Basic.

El Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) método difiere del Union método porque el Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) método devuelve todos los elementos originales de las secuencias de entrada. El Union método devuelve solo elementos únicos.