Compartilhar via


Método TSource Observable.Concat<(IObservable<TSource>, IObservable<TSource>)>

Concatena duas sequências observáveis.

Namespace:System.Reactive.Linq
Assembly: System.Reactive (em System.Reactive.dll)

Sintaxe

'Declaration
<ExtensionAttribute> _
Public Shared Function Concat(Of TSource) ( _
    first As IObservable(Of TSource), _
    second As IObservable(Of TSource) _
) As IObservable(Of TSource)
'Usage
Dim first As IObservable(Of TSource)
Dim second As IObservable(Of TSource)
Dim returnValue As IObservable(Of TSource)

returnValue = first.Concat(second)
public static IObservable<TSource> Concat<TSource>(
    this IObservable<TSource> first,
    IObservable<TSource> second
)
[ExtensionAttribute]
public:
generic<typename TSource>
static IObservable<TSource>^ Concat(
    IObservable<TSource>^ first, 
    IObservable<TSource>^ second
)
static member Concat : 
        first:IObservable<'TSource> * 
        second:IObservable<'TSource> -> IObservable<'TSource> 
JScript does not support generic types and methods.

Parâmetros de tipo

  • TSource
    O tipo de fonte.

Parâmetros

Valor Retornado

Tipo: System.IObservable<TSource>
Uma sequência observável que contém os elementos da primeira sequência, seguidos pelos da segunda sequência.

Observação de uso

No Visual Basic e no C#, você pode chamar esse método como um método de instância em qualquer objeto do tipo IObservable<TSource>. Quando você usar a sintaxe de método de instância para chamar esse método, omita o primeiro parâmetro. Para obter mais informações, consulte ou .

Comentários

O operador Concat executa a primeira sequência até a conclusão. Em seguida, a segunda sequência é executada até a conclusão concatenando efetivamente a segunda sequência até o final da primeira sequência. Outras sobrecargas desse operador permitem concatenar mais de duas sequências observáveis. Ao chamar o operador Concat como um método de extensão, o primeiro parâmetro é a sequência da qual o método de extensão está sendo executado. Isso é demonstrado no exemplo de código neste tópico. A sequência passada para o operador como o segundo parâmetro será concatenada para a primeira sequência somente quando a primeira sequência for executada até a conclusão. Portanto, é importante observar que a assinatura da segunda sequência é adiada até que a primeira sequência seja executada até sua conclusão. Se ele não for executado até a conclusão devido a uma exceção ou ao bloqueio, uma assinatura para a segunda sequência não será criada.

Exemplos

Este código de exemplo demonstra a concatenação de duas sequências de inteiros para produzir uma sequência de inteiros de 1 a 6. Cada inteiro é gravado na janela do console.

using System;
using System.Collections.Generic;
using System.Reactive.Linq;

namespace Example
{

  class Program
  {

    static void Main()
    {
      int[] sequence1 = {1, 2, 3};
      int[] sequence2 = {4, 5, 6};
      
      //*** Create a new observable sequence of integers by concatenating sequence2 to sequence1 ***//
      IObservable<int> sequences = sequence1.ToObservable().Concat(sequence2.ToObservable());

      //*** The event handler for the subscription will just write each integer from the sequence to the console window. ***//
      sequences.Subscribe(i => Console.WriteLine(i));

      Console.ReadLine();     
    }
  }
}

A saída do código de exemplo é mostrada abaixo.

1
2
3
4
5
6

Consulte Também

Referência

Classe Observável

Sobrecarga do Concat

System.Reactive.Linq Namespace