FromBase64Transform.TransformBlock 메서드

정의

네임스페이스:

System.Security.Cryptography

어셈블리:

System.Security.Cryptography.dll

Source:

Base64Transforms.cs

base 64인 입력 바이트 배열의 지정된 영역을 변환하여 해당 결과를 출력 바이트 배열의 지정된 영역으로 복사합니다.

public:
 virtual int TransformBlock(cli::array <System::Byte> ^ inputBuffer, int inputOffset, int inputCount, cli::array <System::Byte> ^ outputBuffer, int outputOffset);

public int TransformBlock (byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset);

abstract member TransformBlock : byte[] * int * int * byte[] * int -> int
override this.TransformBlock : byte[] * int * int * byte[] * int -> int

Public Function TransformBlock (inputBuffer As Byte(), inputOffset As Integer, inputCount As Integer, outputBuffer As Byte(), outputOffset As Integer) As Integer

매개 변수

inputBuffer

Byte[]

base 64에서 컴퓨팅할 입력입니다.

inputOffset

Int32

데이터 사용을 시작할 입력 바이트 배열의 오프셋입니다.

inputCount

Int32

데이터로 사용할 입력 바이트 배열의 바이트 수입니다.

outputBuffer

Byte[]

결과를 쓸 출력입니다.

outputOffset

Int32

데이터 쓰기를 시작할 출력 바이트 배열의 오프셋입니다.

반환

Int32

쓴 바이트 수.

구현

TransformBlock(Byte[], Int32, Int32, Byte[], Int32)

예외

ObjectDisposedException

현재 FromBase64Transform 개체가 이미 삭제된 경우

ArgumentException

inputCount에 잘못된 값이 사용된 경우

또는

inputBuffer의 오프셋 길이가 잘못된 경우

ArgumentOutOfRangeException

inputOffset이 범위에서 벗어난 경우. 이 매개 변수에는 0 또는 양의 정수가 필요합니다.

ArgumentNullException

inputBuffer이(가) null인 경우

예제

다음 예제에서는 기본 64로 인코딩된 파일을 출력 텍스트 파일로 암호 해독합니다.

using namespace System;
using namespace System::IO;
using namespace System::Security::Cryptography;
class MyMainClass
{
public:
   static void DecodeFromFile( String^ inFileName, String^ outFileName )
   {
      FromBase64Transform^ myTransform = gcnew FromBase64Transform( FromBase64TransformMode::IgnoreWhiteSpaces );
      array<Byte>^myOutputBytes = gcnew array<Byte>(myTransform->OutputBlockSize);
      
      //Open the input and output files.
      FileStream^ myInputFile = gcnew FileStream( inFileName,FileMode::Open,FileAccess::Read );
      FileStream^ myOutputFile = gcnew FileStream( outFileName,FileMode::Create,FileAccess::Write );
      
      //Retrieve the file contents into a Byte array.
      array<Byte>^myInputBytes = gcnew array<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->TransformBlock( myInputBytes, i, 4, myOutputBytes, 0 );
         
         /*myTransform->InputBlockSize*/
         i += 4;
         
         /*myTransform->InputBlockSize*/
         myOutputFile->Write( myOutputBytes, 0, myTransform->OutputBlockSize );
      }

      
      //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();
      myInputFile->Close();
      myOutputFile->Close();
   }

};

int main()
{
   MyMainClass * m = new MyMainClass;
   
   //Insert your file names into this method call.
   m->DecodeFromFile(  "c:\\encoded.txt",  "c:\\roundtrip.txt" );
}

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)
                {
                    // Initialize 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 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();
                    }
                }
            }
        }
}

Imports System.IO
Imports System.Security.Cryptography

Friend Class Members
    <STAThread()> _
    Shared Sub Main(ByVal args() As String)
        Dim appPath As String = (System.IO.Directory.GetCurrentDirectory())
        appPath = appPath & "..\\..\\..\"
        ' Insert your file names into this method call.
        EncodeFromFile(appPath & "program.vb", appPath & "code.enc")
        DecodeFromFile(appPath & "code.enc", appPath & "roundtrip.txt")

    End Sub

    ' Read in the specified source file and write out an encoded target file.
    Private Shared Sub EncodeFromFile(ByVal sourceFile As String, ByVal targetFile As String)
        ' Verify members.cs exists at the specified directory.
        If Not File.Exists(sourceFile) Then
            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
        End If

        ' Retrieve the input and output file streams.
        Using inputFileStream As New FileStream(sourceFile, FileMode.Open, FileAccess.Read)
            Using outputFileStream As New FileStream(targetFile, FileMode.Create, FileAccess.Write)

                ' Create a new ToBase64Transform object to convert to base 64.
                Dim base64Transform As New ToBase64Transform()

                ' Create a new byte array with the size of the output block size.
                Dim outputBytes(base64Transform.OutputBlockSize - 1) As Byte

                ' Retrieve the file contents into a byte array.
                Dim inputBytes(inputFileStream.Length - 1) As Byte
                inputFileStream.Read(inputBytes, 0, inputBytes.Length)

                ' Verify that multiple blocks can not be transformed.
                If Not base64Transform.CanTransformMultipleBlocks Then
                    ' Initializie the offset size.
                    Dim inputOffset As Integer = 0

                    ' Iterate through inputBytes transforming by blockSize.
                    Dim inputBlockSize As Integer = base64Transform.InputBlockSize

                    Do While inputBytes.Length - inputOffset > inputBlockSize
                        base64Transform.TransformBlock(inputBytes, inputOffset, inputBytes.Length - inputOffset, outputBytes, 0)

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

                    ' 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)
                End If

                ' Determine if the current transform can be reused.
                If Not base64Transform.CanReuseTransform Then
                    ' Free up any used resources.
                    base64Transform.Clear()
                End If
            End Using
        End Using

    End Sub

    Public Shared Sub DecodeFromFile(ByVal inFileName As String, ByVal outFileName As String)
        Using myTransform As New FromBase64Transform(FromBase64TransformMode.IgnoreWhiteSpaces)

            Dim myOutputBytes(myTransform.OutputBlockSize - 1) As Byte

            'Open the input and output files.
            Using myInputFile As New FileStream(inFileName, FileMode.Open, FileAccess.Read)
                Using myOutputFile As New FileStream(outFileName, FileMode.Create, FileAccess.Write)

                    'Retrieve the file contents into a byte array. 
                    Dim myInputBytes(myInputFile.Length - 1) As Byte
                    myInputFile.Read(myInputBytes, 0, myInputBytes.Length)

                    'Transform the data in chunks the size of InputBlockSize. 
                    Dim i As Integer = 0
                    Do While myInputBytes.Length - i > 4 'myTransform.InputBlockSize
                        Dim bytesWritten As Int32 = myTransform.TransformBlock(myInputBytes, i, 4, myOutputBytes, 0) 'myTransform.InputBlockSize
                        i += 4 'myTransform.InputBlockSize
                        myOutputFile.Write(myOutputBytes, 0, bytesWritten)
                    Loop

                    '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()
                End Using
            End Using
        End Using

    End Sub
End Class

추가 정보

• 암호화 서비스