この記事は機械翻訳されています。英語版の記事を表示するには、[英語] のチェック ボックスをオンにしてください。また、テキストにマウス ポインターを合わせると、ポップアップ ウィンドウに英語のテキストを表示することもできます。
翻訳
英語

FromBase64Transform クラス

 

公開日: 2016年10月

base 64 から CryptoStream を変換します。

名前空間:   System.Security.Cryptography
アセンブリ:  mscorlib (mscorlib.dll 内)

System.Object
  System.Security.Cryptography.FromBase64Transform

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

名前説明
System_CAPS_pubmethodFromBase64Transform()

FromBase64Transform クラスの新しいインスタンスを初期化します。

System_CAPS_pubmethodFromBase64Transform(FromBase64TransformMode)

変換モードを指定して、FromBase64Transform クラスの新しいインスタンスを初期化します。

名前説明
System_CAPS_pubpropertyCanReuseTransform

現在の変換を再利用できるかどうかを示す値を取得します。

System_CAPS_pubpropertyCanTransformMultipleBlocks

複数のブロックを変換できるかどうかを示す値を取得します。

System_CAPS_pubpropertyInputBlockSize

入力ブロック サイズを取得します。

System_CAPS_pubpropertyOutputBlockSize

出力ブロック サイズを取得します。

名前説明
System_CAPS_pubmethodClear()

FromBase64Transform によって使用されているすべてのリソースを解放します。

System_CAPS_pubmethodDispose()

FromBase64Transform クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。

System_CAPS_protmethodDispose(Boolean)

FromBase64Transform によって使用されているアンマネージ リソースを解放し、オプションでマネージ リソースも解放します。

System_CAPS_pubmethodEquals(Object)

指定したオブジェクトが、現在のオブジェクトと等しいかどうかを判断します。(Object から継承されます。)

System_CAPS_protmethodFinalize()

FromBase64Transform によって使用されているアンマネージ リソースを解放します。(Object.Finalize() をオーバーライドします。)

System_CAPS_pubmethodGetHashCode()

既定のハッシュ関数として機能します。(Object から継承されます。)

System_CAPS_pubmethodGetType()

現在のインスタンスの Type を取得します。(Object から継承されます。)

System_CAPS_protmethodMemberwiseClone()

現在の Object の簡易コピーを作成します。(Object から継承されます。)

System_CAPS_pubmethodToString()

現在のオブジェクトを表す文字列を返します。(Object から継承されます。)

System_CAPS_pubmethodTransformBlock(Byte[], Int32, Int32, Byte[], Int32)

入力バイト配列の指定した領域を base 64 から変換し、その結果を出力バイト配列の指定した領域にコピーします。

System_CAPS_pubmethodTransformFinalBlock(Byte[], Int32, Int32)

指定したバイト配列の指定した領域を base 64 から変換します。

人間ではない形式で任意のビット シーケンスを表す base 64 のコンテンツ転送エンコード読みやすくします。

次の例では、base 64 でエンコードされたファイルを出力テキスト ファイルをデコードします。


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
1.1 以降で使用可能

この型のパブリック static (Visual Basic では Shared ) メンバーはスレッド セーフです。インスタンス メンバーの場合は、スレッド セーフであるとは限りません。

トップに戻る
表示: