Patrón de objeto de transferencia de datos

Lo siento, soy novato en la aplicación empresarial, así como en el patrón de diseño. Podría ser esta pregunta que surja la falta de conocimiento sobre el patrón de diseño. Encontré que es mejor usar DTO para transferir datos.

mi clase de entidad de negocios como abajo:

public class Patient { public string ID{ get; set; } public string FullName { get; set; } public string FirstName { get; set; } public string Surname { get; set; } } 

así que en mi aplicación el usuario solo da ID y HospitalID. por lo que requiere otro servicio web y obtener información personal

  public class PersonDTO { public string NIC { get; set; } public string FullName { get; set; } public string FirstName { get; set; } public string BirthPlace { get; set; } public string BirthCertificateID { get; set; } } 

Así que en base a esta información voy al objeto del paciente. (Usando el patrón DTO)

Así que pensé en escribir una nueva clase para convertir esto de la siguiente manera.

 public class PatientDO { public static Patient ConvertToEntity(PatientRegistrationDTO pregDTO,PersonDTO person) { Patient p=new Patient(); p.NIC = pregDTO.NIC; p.FullName = person.FullName; p.FirstName = person.FirstName; return p; } } 

pero últimamente leí algunos artículos y usaron la Serializer Helper class así como el XmlSerializer , no puedo entender por qué usaron algo así.

para el patrón DTO es que es necesario utilizar XmlSerializer y por qué se utiliza?

Realmente deberías echar un vistazo a AutoMapper.

http://automapper.org

Este es un software que puede incluir en su solución que automáticamente asignará valores de una clase a otra.

Asignará las 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 necesite.

EDITAR

Un par de ejemplos para mostrar cómo funciona AutoMapper. Tenga en cuenta que nunca codificaría así en la vida real. ¡Brevedad!

Ejemplo de clases.

 // 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á una parte de su proyecto para configurar todo su AutoMapping. Con los ejemplos que acabo de dar, puedes configurar un mapa entre Entities.Manager y Models.Manager de la siguiente manera:

 // 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 de 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 nombras 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 asignación 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. Es digno de pasar por ello. Los novatos pueden tener una idea básica de diseñar DTOs.

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 a través de niveles. El marco también se basa en otros patrones de OO como Factory, Facade, etc. Una de las mejores cosas de la DTO en comparación con un DataSet es que 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 des-serializar 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 usar un XmlSerializer o JsonSerializer para serializar (cargar) datos XML o Json de una fuente (servicio web). O explicando el nombre DTO: usted serializa (transfiere) datos de una fuente (servicio web) a un objeto (DTO). Así que las DTO son objetos de propósito general. A veces es inteligente hacer un objeto DTO lo más amplio posible y rellenarlo por completo para que pueda usar desde ese objeto lo que quiera y copiarlo en sus objetos “propios” del progtwig.

Ejemplo: Desarrollé un progtwig 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 progtwig y puede estar en una forma diferente, así que solo usaré lo que sea necesario. DJ ojbjects facilita la extracción de datos de fonts (servicios web).

No quiero usar AutoMapper por el nombre “Auto”. Quiero saber qué estoy haciendo y pensar a dónde irán mis datos.