Te sugerimos que revises esta respuesta en un ambiente controlado antes de enviarlo a producción, un saludo.
Solución:
Realmente deberías echarle un vistazo a AutoMapper.
http://automapper.org
Esta es una pieza de software que puede incluir en su solución y que asignará automáticamente valores de una clase a otra.
Mapeará propiedades con el mismo nombre automáticamente, y también es bastante inteligente cuando se trata de objetos secundarios. Sin embargo, también ofrece un control de mapeo completo cuando lo necesita.
EDITAR
Un par de ejemplos para mostrar cómo funciona AutoMapper. Tenga en cuenta que nunca codificaría así en la vida real. ¡Brevedad!
Clases de ejemplo.
// Common scenario. Entity classes that have a connection to the DB.
namespace Entities
public class Manager
public virtual int Id get; set;
public virtual User User get; set;
public virtual IList Serfs get; set;
public class User
public virtual int Id get; set;
public virtual string Firstname get; set;
public virtual string Lastname get; set;
// Model class - bit more flattened
namespace Models
public class Manager
public int Id get; set;
public string UserFirstname get; set;
public string UserLastname get; set;
public string UserMiddlename get; set;
Normalmente, tendría una parte de su proyecto para configurar todos sus AutoMapping. Con los ejemplos que acabo de dar, puede configurar un mapa entre Entities.Manager y Models.Manager así: –
// Tell AutoMapper that this conversion is possible
Mapper.CreateMap();
Luego, en su código, usaría algo como esto para obtener un nuevo objeto Models.Manager de la versión Entity.
// Map the class
var mgr = Map
( repoManager, new Models.Manager() );
Por cierto, AM es lo suficientemente inteligente como para resolver muchas propiedades automáticamente si nombra las cosas de manera consistente.
En el ejemplo anterior, UserFirstname y UserLastname deben completarse automáticamente porque: –
- El administrador tiene una propiedad llamada Usuario
- El usuario tiene propiedades llamadas Nombre y Apellido
Sin embargo, la propiedad UserMiddlename en Models.Manager siempre estará en blanco después de una operación de mapeo entre Entities.Manager y Models.Manager, porque el usuario no tiene una propiedad pública llamada Middlename.
Hay una demostración agradable pero simple en CodeProject. Vale la pena atravesarlo. Los novatos pueden tener una idea básica del diseño de DTO.
http://www.codeproject.com/Articles/8824/C-Data-Transfer-Object
Aquí hay un resumen del contenido:
El objeto de transferencia de datos “DTO” es un objeto serializable simple que se utiliza para transferir datos a través de múltiples capas de una aplicación. Los campos contenidos en el DTO suelen ser tipos primitivos como cadenas, booleanos, etc. Otros DTO pueden estar contenidos o agregados en el DTO. Por ejemplo, puede tener una colección de BookDTOs contenida en un LibraryDTO. He creado un marco utilizado por múltiples aplicaciones que utiliza DTO para transferir datos entre niveles. El marco también se basa en otros patrones OO como Factory, Facade, etc. Una de las mejores cosas del DTO en comparación con un DataSet es que el DTO no tiene que coincidir directamente con una tabla o vista de datos. El DTO puede agregar campos de otro DTO
Esta es la clase base para todos los objetos de transferencia de datos.
using System;
namespace DEMO.Common
/// This is the base class for all DataTransferObjects.
public abstract class DTO
public DTO()
Esta es una clase derivada de DTO:
using System;
using System.Xml.Serialization;
using DEMO.Common;
namespace DEMO.DemoDataTransferObjects
{
public class DemoDTO : DTO
// Variables encapsulated by class (private).
private string demoId = "";
private string demoName = "";
private string demoProgrammer = "";
public DemoDTO()
///Public access to the DemoId field.
///String
[XmlElement(IsNullable=true)]
public string DemoId
get
return this.demoId;
set
this.demoId = value;
///Public access to the DemoId field.
///String
[XmlElement(IsNullable=true)]
public string DemoName
get
return this.demoName;
set
this.demoName = value;
///Public access to the DemoId field.
///String
[XmlElement(IsNullable=true)]
public string DemoProgrammer
get
return this.demoProgrammer;
set
this.demoProgrammer = value;
Esta es la clase de ayuda para un DTO. Tiene métodos públicos para serializar y deserializar un DTO.
using System;
using System.Xml.Serialization;
using System.IO;
namespace DEMO.Common
{
public class DTOSerializerHelper
public DTOSerializerHelper()
///
/// Creates xml string from given dto.
///
/// DTO
/// XML
public static string SerializeDTO(DTO dto)
try
XmlSerializer xmlSer = new XmlSerializer(dto.GetType());
StringWriter sWriter = new StringWriter();
// Serialize the dto to xml.
xmlSer.Serialize(sWriter, dto);
// Return the string of xml.
return sWriter.ToString();
catch(Exception ex)
// Propogate the exception.
throw ex;
///
/// Deserializes the xml into a specified data transfer object.
///
/// string of xml
/// type of dto
/// DTO
public static DTO DeserializeXml(string xml, DTO dto)
try
XmlSerializer xmlSer = new XmlSerializer(dto.GetType());
// Read the XML.
StringReader sReader = new StringReader(xml);
// Cast the deserialized xml to the type of dto.
DTO retDTO = (DTO)xmlSer.Deserialize(sReader);
// Return the data transfer object.
return retDTO;
catch(Exception ex)
// Propogate the exception.
throw ex;
Ahora comience la serialización / deserialización:
using System;
using DEMO.Common;
using DEMO.DemoDataTransferObjects;
namespace DemoConsoleApplication
{
public class DemoClass
public DemoClass()
public void StartDemo()
this.ProcessDemo();
private void ProcessDemo()
DemoDTO dto = this.CreateDemoDto();
// Serialize the dto to xml.
string strXml = DTOSerializerHelper.SerializeDTO(dto);
// Write the serialized dto as xml.
Console.WriteLine("Serialized DTO");
Console.WriteLine("=======================");
Console.WriteLine("r");
Console.WriteLine(strXml);
Console.WriteLine("r");
// Deserialize the xml to the data transfer object.
DemoDTO desDto =
(DemoDTO) DTOSerializerHelper.DeserializeXml(strXml,
new DemoDTO());
// Write the deserialized dto values.
Console.WriteLine("Deseralized DTO");
Console.WriteLine("=======================");
Console.WriteLine("r");
Console.WriteLine("DemoId : " + desDto.DemoId);
Console.WriteLine("Demo Name : " + desDto.DemoName);
Console.WriteLine("Demo Programmer: " + desDto.DemoProgrammer);
Console.WriteLine("r");
private DemoDTO CreateDemoDto()
DemoDTO dto = new DemoDTO();
dto.DemoId = "1";
dto.DemoName = "Data Transfer Object Demonstration Program";
dto.DemoProgrammer = "Kenny Young";
return dto;
Finalmente este código se ejecuta en la aplicación principal.
static void Main(string[] args)
DemoClass dc = new DemoClass();
dc.StartDemo();
Se puede utilizar un XmlSerializer o JsonSerializer para serializar (cargar) datos XML o Json desde una fuente (servicio web). O explicando el nombre DTO: serializas (transfieres) datos desde una fuente (servicio web) a un objeto (DTO general). Entonces, los DTO son objetos de propósito general. A veces es inteligente hacer un objeto DTO lo más ancho posible y llenarlo por completo para que pueda usar de ese objeto lo que quiera y copiarlo en sus “propios” objetos de programa.
Ejemplo: desarrollé un programa para mostrar datos de navegación de transporte. Serializo todo el mensaje xml o json en un objeto DTO. En este objeto DTO hay más información de la que necesitaré en mi programa y puede estar en una forma diferente, por lo que usaré solo lo que sea necesario. Los objetos DTO facilitan la extracción de datos de fuentes (servicios web).
No quiero usar AutoMapper por el nombre “Auto”. Quiero saber lo que estoy haciendo y pensar a dónde van mis datos.