Está en la página 1de 7

La clase siguiente tiene todas las funciones bsicas para serializar.

Pasando un objeto a Serialize te devuelve un string con el mismo serializado.


Si usas Deserialize todo lo que tenes que hacer es pasarle el tipo y el string para que te levante el objeto de nuevo.

/// <summary>
/// Clase que contiene todas las funciones de serializacin bsicas.
/// </summary>
public class Serializacion
{
#region -- Binary Serialization -/// <summary>
/// Serializa un objeto a un archivo binario.
/// </summary>
/// <param name="fileName">Ruta del archivo en el cual depositar los bytes</param>
/// <param name="objToSerialize">Objeto en memoria a transformar en bytes</param>
public static void SerializeToBin(string fileName, object objToSerialize)
{
if (objToSerialize == null)
{
throw new Exception("El objeto a serializar no debe ser nulo.");
}
// Creo el archivo de destino y lo devuelvo a un fileStream
FileStream fs = File.Create(fileName);
// Creo un BinaryFormatter que me sirve como serializador
BinaryFormatter serializer = new BinaryFormatter();
// Le digo al serializador que guarde los bytes en un archivo
// binario, representado por el FileStream
serializer.Serialize(fs, objToSerialize);
// Cierro el FileStream

fs.Close();
}
///
///
///
///
///
///

<summary>
Deserializa un objeto a partir del contenido de un archivo binario
</summary>
<param name="fileName">Archivo desde donde toma los bytes que se
encuentran serializados</param>
<returns>objeto deserializado</returns>
public static object DeserializeFromBin(string fileName)
{
if (!File.Exists(fileName))
{
throw new Exception("El archivo de origen para deserializar " +
"no existe. No se encuentra la ruta '" + fileName + "'");
}
// Abro el archivo de origen y lo devuelvo a un fileStream
FileStream fs = File.OpenRead(fileName);
// Creo un BinaryFormatter que me sirve como deserializador
BinaryFormatter deserializer = new BinaryFormatter();
// Le digo al deserializador que me devuelva el objeto a partir
// del FileStream
object objDeserialized = deserializer.Deserialize(fs);
// Cierro el FileStream
fs.Close();
// Devuelvo el objeto deserializado
return objDeserialized;
}
#endregion
#region -- Xml Serialization using DataSet -/// <summary>

/// Serializa a un XML y lo coloca en un DataSet


/// </summary>
/// <param name="pObject">Objeto a serializar</param>
/// <param name="pDataSet">Dataset donde se coloca el XML</param>
public static void SerializeToXml(object pObject, ref DataSet pDataSet)
{
XmlSerializer wSerializer;
MemoryStream wStream = new MemoryStream();
if (pDataSet == null)
pDataSet = new DataSet();
wSerializer = new XmlSerializer(pObject.GetType());
wSerializer.Serialize(wStream, pObject);
wStream.Position = 0;
pDataSet.ReadXml(wStream);
}
/// <summary>
/// Serializa un objeto
/// </summary>
/// <param name="pObj"></param>
/// <param name="pDataSet"></param>
public static void Serialize(object pObj, ref DataSet pDataSet)
{
XmlSerializer serializer;
MemoryStream ms = new MemoryStream();
if (pDataSet == null)
pDataSet = new DataSet();
serializer = new XmlSerializer(pObj.GetType());
serializer.Serialize(ms, pObj);
ms.Position = 0;
pDataSet.ReadXml(ms);
}

/// <summary>
/// Deserializa un objeto a partir de un DataSet
/// </summary>
/// <param name="pObjType"></param>
/// <param name="pDataSet"></param>
/// <param name="pTableName"></param>
/// <returns></returns>
public static object Deserialize(Type pObjType, DataSet pDataSet, string pTableName)
{
XmlDocument wDom = new XmlDocument();
wDom.LoadXml(pDataSet.GetXml());
return Deserialize(pObjType, wDom.GetElementsByTagName(pTableName).Item(0).OuterXml);
}
#endregion
#region -- Xml Serialization using Xml -/// <summary>
/// Deserializa un objeto.
/// </summary>
/// <param name="pObjType"></param>
/// <param name="pXmlData"></param>
/// <returns></returns>
public static object Deserialize(Type pObjType, string pXmlData)
{
XmlSerializer wSerializer;
UTF8Encoding wEncoder = new UTF8Encoding();
MemoryStream wStream = new MemoryStream(wEncoder.GetBytes(pXmlData));
wSerializer = new XmlSerializer(pObjType);
return wSerializer.Deserialize(wStream);
}
///
///
///
///
///

<summary>
Deserializa un objeto.
</summary>
<param name="pObjType"></param>
<param name="pXmlData"></param>

/// <param name="pXPath"></param>


/// <returns></returns>
public static object Deserialize(Type pObjType, string pXmlData, string pXPath)
{
XmlDocument wDom = new XmlDocument();
wDom.LoadXml(pXmlData);
return Deserialize(pObjType, wDom.DocumentElement.SelectSingleNode(pXPath).OuterXml);
}
/// <summary>
/// Deserializa un objeto
/// </summary>
/// <param name="pTipo"></param>
/// <param name="pXml"></param>
/// <returns></returns>
public static object DeserializeFromXml(Type pTipo, string pXml)
{
XmlSerializer wSerializer;
StringReader wStrSerializado = new StringReader(pXml);
XmlTextReader wXmlReader = new XmlTextReader(wStrSerializado);
XmlSerializerNamespaces wNameSpaces = new XmlSerializerNamespaces();
object wResObj = null;
wNameSpaces.Add("", "");
wSerializer = new XmlSerializer(pTipo);
wResObj = wSerializer.Deserialize(wXmlReader);
return wResObj;
}
/// <summary>
/// Serializa un objeto
/// </summary>
/// <param name="pObj"></param>
/// <returns></returns>
public static string SerializeToXml(object pObj)
{
XmlSerializer wSerializer;
StringWriter wStwSerializado = new StringWriter();

XmlTextWriter wXmlWriter = new XmlTextWriter(wStwSerializado);


XmlSerializerNamespaces wNameSpaces = new XmlSerializerNamespaces();
wXmlWriter.Formatting = Formatting.Indented;
wNameSpaces.Add("", "");
wSerializer = new XmlSerializer(pObj.GetType());
wSerializer.Serialize(wXmlWriter, pObj, wNameSpaces);
return wStwSerializado.ToString().Replace("<?xml version=\"1.0\" encoding=\"utf-16\"?>", "");
}
/// <summary>
/// Serializa un objeto.
/// </summary>
/// <param name="pObj">Objeto a serializar</param>
/// <returns>Representacin en XML del objeto</returns>
public static string Serialize(object pObj)
{
return Serialize(pObj, false);
}
/// <summary>
/// Serializa un objeto.
/// </summary>
/// <param name="pObj">Objeto a serializar</param>
/// <param name="pRemoveDeclaration">Indica si se debe remover el nodo de declaracin</param>
/// <returns>Representacin en XML del objeto</returns>
public static string Serialize(object pObj, bool pRemoveDeclaration)
{
XmlDocument wDoc = new XmlDocument();
wDoc.Load(GetStream(pObj));
if (pRemoveDeclaration && wDoc.ChildNodes.Count > 0 && wDoc.FirstChild.NodeType == XmlNodeType.XmlDeclaration)
{
wDoc.RemoveChild(wDoc.FirstChild);
}
return wDoc.InnerXml;
}

/// <summary>
/// Devuelve un stream formado a partir del objeto enviado por parmetro.
/// </summary>
/// <param name="pObj">Objeto para extraer stream</param>
/// <returns>MemoryStream</returns>
public static MemoryStream GetStream(object pObj)
{
XmlSerializer wSerializer;
MemoryStream wStream = new MemoryStream();
wSerializer = new XmlSerializer(pObj.GetType());
wSerializer.Serialize(wStream, pObj);
wStream.Position = 0;
return wStream;
}
#endregion
}