Modèle d'objet de transfert de données
je suis désolé, je suis débutant dans l'application d'entreprise ainsi que dans le modèle de conception. Peut-être cette question est-elle liée au manque de connaissances sur les modèles de conception. J'ai trouvé qu'il est préférable d'utiliser DTO pour transférer des données.
ma classe d'entité commerciale comme ci-dessous:
public class Patient
{
public string ID { get; set; }
public string FullName { get; set; }
public string FirstName { get; set; }
public string Surname { get; set; }
}
ainsi, dans mon application, l'utilisateur ne donne que l'ID et HospitalID. il appelle donc un autre service Web et obtient des informations personnelles
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; }
}
donc basé sur ces informations im aller à l'objet Patient. (Utilisation d'un motif DTO)
j'ai donc pensé à écrire une nouvelle classe pour convertir ceci comme suit.
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;
}
}
mais dernièrement, j'ai lu quelques articles et ils ont utilisé Serializer Helper class ainsi que la XmlSerializer. Je ne comprends pas pourquoi ils ont utilisé quelque chose comme ça.
pour le modèle DTO est-il nécessaire d'utiliser XmlSerializer et pourquoi est-il utilisé?
Vous devriez vraiment jeter un coup d'oeil à AutoMapper.
C’est un logiciel que vous pouvez inclure dans votre solution et qui mappera automatiquement les valeurs d’une classe à l’autre.
Il mappera automatiquement les propriétés avec le même nom et sera également très intelligent en ce qui concerne les objets enfants. Cependant, il offre également un contrôle complet de la cartographie lorsque vous en avez besoin.
MODIFIER
Quelques exemples illustrant le fonctionnement d'AutoMapper. S'il vous plaît noter que je ne coderais jamais comme ça dans la vraie vie. Brièveté!
Exemple de cours.
// 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<User> 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; }
}
}
Généralement, une partie de votre projet vous permet de configurer tout votre AutoMapping. Avec les exemples que je viens de donner, vous pouvez configurer une carte entre Entities.Manager et Models.Manager comme suit: -
// Tell AutoMapper that this conversion is possible
Mapper.CreateMap<Entities.Manager, Models.Manager>();
Ensuite, dans votre code, vous utiliseriez quelque chose comme ceci pour obtenir un nouvel objet Models.Manager à partir de la version de l'entité.
// Map the class
var mgr = Map<Entities.Manager, Models.Manager>
( repoManager, new Models.Manager() );
Incidemment, AM est assez intelligent pour résoudre automatiquement un grand nombre de propriétés si vous nommez les choses de manière cohérente.
Exemple ci-dessus, UserFirstname et UserLastname doivent être automatiquement renseignés car: -
- Le gestionnaire a une propriété appelée utilisateur
- L'utilisateur a des propriétés appelées Prénom et Nom
Toutefois, la propriété UserMiddlename dans Models.Manager sera toujours vide après un mappage entre Entities.Manager et Models.Manager, car User ne possède pas de propriété publique appelée Middlename.
Il y a une démonstration simple mais simple dans CodeProject. Il vaut la peine de passer par là… .. Les débutants peuvent avoir une idée de base de la conception de DTO.
http://www.codeproject.com/Articles/8824/C-Data-Transfer-Object
Voici un résumé du contenu:
L'objet de transfert de données "DTO" est un objet sérialisable simple utilisé pour transférer des données sur plusieurs couches d'une application. Les champs contenus dans le DTO sont généralement des types primitifs tels que des chaînes, des booléens, etc. D'autres DTO peuvent être contenus ou agrégés dans le DTO. Par exemple, vous pouvez avoir une collection de BookDTO contenus dans un LibraryDTO. J'ai créé un framework utilisé par plusieurs applications utilisant des DTO pour transférer des données sur plusieurs niveaux. Le cadre s'appuie également sur d'autres modèles OO tels que Usine, Façade, etc. L'un des avantages du DTO par rapport à un DataSet est que le DTO n'a pas besoin de faire correspondre directement une table ou une vue de données. Le DTO peut agréger les champs d'un autre DTO
C'est la classe de base pour tous les objets de transfert de données.
using System;
namespace DEMO.Common
{
/// This is the base class for all DataTransferObjects.
public abstract class DTO
{
public DTO()
{
}
}
}
C'est une classe dérivée 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;
}
}
}
C'est la classe d'assistance d'un DTO. Il a des méthodes publiques pour sérialiser et désérialiser 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;
}
}
}
Commencez maintenant la sérialisation/désérialisation:
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;
}
}
Enfin ce code est exécuté dans l'application principale
static void Main(string[] args)
{
DemoClass dc = new DemoClass();
dc.StartDemo();
}
Un XmlSerializer ou un JsonSerializer peut être utilisé pour sérialiser (charger) des données XML ou Json à partir d'une source (webservice). Ou expliquer le nom DTO: vous sérialisez (transférez) les données d'un source (webservice) vers un objet (DTO général). Les DTO sont donc des objets à usage général. Parfois, il est judicieux de créer un objet DTO le plus large possible et de le remplir complètement pour que vous puissiez utiliser ce que vous voulez et le copier dans vos "propres" objets de programme.
Exemple: J'ai développé un programme pour afficher les données de navigation dans les transports. Je sérialise le message XML ou JSON entier dans un objet DTO. Dans cet objet DTO, il y a plus d'informations que j'en aurai besoin dans mon programme et il peut être sous une forme différente, je n'utiliserai donc que ce qui est nécessaire. Les objets DTO facilitent l'extraction de données à partir de sources (webservices).
Je ne veux pas utiliser AutoMapper à cause du nom "Auto". Je veux savoir ce que je fais et penser à la destination de mes données.