Meu uso do operador de transmissão explícita é razoável ou um hack ruim?

Eu tenho um grande objeto:

class BigObject{
    public int Id {get;set;}
    public string FieldA {get;set;}
    // ...
    public string FieldZ {get;set;}
}

e um objeto especializado, semelhante ao DTO:

class SmallObject{
    public int Id {get;set;}
    public EnumType Type {get;set;}
    public string FieldC {get;set;}
    public string FieldN {get;set;}
}

Pessoalmente, acho um conceito de conversão explícita do BigObject no SmallObject - sabendo que é uma operação unidirecional e com perda de dados - muito intuitiva e legível:

var small = (SmallObject) bigOne;
passSmallObjectToSomeone(small);

É implementado usando o operador explícito:

public static explicit operator SmallObject(BigObject big){
    return new SmallObject{
        Id = big.Id,
        FieldC = big.FieldC,
        FieldN = big.FieldN,
        EnumType = MyEnum.BigObjectSpecific
    };
}

Agora, eu poderia criar uma SmallObjectFactoryclasse com o FromBigObject(BigObject big)método, que faria a mesma coisa, adicioná-la à injeção de dependência e chamá-la quando necessário ... mas para mim parece ainda mais complicado e desnecessário.

PS Não tenho certeza se isso é relevante, mas haverá OtherBigObjectque também poderá ser convertido em SmallObjectconfigurações diferentes EnumType.

Nenhuma das outras respostas está certa na minha humilde opinião. Nesta pergunta de stackoverflow, a resposta mais votada argumenta que o código de mapeamento deve ser mantido fora do domínio. Para responder sua pergunta, não - o uso do operador de elenco não é ótimo. Aconselho a criação de um serviço de mapeamento entre o DTO e o objeto do domínio, ou você pode usar o automapper para isso.

Isso não é ótimo. Eu trabalhei com código que fez esse truque inteligente e que levou à confusão. Afinal, você seria de esperar para ser capaz de simplesmente atribuir o BigObjectem uma SmallObjectvariável, se os objetos são suficientes relacionado para lançá-los. Porém, não funciona - você obtém erros do compilador se tentar, pois, no que diz respeito ao sistema de tipos, eles não são relacionados. Também é um pouco desagradável para o operador de fundição criar novos objetos.

Eu recomendaria um .ToSmallObject()método. É mais claro sobre o que realmente está acontecendo e sobre como detalhado.

Embora eu possa entender por que você precisaria de um SmallObject, eu abordaria o problema de maneira diferente. Minha abordagem para esse tipo de problema é usar uma fachada . Seu único objetivo é encapsular BigObjecte disponibilizar apenas membros específicos. Dessa maneira, é uma nova interface na mesma instância, e não uma cópia. Claro que você também pode querer fazer uma cópia, mas eu recomendaria que você o fizesse através de um método criado para esse fim em combinação com a Fachada (por exemplo return new SmallObject(instance.Clone())).

O Facade tem uma série de outras vantagens, a saber: garantir que determinadas seções do seu programa só possam fazer uso dos membros disponibilizados através da sua fachada, garantindo efetivamente que ele não possa fazer uso do que não deveria saber. Além disso, ele também tem a enorme vantagem de ter mais flexibilidade nas alterações de BigObjectmanutenção futura sem precisar se preocupar muito com a forma como ela é usada em todo o programa. Contanto que você possa emular o antigo comportamento de uma forma ou de outra, poderá fazer o SmallObjecttrabalho da mesma maneira que antes, sem precisar alterar seu programa em todos BigObjectos lugares que seriam usados.

Note, isso significa BigObjectque não depende, SmallObjectmas o contrário (como deveria ser na minha humilde opinião).

Há uma convenção muito forte que se baseia em tipos de referência mutáveis ​​que preservam a identidade. Como o sistema geralmente não permite operadores de conversão definidos pelo usuário em situações em que um objeto do tipo de origem pode ser atribuído a uma referência do tipo de destino, existem apenas alguns casos em que as operações de conversão definidas pelo usuário seriam razoáveis ​​para referência mutável tipos.

Eu sugeriria como requisito que, dado x=(SomeType)foo;seguido algum tempo depois y=(SomeType)foo;, com ambos os elencos aplicados ao mesmo objeto, x.Equals(y)fosse sempre e para sempre verdadeiro, mesmo que o objeto em questão fosse modificado entre os dois elencos. Essa situação poderia ser aplicada se, por exemplo, um tivesse um par de objetos de tipos diferentes, cada um com uma referência imutável ao outro, e converter um objeto para o outro tipo retornaria sua instância emparelhada. Também poderia se aplicar a tipos que servem como invólucros para objetos mutáveis, desde que as identidades dos objetos que estão sendo quebrados sejam imutáveis, e dois invólucros do mesmo tipo se reportariam iguais se envoltassem a mesma coleção.

Seu exemplo específico usa classes mutáveis, mas não preserva nenhuma forma de identidade; como tal, eu sugeriria que não é um uso apropriado de um operador de fundição.

Pode estar tudo bem.

Um problema com o seu exemplo é que você usa esses nomes de exemplo. Considerar:

SomeMethod(long longNum)
{
  int num = (int)longNum;
  /* ... */

Agora, quando você tem uma boa idéia do significado de long e int , tanto o elenco implícito de intpara longquanto o elenco explícito de longpara intsão bastante compreensíveis. Também é compreensível como 3se torna 3e é apenas outra maneira de trabalhar 3. É compreensível como isso falhará int.MaxValue + 1em um contexto verificado. Mesmo como ele funcionará int.MaxValue + 1em um contexto desmarcado para resultar int.MinValuenão é a coisa mais difícil de entender.

Da mesma forma, quando você lança implicitamente para um tipo de base ou explicitamente para um tipo derivado, é compreensível para quem sabe como a herança funciona o que está acontecendo e qual será o resultado (ou como poderá falhar).

Agora, com BigObject e SmallObject , não tenho noção de como esse relacionamento funciona. Se o seu tipo real é tal que a relação de elenco é óbvia, o elenco pode realmente ser uma boa idéia, embora muitas vezes, talvez a grande maioria, se esse for o caso, isso deve refletir-se na hierarquia de classes e na classe. fundição normal baseada em herança será suficiente.