miércoles, 27 de marzo de 2013

Acceder al ClientID de un control que está dentro de un UserControl desde Javascript


Hoy quiero comentarles la forma de acceder al ClientID de un control que está dentro de un UserControl en ASP.NET desde Javascript en el cliente. El ClienteID es el ID que genera ASP.NET al crear la página.

Me surgió la necesidad de acceder a un control que está dentro de un UserControl a través de Javascript o jQuery cuando estaba programando una página un tanto compleja. Estuve buscando una solución y la mayoría hacia una inyección de código Javascript en alguna parte del UserControl de una forma parecida a esta:

ClientScriptManager script = Page.ClientScript;
if (!script.IsClientScriptBlockRegistered(this.GetType(), "RegisterVariables"))
{
 
StringBuilder scriptBlock = new StringBuilder();
  scriptBlock
.AppendLine("<script type=text/javascript>");
  scriptBlock
.AppendFormat("var someVar = {0}", TextBox1.ClientID);
  scriptBlock
.AppendLine("</script>");


  script
.RegisterClientScriptBlock(this.GetType(), "RegisterVariables", 
scriptBlock.ToString());
}

ver: http://forums.asp.net/t/1506954.aspx

Luego someVar al ser global puede ser accedida en cualquier parte de nuestro script.

Realmente me pareció una manera poco elegante de solucionar el problema. Cada vez que el UserControl es utilizado ese código es agregado a la página, se use o no se use.

Mi UserControl, llamado "SeleccionarEmpleados" tenía un listbox llamado "lsEmpleados". Decidí crear una propiedad pública en él de la siguiente forma:


public string lsEmpleados_ClientID
{
        get
        {
            return lsEmpleados.ClientID;
        }
}



Esta propiedad de  "SeleccionarEmpleados" devuelve el ClientID del listbox.

Luego en mi webform puedo acceder de esta forma:



var lst = document.getElementById('<%=SeleccionarEmpleados.lsEmpleados_ClientID%>');




De está forma no hay inyección de código innecesario para otras páginas que no necesiten la funcionalidad y además el código utilizado es mucho más simple y fácil de leer.

Espero que les haya servido!!


miércoles, 18 de enero de 2012

Acá estamos de vuelta

Luego de mucho tiempo vuelvo a escribir en el blog. Estaré posteando nuevas entradas acerca de características avanzadas de .net.

jueves, 20 de diciembre de 2007

Diego Rivera

Este es otro de los íconos de la pintura mundial. Aca les dejo dos pinturas excelentes del pintor.



La clase game

Hoy vamos a ver un poco el tema de la clase Game que dejamos abierta en la publicación pasada.
Esta clase es la más importante de todas porque se ocupa de orquestar los distintos componentes del juego de manera tal que trabajen en sintonia.

Veamos un poco de código...

import javax.microedition.lcdui.*;
import javax.microedition.media.*;
import javax.microedition.media.control.*;
import java.io.*;
import java.util.*;
import javax.microedition.lcdui.game.*;

class Game extends Canvas implements Runnable
{

public Game()
{
}

static long FPS=14;

public void run()
{
setState(Estados.Load);
setFullScreenMode(true);
while (true)
{
try
{
long FPS_Timer = System.currentTimeMillis();
Update();
draw();
repaint();
serviceRepaints();
GameTimer++;
while ((System.currentTimeMillis()-FPS_Timer)<1000/FPS)
Thread.sleep(1);
}
catch (InterruptedException e)
{
//System.out.println(e.toString());
}
catch (Exception e)
{
//e.printStackTrace();
//System.out.println(e.toString());
}
}
}

public void hideNotify ()
{ }

public void showNotify()
{ }

}

Como ya hemos dicho la clase game hereda de Canvas una clase muy importante para los midlets. pueden encontrar mucha info de ella en la red. Lo que no habíamos dicho era que implementa la interfaz Runnable
Esta interfaz lo que permite es correr la clase game en un nuevo hilo. Esencial para hacer el game loop.

Cuando se implementa esta interfaz se debe agregar un método run a la clase. Este método se ejecutará cuando se dispare el hilo.

En este método setearemos el estado incial y que se utilice la pantalla completa de celular.
además crearemos un while para crear el game loop.

Aquí llamaremos a varios métodos muy importantes para nuestro juego (update, draw, etc que aún no están implementados y sirven para actualizar estados y dibujar la animación) y calcularemos los cuadros por segundo. Repaint y serviceRepaints son métodos de canvas que sirven para pintar en la pantalla.

Bueno... ya tenemos lo básico. la estructura. Aunque todavia no hace ni pinta nada ya hemos comenzado...

miércoles, 19 de diciembre de 2007

Video juegos para móviles!!

Hace un tiempo que he incursionado en el área de los video juegos para móviles.
Estuve desarrollando un juego de aventura muy simple al mejor estilo Super Mario Bros.

Como saben (o no) los móviles usan j2me. Una versión reducida de java. hay mucha info al repsecto en la red.

Hoy voy a empezar dandoles la estructura básica de un midlet de un juego:
(si no entienden a priori no importa ya lo vamos a ir explicando...)


import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class gfx extends MIDlet
{
private Display display;
static Game game;
static gfx _instance;

public gfx()
{
display=Display.getDisplay(this);
_instance=this;
game=new Game();
new Thread(game).start();
}

public void startApp() throws MIDletStateChangeException
{
display.setCurrent(game);
}

public void pauseApp()
{}
public void destroyApp(boolean unconditional)
{}

}

Como verán lo primero que hago es heredar mi clase de midlet... muy importante. Sino no es un midlet.
Creo un display para mostrar el juego en pantalla, un Game que hereda de Canvas y que lo vamos a ver más a delante.
En el contructor creo las instancias de los distintos objetos y lanzó un hilo que ejecuta Game.
En el método startApp() le digo a display que canvas dibujar y como Game hereda de canvas le paso esa instancia.

Es mul sencillo. Ahora el tema de como implementar la clase Game es bastante más complejo. lo iremos viendo en varias entragas más.

Estoy de vuelta

Hola!

Hace un tiempo que no he tenido tiempo de crear nuevas entradas. En adelante trateré de hacerlo más seguido. :)

viernes, 13 de julio de 2007

FTP con C#

La siguiente es una clase que hice para subir, bajar, eliminar y renombrar archivos y carpetas en un servidor FTP con c#.




/// <summary>
/// Clase para hacer uso de un servidor FTP
/// </summary>
/// <date>2007-07-11</date>
/// <author>Rodrigo Barros Pascual</author>
public class ManejadorFTP
{
#region <<Propiedades>>

private String _usuario;

/// <summary>
/// Usuario FTP
/// </summary>
public String Usuario
{
get { return _usuario; }
set { _usuario = value; }
}

private String _contraseña;
/// <summary>
/// Contraseña de Usuario FTP
/// </summary>
public String Contraseña
{
get { return _contraseña; }
set { _contraseña = value; }
}

private String _servidor;

/// <summary>
/// URL servidor FTP
/// </summary>
public String Servidor
{
get { return _servidor; }
set { _servidor = value; }
}



#endregion

/// <summary>
/// Sube Documentos al servidor FTP
/// </summary>
/// <param name=pPathDocumento">Path del Documento</param>"
/// <param name=pNombreDocumento">Nombre del Documento</param>"
/// <param name=pPathServidor">Path en el servidor donde se guardará el documento</param>"

public void SubirDocumento(string pPathDocumento, string pNombreDocumento, string pPathServidor)
{
try
{
WebClient request = new WebClient();
request.Credentials = new NetworkCredential(Usuario, Contraseña);
request.UploadFile(Servidor + pPathServidor + pNombreDocumento, pPathDocumento + "\\" + pNombreDocumento);
}
catch (Exception ex)
{
throw new Exception("Error al intentar subir el documento al servidor.", ex);
}
}

/// <summary>
/// Sube archivos al servidor FTP
/// </summary>
/// <param name=pPathDocumento">Path del Documento</param>"
/// <param name=pNombreDocumento">Nombre del Documento</param>"

public void SubirDocumento(string pPathDocumento, string pNombreDocumento)
{
SubirDocumento(pPathDocumento, pNombreDocumento, String.Empty);
}

/// <summary>
/// Baja Documentos del servidor FTP
/// </summary>
/// <param name=pPathServidor">Ruta del Documento en el servidor</param>"
/// <param name=pNombreDocumento">Nombre y extensión del Documento</param>"
/// <param name=pPathFisico">Ruta del documento en el sistema de archivos</param>"
/// <param name=pNombreFisico">Nombre y extensión que se le asignará al documento en el sistema de archivos</param>"

public void BajarDocumento(string pPathServidor, string pNombreDocumento, string pPathFisico, string pNombreFisico)
{
try
{
WebClient request = new WebClient();
request.Credentials = new NetworkCredential(Usuario, Contraseña);
request.DownloadFile(Servidor + pPathServidor + pNombreDocumento, pPathFisico + "\\" + pNombreFisico);
}
catch (Exception ex)
{
throw new Exception("Error al intentar bajar el documento del servidor.", ex);
}
}

/// <summary>
/// Baja Documentos del servidor FTP
/// </summary>
/// <param name=pNombreDocumento">Nombre y extensión del Documento situado en el directorio raíz</param>"
/// <param name=pPathFisico">Ruta del documento en el sistema de archivos</param>"
/// <param name=pNombreFisico">Nombre y extensión que se le asignará al documento en el sistema de archivos</param>"

public void BajarDocumento(string pNombreDocumento, string pPathFisico, string pNombreFisico)
{
BajarDocumento(String.Empty, pNombreDocumento, pPathFisico, pNombreFisico);
}

/// <summary>
/// Crea directorios en el servidor FTP
/// </summary>
/// <param name=pPathDirectorio">Path del directorio</param>"
/// <param name=pNombreDirectorio">Nombre del directorio</param>"

public String CrearDirectorio(string pPathDirectorio, string pNombreDirectorio)
{
try
{
FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPathDirectorio + "/" + pNombreDirectorio);
ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
ftp.KeepAlive = false;
ftp.Method = WebRequestMethods.Ftp.MakeDirectory;
ftp.Proxy = null;
FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
return response.StatusDescription;
}
catch (Exception ex)
{
throw new Exception("Error al intentar crear el directorio en el servidor.", ex);
}
}

/// <summary>
/// Crea directorios en el servidor FTP
/// </summary>
/// <param name=pNombreDirectorio">Nombre del directorio que se agregará al directorio raíz</param>"
public String CrearDirectorio(string pNombreDirectorio)
{
return CrearDirectorio(String.Empty, pNombreDirectorio);
}

/// <summary>
/// Elimina directorios en el servidor FTP
/// </summary>
/// <param name=pPathDirectorio">Path del directorio</param>"
/// <param name=pNombreDirectorio">Nombre del directorio</param>"

public String EliminarDirectorio(string pPathDirectorio, string pNombreDirectorio)
{
try
{
FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPathDirectorio + "/" + pNombreDirectorio);
ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
ftp.KeepAlive = false;
ftp.Method = WebRequestMethods.Ftp.RemoveDirectory;
ftp.Proxy = null;
FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
return response.StatusDescription;
}
catch (Exception ex)
{
throw new Exception("Error al intentar eliminar el directorio del servidor.", ex);
}
}

/// <summary>
/// Elimina directorios en el servidor FTP
/// </summary>
/// <param name=pNombreDirectorio">Nombre del directorio que se eliminará del directorio raíz</param>"
public String EliminarDirectorio(string pNombreDirectorio)
{
return EliminarDirectorio(String.Empty, pNombreDirectorio);
}

/// <summary>
/// Renombra directorios en el servidor FTP
/// </summary>
/// <param name=pPathDirectorio">Path del directorio</param>"
/// <param name=pNombreDirectorio">Nombre del directorio</param>"
/// <param name=pNuevoNombreDirectorio">Nombre con el que se renombrará</param>"

public String RenombrarDirectorio(string pPathDirectorio, string pNombreDirectorio, string pNuevoNombreDirectorio)
{
return Renombrar(pPathDirectorio, pNombreDirectorio, pNuevoNombreDirectorio);
}

/// <summary>
/// Renombra directorios en el servidor FTP
/// </summary>
/// <param name=pNombreDirectorio">Nombre del directorio</param>"
/// <param name=pNuevoNombreDirectorio">Nombre con el que se renombrará</param>"

public String RenombrarDirectorio(string pNombreDirectorio, string pNuevoNombreDirectorio)
{
return Renombrar(String.Empty, pNombreDirectorio, pNuevoNombreDirectorio);
}

/// <summary>
/// Renombra Documentos en el servidor FTP
/// </summary>
/// <param name=pPathDocumento">Path del Documento</param>"
/// <param name=pNombreDocumento">Nombre del Documento</param>"
/// <param name=pNuevoNombreDocumento">Nombre con el que se renombrará</param>"

public String RenombrarDocumento(string pPathDocumento, string pNombreDocumento, string pNuevoNombreDocumento)
{
return Renombrar(pPathDocumento, pNombreDocumento, pNuevoNombreDocumento);
}

/// <summary>
/// Renombra Documentos en el servidor FTP
/// </summary>
/// <param name=pNombreDocumento">Nombre del Documento</param>"
/// <param name=pNuevoNombreDocumento">Nombre con el que se renombrará</param>"

public String RenombrarDocumento(string pNombreDocumento, string pNuevoNombreDocumento)
{
return Renombrar(String.Empty, pNombreDocumento, pNuevoNombreDocumento);
}

/// <summary>
/// Renombra en el servidor FTP
/// </summary>
/// <param name=pPath">Path del directorio o documento</param>"
/// <param name=pNombre">Nombre del directorio o documento</param>"
/// <param name=pNuevoNombre">Nombre con el que se renombrará</param>"

private String Renombrar(string pPath, string pNombre, string pNuevoNombre)
{
try
{
FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPath + "/" + pNombre);
ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
ftp.KeepAlive = false;
ftp.Method = WebRequestMethods.Ftp.Rename;
ftp.RenameTo = pNuevoNombre;
ftp.Proxy = null;
FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
return response.StatusDescription;
}
catch (Exception ex)
{
throw new Exception("Error al intentar renombrar en el servidor.", ex);
}
}

/// <summary>
/// Elimina documentos en el servidor FTP
/// </summary>
/// <param name=pPathDirectorio">Path del documento</param>"
/// <param name=pNombreDirectorio">Nombre del documento</param>"

public String EliminarDocumento(string pPathDocumento, string pNombreDocumento)
{
try
{
FtpWebRequest ftp = (FtpWebRequest)FtpWebRequest.Create(Servidor + pPathDocumento + "/" + pNombreDocumento);
ftp.Credentials = new NetworkCredential(Usuario, Contraseña);
ftp.KeepAlive = false;
ftp.Method = WebRequestMethods.Ftp.DeleteFile;
ftp.Proxy = null;
FtpWebResponse response = (FtpWebResponse)ftp.GetResponse();
return response.StatusDescription;
}
catch (Exception ex)
{
throw new Exception("Error al intentar eliminar el documento del servidor.", ex);
}
}

/// <summary>
/// Elimina documentos en el servidor FTP
/// </summary>
/// <param name=pNombreDirectorio">Nombre del documento</param>"
public String EliminarDocumento(string pNombreDocumento)
{
return EliminarDocumento(String.Empty, pNombreDocumento);
}

/// <summary>
/// Constructor por defecto.
/// </summary>
/// <param name=pUsuario">Usuario FTP</param>"
/// <param name=pContraseña">Contraseña de usuario FTP</param>"
/// <param name=pURLServidor">URL del servidor FTP</param>"

public ManejadorFTP(String pUsuario, String pContraseña, String pURLServidor)
{
Usuario = pUsuario;
Contraseña = pContraseña;
Servidor = pURLServidor;
}

}
 
Espero que les sirva.

lunes, 2 de julio de 2007

Wrapper

Disculpen, pero he estado un poco ocupado y no he podido hacer publicaciones.


Acontinuación expongo un wrapper simple que he utilizado para la llamada a un servicio genérico expuesto en un servicio web. El mismo puede recibir cualquier objeto y devolver cualquier objeto. BSService.BSInterfazService es una referencia web. Como ven utilizo la clase Serializacion de la publicación anterior.

    public static RESPONSE EjecutarServicio<REQUEST, RESPONSE>(String pNombreProcesoDeNegocios, REQUEST pEntidad)
{
try
{
BSService.BSInterfazService ws = new BS.FWK.Wrapper.BSService.BSInterfazService();
String wXML = ws.EjecutarServicio(pNombreProcesoDeNegocios, Serializacion.Serialize(pEntidad));

RESPONSE dev = (RESPONSE)Serializacion.Deserialize(typeof(RESPONSE), wXML);

return dev;
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
}
 
Es un caso sencillo, pero efectivo.

miércoles, 20 de junio de 2007

Serialización en C#

La clase siguiente tiene todas las funciones básicas 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 serialización básicas.
/// </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>Representación 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 declaración</param>
/// <returns>Representación 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 parámetro.
/// </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
}