Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais
Cette documentation est archivée et n’est pas conservée.

XStreamingElement, classe

Représente les éléments d'une arborescence XML qui prend en charge la sortie de diffusion en continu différée.

System.Object
  System.Xml.Linq.XStreamingElement

Espace de noms :  System.Xml.Linq
Assembly :  System.Xml.Linq (dans System.Xml.Linq.dll)

public class XStreamingElement

Le type XStreamingElement expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkXStreamingElement(XName)Initialise une nouvelle instance de la classe XElement à partir du XName spécifié.
Méthode publiquePris en charge par XNA FrameworkXStreamingElement(XName, Object)Initialise une nouvelle instance de la classe XStreamingElement avec le nom et le contenu spécifiés.
Méthode publiquePris en charge par XNA FrameworkXStreamingElement(XName, Object[])Initialise une nouvelle instance de la classe XStreamingElement avec le nom et le contenu spécifiés.
Début

  NomDescription
Propriété publiquePris en charge par XNA FrameworkNameObtient ou définit le nom de cet élément de transmission en continu.
Début

  NomDescription
Méthode publiquePris en charge par XNA FrameworkAdd(Object)Ajoute le contenu spécifié en tant qu'enfants à ce XStreamingElement.
Méthode publiquePris en charge par XNA FrameworkAdd(Object[])Ajoute le contenu spécifié en tant qu'enfants à ce XStreamingElement.
Méthode publiquePris en charge par XNA FrameworkEquals(Object)Détermine si l'Object spécifié est égal à l'Object en cours. (Hérité de Object.)
Méthode protégéePris en charge par XNA FrameworkFinalizeAutorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkGetHashCodeSert de fonction de hachage pour un type particulier. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode protégéePris en charge par XNA FrameworkMemberwiseCloneCrée une copie superficielle de l'objet Object actif. (Hérité de Object.)
Méthode publiqueSave(Stream)Génère ce XStreamingElement vers le Stream spécifié.
Méthode publiquePris en charge par XNA FrameworkSave(String)Sérialiser cet élément de transmission en continu vers un fichier.
Méthode publiquePris en charge par XNA FrameworkSave(TextWriter)Sérialiser cet élément de transmission en continu vers un TextWriter.
Méthode publiquePris en charge par XNA FrameworkSave(XmlWriter)Sérialiser cet élément de transmission en continu vers un XmlWriter.
Méthode publiqueSave(Stream, SaveOptions)Génère ce XStreamingElement vers le Stream spécifié, en précisant le cas échéant le comportement de mise en forme.
Méthode publiquePris en charge par XNA FrameworkSave(String, SaveOptions)Sérialiser cet élément de transmission en continu vers un fichier, en désactivant éventuellement la mise en forme.
Méthode publiquePris en charge par XNA FrameworkSave(TextWriter, SaveOptions)Sérialiser cet élément de transmission en continu vers un TextWriter, en désactivant éventuellement la mise en forme.
Méthode publiquePris en charge par XNA FrameworkToString()Retourne le code XML mis en forme (en retrait) pour cet élément de transmission en continu. (Substitue Object.ToString().)
Méthode publiquePris en charge par XNA FrameworkToString(SaveOptions)Retourne le code XML pour cet élément de transmission en continu, en désactivant éventuellement la mise en forme.
Méthode publiquePris en charge par XNA FrameworkWriteToÉcrit cet élément de diffusion en continu vers un XmlWriter.
Début

Cette classe vous permet de créer une arborescence XML qui prend en charge la sortie de diffusion en continu différée. Vous utilisez cette classe pour créer une arborescence XML pratiquement comme vous le feriez pour créer une arborescence à l'aide de XElement. Toutefois, il y a une différence fondamentale. Lorsque vous utilisez une requête LINQ pour spécifier le contenu lors de la création d'une arborescence XML à l'aide de XElement, la variable de requête est parcourue au moment de la construction de l'arborescence XML, et les résultats de la requête sont ajoutés à l'arborescence XML. À l'inverse, lorsque vous créez une arborescence XML à l'aide de XStreamingElement, une référence à la variable de requête est stockée dans l'arborescence XML sans être parcourue. Les requêtes sont uniquement parcourues lors de la sérialisation. Cela vous permet de créer de plus grandes arborescences XML tout en limitant l'encombrement mémoire.

Si vous transmettez en continu à partir d'une source d'entrée, telle qu'un fichier texte, vous pouvez alors lire un fichier texte très volumineux et générer un document XML de grande taille tout en limitant l'encombrement mémoire.

Un autre scénario est celui dans lequel une arborescence XML de grande taille a été chargée dans la mémoire et dans lequel vous voulez créer une version transformée du document. Si vous créez un document à l'aide de XElement, vous aurez alors deux arborescences XML de grande taille en mémoire une fois la transformation terminée. Toutefois, si vous créez l'arborescence XML à l'aide de XStreamingElement, votre jeu de travail sera alors effectivement divisé par deux.

Notez que lors du débogage d'un programme qui utilise XStreamingElement, l'affichage de la valeur d'un objet provoque l'appel de sa méthode ToString. Cela entraîne la sérialisation du code XML. Si la sémantique de votre requête d'élément de transmission en continu est telle que l'élément de transmission en continu ne peut être transmis qu'en une seule fois, cela peut provoquer un comportement indésirable dans votre phase de débogage.

L'exemple suivant crée d'abord une arborescence XML source. Il crée ensuite une transformation de l'arborescence XML source à l'aide de XElement. Cette transformation crée une arborescence dans la mémoire. Il crée ensuite une transformation de l'arborescence XML source à l'aide de XStreamingElement. Cette transformation n'exécute pas la requête tant que l'arborescence transformée n'est pas sérialisée sur la console. Son utilisation de mémoire est moindre.

XElement srcTree = new XElement("Root",
                       new XElement("Child", 1),
                       new XElement("Child", 2),
                       new XElement("Child", 3),
                       new XElement("Child", 4),
                       new XElement("Child", 5)
                   );

XElement dstTree1 = new XElement("NewRoot",
                        from el in srcTree.Elements()
                        where (int)el >= 3
                        select new XElement("DifferentChild", (int)el)
                    );

XStreamingElement dstTree2 = new XStreamingElement("NewRoot",
                        from el in srcTree.Elements()
                        where (int)el >= 3
                        select new XElement("DifferentChild", (int)el)
                    );

Console.WriteLine(dstTree1);
Console.WriteLine("------");
Console.WriteLine(dstTree2);

Cet exemple produit la sortie suivante :

<NewRoot>
  <DifferentChild>3</DifferentChild>
  <DifferentChild>4</DifferentChild>
  <DifferentChild>5</DifferentChild>
</NewRoot>
------
<NewRoot>
  <DifferentChild>3</DifferentChild>
  <DifferentChild>4</DifferentChild>
  <DifferentChild>5</DifferentChild>
</NewRoot>

Une approche du traitement d'un fichier texte consiste à écrire une méthode d'extension qui transmet le fichier texte en continu, ligne par ligne, à l'aide de la construction yield return. Vous pouvez ensuite écrire une requête LINQ qui traite le fichier texte de façon différée. Si vous utilisez ensuite le XStreamingElement pour transmettre la sortie en continu, vous pouvez alors créer une transformation du fichier texte en XML, qui utilise moins de mémoire, quelle que soit la taille du fichier texte source.

Le fichier texte suivant, People.txt, est la source pour cet exemple.

#This is a comment
1,Tai,Yee,Writer
2,Nikolay,Grachev,Programmer
3,David,Wright,Inventor

Le code suivant contient une méthode d'extension qui transmet les lignes du fichier texte en continu de façon différée.

RemarqueRemarque

L'exemple suivant utilise la construction yield return de C#. Parce qu'il n'existe pas de fonctionnalité équivalente dans Visual Basic 2008, cet exemple est fourni uniquement en C#.

public static class StreamReaderSequence
{
    public static IEnumerable<string> Lines(this StreamReader source)
    {
        String line;

        if (source == null)
            throw new ArgumentNullException("source");
        while ((line = source.ReadLine()) != null)
        {
            yield return line;
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        StreamReader sr = new StreamReader("People.txt");
        XStreamingElement xmlTree = new XStreamingElement("Root",
            from line in sr.Lines()
            let items = line.Split(',')
            where !line.StartsWith("#")
            select new XElement("Person",
                       new XAttribute("ID", items[0]),
                       new XElement("First", items[1]),
                       new XElement("Last", items[2]),
                       new XElement("Occupation", items[3])
                   )
        );
        Console.WriteLine(xmlTree);
        sr.Close();
    }
}

Cet exemple produit la sortie suivante :

<Root>
  <Person ID="1">
    <First>Tai</First>
    <Last>Yee</Last>
    <Occupation>Writer</Occupation>
  </Person>
  <Person ID="2">
    <First>Nikolay</First>
    <Last>Grachev</Last>
    <Occupation>Programmer</Occupation>
  </Person>
  <Person ID="3">
    <First>David</First>
    <Last>Wright</Last>
    <Occupation>Inventor</Occupation>
  </Person>
</Root>

Parfois, vous devez transformer des fichiers XML volumineux et écrire votre application pour que l'encombrement mémoire de l'application soit prévisible. Si vous essayez de remplir une arborescence XML avec un fichier XML très volumineux, votre utilisation de mémoire sera proportionnelle à la taille du fichier (autrement dit, excessive). Par conséquent, vous devez plutôt utiliser une technique de transmission en continu.

Certains opérateurs de requête standard, tels que OrderBy, parcourent leur source, recueillent toutes les données, les trient, puis produisent le premier élément de la séquence. Notez que si vous utilisez un opérateur de requête qui matérialise sa source avant de produire le premier élément, vous utiliserez beaucoup plus de mémoire pour votre application.

Même si vous utilisez la technique décrite dans Comment : transmettre des fragments XML en continu avec accès aux informations d'en-tête, si vous essayez d'assembler une arborescence XML qui contient le document transformé, l'utilisation de la mémoire sera peut être trop importante.

L'exemple suivant repose sur l'exemple présenté dans Procédure : diffuser des fragments XML en continu avec accès aux informations d'en-tête.

Cet exemple utilise les fonctions d'exécution différée de XStreamingElement pour transmettre la sortie en continu.

Notez que l'axe personnalisé (StreamCustomerItem) est spécifiquement écrit pour attendre un document qui a des éléments Customer, Name et Item, et pour que ces éléments soient organisés comme dans le document Source.xml suivant. Toutefois, une implémentation plus fiable validerait le document source avec un XSD ou serait préparée à analyser un document non valide.

Le document suivant est le document source, Source.xml :

<?xml version="1.0" encoding="utf-8" ?> 
<Root>
  <Customer>
    <Name>A. Datum Corporation</Name>
    <Item>
      <Key>0001</Key>
    </Item>
    <Item>
      <Key>0002</Key>
    </Item>
    <Item>
      <Key>0003</Key>
    </Item>
    <Item>
      <Key>0004</Key>
    </Item>
  </Customer>
  <Customer>
    <Name>Fabrikam, Inc.</Name>
    <Item>
      <Key>0005</Key>
    </Item>
    <Item>
      <Key>0006</Key>
    </Item>
    <Item>
      <Key>0007</Key>
    </Item>
    <Item>
      <Key>0008</Key>
    </Item>
  </Customer>
  <Customer>
    <Name>Southridge Video</Name>
    <Item>
      <Key>0009</Key>
    </Item>
    <Item>
      <Key>0010</Key>
    </Item>
  </Customer>
</Root>

Le code suivant contient une méthode qui utilise un XmlReader pour transmettre le code XML source en continu. Il utilise XStreamingElement pour transmettre le nouveau code XML en continu.

RemarqueRemarque

L'exemple suivant utilise la construction yield return de C#. Parce qu'il n'existe pas de fonctionnalité équivalente dans Visual Basic 2008, cet exemple est fourni uniquement en C#.

static IEnumerable<XElement> StreamCustomerItem(string uri)
{
    using (XmlReader reader = XmlReader.Create(uri))
    {
        XElement name = null;
        XElement item = null;

        reader.MoveToContent();

        // Parse the file, save header information when encountered, and yield the
        // Item XElement objects as they are created.

        // loop through Customer elements
        while (reader.Read())
        {
            if (reader.NodeType == XmlNodeType.Element
                && reader.Name == "Customer")
            {
                // move to Name element
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element &&
                        reader.Name == "Name")
                    {
                        name = XElement.ReadFrom(reader) as XElement;
                        break;
                    }
                }

                // loop through Item elements
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.EndElement)
                        break;
                    if (reader.NodeType == XmlNodeType.Element
                        && reader.Name == "Item")
                    {
                        item = XElement.ReadFrom(reader) as XElement;
                        if (item != null)
                        {
                            XElement tempRoot = new XElement("Root",
                                new XElement(name)
                            );
                            tempRoot.Add(item);
                            yield return item;
                        }
                    }
                }
            }
        }
    }
}

static void Main(string[] args)
{
    XStreamingElement root = new XStreamingElement("Root",
        from el in StreamCustomerItem("Source.xml")
        select new XElement("Item",
            new XElement("Customer", (string)el.Parent.Element("Name")),
            new XElement(el.Element("Key"))
        )
    );
    root.Save("Test.xml");
    Console.WriteLine(File.ReadAllText("Test.xml"));
}

Cet exemple produit la sortie suivante :

<?xml version="1.0" encoding="utf-8"?>
<Root>
  <Item>
    <Customer>A. Datum Corporation</Customer>
    <Key>0001</Key>
  </Item>
  <Item>
    <Customer>A. Datum Corporation</Customer>
    <Key>0002</Key>
  </Item>
  <Item>
    <Customer>A. Datum Corporation</Customer>
    <Key>0003</Key>
  </Item>
  <Item>
    <Customer>A. Datum Corporation</Customer>
    <Key>0004</Key>
  </Item>
  <Item>
    <Customer>Fabrikam, Inc.</Customer>
    <Key>0005</Key>
  </Item>
  <Item>
    <Customer>Fabrikam, Inc.</Customer>
    <Key>0006</Key>
  </Item>
  <Item>
    <Customer>Fabrikam, Inc.</Customer>
    <Key>0007</Key>
  </Item>
  <Item>
    <Customer>Fabrikam, Inc.</Customer>
    <Key>0008</Key>
  </Item>
  <Item>
    <Customer>Southridge Video</Customer>
    <Key>0009</Key>
  </Item>
  <Item>
    <Customer>Southridge Video</Customer>
    <Key>0010</Key>
  </Item>
</Root>

.NET Framework

Pris en charge dans : 4, 3.5

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.
Afficher: