Utilizzo di un DTO superset per un numero di metodi in una classe

Restituisce una collezione di KeyValuePair<K,V> con solo i valori per il particolare metodo chiamato.

o

Restituisce un particolare tipo Tuple per un dato MethodX .

o

Imposta i valori che non stai inviando. Questo potrebbe essere un problema: come fai a capire la differenza tra "ignora me" e il suo valore È quello predefinito.

o

parametrizza il metodo per dire quali valori sono desiderati. Il tipo / struttura di ritorno spetta a te.

o

Dai al cliente l'onere di ignorare le cose giuste. Nel qual caso vedo una proliferazione di classi "DTO" più anemiche dal lato del cliente.

Dai al cliente qualcosa con cui possono effettivamente lavorare

Qualunque sia l'implementazione, dovrebbe essere nella classe DTO stessa. Pertanto, il DTO non è più un DTO di per sé, ma una classe "reale" come dovrebbe essere. Come bonus puoi dimenticare tutto quel interface di spese generali.

Non sono sicuro di quanto senso possa avere, ma, FWIW:

(forzato)

/// <summary>
/// TDto below not meant to be closed over the actual DTOs, but only
/// local proxies of those that a (likewise) proxy implementation of
/// the interface will reflect over/interpret (cf. System.Reflection)
/// before forwarding the call to the actual service client,
/// with the actual DTOs
/// </summary>
public interface IMyBusinessFacade
{
    TDto GetById<TDto, TIdentifier>(TDto protoDto, TIdentifier id)
        // DTOs being anemic by their very nature, whatever will be TDto on call sites (as a closed type)
        // we can reasonably expect it to come as either (a) a named reference type
        // (most likely with a public parameter-less constructor) or
        // (b) an anonymous type that a proxy can validate (or not) before even bothering
        // to forwarding to the service layer
        where TDto : class;

    IEnumerable<TDto> GetFiltered<TDto, TCriteria>(TDto protoDto, TCriteria criteria)
        where TDto : class;
}

// If the tooling can generate service clients, it might as well generate
// such local proxies for those clients
public class MyBusinessFacade : /*ProxyBase, */IMyBusinessFacade
{
    private IMyBusinessService service;

    public MyBusinessFacade(IMyBusinessService service)
    {
        this.service = service;
    }

    public TDto GetById<TDto, TIdentifier>(TDto protoDto, TIdentifier id)
        where TDto : class
    {
        // auto-generated implementation to use reflection over typeof(TDto)
        // and typeof(TIdentifier) before forwarding the calls to the service layer
        // if applicable (or throw exception on invalid client-specified input)
        // ...
        // resolve, using this.service
        // ...
        // instantiate and hydrate a TDto, if applicable
        TDto dto = ...
        // and return it
        return dto;
    }

    public IEnumerable<TDto> GetFiltered<TDto, TCriteria>(TDto protoDto, TCriteria criteria)
         where TDto : class
    {
        // ...
        // resolve, using this.service
        // ...
        // instantiate and hydrate an IEnumerable<TDto>, if applicable
        IEnumerable<TDto> dtos = ...
        // and return it
        return dtos;
    }
}

public enum CustomerKind
{
    Regular,
    Premium
}

public enum SubscriptionType
{
    OneMonthTrial,
    MonthlyAutoRenew
}

Quindi, più avanti:

        // (actual service client)
        IMyBusinessService myService = ...
        // ...
        IMyBusinessFacade myFacade = new MyBusinessFacade(myService);

        var GetCustomerById =
            new
            {
                // the facade/proxy will relate/interpret this property's
                // type & name (but not its useless value) with that of the id parameter
                CustomerId = default(int),

                // facade/proxy to interpret those too, as what the caller
                // expects:
                CustomerKind = default(CustomerKind),
                // etc
            };

        var GetCustomerContractById =
            new
            {
                ContractId = default(int),

                // facade/proxy to interpret those too, as what the caller
                // expects:
                Customer = GetCustomerById,
                SubscriptionType = default(SubscriptionType),
                // etc
            };

        var customer123 = myFacade.
            GetById
            (
                GetCustomerById,
                123
            );

        var contrat456 = myFacade.
            GetById
            (
                GetCustomerContractById,
                456
            );

        Console.WriteLine("Customer: {0}, {1} ...", customer123.CustomerId, customer123.CustomerKind);
        Console.WriteLine("Contract: {0} (Customer: {1}) Subscription: {2} ...", contrat456.ContractId, contract456.Customer.CustomerId, contract456.SubscriptionType);

Concesso, un uso piuttosto hacker del tipo di inferenza di C # combinata con tipi anonimi, anche se non di nuovo, in realtà, come è quello che, ad esempio, alcuni serializzatori JSON già fanno, per comodità del chiamante, come per esempio:

di JSON.NET Deserializza un tipo anonimo

'Spero che questo aiuti.