XmlTextWriter.WriteBase64(Byte[], Int32, Int32) Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Xml

Assembly:: System.Xml.ReaderWriter.dll

Assembly:: System.Xml.dll

Assembly:: netstandard.dll

Source:: XmlTextWriter.cs

Source:: XmlTextWriter.cs

Source:: XmlTextWriter.cs

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Codifica i byte binari specificati come valori Base64 e scrive il testo risultante.

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)

Parametri

buffer: Byte[]

Matrice di byte da codificare.

index: Int32

Posizione all'interno del buffer che indica l'inizio dei byte da scrivere.

count: Int32

Numero di byte da scrivere.

Eccezioni

ArgumentNullException

buffer è null.

ArgumentException

La lunghezza del buffer meno index è minore di count.

ArgumentOutOfRangeException

index o count è minore di zero.

InvalidOperationException

L'elemento WriteState è Closed.

Esempio

Nell'esempio seguente viene codificato un file di input usando WriteBase64 e viene generato un file XML temporaneo. Il file XML temporaneo viene decodificato usando il metodo e confrontato con il ReadBase64 file originale.

#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

Commenti

Nota

A partire da .NET Framework 2.0, è consigliabile creare XmlWriter istanze usando il metodo e la XmlWriter.Create XmlWriterSettings classe per sfruttare nuove funzionalità.

Si applica a