XmlTextWriter.WriteBase64(Byte[], Int32, Int32) Yöntem

Tanım

Ad Alanı:

System.Xml

Bütünleştirilmiş Kod:

System.Xml.ReaderWriter.dll

Bütünleştirilmiş Kod:

System.Xml.dll

Bütünleştirilmiş Kod:

netstandard.dll

Belirtilen ikili baytları base64 olarak kodlar ve sonuçta elde edilen metni yazar.

public:
 override void WriteBase64(cli::array <System::Byte> ^ buffer, int index, int count);

public override void WriteBase64 (byte[] buffer, int index, int count);

override this.WriteBase64 : byte[] * int * int -> unit

Public Overrides Sub WriteBase64 (buffer As Byte(), index As Integer, count As Integer)

Parametreler

buffer

Byte[]

Kodlanacak bayt dizisi.

index

Int32

Yazacak baytların başlangıcını gösteren arabellek içindeki konum.

count

Int32

Yazılacak bayt sayısı.

Özel durumlar

ArgumentNullException

buffer, null değeridir.

ArgumentException

Arabellek uzunluğu eksi index değeri değerinden countküçüktür.

ArgumentOutOfRangeException

index veya count sıfırdan küçüktür.

InvalidOperationException

, WriteState şeklindedir Closed.

Örnekler

Aşağıdaki örnek kullanarak WriteBase64 bir giriş dosyasını kodlar ve geçici bir XML dosyası oluşturur. Geçici XML dosyasının kodu yöntemi kullanılarak ReadBase64 çözülerek özgün dosyayla karşılaştırılır.

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
using namespace System::Text;
ref class TestBase64
{
private:
   static int bufferSize = 4096;

public:

   // Use the WriteBase64 method to create an XML document.  The object  
   // passed by the user is encoded and included in the document.
   void EncodeXmlFile( String^ xmlFileName, FileStream^ fileOld )
   {
      array<Byte>^buffer = gcnew array<Byte>(bufferSize);
      int readByte = 0;
      XmlTextWriter^ xw = gcnew XmlTextWriter( xmlFileName,Encoding::UTF8 );
      xw->WriteStartDocument();
      xw->WriteStartElement( "root" );

      // Create a Char writer.
      BinaryReader^ br = gcnew BinaryReader( fileOld );

      // Set the file pointer to the end.
      try
      {
         do
         {
            readByte = br->Read( buffer, 0, bufferSize );
            xw->WriteBase64( buffer, 0, readByte );
         }
         while ( bufferSize <= readByte );
      }
      catch ( Exception^ ex ) 
      {
         EndOfStreamException^ ex1 = gcnew EndOfStreamException;
         if ( ex1->Equals( ex ) )
                  Console::WriteLine( "We are at end of file" );
         else
                  Console::WriteLine( ex );
      }

      xw->WriteEndElement();
      xw->WriteEndDocument();
      xw->Flush();
      xw->Close();
   }

   // Use the ReadBase64 method to decode the new XML document 
   // and generate the original object.
   void DecodeOrignalObject( String^ xmlFileName, FileStream^ fileNew )
   {
      array<Byte>^buffer = gcnew array<Byte>(bufferSize);
      int readByte = 0;

      // Create a file to write the bmp back.
      BinaryWriter^ bw = gcnew BinaryWriter( fileNew );
      XmlTextReader^ tr = gcnew XmlTextReader( xmlFileName );
      tr->MoveToContent();
      Console::WriteLine( tr->Name );
      do
      {
         readByte = tr->ReadBase64( buffer, 0, bufferSize );
         bw->Write( buffer, 0, readByte );
      }
      while ( readByte >= bufferSize );

      bw->Flush();
   }

   // Compare the two files.
   bool CompareResult( FileStream^ fileOld, FileStream^ fileNew )
   {
      int readByteOld = 0;
      int readByteNew = 0;
      int count;
      int readByte = 0;
      array<Byte>^bufferOld = gcnew array<Byte>(bufferSize);
      array<Byte>^bufferNew = gcnew array<Byte>(bufferSize);
      BinaryReader^ binaryReaderOld = gcnew BinaryReader( fileOld );
      BinaryReader^ binaryReaderNew = gcnew BinaryReader( fileNew );
      binaryReaderOld->BaseStream->Seek( 0, SeekOrigin::Begin );
      binaryReaderNew->BaseStream->Seek( 0, SeekOrigin::Begin );
      do
      {
         readByteOld = binaryReaderOld->Read( bufferOld, 0, bufferSize );
         readByteNew = binaryReaderNew->Read( bufferNew, 0, bufferSize );
         if ( readByteOld != readByteNew )
                  return false;

         for ( count = 0; count < bufferSize; ++count )
            if ( bufferOld[ count ] != bufferNew[ count ] )
                        return false;
      }
      while ( count < readByte );

      return true;
   }

   // Display the usage statement.
   void Usage()
   {
      Console::WriteLine( "TestBase64 sourceFile, targetFile \n" );
      Console::WriteLine( "For example: TestBase64 winlogon.bmp, target.bmp\n" );
   }
};

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   TestBase64^ testBase64 = gcnew TestBase64;

   // Check that the usage is correct.
   if ( args->Length < 3 )
   {
      testBase64->Usage();
      return 1;
   }

   FileStream^ fileOld = gcnew FileStream( args[ 1 ],FileMode::OpenOrCreate,FileAccess::Read,FileShare::Read );
   testBase64->EncodeXmlFile( "temp.xml", fileOld );
   FileStream^ fileNew = gcnew FileStream( args[ 2 ],FileMode::Create,FileAccess::ReadWrite,FileShare::ReadWrite );
   testBase64->DecodeOrignalObject( "temp.xml", fileNew );

   // Compare the two files.
   if ( testBase64->CompareResult( fileOld, fileNew ) )
      Console::WriteLine( "The recreated binary file {0} is the same as {1}", args[ 2 ], args[ 1 ] );
   else
      Console::WriteLine( "The recreated binary file {0} is not the same as {1}", args[ 2 ], args[ 1 ] );

   fileOld->Flush();
   fileNew->Flush();
   fileOld->Close();
   fileNew->Close();
   return 0;
}

using System;
using System.IO;
using System.Xml;
using System.Text;

public static class TestBase64
{

    private const int bufferSize = 4096;

    public static void Main(string[] args)
    {
        // Check that the usage string is correct.
        if (args.Length < 2)
        {
            TestBase64.Usage();
            return;
        }

        var fileOld = new FileStream(args[0], FileMode.OpenOrCreate, FileAccess.Read, FileShare.Read);
        TestBase64.EncodeXmlFile("temp.xml", fileOld);

        var fileNew = new FileStream(args[1], FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);

        TestBase64.DecodeOrignalObject("temp.xml", fileNew);

        // Compare the two files.
        if (TestBase64.CompareResult(fileOld, fileNew))
        {
            Console.WriteLine($"The recreated binary file {args[1]} is the same as {args[0]}");
        }
        else
        {
            Console.WriteLine($"The recreated binary file {args[1]} is not the same as {args[0]}");
        }

        fileOld.Flush();
        fileNew.Flush();
        fileOld.Close();
        fileNew.Close();
    }

    // Use the WriteBase64 method to create an XML document.  The object
    // passed by the user is encoded and included in the document.
    public static void EncodeXmlFile(string xmlFileName, FileStream fileOld)
    {

        var buffer = new byte[bufferSize];
        int readByte = 0;

        var xw = new XmlTextWriter(xmlFileName, Encoding.UTF8);
        xw.WriteStartDocument();
        xw.WriteStartElement("root");
        // Create a Char writer.
        var br = new BinaryReader(fileOld);
        // Set the file pointer to the end.

        try
        {
              do
              {
                  readByte = br.Read(buffer, 0, bufferSize);
                  xw.WriteBase64(buffer, 0, readByte);
              } while (bufferSize <= readByte);
        }
        catch (Exception ex)
        {
            var ex1 = new EndOfStreamException();

            if (ex1.Equals(ex))
            {
                Console.WriteLine("We are at end of file");
            }
            else
            {
                Console.WriteLine(ex);
            }
        }
        xw.WriteEndElement();
        xw.WriteEndDocument();

        xw.Flush();
        xw.Close();
    }

    // Use the ReadBase64 method to decode the new XML document
    // and generate the original object.
    public static void DecodeOrignalObject(string xmlFileName, FileStream fileNew)
    {

        var buffer = new byte[bufferSize];
        int readByte = 0;

        // Create a file to write the bmp back.
        var bw = new BinaryWriter(fileNew);

        var tr = new XmlTextReader(xmlFileName);
        tr.MoveToContent();
        Console.WriteLine(tr.Name);

        do
        {
          readByte=tr.ReadBase64(buffer, 0, bufferSize);
          bw.Write(buffer, 0, readByte);
        } while(readByte >= bufferSize);

        bw.Flush();
    }

    // Compare the two files.
    public static bool CompareResult(FileStream fileOld, FileStream fileNew) {

        int readByteOld = 0;
        int readByteNew = 0;
        int count, readByte =0 ;

        var bufferOld = new byte[bufferSize];
        var bufferNew = new byte[bufferSize];

        var binaryReaderOld = new BinaryReader(fileOld);
        var binaryReaderNew = new BinaryReader(fileNew);

        binaryReaderOld.BaseStream.Seek(0, SeekOrigin.Begin);
        binaryReaderNew.BaseStream.Seek(0, SeekOrigin.Begin);

        do
        {
          readByteOld = binaryReaderOld.Read(bufferOld, 0, bufferSize);
          readByteNew = binaryReaderNew.Read(bufferNew, 0, bufferSize);

          if (readByteOld != readByteNew)
          {
              return false;
          }

          for (count = 0; count < bufferSize; count++)
          {
              if (bufferOld[count] != bufferNew[count])
              {
                  return false;
              }
          }
        } while (count < readByte);

        return true;
    }

    // Display the usage statement.
    public static void Usage()
    {
        Console.WriteLine("TestBase64 sourceFile, targetFile \n");
        Console.WriteLine("For example: TestBase64 winlogon.bmp, target.bmp\n");
    }
}

Imports System.IO
Imports System.Xml
Imports System.Text

Public Module TestBase64

    Private Const bufferSize As Integer = 4096

    Public Sub Main()

        Dim args As String() = System.Environment.GetCommandLineArgs()
        
        ' Check that the usage string is correct.
        If args.Length < 3
            TestBase64.Usage()
            Return
        End If

        Dim fileOld As New FileStream(args(1), FileMode.OpenOrCreate, FileAccess.Read, FileShare.Read)
        TestBase64.EncodeXmlFile("temp.xml", fileOld)

        Dim fileNew As New FileStream(args(2), FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite)

        TestBase64.DecodeOrignalObject("temp.xml", fileNew)

        ' Compare the two files.
        If TestBase64.CompareResult(fileOld, fileNew)
            Console.WriteLine($"The recreated binary file {args(2)} is the same as {args(1)}")
        Else
            Console.WriteLine($"The recreated binary file {args(2)} is not the same as {args(1)}")
        End If

        fileOld.Flush()
        fileNew.Flush()
        fileOld.Close()
        fileNew.Close()

    End Sub

    ' Use the WriteBase64 method to create an XML document.  The object  
    ' passed by the user is encoded and included in the document.
    Public Sub EncodeXmlFile(xmlFileName As String, fileOld As FileStream)

        Dim buffer(bufferSize - 1) As Byte
        Dim readByte As Integer = 0

        Dim xw As New XmlTextWriter(xmlFileName, Encoding.UTF8)
        xw.WriteStartDocument()
        xw.WriteStartElement("root")
        ' Create a Char writer.
        Dim br As New BinaryReader(fileOld)
        ' Set the file pointer to the end.

        Try
            Do
                readByte = br.Read(buffer, 0, bufferSize)
                xw.WriteBase64(buffer, 0, readByte)
            Loop While (bufferSize <= readByte)

        Catch ex As Exception
            Dim ex1 As New EndOfStreamException()

            If (ex1.Equals(ex))
                Console.WriteLine("We are at end of file")
            Else
                Console.WriteLine(ex)
            End If
        End Try
        xw.WriteEndElement()
        xw.WriteEndDocument()

        xw.Flush()
        xw.Close()
    End Sub

    ' Use the ReadBase64 method to decode the new XML document 
    ' and generate the original object.
    Public Sub DecodeOrignalObject(xmlFileName As String, fileNew As FileStream)

        Dim buffer(bufferSize - 1) As Byte
        Dim readByte As Integer = 0

        ' Create a file to write the bmp back.
        Dim bw As New BinaryWriter(fileNew)

        Dim tr As New XmlTextReader(xmlFileName)
        tr.MoveToContent()
        Console.WriteLine(tr.Name)

        Do
            readByte = tr.ReadBase64(buffer, 0, bufferSize)
            bw.Write(buffer, 0, readByte)
        Loop While (readByte >= bufferSize)

        bw.Flush()

    End Sub

    ' Compare the two files.
    Public Function CompareResult(fileOld As FileStream, fileNew As FileStream) As Boolean

        Dim readByteOld As Integer = 0
        Dim readByteNew As Integer = 0
        Dim count As Integer
        Dim readByte as integer = 0

        Dim bufferOld(bufferSize - 1) As Byte
        Dim bufferNew(bufferSize - 1) As Byte

        Dim binaryReaderOld As New BinaryReader(fileOld)
        Dim binaryReaderNew As New BinaryReader(fileNew)

        binaryReaderOld.BaseStream.Seek(0, SeekOrigin.Begin)
        binaryReaderNew.BaseStream.Seek(0, SeekOrigin.Begin)

        Do
            readByteOld = binaryReaderOld.Read(bufferOld, 0, bufferSize)
            readByteNew = binaryReaderNew.Read(bufferNew, 0, bufferSize)

            If readByteOld <> readByteNew
                Return False
            End If

            For count = 0 To bufferSize - 1
                If bufferOld(count) <> bufferNew(count)
                    Return False
                End If
            Next

        Loop While (count < readByte)
        Return True
    End Function

    ' Display the usage statement.
    Public Sub Usage()
        Console.WriteLine("TestBase64 sourceFile, targetFile")
        Console.WriteLine("For example: TestBase64 winlogon.bmp, target.bmp")
    End Sub

End Module

Açıklamalar

Not

.NET Framework 2.0'dan başlayarak, yeni işlevlerden yararlanmak için yöntemini ve XmlWriterSettings sınıfını XmlWriter.Create kullanarak örnekler oluşturmanızı XmlWriter öneririz.