El método de persistir objetos de datos serializando y deserializando una colección de entidades de datos genéricas
Cuando usualmente usamos la base de datos, a menudo encontramos un problema, es decir, no queremos que los objetos de la entidad de datos se inserten en la base de datos, pero sí. Si queremos conservarlos, podemos serializarlos en
una cadena XML y guardarlos en otros lugares. Dado que la cadena se genera, se puede guardar en cualquier lugar donde queramos guardarlos. Por ejemplo, ViewState, cookie, caché, etc. de asp.net.
Primero, definimos una clase de entidad de datos.
entidad de clase
{
entidad pública()
{}
identificación interna privada;
identificación interna pública
{
conseguir
{
identificación de devolución;
}
colocar
{
identificación = valor;
}
}
nombre de cadena privada;
Nombre de cadena pública
{
conseguir
{
nombre de retorno;
}
colocar
{
nombre = valor;
}
}
precio doble privado;
público doble precio
{
conseguir
{
precio de devolución;
}
colocar
{
precio = valor;
}
}
}
Así que insértelo en el objeto List<Entity>
List<Entity> list = new List<Entity>();
Entidad obj = nueva Entidad();
obj.Id = 1;
obj.Name = "prueba";
obj.Precio = 3,23;
lista.Agregar(obj);
De esta manera, un objeto List<Entity> se crea con éxito. Vamos a serializarlo
con la cadena estática pública Serialize<BusinessObject>(List<BusinessObject> GenericList).
{
Resultado de XmlDocument = nuevo XmlDocument();
resultado.LoadXml("<Raíz></Root>");
foreach (obj BusinessObject en GenericList)
{
Elemento XmlElement = resultado.CreateElement("Elemento");
PropertyInfo[] propiedades = obj.GetType().GetProperties();
foreach (propiedad PropertyInfo en propiedades)
{
si (propiedad.GetValue(obj, nulo)! = nulo)
{
Elemento XmlElement = resultado.CreateElement(propiedad.Nombre);
element.SetAttribute("Tipo", propiedad.PropertyType.Name);
elemento.InnerText = propiedad.GetValue(obj, null).ToString();
Artículo.AppendChild(elemento);
}
}
resultado.DocumentElement.AppendChild(Artículo);
}
devolver resultado.InnerXml;
}
Luego llamamos a este método
string str = Serialize<Entity>(list);
El archivo XML generado es:
<Raíz>
<Artículo>
<Id Tipo="Int32">1</Id>
<Nombre Tipo="String">prueba</Nombre>
<Precio Tipo="Doble">3.23</Precio>
</Artículo>
</raíz>
A continuación, deserializamos el archivo xml generado anteriormente y generamos el objeto List<Entity> ahora
public static List<BusinessObject> Deserialize<BusinessObject>(string XmlStr)
{
Lista<BusinessObject> resultado = nueva Lista<BusinessObject>();
XmlDocument XmlDoc = nuevo XmlDocument();
XmlDoc.LoadXml(XmlStr);
foreach (XmlNode ItemNode en XmlDoc.GetElementsByTagName("Root").Item(0).ChildNodes)
{
Elemento BusinessObject = Activator.CreateInstance<BusinessObject>();
PropertyInfo[] propiedades = typeof(BusinessObject).GetProperties();
foreach (Nodo de propiedad XmlNode en ItemNode.ChildNodes)
{
nombre de cadena = propiedadNodo.Nombre;
tipo de cadena = propertyNode.Attributes["Tipo"].Valor;
valor de cadena = propertyNode.InnerXml;
foreach (propiedad PropertyInfo en propiedades)
{
if (nombre == propiedad.Nombre)
{
propiedad.SetValue(elemento,Convert.ChangeType(valor,propiedad.PropertyType), nulo);
}
}
}
resultado.Agregar(elemento);
}
resultado de devolución;
}
Luego llamamos a este método:
List<Entity> list = Deserialize<Entity>(str);
Se acabó.
Este artículo solo le presenta un método simple para serializar objetos List <>. Debe usarlo según su propia situación.
http://www.cnblogs.com/kchen/archive/2006/11/04/550382.html