Comment puis-je télécharger un fichier et enregistrer dans un flux pour un aperçu supplémentaire en utilisant c #?

Bien sûr. Je télécharge des fichiers (pdf / images) vers My DB dans mon app . Mon objet de modèle stocke réellement le fichier sous forme de tableau d'octets, mais pour d'autres fonctions que je dois convertir et depuis des flux, donc je suis sûr que c'est tout aussi facile à maintenir en format de flux.

Voici quelques exemples de code (Copier N Coller) de mon application - p>

Le fichier code> objet code> que j'utilise pour déplacer des fichiers (pdfs / images) autour de: p> xxx pré>

. .Le pdfdoc code> Tapez spécifiquement pour les fichiers PDF: p> xxx pré>

.. Un exemple d'action qui reçoit un poste de plusieurs pièces pour le téléchargement de fichier: p> xxx pré>

Vous pouvez maintenant voir que je passe l'objet de fichier à mon service ici, mais vous pouvez choisir de l'ajouter à la session et de passer un identifiant à la vue "Aperçu" par exemple. P>

Enfin, voici une action générique que j'utilise pour rendant des fichiers sur le client (vous pouvez avoir quelque chose de similaire rendu les fichiers / flux de la session): p>

    /// <summary>
    /// Reads data from a stream until the end is reached. The
    /// data is returned as a byte array. An IOException is
    /// thrown if any of the underlying IO calls fail.
    /// </summary>
    /// <param name="stream">The stream to read data from</param>
    /// <param name="initialLength">The initial buffer length</param>
    public static byte[] ReadFully(System.IO.Stream stream, long initialLength)
    {
        // reset pointer just in case
        stream.Seek(0, System.IO.SeekOrigin.Begin);

        // If we've been passed an unhelpful initial length, just
        // use 32K.
        if (initialLength < 1)
        {
            initialLength = 32768;
        }

        byte[] buffer = new byte[initialLength];
        int read = 0;

        int chunk;
        while ((chunk = stream.Read(buffer, read, buffer.Length - read)) > 0)
        {
            read += chunk;

            // If we've reached the end of our buffer, check to see if there's
            // any more information
            if (read == buffer.Length)
            {
                int nextByte = stream.ReadByte();

                // End of stream? If so, we're done
                if (nextByte == -1)
                {
                    return buffer;
                }

                // Nope. Resize the buffer, put in the byte we've just
                // read, and continue
                byte[] newBuffer = new byte[buffer.Length * 2];
                Array.Copy(buffer, newBuffer, buffer.Length);
                newBuffer[read] = (byte)nextByte;
                buffer = newBuffer;
                read++;
            }
        }
        // Buffer is now too big. Shrink it.
        byte[] ret = new byte[read];
        Array.Copy(buffer, ret, read);
        return ret;
    }

Oui, mais vous ne pouvez pas l'enregistrer dans un flux. Un flux ne contient aucune donnée, ce n'est que des moyens d'accéder au stockage réel.

Obtenez les données sous forme de tableau d'octets, vous pouvez la mettre dans une variable de session, le sauvegarder en tant que fichier et l'envoyer comme une réponse.

Utilisez un BinaryReader pour obtenir les données du flux d'entrée à un tableau d'octets: xxx

(modifier: modifié à partir d'un flux planteur à un BinaryReader)

byte[] data; 
using (Stream inputStream = PdfPath.InputStream) 
{ 
    MemoryStream memoryStream = inputStream as MemoryStream; 

    if (memoryStream == null) 
    { 
        memoryStream = new MemoryStream(); 
        inputStream.CopyTo(memoryStream); 
    } 

    data = memoryStream.ToArray(); 
}