Restrição de tipo genérico de método múltiplo (OR)

Ao ler isso , aprendi que era possível permitir que um método aceitasse parâmetros de vários tipos, tornando-o um método genérico. No exemplo, o código a seguir é usado com uma restrição de tipo para garantir que "U" seja um IEnumerable<T>.

public T DoSomething<U, T>(U arg) where U : IEnumerable<T>
{
    return arg.First();
}

Encontrei um pouco mais de código que permitia adicionar várias restrições de tipo, como:

public void test<T>(string a, T arg) where T: ParentClass, ChildClass 
{
    //do something
}

No entanto, esse código parece impor que argdeve ser um tipo de ParentClass e ChildClass . O que eu quero fazer é dizer que arg pode ser um tipo de ParentClass ou ChildClass da seguinte maneira:

public void test<T>(string a, T arg) where T: string OR Exception
{
//do something
}

Sua ajuda é apreciada como sempre!

Isso não é possível. No entanto, você pode definir sobrecargas para tipos específicos:

public void test(string a, string arg);
public void test(string a, Exception arg);

Se eles fazem parte de uma classe genérica, serão preferidos à versão genérica do método.

A resposta de Botz é 100% correta, aqui está uma breve explicação:

Ao escrever um método (genérico ou não) e declarar os tipos de parâmetros que o método utiliza, você define um contrato:

Se você me der um objeto que saiba fazer o que o Tipo T sabe fazer, posso fornecer 'a': um valor de retorno do tipo que declaro, ou 'b': algum tipo de comportamento que usa esse tipo.

Se você tentar atribuir mais de um tipo por vez (com um ou) ou tentar fazer com que retorne um valor que pode ser mais de um tipo que o contrato fica confuso:

Se você me der um objeto que saiba pular corda ou saiba calcular pi até o 15º dígito, retornarei um objeto que possa pescar ou talvez misturar concreto.

O problema é que, quando você entra no método, não tem idéia se eles lhe deram um IJumpRopeou um PiFactory. Além disso, quando você segue em frente e usa o método (supondo que você o tenha compilado magicamente), você não tem certeza se possui um Fisherou um AbstractConcreteMixer. Basicamente, torna tudo mais confuso.

A solução para o seu problema é uma das duas possibilidades:

1. Defina mais de um método que define cada possível transformação, comportamento ou qualquer outra coisa. Essa é a resposta de Botz. No mundo da programação, isso é conhecido como Sobrecarregando o método.

2. Defina uma classe base ou interface que saiba como fazer todas as coisas necessárias para o método e faça com que um método use exatamente esse tipo. Isso pode envolver agrupar uma classe stringe Exceptionuma classe pequena para definir como você planeja mapeá-las para a implementação, mas tudo é super claro e fácil de ler. Eu poderia vir daqui a quatro anos e ler seu código e entender facilmente o que está acontecendo.

Qual você escolhe depende de quão complicada a escolha 1 e 2 seria e quão extensível ela precisa ser.

Então, para a sua situação específica, vou imaginar que você está apenas recebendo uma mensagem ou algo da exceção:

public interface IHasMessage
{
    string GetMessage();
}

public void test(string a, IHasMessage arg)
{
    //Use message
}

Agora, tudo o que você precisa são métodos que transformam um stringe um Exceptionem um IHasMessage. Muito fácil.

Se ChildClass significa que é derivado de ParentClass, você pode apenas escrever o seguinte para aceitar ParentClass e ChildClass;

public void test<T>(string a, T arg) where T: ParentClass 
{
    //do something
}

Por outro lado, se você quiser usar dois tipos diferentes sem nenhuma relação de herança entre eles, considere os tipos que implementam a mesma interface;

public interface ICommonInterface
{
    string SomeCommonProperty { get; set; }
}

public class AA : ICommonInterface
{
    public string SomeCommonProperty
    {
        get;set;
    }
}

public class BB : ICommonInterface
{
    public string SomeCommonProperty
    {
        get;
        set;
    }
}

então você pode escrever sua função genérica como;

public void Test<T>(string a, T arg) where T : ICommonInterface
{
    //do something
}

Por mais antiga que seja essa pergunta, ainda recebo votos aleatórios na minha explicação acima. A explicação ainda está perfeitamente bem, mas vou responder uma segunda vez com um tipo que me serviu bem como substituto para tipos de união (a resposta fortemente tipada para a pergunta que não é diretamente suportada pelo C #, como é )

using System;
using System.Diagnostics;

namespace Union {
    [DebuggerDisplay("{currType}: {ToString()}")]
    public struct Either<TP, TA> {
        enum CurrType {
            Neither = 0,
            Primary,
            Alternate,
        }
        private readonly CurrType currType;
        private readonly TP primary;
        private readonly TA alternate;

        public bool IsNeither => currType == CurrType.Primary;
        public bool IsPrimary => currType == CurrType.Primary;
        public bool IsAlternate => currType == CurrType.Alternate;

        public static implicit operator Either<TP, TA>(TP val) => new Either<TP, TA>(val);

        public static implicit operator Either<TP, TA>(TA val) => new Either<TP, TA>(val);

        public static implicit operator TP(Either<TP, TA> @this) => @this.Primary;

        public static implicit operator TA(Either<TP, TA> @this) => @this.Alternate;

        public override string ToString() {
            string description = IsNeither ? "" :
                $": {(IsPrimary ? typeof(TP).Name : typeof(TA).Name)}";
            return $"{currType.ToString("")}{description}";
        }

        public Either(TP val) {
            currType = CurrType.Primary;
            primary = val;
            alternate = default(TA);
        }

        public Either(TA val) {
            currType = CurrType.Alternate;
            alternate = val;
            primary = default(TP);
        }

        public TP Primary {
            get {
                Validate(CurrType.Primary);
                return primary;
            }
        }

        public TA Alternate {
            get {
                Validate(CurrType.Alternate);
                return alternate;
            }
        }

        private void Validate(CurrType desiredType) {
            if (desiredType != currType) {
                throw new InvalidOperationException($"Attempting to get {desiredType} when {currType} is set");
            }
        }
    }
}

A classe acima representa um tipo que pode ser quer TP ou TA. Você pode usá-lo como tal (os tipos se referem à minha resposta original):

// ...
public static Either<FishingBot, ConcreteMixer> DemoFunc(Either<JumpRope, PiCalculator> arg) {
  if (arg.IsPrimary) {
    return new FishingBot(arg.Primary);
  }
  return new ConcreteMixer(arg.Secondary);
}

// elsewhere:

var fishBotOrConcreteMixer = DemoFunc(new JumpRope());
var fishBotOrConcreteMixer = DemoFunc(new PiCalculator());

Anotações importantes:

• Você receberá erros de tempo de execução se não verificar IsPrimaryprimeiro.
• Você pode verificar qualquer um IsNeither IsPrimaryou IsAlternate.
• Você pode acessar o valor por meio de PrimaryeAlternate
• Existem conversores implícitos entre TP / TA e E para permitir a passagem dos valores ou para Eitherqualquer lugar em que seja esperado. Se você fazer passar um Eitheronde um TAou TPé esperado, mas o Eithercontém o tipo errado de valor que você vai receber um erro de execução.

Normalmente, uso isso onde quero que um método retorne um resultado ou um erro. Realmente limpa esse código de estilo. Eu também muito ocasionalmente ( raramente ) uso isso como um substituto para sobrecargas de método. Realisticamente, esse é um substituto muito ruim para essa sobrecarga.