Compartir a través de

Ejemplo de extensiones débilmente tipadas

En el ejemplo LooselyTypedExtensions se muestran las técnicas básicas para trabajar con datos de extensión.

El modelo de objetos de distribución proporciona compatibilidad enriquecida para trabajar con datos de extensión, información que está presente en la representación XML de una fuente de distribución, pero no expuesta explícitamente por clases como SyndicationFeed y SyndicationItem.

En el ejemplo se usa la SyndicationFeed clase para los fines del ejemplo. Sin embargo, los patrones que se muestran en este ejemplo se pueden usar con todas las clases de syndication que admiten datos de extensión:

SyndicationFeed

SyndicationItem

SyndicationCategory

SyndicationPerson

SyndicationLink

XML de ejemplo

Como referencia, en este ejemplo se usa el siguiente documento XML.

<?xml version="1.0" encoding="IBM437"?>
<feed myAttribute="someValue" xmlns="http://www.w3.org/2005/Atom">
  <title type="text"></title>
  <id>uuid:8f60c7b3-a3c0-4de7-a642-2165d77ce3c1;id=1</id>
  <updated>2007-09-07T22:15:34Z</updated>
  <simpleString xmlns="">hello, world!</simpleString>
  <simpleString xmlns="">another simple string</simpleString>
  <DataContractExtension xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.d
atacontract.org/2004/07/Microsoft.Syndication.Samples">
    <Key>X</Key>
    <Value>4</Value>
  </DataContractExtension>
  <XmlSerializerExtension xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://ww
w.w3.org/2001/XMLSchema" xmlns="">
    <Key>Y</Key>
    <Value>8</Value>
  </XmlSerializerExtension>
  <xElementExtension xmlns="">
    <Key attr1="someValue">Z</Key>
    <Value attr1="someValue">15</Value>
  </xElementExtension>
</feed>

Este documento contiene los siguientes fragmentos de datos de extensión:

  • Atributo myAttribute del <feed> elemento.

  • <simpleString> elemento.

  • <DataContractExtension> elemento.

  • <XmlSerializerExtension> elemento.

  • <xElementExtension> elemento.

Escribir datos de extensión

Las extensiones de atributo se crean agregando entradas a la AttributeExtensions colección, como se muestra en el código de ejemplo siguiente.

//Attribute extensions are stored in a dictionary indexed by
// XmlQualifiedName
feed.AttributeExtensions.Add(new XmlQualifiedName("myAttribute", ""), "someValue");

Las extensiones de elemento se crean agregando entradas a la ElementExtensions colección. Estas extensiones pueden ser mediante valores básicos como cadenas, serializaciones XML de objetos de .NET Framework o nodos XML codificados manualmente.

El código de ejemplo siguiente crea un elemento de extensión denominado simpleString.

feed.ElementExtensions.Add("simpleString", "", "hello, world!");

El espacio de nombres XML de este elemento es el espacio de nombres vacío ("") y su valor es un nodo de texto que contiene la cadena "hello, world!".

Una manera de crear extensiones de elementos complejas que constan de muchos elementos anidados es usar las API de .NET Framework para la serialización (se admiten tanto DataContractSerializer como XmlSerializer) como se muestra en los ejemplos siguientes.

feed.ElementExtensions.Add( new DataContractExtension() { Key = "X", Value = 4 } );
feed.ElementExtensions.Add( new XmlSerializerExtension { Key = "Y", Value = 8 }, new XmlSerializer( typeof( XmlSerializerExtension ) ) );

En este ejemplo, DataContractExtension y XmlSerializerExtension son tipos personalizados escritos para su uso con un el serializador.

La clase SyndicationElementExtensionCollection también se puede usar para crear extensiones de elemento a partir de una instancia XmlReader. Esto permite una integración sencilla con las API de procesamiento XML, como XElement se muestra en el código de ejemplo siguiente.

feed.ElementExtensions.Add(new XElement("xElementExtension",
        new XElement("Key", new XAttribute("attr1", "someValue"), "Z"),
        new XElement("Value", new XAttribute("attr1", "someValue"),
        "15")).CreateReader());

Leer datos de extensión

Los valores para las extensiones de atributo se pueden obtener buscando el atributo en la colección AttributeExtensions por su XmlQualifiedName tal y como se muestra en el código de ejemplo siguiente.

Console.WriteLine( feed.AttributeExtensions[ new XmlQualifiedName( "myAttribute", "" )]);

Se accede a las extensiones de elemento mediante el ReadElementExtensions<T> método .

foreach( string s in feed2.ElementExtensions.ReadElementExtensions<string>("simpleString", ""))
{
    Console.WriteLine(s);
}

foreach (DataContractExtension dce in feed2.ElementExtensions.ReadElementExtensions<DataContractExtension>("DataContractExtension",
"http://schemas.datacontract.org/2004/07/SyndicationExtensions"))
{
    Console.WriteLine(dce.ToString());
}

foreach (XmlSerializerExtension xse in feed2.ElementExtensions.ReadElementExtensions<XmlSerializerExtension>("XmlSerializerExtension", "", new XmlSerializer(typeof(XmlSerializerExtension))))
{
    Console.WriteLine(xse.ToString());
}

También es posible obtener un XmlReader en las extensiones de elementos individuales utilizando el método GetReader().

foreach (SyndicationElementExtension extension in feed2.ElementExtensions.Where<SyndicationElementExtension>(x => x.OuterName == "xElementExtension"))
{
    XNode xelement = XElement.ReadFrom(extension.GetReader());
    Console.WriteLine(xelement.ToString());
}

Para configurar, compilar y ejecutar el ejemplo

  1. Asegúrese de que ha realizado el procedimiento de instalación única para los ejemplos de Windows Communication Foundation.

  2. Para compilar el código C# o Visual Basic .NET Edition de la solución, siga las instrucciones de Building the Windows Communication Foundation Samples.

  3. Para ejecutar el ejemplo en una configuración de una máquina única o entre máquinas, siga las instrucciones de Ejecución de los ejemplos de Windows Communication Foundation.

Consulte también

  • Last updated on