Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Classe CryptoStream

 

Data di pubblicazione: ottobre 2016

Definisce un flusso che collega i flussi di dati alle trasformazioni crittografiche.

Spazio dei nomi:   System.Security.Cryptography
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.MarshalByRefObject
    System.IO.Stream
      System.Security.Cryptography.CryptoStream

[ComVisibleAttribute(true)]
public class CryptoStream : Stream, IDisposable

NomeDescrizione
System_CAPS_pubmethodCryptoStream(Stream, ICryptoTransform, CryptoStreamMode)

Inizializza una nuova istanza della classe CryptoStream con un flusso di dati di destinazione, la trasformazione da usare e la modalità del flusso.

NomeDescrizione
System_CAPS_pubpropertyCanRead

Ottiene un valore che indica se l'oggetto CryptoStream è leggibile.(Esegue l'override di Stream.CanRead.)

System_CAPS_pubpropertyCanSeek

Ottiene un valore che indica se è possibile effettuare ricerche nel flusso CryptoStream corrente.(Esegue l'override di Stream.CanSeek.)

System_CAPS_pubpropertyCanTimeout

Ottiene un valore che determina se il flusso corrente prevede il timeout.(Ereditato da Stream.)

System_CAPS_pubpropertyCanWrite

Ottiene un valore che indica se l'oggetto CryptoStream è scrivibile.(Esegue l'override di Stream.CanWrite.)

System_CAPS_pubpropertyHasFlushedFinalBlock

Ottiene un valore che indica se il blocco finale del buffer è stato scritto nel flusso sottostante.

System_CAPS_pubpropertyLength

Ottiene la lunghezza in byte del flusso.(Esegue l'override di Stream.Length.)

System_CAPS_pubpropertyPosition

Ottiene o imposta la posizione all'interno del flusso corrente.(Esegue l'override di Stream.Position.)

System_CAPS_pubpropertyReadTimeout

Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la lettura prima del timeout.(Ereditato da Stream.)

System_CAPS_pubpropertyWriteTimeout

Ottiene o imposta un valore, in millisecondi, che determina per quanto tempo il flusso tenterà la scrittura prima del timeout.(Ereditato da Stream.)

NomeDescrizione
System_CAPS_pubmethodBeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Inizia un'operazione di lettura asincrona. (Considerare, in alternativa, l'uso di ReadAsync. Vedere la sezione Osservazioni).(Ereditato da Stream.)

System_CAPS_pubmethodBeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Inizia un'operazione di scrittura asincrona. (Considerare, in alternativa, l'uso di WriteAsync. Vedere la sezione Osservazioni).(Ereditato da Stream.)

System_CAPS_pubmethodClear()

Rilascia tutte le risorse usate da CryptoStream.

System_CAPS_pubmethodClose()

Chiude il flusso corrente e libera le risorse, come socket e handle di file, ad esso associate. Anziché chiamare questo metodo, assicurarsi che il flusso sia eliminato correttamente.(Ereditato da Stream.)

System_CAPS_pubmethodCopyTo(Stream)

Legge i byte dal flusso corrente e li scrive in un altro flusso.(Ereditato da Stream.)

System_CAPS_pubmethodCopyTo(Stream, Int32)

Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata.(Ereditato da Stream.)

System_CAPS_pubmethodCopyToAsync(Stream)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso.(Ereditato da Stream.)

System_CAPS_pubmethodCopyToAsync(Stream, Int32)

Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata.(Ereditato da Stream.)

System_CAPS_pubmethodCopyToAsync(Stream, Int32, CancellationToken)

Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata e un token di annullamento.(Ereditato da Stream.)

System_CAPS_pubmethodCreateObjRef(Type)

Crea un oggetto che contiene le informazioni necessarie per generare un proxy utilizzato per comunicare con un oggetto remoto.(Ereditato da MarshalByRefObject.)

System_CAPS_protmethodCreateWaitHandle()

Obsoleto. Alloca un oggetto WaitHandle.(Ereditato da Stream.)

System_CAPS_pubmethodDispose()

Rilascia tutte le risorse usate da Stream.(Ereditato da Stream.)

System_CAPS_protmethodDispose(Boolean)

Rilascia le risorse non gestite usate da CryptoStream e, facoltativamente, le risorse gestite.(Esegue l'override di Stream.Dispose(Boolean).)

System_CAPS_pubmethodEndRead(IAsyncResult)

Attende il completamento della lettura asincrona in sospeso. (Considerare, in alternativa, l'uso di ReadAsync. Vedere la sezione Osservazioni).(Ereditato da Stream.)

System_CAPS_pubmethodEndWrite(IAsyncResult)

Termina un'operazione di scrittura asincrona. (Considerare, in alternativa, l'uso di WriteAsync. Vedere la sezione Osservazioni).(Ereditato da Stream.)

System_CAPS_pubmethodEquals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object.)

System_CAPS_protmethodFinalize()

Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection. (Ereditato da Object.)

System_CAPS_pubmethodFlush()

Cancella tutti i buffer relativi al flusso corrente e consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante.(Esegue l'override di Stream.Flush().)

System_CAPS_pubmethodFlushAsync()

Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante.(Ereditato da Stream.)

System_CAPS_pubmethodFlushAsync(CancellationToken)

Cancella tutti i buffer del flusso corrente in modo asincrono, consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante e monitora le richieste di annullamento.(Esegue l'override di Stream.FlushAsync(CancellationToken).)

System_CAPS_pubmethodFlushFinalBlock()

Aggiorna l'origine dati o il repository sottostante con lo stato corrente del buffer, quindi cancella il buffer.

System_CAPS_pubmethodGetHashCode()

Funge da funzione hash predefinita.(Ereditato da Object.)

System_CAPS_pubmethodGetLifetimeService()

Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza.(Ereditato da MarshalByRefObject.)

System_CAPS_pubmethodGetType()

Ottiene l'oggetto Type dell'istanza corrente.(Ereditato da Object.)

System_CAPS_pubmethodInitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.(Ereditato da MarshalByRefObject.)

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.(Ereditato da Object.)

System_CAPS_protmethodMemberwiseClone(Boolean)

Crea una copia superficiale dell'oggetto corrente MarshalByRefObject oggetto.(Ereditato da MarshalByRefObject.)

System_CAPS_protmethodObjectInvariant()

Obsoleto. Questa API supporta l'infrastruttura prodotto e non può essere usata direttamente dal codice. Fornisce supporto per un oggetto Contract.(Ereditato da Stream.)

System_CAPS_pubmethodRead(Byte[], Int32, Int32)

Legge una sequenza di byte dal flusso corrente e fa avanzare la posizione nel flusso del numero di byte letti.(Esegue l'override di Stream.Read(Byte[], Int32, Int32).)

System_CAPS_pubmethodReadAsync(Byte[], Int32, Int32)

Legge in modo asincrono una sequenza di byte dal flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte letti.(Ereditato da Stream.)

System_CAPS_pubmethodReadAsync(Byte[], Int32, Int32, CancellationToken)

Legge una sequenza di byte dal flusso corrente in modo asincrono, fa avanzare la posizione nel flusso del numero di byte letti e monitora le richieste di annullamento.(Esegue l'override di Stream.ReadAsync(Byte[], Int32, Int32, CancellationToken).)

System_CAPS_pubmethodReadByte()

Legge un byte dal flusso e sposta in avanti la posizione corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso.(Ereditato da Stream.)

System_CAPS_pubmethodSeek(Int64, SeekOrigin)

Imposta la posizione all'interno del flusso corrente.(Esegue l'override di Stream.Seek(Int64, SeekOrigin).)

System_CAPS_pubmethodSetLength(Int64)

Imposta la lunghezza del flusso corrente.(Esegue l'override di Stream.SetLength(Int64).)

System_CAPS_pubmethodToString()

Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object.)

System_CAPS_pubmethodWrite(Byte[], Int32, Int32)

Scrive una sequenza di byte nel flusso CryptoStream corrente e fa avanzare la posizione corrente all'interno del flusso in base al numero dei byte inseriti.(Esegue l'override di Stream.Write(Byte[], Int32, Int32).)

System_CAPS_pubmethodWriteAsync(Byte[], Int32, Int32)

Scrive in modo asincrono una sequenza di byte nel flusso corrente e passa alla posizione successiva nel flusso in base al numero di byte scritti.(Ereditato da Stream.)

System_CAPS_pubmethodWriteAsync(Byte[], Int32, Int32, CancellationToken)

Scrive in modo asincrono una sequenza di byte nel flusso corrente, fa avanzare la posizione corrente nel flusso del numero di byte scritti e monitora le richieste di annullamento.(Esegue l'override di Stream.WriteAsync(Byte[], Int32, Int32, CancellationToken).)

System_CAPS_pubmethodWriteByte(Byte)

Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso.(Ereditato da Stream.)

The common language runtime uses a stream-oriented design for cryptography. The core of this design is T:System.Security.Cryptography.CryptoStream. Any cryptographic objects that implement T:System.Security.Cryptography.CryptoStream can be chained together with any objects that implement T:System.IO.Stream, so the streamed output from one object can be fed into the input of another object. The intermediate result (the output from the first object) does not need to be stored separately.

System_CAPS_importantImportante

This type implements the T:System.IDisposable interface. When you have finished using the type, you should dispose of it either directly or indirectly by calling its M:System.Security.Cryptography.CryptoStream.Clear method, which in turn calls its T:System.IDisposable implementation. To dispose of the type directly, call its M:System.Security.Cryptography.CryptoStream.Clear method in a try/catch block. To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). For more information, see the “Using an Object that Implements IDisposable” section in the T:System.IDisposable interface topic.

You should always explicitly close your T:System.Security.Cryptography.CryptoStream object after you are done using it by calling the M:System.Security.Cryptography.CryptoStream.Clear method. Doing so flushes the underlying stream and causes all remaining blocks of data to be processed by the T:System.Security.Cryptography.CryptoStream object. However, if an exception occurs before you call the M:System.IO.Stream.Close method, the T:System.Security.Cryptography.CryptoStream object might not be closed. To ensure that the M:System.IO.Stream.Close method always gets called, place your call to the M:System.Security.Cryptography.CryptoStream.Clear method within the finally block of a try/catch statement.

The following example demonstrates how to use a T:System.Security.Cryptography.CryptoStream to encrypt a string. This method uses T:System.Security.Cryptography.RijndaelManaged class with the specified P:System.Security.Cryptography.SymmetricAlgorithm.Key and initialization vector (P:System.Security.Cryptography.SymmetricAlgorithm.IV).

using System;
using System.IO;
using System.Security.Cryptography;

namespace RijndaelManaged_Example
{
    class RijndaelExample
    {
        public static void Main()
        {
            try
            {

                string original = "Here is some data to encrypt!";

                // Create a new instance of the Rijndael
                // class.  This generates a new key and initialization 
                // vector (IV).
                using (Rijndael myRijndael = Rijndael.Create())
                {
                    // Encrypt the string to an array of bytes.
                    byte[] encrypted = EncryptStringToBytes(original, myRijndael.Key, myRijndael.IV);

                    // Decrypt the bytes to a string.
                    string roundtrip = DecryptStringFromBytes(encrypted, myRijndael.Key, myRijndael.IV);

                    //Display the original data and the decrypted data.
                    Console.WriteLine("Original:   {0}", original);
                    Console.WriteLine("Round Trip: {0}", roundtrip);
                }

            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}", e.Message);
            }
        }
        static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (plainText == null || plainText.Length <= 0)
                throw new ArgumentNullException("plainText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");
            byte[] encrypted;
            // Create an Rijndael object
            // with the specified key and IV.
            using (Rijndael rijAlg = Rijndael.Create())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;

                // Create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {

                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                        encrypted = msEncrypt.ToArray();
                    }
                }
            }


            // Return the encrypted bytes from the memory stream.
            return encrypted;

        }

        static string DecryptStringFromBytes(byte[] cipherText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (cipherText == null || cipherText.Length <= 0)
                throw new ArgumentNullException("cipherText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");

            // Declare the string used to hold
            // the decrypted text.
            string plaintext = null;

            // Create an Rijndael object
            // with the specified key and IV.
            using (Rijndael rijAlg = Rijndael.Create())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;

                // Create a decryptor to perform the stream transform.
                ICryptoTransform decryptor = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV);

                // Create the streams used for decryption.
                using (MemoryStream msDecrypt = new MemoryStream(cipherText))
                {
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                        {

                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plaintext = srDecrypt.ReadToEnd();
                        }
                    }
                }

            }

            return plaintext;

        }
    }
}

.NET Framework
Disponibile da 1.1
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0

I membri statici pubblici ( Condiviso in Visual Basic) di questo tipo è thread safe. Non tutti i membri di istanza sono garantiti come thread safe.

Torna all'inizio
Mostra: