XmlTextReader.Normalization-Eigenschaft

Artikel
08/20/2007

Ruft einen Wert ab, der angibt, ob Leerraum und Attributwerte normalisiert werden sollen, oder legt diesen fest.

Namespace: System.Xml
Assembly: System.Xml (in system.xml.dll)

Syntax

'Declaration
Public Property Normalization As Boolean
'Usage
Dim instance As XmlTextReader
Dim value As Boolean

value = instance.Normalization

instance.Normalization = value

public bool Normalization { get; set; }

public:
property bool Normalization {
    bool get ();
    void set (bool value);
}

/** @property */
public boolean get_Normalization ()

/** @property */
public void set_Normalization (boolean value)

public function get Normalization () : boolean

public function set Normalization (value : boolean)

Eigenschaftenwert

true, wenn normalisiert wird, andernfalls false. Der Standardwert ist false.

Ausnahmen

Ausnahmetyp	Bedingung
InvalidOperationException	Festlegen dieser Eigenschaft, wenn der Reader geschlossen ist (ReadState ist ReadState.Closed).

Hinweise

Hinweis

Die empfohlene Vorgehensweise für die Version Microsoft .NET Framework, Version 2.0 besteht darin, mithilfe der System.Xml.XmlReader.Create-Methode XmlReader-Instanzen zu erstellen. So können Sie die neuen Features dieser Version in vollem Umfang nutzen. Weitere Informationen finden Sie unter Erstellen von XML-Readern.

Diese Eigenschaft kann jederzeit geändert werden und tritt beim nächsten Lesevorgang in Kraft.

Hinweis

Wenn der XmlTextReader verwendet wird, um einen XmlValidatingReader zu konstruieren, muss Normalization zur Normalisierung der Attributwerte auf true festgelegt werden.

Wenn Normalization auf false festgelegt ist, wird auch der Prüfvorgang für den Zeichenbereich in numerischen Entitäten deaktiviert. Daraus ergibt sich, dass Zeichenentitäten, z. B. , zulässig sind.

Im Folgenden wird die Normalisierung von Attributwerten beschrieben:

Für einen Zeichenverweis wird das Zeichen, auf das verwiesen werden soll, dem Attributwert angefügt.
Für den Verweis auf eine Entität wird der Ersatztext der Entität rekursiv verarbeitet.
Für ein Leerzeichen (#x20, #xD, #xA, #x9) wird dem normalisierten Wert #x20 angefügt. (Für eine "#xD#xA"-Sequenz, die Teil einer extern analysierten Entität oder der literale Entitätswert einer intern analysierten Entität ist, wird nur ein einzelnes #x20 angefügt.)
Andere Zeichen werden durch Anfügen an den normalisierten Wert verarbeitet.
Wenn der deklarierte Wert kein CDATA-Wert ist, müssen Sie alle führenden und nachgestellten Leerzeichen (#x20) entfernen und Leerzeichenfolgen (#x20) durch ein einzelnes Leerzeichen (#x20) ersetzen.

Der XmlTextReader führt nur die Attribut- oder CDATA-Normalisierung aus. Die DTD-spezifische Normalisierung wird von ihm nur eingeschlossen in einem XmlValidatingReader ausgeführt.

Weiterführende Erläuterungen zur Normalisierung finden Sie in der W3C-Empfehlung zu XML, Version 1.0.

Beispiel

Im folgenden Beispiel wird das Verhalten des Readers bei aktivierter und anschließend bei deaktivierter Normalisierung veranschaulicht.

Imports System
Imports System.IO
Imports System.Xml
Imports Microsoft.VisualBasic

public class Sample

  public shared sub Main()

    ' Create the XML fragment to be parsed.
    Dim xmlFrag as string = "<item attr1='  test A B C " + Chr(10) & _
                            "   1 2 3'/>" + Chr(10) & _
                            "<item attr2='&#01;'/>"
                    

    ' Create the XmlNamespaceManager.
    Dim nsmgr as XmlNamespaceManager = new XmlNamespaceManager(new NameTable())

    ' Create the XmlParserContext.
    Dim context as XmlParserContext = new XmlParserContext(nothing, nsmgr, nothing, XmlSpace.Preserve)

    ' Create the reader.
    Dim reader as XmlTextReader = new XmlTextReader(xmlFrag, XmlNodeType.Element, context)

    ' Show attribute value normalization.
    reader.Read()
    reader.Normalization = false
    Console.WriteLine("Attribute value:{0}", reader.GetAttribute("attr1"))
    reader.Normalization = true
    Console.WriteLine("Attribute value:{0}", reader.GetAttribute("attr1"))

    ' Set Normalization back to false.  This allows the reader to accept
    ' character entities in the &#00; to &#20; range.  If Normalization had
    ' been set to true, character entities in this range throw an exception.
    reader.Normalization = false
    reader.Read()
    reader.MoveToContent()
    Console.WriteLine("Attribute value:{0}", reader.GetAttribute("attr2"))
  
    ' Close the reader.
    reader.Close()     
  
  end sub
end class

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

public class Sample{

  public static void Main(){

    // Create the XML fragment to be parsed.
    string xmlFrag  = 
    @"<item attr1='  test A B C
        1 2 3'/>
      <item attr2='&#01;'/>";                         

    // Create the XmlNamespaceManager.
    XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());

    // Create the XmlParserContext.
    XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.Preserve);

    // Create the reader.
    XmlTextReader reader = new XmlTextReader(xmlFrag, XmlNodeType.Element, context);

    // Show attribute value normalization.
    reader.Read();
    reader.Normalization = false;
    Console.WriteLine("Attribute value:{0}", reader.GetAttribute("attr1"));
    reader.Normalization = true;
    Console.WriteLine("Attribute value:{0}", reader.GetAttribute("attr1"));

    // Set Normalization back to false.  This allows the reader to accept
    // character entities in the &#00; to &#20; range.  If Normalization had
    // been set to true, character entities in this range throw an exception.
    reader.Normalization = false;
    reader.Read();
    reader.MoveToContent();
    Console.WriteLine("Attribute value:{0}", reader.GetAttribute("attr2"));
  
    // Close the reader.
    reader.Close();     
  
  }
}

#using <System.Xml.dll>

using namespace System;
using namespace System::IO;
using namespace System::Xml;
int main()
{
   
   // Create the XML fragment to be parsed.
   String^ xmlFrag = "<item attr1='  test A B C\n"
   "1 2 3'/>\n"
   "<item attr2='&#01;'/>\n";
   
   // Create the XmlNamespaceManager.
   XmlNamespaceManager^ nsmgr = gcnew XmlNamespaceManager( gcnew NameTable );
   
   // Create the XmlParserContext.
   XmlParserContext^ context = gcnew XmlParserContext( nullptr,nsmgr,nullptr,XmlSpace::Preserve );
   
   // Create the reader.
   XmlTextReader^ reader = gcnew XmlTextReader( xmlFrag,XmlNodeType::Element,context );
   
   // Show attribute value normalization.
   reader->Read();
   reader->Normalization = false;
   Console::WriteLine( "Attribute value: {0}", reader->GetAttribute( "attr1" ) );
   reader->Normalization = true;
   Console::WriteLine( "Attribute value: {0}", reader->GetAttribute( "attr1" ) );
   
   // Set Normalization back to false.  This allows the reader to accept
   // character entities in the &#00; to &#20; range.  If Normalization had
   // been set to true, character entities in this range throw an exception.
   reader->Normalization = false;
   reader->Read();
   reader->MoveToContent();
   Console::WriteLine( "Attribute value: {0}", reader->GetAttribute( "attr2" ) );
   
   // Close the reader.
   reader->Close();
}

import System.*;
import System.IO.*;
import System.Xml.*;

public class Sample
{
    public static void main(String[] args)
    {
        // Create the XML fragment to be parsed.
        String xmlFrag = "<item attr1='  test A B C\n" + "        1 2 3'/>\n" 
            + "      <item attr2='&#01;'/>";
        // Create the XmlNamespaceManager.
        XmlNamespaceManager nsMgr = new XmlNamespaceManager(new NameTable());
        // Create the XmlParserContext.
        XmlParserContext context = new XmlParserContext(null, nsMgr,
            null, XmlSpace.Preserve);
        // Create the reader.
        XmlTextReader reader = new XmlTextReader(xmlFrag, XmlNodeType.Element,
            context);
        // Show attribute value normalization.
        reader.Read();
        reader.set_Normalization(false);
        Console.WriteLine("Attribute value:{0}", reader.GetAttribute("attr1"));
        reader.set_Normalization(true);
        Console.WriteLine("Attribute value:{0}", reader.GetAttribute("attr1"));
        // Set Normalization back to false.  This allows the reader to accept
        // character entities in the &#00; to &#20; range.  If Normalization had
        // been set to true, character entities in this range throw an exception.
        reader.set_Normalization(false);
        reader.Read();
        reader.MoveToContent();
        Console.WriteLine("Attribute value:{0}", reader.GetAttribute("attr2"));
        // Close the reader.
        reader.Close();
    } //main 
} //Sample

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Freigeben über

XmlTextReader.Normalization-Eigenschaft

Syntax

Eigenschaftenwert

Ausnahmen

Hinweise

Beispiel

Plattformen

Versionsinformationen

.NET Framework

.NET Compact Framework

Siehe auch

Referenz

Weitere Ressourcen

Zusätzliche Ressourcen