Comment puis-je copier le contenu d'un flux à un autre?

De .NET 4.5, il est le Stream.CopyToAsync méthode

input.CopyToAsync(output);

Cela renvoie un Tâche qui peut être poursuivi sur une fois rempli, comme suit:

await input.CopyToAsync(output)

//Code from here on will be run in a continuation.

Note que selon l'endroit où l'appel à CopyToAsync, le code qui suit peut ou ne peut pas continuer sur le même thread qui l'a appelée.

La SynchronizationContext qui a été capturé lors de l'appel de attendre permettra de déterminer quel est le fil que la suite sera exécutée.

En outre, cet appel (et c'est un détail d'implémentation sous réserve de modification) encore des séquences de lectures et d'écritures (il n'a tout simplement pas perdre un fils de blocage sur les I/O d'achèvement).

De .NET 4.0, il est le Stream.CopyTo méthode

input.CopyTo(output);

Pour .NET 3.5 et avant

N'est il pas tout cuit dans le cadre de l'aider avec cela; vous devez copier le contenu manuellement, comme suit:

public static void CopyStream(Stream input, Stream output)
{
    byte[] buffer = new byte[32768];
    int read;
    while ((read = input.Read(buffer, 0, buffer.Length)) > 0)
    {
        output.Write (buffer, 0, read);
    }
}

Note 1: Cette méthode vous permettra de faire rapport sur les progrès (x octets lu jusqu'à présent ...)

Note 2: Pourquoi utiliser un fixe taille de la mémoire tampon et pas input.Length? Parce que la Longueur peut ne pas être disponible! À partir de la docs:

Si une classe dérivée de Flux ne prend pas en charge la recherche, les appels à la Longueur, SetLength, la Position, et de Demander de jeter un NotSupportedException.

J'utilise la suite des méthodes d'extension. Ils ont optimisé les surcharges pour lorsqu'un flux est un MemoryStream.

    public static void CopyTo(this Stream src, Stream dest)
    {
        int size = (src.CanSeek) ? Math.Min((int)(src.Length - src.Position), 0x2000) : 0x2000;
        byte[] buffer = new byte[size];
        int n;
        do
        {
            n = src.Read(buffer, 0, buffer.Length);
            dest.Write(buffer, 0, n);
        } while (n != 0);           
    }

    public static void CopyTo(this MemoryStream src, Stream dest)
    {
        dest.Write(src.GetBuffer(), (int)src.Position, (int)(src.Length - src.Position));
    }

    public static void CopyTo(this Stream src, MemoryStream dest)
    {
        if (src.CanSeek)
        {
            int pos = (int)dest.Position;
            int length = (int)(src.Length - src.Position) + pos;
            dest.SetLength(length); 

            while(pos < length)                
                pos += src.Read(dest.GetBuffer(), pos, length - pos);
        }
        else
            src.CopyTo((Stream)dest);
    }

Il est en fait, une moins lourde façon de faire un stream copy. Prenez note toutefois, que cela implique que vous pouvez stocker la totalité du fichier en mémoire. N'essayez pas de les utiliser si vous travaillez avec des fichiers qui vont de plusieurs centaines de méga-octets ou plus, sans précaution.

public static void CopyStream(Stream input, Stream output)
{
  using (StreamReader reader = new StreamReader(input))
  using (StreamWriter writer = new StreamWriter(output))
  {
    writer.Write(reader.ReadToEnd());
  }
}

REMARQUE: Il se peut également que certains problèmes concernant les données binaires et les encodages de caractères.

Malheureusement, il n'y a pas vraiment de solution simple. Vous pouvez essayer quelque chose comme ça:

Stream s1, s2;
byte[] buffer = new byte[4096];
int bytesRead = 0;
while (bytesRead = s1.Read(buffer, 0, buffer.Length) > 0) s2.Write(buffer, 0, bytesRead);
s1.Close(); s2.Close();

Mais le problème avec qui que la mise en œuvre différente de la classe de Flux peut se comporter différemment si il n'y a rien à lire. Un flux de lecture d'un fichier à partir d'un disque dur local sera probablement bloquer jusqu'à ce que la lecture operaition a lu suffisamment de données à partir du disque de remplissage de la mémoire tampon et ne reviennent moins de données si elle atteint la fin de fichier. D'autre part, un flux de lecture depuis le réseau pourrait revenir moins de données, même si il y a plus de gauche pour être reçu.

Toujours consulter la documentation spécifique de la classe de flux que vous utilisez avant d'utiliser une solution générique.

si vous voulez une procdure pour copier un flux de données vers d'autres celui que nick a posté c'est bien, mais il manque la position de réinitialisation, il devrait être

public static void CopyStream(Stream input, Stream output)
{
    byte[] buffer = new byte[32768];
    long TempPos = input.Position;
    while (true)    
    {
        int read = input.Read (buffer, 0, buffer.Length);
        if (read <= 0)
            return;
        output.Write (buffer, 0, read);
    }
    input.Position = TempPos;//or you make Position = 0 to set it at the start
}

mais si c'est dans l'exécution pas à l'aide d'une procédure vous shpuld utilisation de flux de mémoire

Stream output = new MemoryStream();
byte[] buffer = new byte[32768]; //or you specify the size you want of your buffer
long TempPos = input.Position;
while (true)    
{
    int read = input.Read (buffer, 0, buffer.Length);
    if (read <= 0)
        return;
    output.Write (buffer, 0, read);
 }
    input.Position = TempPos;//or you make Position = 0 to set it at the start

Pour .NET 3.5 et avant d'essayer :

MemoryStream1.WriteTo(MemoryStream2);