디자인 모드 어댑터 em C#

O 디자인 모드 어댑터 ãum padr ã O de projeto do tipo estrutural que permite que interfaces uncompt íveis functionem juntas.Fazendo isso,permitimos que objetos de differentes interfaces se comuniquem.
Neste artigo,vamos aprender como implementar o padrão Adapter em nosso projeto e quando devemos usálo.
Este artigo estádivido nas seguintes seçes:

프로젝트

Implementaão do Adapter

Quando usaro 어댑터

결론

프로젝트 전용

Vamos imaginar que temos uma functionalidade na qual convertemos uma lista de fabricantes de automóveis para o formato JSON e a escrevemos na tela.Mas、em vez de uma lista、foi fornecida uma API que nos fornece todos os fabricantes no formato XML.
Digamos que não possamos modificar a functionalidade da API existent(por causa de restriões técnicas,como ser importado para o nosso projeto de outra soluão que não devemificar ou como um pacote NuGet),então temos que encontar uma maneira de contornar isso.
E a maneira correta de fazer issoéimplementar o padrão Adapter para resolver esse problema.
Vamos começar com a criaço de uma classe de modeloManufacturer(fabricante)e um exemplo simples de objeto para conversor XML:

public class Manufacturer
{
        public string Name { get; set; }
        public string City { get; set; }
        public int Year { get; set; }
}

public static class ManufacturerDataProvider
{
    public List<Manufacturer> GetData() =>
       new List<Manufacturer>
       {
            new Manufacturer { City = "Italy", Name = "Alfa Romeo", Year = 2016 },
            new Manufacturer { City = "UK", Name = "Aston Martin", Year = 2018 },
            new Manufacturer { City = "USA", Name = "Dodge", Year = 2017 },
            new Manufacturer { City = "Japan", Name = "Subaru", Year = 2016 },
            new Manufacturer { City = "Germany", Name = "BMW", Year = 2015 }
       };
}

public class XmlConverter
{
    public XDocument GetXML()
    {
        var xDocument = new XDocument();
        var xElement = new XElement("Manufacturers");
        var xAttributes = ManufacturerDataProvider.GetData()
            .Select(m => new XElement("Manufacturer", 
                                new XAttribute("City", m.City),
                                new XAttribute("Name", m.Name),
                                new XAttribute("Year", m.Year)));

        xElement.Add(xAttributes);
        xDocument.Add(xElement);

        Console.WriteLine(xDocument);

        return xDocument;
    }
}

Como podemos ver,esteéum código bastante simples.Estamos coletando dados do fabricante,criando um elemento raiz do fabricante e todos os subelementos do fabricante com seus atributos.
deposis disso,estamos imprimindo os resultados na janela do console para mostrar a aparência do XML final.
Estaéa aparência doxDocument:

Agora vamos implementar uma classeJsonConverter:

public class JsonConverter
{
    private IEnumerable<Manufacturer> _manufacturers;

    public JsonConverter(IEnumerable<Manufacturer> manufacturers)
    {
        _manufacturers = manufacturers;
    }

    public void ConvertToJson()
    {
        var jsonManufacturers = JsonConvert.SerializeObject(_manufacturers, Formatting.Indented);

        Console.WriteLine("\nPrinting JSON list\n");
        Console.WriteLine(jsonManufacturers);
    }
}

Este c ó digoé ainda mais는 porque apenas serializamos nossa lista de fabricantes emum formato JSON을 간소화했다.
Claro,para que a serializaão funcione,precisamos instalar a bibliotecaNewtonsoft.Json,então não se esqueça de instala.
Excellente,temos nossa Functionalidade JSON e a interface XML fornecida.Mas agora,precisamos resolver um problema real.Como combinar essas duas interfaces para realizar nossa tarefa,queéconverter fabricantes do formato XML para JSON.

Implementa ão do 어댑터

Como podemos ver neste caso,não hánenhuma maneira de passar umxDocumentpara a classeJsonConvertere não deveria haver.Então precisamos criar a classe adapter que farácom que essas duas interfaces functionem juntas.
Para fazer isso,vamos começar criando uma interfaceIXmlToJsonPara definir o comportamento de nossa classe adapter:

public interface IXmlToJson
{
    void ConvertXmlToJson();
}

E então,vamos continuar com a classeXmlToJsonAdapterque implementaráa interfaceIXmlToJson:

public class XmlToJsonAdapter : IXmlToJson
{
    private readonly XmlConverter _xmlConverter;

    public XmlToJsonAdapter(XmlConverter xmlConverter)
    {
        _xmlConverter = xmlConverter;
    }

    public void ConvertXmlToJson()
    {
        var manufacturers = _xmlConverter.GetXML()
                .Element("Manufacturers")
                .Elements("Manufacturer")
                .Select(m => new Manufacturer
                             {
                                City = m.Attribute("City").Value,
                                Name = m.Attribute("Name").Value,
                                Year = Convert.ToInt32(m.Attribute("Year").Value)
                             });

        new JsonConverter(manufacturers)
            .ConvertToJson();
    }
}

탁월하다Criamos nossa classe adapter que converte o objeto de documento Xml na lista de fabricantes e fornece essa lista para a classeJsonConverter.
Portanto、como vocêpode ver、habilitamos a compatibilidade entre duas interfaces completamente differentes apenas introzindo uma classe adapter em nosso projeto.
Agora,podemos fazer uma chamada para esta classe adapter da nossa classe de cliente:

public class Program
{
   public static void Main(string[] args)
    {
        var xmlConverter = new XmlConverter();
        var adapter = new XmlToJsonAdapter(xmlConverter);
        adapter.ConvertXmlToJson();
    }
}

Assim que iniciarmos nosso aplicativo,veremos o seguinte resultado:

Muito legal,nãoé?
E assim Concluímos nossa implementaço.

Quando usar o 어댑터

Devemos usar uma classe Adapter sempre que quisermos trabalhar com uma classe existent,mas que sua interface nãoécompativel com o resto do nosso código.Basicamente,o padrão Adapteréuma camada intermediaária que serve como um tradutor entre o código implementado em nosso projeto e alguma classe de terceiros ou qualquer outra classe com uma interface differente.
Além disso,devemos usar o Adapter quando quisermos reutilizar classes existentes de nosso projeto,quando elas não possuem uma Functionalidade comum.Ao usar o padrão Adapter neste caso,não precisamos estender cada classe separadamente e criar um código redundante.

결론

O padrãO Adapterébastante comum no mundo do C#eébastante usado quando temos que Adapter algumas classes existentes para uma nova interface.Pode aumentar a complexidade do código essas classes adicionais(adadatoras),mas vale a pena o esforço com certeza.