Questa pagina è stata utile?
I suggerimenti relativi al contenuto di questa pagina sono importanti. Comunicaceli.
Altri suggerimenti?
1500 caratteri rimanenti
Classe FromBase64Transform
Collapse the table of content
Expand the table of content
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe FromBase64Transform

Consente di convertire un oggetto CryptoStream da Base 64.

System.Object
  System.Security.Cryptography.FromBase64Transform

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

[ComVisibleAttribute(true)]
public class FromBase64Transform : ICryptoTransform, 
	IDisposable

Il tipo FromBase64Transform espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoFromBase64Transform()Inizializza una nuova istanza della classe FromBase64Transform.
Metodo pubblicoFromBase64Transform(FromBase64TransformMode)Consente di inizializzare una nuova istanza della classe FromBase64Transformcon la modalità di trasformazione specificata.
In alto

  NomeDescrizione
Proprietà pubblicaCanReuseTransformOttiene un valore che indica se è possibile riutilizzare la trasformazione corrente.
Proprietà pubblicaCanTransformMultipleBlocksOttiene un valore che indica se è possibile trasformare più blocchi.
Proprietà pubblicaInputBlockSizeOttiene la dimensione del blocco di input.
Proprietà pubblicaOutputBlockSizeOttiene la dimensione del blocco di output.
In alto

  NomeDescrizione
Metodo pubblicoClearRilascia tutte le risorse utilizzate dall'oggetto FromBase64Transform.
Metodo pubblicoDispose()Rilascia tutte le risorse utilizzate dall'istanza corrente della classe FromBase64Transform.
Metodo protettoDispose(Boolean)Rilascia le risorse non gestite utilizzate da FromBase64Transform e, facoltativamente, le risorse gestite.
Metodo pubblicoEquals(Object) Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Metodo protettoFinalizeRilascia le risorse non gestite utilizzate da FromBase64Transform. (Esegue l'override di Object.Finalize()).
Metodo pubblicoGetHashCode Funge da funzione hash per un particolare tipo. (Ereditato da Object)
Metodo pubblicoGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo protettoMemberwiseClone Crea una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object)
Metodo pubblicoToString Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Metodo pubblicoTransformBlockConsente di convertire l'area specificata della matrice di byte di input da Base 64 e di copiare il risultato nell'area specificata della matrice di byte di output.
Metodo pubblicoTransformFinalBlockConsente di convertire l'area definita della matrice di byte specificata da Base 64.
In alto

Il formato Base 64 Content-Transfer-Encoding rappresenta sequenze di bit arbitrari in formato non leggibile.

Nell'esempio decodifica un file codificato in base 64 in un file di testo di output.



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

class Members
{
    [STAThread]
    static void Main(string[] args)
    {
        string appPath = (System.IO.Directory.GetCurrentDirectory() );
        appPath = appPath + "..\\\\..\\\\..\\";
        // Insert your file names into this method call.
        EncodeFromFile(appPath + "program.cs", appPath + "code.enc");
        DecodeFromFile(appPath + "code.enc", appPath + "roundtrip.txt");

    }

    // Read in the specified source file and write out an encoded target file.
    private static void EncodeFromFile(string sourceFile, string targetFile) 
    {
        // Verify members.cs exists at the specified directory.
        if (!File.Exists(sourceFile))
        {
            Console.Write("Unable to locate source file located at ");
            Console.WriteLine(sourceFile + ".");
            Console.Write("Please correct the path and run the ");
            Console.WriteLine("sample again.");
            return;
        }

        // Retrieve the input and output file streams.
        using (FileStream inputFileStream =
            new FileStream(sourceFile, FileMode.Open, FileAccess.Read))
        {
            using (FileStream outputFileStream =
                new FileStream(targetFile, FileMode.Create, FileAccess.Write))
            {

                // Create a new ToBase64Transform object to convert to base 64.
                ToBase64Transform base64Transform = new ToBase64Transform();

                // Create a new byte array with the size of the output block size.
                byte[] outputBytes = new byte[base64Transform.OutputBlockSize];

                // Retrieve the file contents into a byte array.
                byte[] inputBytes = new byte[inputFileStream.Length];
                inputFileStream.Read(inputBytes, 0, inputBytes.Length);

                // Verify that multiple blocks can not be transformed.
                if (!base64Transform.CanTransformMultipleBlocks)
                {
                    // Initializie the offset size.
                    int inputOffset = 0;

                    // Iterate through inputBytes transforming by blockSize.
                    int inputBlockSize = base64Transform.InputBlockSize;

                    while (inputBytes.Length - inputOffset > inputBlockSize)
                    {
                        base64Transform.TransformBlock(
                            inputBytes,
                            inputOffset,
                            inputBytes.Length - inputOffset,
                            outputBytes,
                            0);

                        inputOffset += base64Transform.InputBlockSize;
                        outputFileStream.Write(
                            outputBytes,
                            0,
                            base64Transform.OutputBlockSize);
                    }

                    // Transform the final block of data.
                    outputBytes = base64Transform.TransformFinalBlock(
                        inputBytes,
                        inputOffset,
                        inputBytes.Length - inputOffset);

                    outputFileStream.Write(outputBytes, 0, outputBytes.Length);
                    Console.WriteLine("Created encoded file at " + targetFile);
                }

                // Determine if the current transform can be reused.
                if (!base64Transform.CanReuseTransform)
                {
                    // Free up any used resources.
                    base64Transform.Clear();
                }
            }
        }

    }

        public static void DecodeFromFile(string inFileName, string outFileName)
        {
            using (FromBase64Transform myTransform = new FromBase64Transform(FromBase64TransformMode.IgnoreWhiteSpaces))
            {

                byte[] myOutputBytes = new byte[myTransform.OutputBlockSize];

                //Open the input and output files.
                using (FileStream myInputFile = new FileStream(inFileName, FileMode.Open, FileAccess.Read))
                {
                    using (FileStream myOutputFile = new FileStream(outFileName, FileMode.Create, FileAccess.Write))
                    {

                        //Retrieve the file contents into a byte array. 
                        byte[] myInputBytes = new byte[myInputFile.Length];
                        myInputFile.Read(myInputBytes, 0, myInputBytes.Length);

                        //Transform the data in chunks the size of InputBlockSize. 
                        int i = 0;
                        while (myInputBytes.Length - i > 4/*myTransform.InputBlockSize*/)
                        {
                            int bytesWritten = myTransform.TransformBlock(myInputBytes, i, 4/*myTransform.InputBlockSize*/, myOutputBytes, 0);
                            i += 4/*myTransform.InputBlockSize*/;
                            myOutputFile.Write(myOutputBytes, 0, bytesWritten);
                        }

                        //Transform the final block of data.
                        myOutputBytes = myTransform.TransformFinalBlock(myInputBytes, i, myInputBytes.Length - i);
                        myOutputFile.Write(myOutputBytes, 0, myOutputBytes.Length);

                        //Free up any used resources.
                        myTransform.Clear();
                    }
                }
            }

        }
}



.NET Framework

Supportato in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Qualsiasi membro pubblico static (Shared in Visual Basic) di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft