webentwicklung-frage-antwort-db.com.de

Datenübertragungsobjektmuster

es tut mir leid, ich bin ein Neuling für die Unternehmensanwendung sowie das Entwurfsmuster. Diese Frage könnte ein Mangel an Wissen über Designmuster sein. Ich fand, dass es besser ist, DTO zu verwenden, um Daten zu übertragen.

meine Business Entity-Klasse wie folgt:

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

geben Sie in meinem Anwendungsbenutzer also nur die ID und die HospitalID an. es erfordert also einen anderen Webdienst und erfragt die Personendaten

 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; }
 }

basierend auf diesen Informationen gehe ich zum Patientenobjekt. (DTO-Muster verwenden)

also dachte ich daran, eine neue Klasse zu schreiben, um dies wie folgt zu konvertieren.

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;
    }
}

aber in letzter Zeit las ich einige Artikel und sie verwendeten Serializer Helper class sowie XmlSerializer. Ich kann nicht verstehen, warum sie so etwas verwenden. 

für das DTO-Muster muss XmlSerializer verwendet werden und warum wird es verwendet?

13
DevT

Sie sollten sich AutoMapper wirklich ansehen.

http://automapper.org

Dies ist eine Software, die Sie in Ihre Lösung integrieren können und die automatisch Werte von einer Klasse zu einer anderen zuordnen.

Es ordnet Eigenschaften mit demselben Namen automatisch zu und ist auch sehr intelligent, wenn es um untergeordnete Objekte geht. Es bietet jedoch auch eine vollständige Zuordnungssteuerung, wenn Sie es benötigen.

EDIT

Einige Beispiele, die zeigen, wie der AutoMapper funktioniert. Bitte beachten Sie, dass ich im wirklichen Leben niemals so codieren würde. Kürze!

Beispielklassen.

// 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; }
   }
}

Normalerweise haben Sie einen Teil Ihres Projekts, um alle AutoMapping-Einstellungen zu konfigurieren. Mit den gerade genannten Beispielen können Sie eine Zuordnung zwischen Entities.Manager und Models.Manager wie folgt konfigurieren: -

// Tell AutoMapper that this conversion is possible
Mapper.CreateMap<Entities.Manager, Models.Manager>();

Dann würden Sie in Ihrem Code so etwas verwenden, um ein neues Models.Manager-Objekt aus der Entity-Version zu erhalten.

// Map the class
var mgr = Map<Entities.Manager, Models.Manager>
  ( repoManager, new Models.Manager() );

Übrigens ist AM intelligent genug, um viele Eigenschaften automatisch aufzulösen, wenn Sie die Dinge konsistent benennen.

Beispiel oben, UserFirstname und UserLastname sollten aus folgenden Gründen automatisch ausgefüllt werden: -

  • Manager verfügt über eine Eigenschaft mit dem Namen Benutzer
  • Der Benutzer hat Eigenschaften mit den Namen Vorname und Nachname

Die UserMiddlename-Eigenschaft in Models.Manager ist jedoch nach einer Zuordnungsoperation zwischen Entities.Manager und Models.Manager immer leer, da der Benutzer keine öffentliche Eigenschaft namens Middlename hat.

19

Es gibt eine nette, aber einfache Demo in CodeProject. Es lohnt sich, es durchzugehen ... _. Neulinge können eine grundlegende Idee bekommen, wie man DTOs entwerfen kann.

http://www.codeproject.com/Articles/8824/C-Data-Transfer-Object

Hier ist eine Zusammenfassung des Inhalts:

Das Datenübertragungsobjekt "DTO" ist ein einfaches serialisierbares Objekt, das zum Übertragen von Daten über mehrere Schichten einer Anwendung hinweg verwendet wird. Die in der DTO enthaltenen Felder sind normalerweise primitive Typen wie Strings, Boolean usw. Andere DTOs können in der DTO enthalten oder zusammengefasst sein. Beispielsweise können Sie eine Sammlung von BookDTOs in einem LibraryDTO enthalten. Ich habe ein Framework erstellt, das von mehreren Anwendungen verwendet wird und DTOs verwendet, um Daten über mehrere Ebenen hinweg zu übertragen. Das Framework basiert auch auf anderen OO -Mustern wie Factory, Facade usw. Ein großer Vorteil der DTO im Vergleich zu einem DataSet ist, dass die DTO nicht direkt mit einer Datentabelle oder einer Sicht übereinstimmen muss. Die DTO kann Felder aus einer anderen DTO zusammenfassen

Dies ist die Basisklasse für alle Datenübertragungsobjekte.

using System;

namespace DEMO.Common
{
/// This is the base class for all DataTransferObjects.
    public abstract class DTO
    {
        public DTO()
        {
        }
    }
}

Dies ist eine abgeleitete Klasse von 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;
        }
    }

}

Dies ist die Hilfsklasse für eine DTO. Es gibt öffentliche Methoden zum Serialisieren und Deserialisieren eines 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;
        }            
    }

}

Beginnen Sie nun mit der Serialisierung/Deserialisierung:

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;
    }
}

Schließlich wird dieser Code in der Hauptanwendung ausgeführt

static void Main(string[] args)
{
    DemoClass dc = new DemoClass();
    dc.StartDemo();
}
3
Venugopal M

Ein XmlSerializer oder JsonSerializer kann zum Serialisieren (Laden) von XML- oder Json-Daten aus einer Quelle (Webservice) verwendet werden. Oder den Namen DTO erklären: Sie serialisieren (übertragen) Daten von einer Quelle (Webservice) in ein (allgemeines DTO) Objekt. DTOs sind also Objekte für allgemeine Zwecke. Manchmal ist es klug, ein möglichst breites DTO-Objekt zu erstellen und dieses vollständig auszufüllen, sodass Sie das Objekt beliebig verwenden und in Ihre "eigenen" Programmobjekte kopieren können.

Beispiel: Ich habe ein Programm zur Anzeige von Transportnavigationsdaten entwickelt. Ich serialisiere die gesamte XML- oder Json-Nachricht in einem DTO-Objekt. In diesem DTO-Objekt befinden sich weitere Informationen, die in meinem Programm benötigt werden, und es kann sich in einer anderen Form befinden, daher werde ich nur das verwenden, was benötigt wird. DTO-Objekte erleichtern das Extrahieren von Daten aus Quellen (Webservices).

Ich möchte AutoMapper wegen des Namens "Auto" nicht verwenden. Ich möchte wissen, was ich mache und darüber nachdenken, wohin meine Daten gehen sollen.

1