Best practice relative alla mappatura dei tipi e ai metodi di estensione

Is putting conversion method inside (POCO?) object (like .ToPerson() method in Consumer class) considered breaking single responsibility pattern?

Sì, perché la conversione è un'altra responsabilità.

Is using converting constructors in (DTO-like) class considered breaking single responsibility pattern? Especially if such class can be converted from multiple source types, so multiple converting constructors would be required?

Sì, la conversione è un'altra responsabilità. Non fa alcuna differenza se lo fai tramite costruttori o tramite metodi di conversione (ad esempio ToPerson ).

Is using extension methods while having access to original class source code considered bad practice?

Non necessariamente. È possibile creare metodi di estensione anche se si ha il codice sorgente della classe che si desidera estendere. Penso che la creazione di un metodo di estensione o meno debba essere determinata dalla natura di tale metodo. Ad esempio, contiene un sacco di logica? Dipende da qualsiasi altra cosa che i membri dell'oggetto stesso? Direi che non dovresti avere un metodo di estensione che richiede che le dipendenze funzionino o che contengano una logica complessa. Solo la logica più semplice dovrebbe essere contenuta in un metodo di estensione.

Can such behavior be used as viable pattern for separating logic or is it an anti-pattern?

Se la logica è complessa, allora penso che non dovresti usare un metodo di estensione. Come ho notato in precedenza, dovresti usare i metodi di estensione solo per le cose più semplici. Non prenderei in considerazione la conversione semplice.

Ti suggerisco di creare servizi di conversione. Puoi avere un'unica interfaccia generica per questo in questo modo:

public interface IConverter<TSource,TDestination>
{
    TDestination Convert(TSource source_object);
}

E puoi avere convertitori come questo:

public class PersonToCustomerConverter : IConverter<Person,Customer>
{
    public Customer Convert(Person source_object)
    {
        //Do the conversion here. Note that you can have dependencies injected to this class
    }
}

E puoi utilizzare Iniezione di dipendenza per iniettare un convertitore (ad esempio IConverter<Person,Customer> ) in qualsiasi classe che richiede l'abilità per convertire tra Person e Customer .

Is putting conversion method inside (POCO?) object (like .ToPerson() method in Consumer class) considered breaking single responsibility pattern?

Sì. Una classe Consumer è responsabile della conservazione dei dati relativi a un consumatore (e probabilmente dell'esecuzione di alcune azioni) e non dovrebbe essere responsabile della conversione di stesso in un altro tipo non correlato.

Is using converting constructors in (DTO-like) class considered breaking single responsibility pattern? Especially if such class can be converted from multiple source types, so multiple converting constructors would be required?

Probabilmente. Solitamente ho metodi al di fuori del dominio e degli oggetti DTO per eseguire la conversione. Uso spesso un repository che accetta oggetti di dominio e li de-serializza, sia su un database, su una memoria, su un file, qualunque sia. Se inserisco questa logica nelle mie classi di dominio, ora le ho legate a una particolare forma di serializzazione, il che è dannoso per i test (e altre cose). Se inserisco la logica nelle mie classi DTO, li ho collegati al mio dominio, limitando di nuovo i test.

Is using extension methods while having access to original class source code considered bad practice?

Non in generale, sebbene possano essere sovrautilizzati. Con i metodi di estensione, crei estensioni facoltative che semplificano la lettura del codice. Hanno degli svantaggi: è più facile creare ambiguità che il compilatore deve risolvere (a volte in modo silenzioso) e può rendere il codice più difficile da eseguire il debug poiché non è del tutto ovvio da dove provenga il metodo di estensione.

Nel tuo caso, un convertitore o una classe mapper sembra l'approccio più semplice e diretto, anche se non penso che tu stia facendo qualcosa di sbagliato usando i metodi di estensione.

Come usare l'AutoMapper o il mapper personalizzato potrebbe essere usato come

MyMapper
   .CreateMap<Person>()
   .To<PersonViewModel>()
   .Map(p => p.Name, vm => vm.FirstName)
   .To<SomeDTO>()
   .Map(...);

dal dominio

 db.Persons
   .ToListAsync()
   .Map<PersonViewModel>();

Sotto il cofano si può astrarre AutoMapper o rollare il proprio mappatore

So che è vecchio, ma è ancora in voga. Questo ti permetterà di convertire in entrambi i modi. Trovo utile questo quando si lavora con Entity Framework e creando viewmodels (DTO).

public interface IConverter<TSource, TDestination>
{
    TDestination Convert(TSource source_object);
    TSource Convert(TDestination source_object);
}

public class PersonCustomerConverter : IConverter<Person, Customer>
{
    public Customer Convert(Person source_object)
    {
        //Do the conversion here. Note that you can have dependencies injected to this class
    }
    public Person Convert(Customer source_object)
    {
        //Do the conversion here. Note that you can have dependencies injected to this class
    }
}

Trovo che AutoMapper sia un po 'troppo per fare operazioni di mappatura davvero semplici.