Método genérico múltiple (OR) tipo restricción

Question

Leyendo this, me enteré de que era posible permitir que un método aceptara parámetros de varios tipos haciéndolo un método genérico. En el ejemplo, el siguiente código se usa con una restricción de tipo para asegurar que "U" sea IEnumerable<T>.

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

he encontrado algunas más código que permitió la adición de múltiples restricciones de tipo, tales como:

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

Sin embargo, este código aparece para hacer cumplir esa arg debe ser a la vez un tipo de ParentClassyChildClass. Lo que quiero hacer es decir que arg podría ser un tipo de ParentClassoChildClass de la siguiente manera:

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

Su ayuda se agradece como siempre!

Answer 1

Eso no es posible. Puede, sin embargo, definir las sobrecargas para tipos específicos:

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

Si esas son parte de una clase genérica, serán preferibles a la versión genérica del método.

Answer 2

Si ChildClass significa que se deriva de ParentClass, puede escribir lo siguiente para aceptar tanto ParentClass y ChildClass;

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

En el otherhand, si desea utilizar dos tipos diferentes, sin relación de herencia entre ellos, se debe considerar el tipo de aplicación de la misma interfaz;

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; 
    } 
} 

Luego puede escribir su función genérica como;

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

Answer 3

Botz respuesta es 100% correcto, he aquí una breve explicación:

Cuando está escribiendo un método (genérico o no) y la declaración de los tipos de los parámetros que el método toma que está definiendo un contrato :

Si me das un objeto que sabe hacer el conjunto de cosas que tipo T sabe cómo hacer que puedo ofrecer ya sea 'a': un valor de retorno del tipo declaro, o " b ': algún tipo de comportamiento que usa ese tipo.

Si tratas de darle más de un tipo a la vez (por tener una o) o tratar de conseguir que se devuelve un valor que podría ser más de un tipo que se contraen pone borrosa:

Si me das un objeto que sepa saltar la cuerda o sepa cómo calcular pi hasta el 15º dígito, devolveré un objeto que pueda ir a pescar o quizás mezcle de hormigón.

El problema es que cuando usted entra en el método no tiene idea de si le han dado un IJumpRope o una PiFactory. Además, cuando continúe y use el método (suponiendo que lo haya compilado mágicamente), no está seguro si tiene un Fisher o un AbstractConcreteMixer. Básicamente hace que todo sea más confuso.

La solución a su problema es una de dos posibilidades:

1. definir más de un método que define cada transformación es posible, comportamiento, o lo que sea. Esa es la respuesta de Botz. En el mundo de la programación esto se conoce como Sobrecarga del método.

2. definir una clase base o interfaz que sabe hacer todas las cosas que necesitas para el método y tener un método toma solo ese tipo. Esto puede implicar completar un string y Exception en una clase pequeña para definir cómo planea asignarlos a la implementación, pero luego todo es súper claro y fácil de leer. Podría venir, dentro de cuatro años, leer su código y entender fácilmente lo que está pasando.

Lo que elija depende de cuán complicadas serían las opciones 1 y 2 y cuán extensible debe ser.

Así que para su situación específica voy a imaginar que estás sacando un mensaje o algo de la excepción:

public interface IHasMessage 
{ 
    string GetMessage(); 
} 

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

Ahora todo lo que necesita son métodos que transforman un string y un Exception a un IHasMessage. Muy fácil.