Como a usar la colección de diccionarios en C#




El término 'Diccionario' en C # programación, tiene algunos otros sinónimos para referirse a él como "matriz asociativa", "key-value pair", "index-value pair", etc. Diccionario utiliza la estructura de datos ' tabla hash ' para construir subir el index/value pair. En realidad, este es un sistema de matriz extendida / avanzada donde puede definir el índice con otros tipos de datos que no sean int y configurar su estructura de datos de una manera más significativa. En este tutorial, veremos el uso básico de la clase de diccionario c#.





¡Espere! ¿Sabía que, por defecto, los objetos de diccionario en c # no se pueden serializar? Aquí, además de la introducción a la clase de diccionario c #, también le mostraré cómo puede hacer que su objeto de diccionario sea serializado / deserializado a / desde XML también. 

Inicializar un objeto de diccionario en C#:

Como el diccionario funciona con dos tipos de datos (uno para 'clave' y otro para 'valor'), requiere ambos tipos de datos para ser definidos en el momento de la inicialización. Además, se requiere el espacio de nombre "System.Collections.Generic" para usar el diccionario en su aplicación.

El siguiente fragmento inicializará un diccionario simple con cadena como ambos tipos de datos:

Dictionary myDictionaryData 
                      = new Dictionary();


También podemos definir algunos valores iniciales predeterminados en el momento de la inicialización. Los siguientes ejemplos agregarán dos pares de datos en el objeto en el momento de la inicialización:

Dictionary myDictionaryData 
                       = new Dictionary() {
                         {"testDictionaryIndex1","Test Dictionary Data Value 1"},
                         {"testDictionaryIndex2","Test Dictionary Data Value 2"}};


Agregar / eliminar pares en el objeto del diccionario:

Insertar y eliminar operaciones es bastante fácil con un objeto de diccionario. Para agregar un nuevo par, deberá pasar la clave y el valor como parámetro en el método "Agregar" en el objeto. La eliminación del objeto solo se realiza mediante la parte 'clave'. Solo tiene que pasarlo al método "Eliminar" del objeto. Compruebe los siguientes ejemplos de código c # para agregar / eliminar par de datos del diccionario al objeto:

//pasar tanto la clave como el valor para agregar un nuevo par
myDictionaryData.Add("test1", "test value 1");
 
//pasar solo la clave para eliminar un par
myDictionaryData.Remove("test1");

Atraviesa los pares en un objeto de diccionario:

También hay una versión de par de valor único para la clase de diccionario C #. Es la clase 'KeyValuePair' que puede contener un solo par. Cuando realizamos un desplazamiento con o para el bucle foreach , esta variable de clase se puede usar para mantener cada par y procesarlo más si es necesario.

foreach (KeyValuePair myItem in myDictionaryData)
{
    //Hacer lo necesario con myItem
    Console.WriteLine(myItem.Key + " : " + myItem.Value);
}

Fusionar dos diccionario:

¿Qué sucede si tenemos que fusionar dos diccionarios diferentes en un solo objeto de diccionario? Sí, podemos hacerlo. El siguiente ejemplo utiliza la técnica de expresión C # LinQ Lambda para fusionar dos diccionarios diferentes en un tercero diferente:

Dictionary myDictionaryData1 
                             = new Dictionary() {
                               {"testDictionary1Index1","Test Dictionary1 Data Value 1"},
                               {"testDictionary1Index2","Test Dictionary1 Data Value 2"}};
Dictionary myDictionaryData2 
                            = new Dictionary() {
                              {"testDictionary2Index1","Test Dictionary2 Data Value 1"},
                              {"testDictionary2Index2","Test Dictionary2 Data Value 2"}};
 
Dictionary mergedDictionary = new Dictionary();
myDictionaryData1.ToList().ForEach(x => mergedDictionary.Add(x.Key, x.Value));
myDictionaryData1.ToList().ForEach(x => mergedDictionary.Add(x.Key, x.Value));



Implementar diccionario serializable en C #:

Como por defecto .NET Framework no proporciona la facilidad de la serialización c # xml para los objetos del Diccionario, tendremos que implementarlo nosotros mismos. podemos hacerlo implementando la interfaz "IXMLSerializable". La siguiente clase personalizada debe hacer su trabajo bien:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
 
[XmlRoot("dictionary")]
public class SerializableDictionary : 
Dictionary, IXmlSerializable
{
 
    #region IXmlSerializable Members
 
    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }
            
    /// 
    /// Custom implementation to read xml data and assign into dictionary 
    /// 
    /// XmlReader object to be used
    public void ReadXml(System.Xml.XmlReader reader)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();
 
        if (wasEmpty)
        {
            return;
        }
 
        while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
        {
 
            reader.ReadStartElement("item");
            reader.ReadStartElement("key");
            TKey key = (TKey)keySerializer.Deserialize(reader);
            reader.ReadEndElement();
 
            reader.ReadStartElement("value");
            TValue value = (TValue)valueSerializer.Deserialize(reader);
            reader.ReadEndElement();
 
            this.Add(key, value);
 
            reader.ReadEndElement();
            reader.MoveToContent();
        }
        reader.ReadEndElement();
    }
 
    /// 
    /// Custom implementation to write dictionary into xml file
    /// 
    /// XmlWriter object to be used
    public void WriteXml(System.Xml.XmlWriter writer)
    {
        XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
        XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
        foreach (TKey key in this.Keys)
        {
            writer.WriteStartElement("item");
            writer.WriteStartElement("key");
            keySerializer.Serialize(writer, key);
            writer.WriteEndElement();
 
            writer.WriteStartElement("value");
            TValue value = this[key];
            valueSerializer.Serialize(writer, value);
            writer.WriteEndElement();
            writer.WriteEndElement();
        }
 
    }
    #endregion
 
}

Y esto es todo amigos!

Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...

Aplicar LinQ a datos XML usando C#




Hoy voy a mostrar cómo se puede aplicar linq en datos XML junto con ejemplos de código c #. Esto se conoce como 'Linq To XML'. Supongo que ya está familiarizado con el uso básico de Linq. Si no, mi sugerencia será estudiar los conceptos básicos de Linq primero. Aquí, en este tutorial, mostraré las operaciones más básicas, como recuperar datos (seleccionar), insertar datos, borrar datos y modificar datos existentes desde y hacia el archivo xml utilizando linq.




Data de muestra:

Para este ejercicio simple, utilizaremos una estructura de archivo xml muy básica de la siguiente manera:



  
    Test1    
  
  
    Test2    
  
  
    Test3     
    


Este archivo tiene un elemento raíz llamado 'estudiantes' que contiene un conjunto de elementos con la etiqueta 'estudiante', se refiere a cada estudiante en el conjunto de datos. Cada 'estudiante' tiene un atributo 'id' y un elemento interno 'nombre'. Para una estructura más compleja, podemos agregar tantos atributos / elementos internos que deseemos.


Recuperación de datos utilizando linq To XML:

Primero voy a poner un fragmento de código que realmente hará ese trabajo de recuperar datos del archivo xml. Luego explicaré cómo funciona en cada paso.
private string path = "TestData.xml";
 
        private void GetXMLData()
        {
            try
            {
                XDocument testXML = XDocument.Load(path);
                var students = from student in testXML.Descendants("Student")
                                select new
                                {
                                    ID = Convert.ToInt32(student.Attribute("ID").Value),
                                    Name = student.Element("Name").Value 
                                };
 
                foreach (var student in students)
                {
                   // Do other operations with each student object
                }
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }


Al principio, necesitaremos crear un objeto "XDocument" del archivo xml. Simplemente pasar la ubicación del archivo como parámetro del constructor funcionará bien. Aquí, dos cosas deben recordarse cuidadosamente:

  • Si el archivo xml no está en formato xml válido, arrojará una excepción.
  • El ejemplo anterior es para el formato de aplicación de escritorio, donde se requiere que el archivo xml esté en el directorio actual desde donde se ejecuta la aplicación. Si necesita especificar alguna otra ubicación, debe ser necesario especificar el URI absoluto para ese archivo. Si se trata de una aplicación web, es posible que deba utilizar el método Server.MapPath () para especificar el uri correctamente.

Ahora, tan pronto como obtengamos un objeto XDocument válido, estamos listos para aplicar la operación linq sobre él. Para especificar los elementos que se consultarán, necesitamos usar el patrón "xDocObject.Descendants (elementTagName)". Puede ver que hemos utilizado expresiones similares en la consulta de linq. Mientras selecciona, puede crear un objeto dinámico con las propiedades que necesita. O puede declarar de antemano, una clase con miembros y crear un objeto de esa clase. En el código anterior, hemos utilizado el enfoque de objeto dinámico simplificado.


Insertar datos usando Linq a XML:

Insertar datos en un archivo xml usando linq es bastante directo. primero necesitaremos preparar un objeto XElement apropiado que se insertará. De nuevo, hay que tener cuidado de que el XElement construido esté completamente sincronizado con el formato del archivo xml. Y luego, tenemos que agregarlo a la colección de elementos correspondientes de los objetos 'Xdocument' y finalmente sobrescribir el archivo xml existente. Aquí está el ejemplo de código para esto:
private void InsertXMLData(string name)
        {
            try
            {
                XDocument testXML = XDocument.Load(path);               
                 
                XElement newStudent = new XElement("Student",                                               
                                               new XElement("Name", name)                                               
                                           );
                var lastStudent = testXML.Descendants("Student").Last();
 
                int newID =  Convert.ToInt32(lastStudent.Attribute("ID").Value);
                newStudent.SetAttributeValue("ID",4);               
                testXML.Element("Students").Add(newStudent);
                testXML.Save(path);
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }

Modify Existing Data Using Linq To XML:

Para cambiar el registro existente en el archivo xml, primero necesitaremos recuperar el registro que coincida con algunas restricciones, como la coincidencia del atributo id o la coincidencia del valor del nombre. Guarde los datos recuperados en XElement, luego realice los cambios necesarios y finalmente aplique la operación de salvar en la clase de objeto XDocument. Tenga en cuenta que no es necesario reasignar el objeto XElement modificado como referencia interna desde el objeto XDocument y aplicar los cambios necesarios mientras se guarda. Lo siguiente es la muestra del código para hacer la modificación:

private void UpdateXMLData(string name,int id)
        {
            try
            {
                XDocument testXML = XDocument.Load(path);
                XElement cStudent = testXML.Descendants("Student").Where(c => c.Attribute("ID").Value.Equals(id.ToString())).FirstOrDefault();
 
                cStudent.Element("Name").Value = name;
                testXML.Save(path);
            }
            catch (Exception err)
            {
                MessageBox.Show(err.Message);
            }
        }


Eliminar un registro del archivo XML utilizando Linq:

Para eliminar un registro, simplemente tenemos que recuperarlo y luego llamar al método "Eliminar" de este Objeto XElement. que hará la eliminación necesaria en el objeto XDocument y finalmente aplicará los cambios al sobreescribir el archivo xml. A continuación se muestra el ejemplo del código que eliminará un registro:


private void DeleteXMLData(int id)
       {
           try
           {
               XDocument testXML = XDocument.Load(path);
               XElement cStudent = testXML.Descendants("Student").Where(c => c.Attribute("ID").Value.Equals(id.ToString())).FirstOrDefault();
               cStudent.Remove();
               testXML.Save(path);
           }
           catch (Exception err)
           {
               MessageBox.Show(err.Message);
           }
       }


Eso es todo por hoy, espero que sea clara la información, si tienen alguna duda, escríbanme en los comentarios y pronto responderé!

Espero que lo disfruten, compartan y comenten. ;)

"Si se puede imaginar... se puede programar."
Leer más...
Google