¿Cómo pasar el tipo Type como parámetro t de t genérico en C#?

Método booleano ltT gt (parámetro bool) donde T: clase

{parámetro de retorno;}

Este es un método genérico completo, el calificador T: la clase indica la restricción de tipo de T genérica. Busque la entrada "Restricciones de tipo genérico" en MSDN/library/bb384067.aspx.

El uso de métodos genéricos se usa generalmente para métodos que involucran genéricos (t):

Hay al menos un tipo en los parámetros genéricos, como método

Retorno valor Implica genéricos, como lista

Los métodos deben funcionar en función de tipos genéricos de parámetros, por ejemplo, el contenido del método es return T es IComparable

Los parámetros implican tipos inciertos, como métodos

Si solo necesita pasar el tipo t y no necesita devolver el valor que involucra t, puede usar el Método (Tipo t) en su lugar.

Cabe señalar que la importancia de los métodos genéricos es reducir una gran cantidad de código redundante y no pueden eliminar ni manejar automáticamente la lógica if/else como dice el cartel en 1 (pero le permite escribir solo uno). if/else en lugar de docenas o cientos de veces).

No estoy seguro de lo que quieres preguntar. Si es solo un uso simple, daré un ejemplo que escribí ahora, que involucra los cuatro escenarios de uso anteriores. Aunque parece un poco complicado, no es un problema utilizar métodos genéricos con habilidad después de comprenderlos por completo.

Nuestro objetivo es escribir un método que reciba dos parámetros de tipo indefinido, pero herede de IEnumerable (interfaz enumerable) y genere una lista que tenga el tamaño de cada elemento de los dos parámetros A. colección de elementos más grandes. Por ejemplo, las entradas {1, 3, 4, 5} y {2, 2} deberían ser la salida {2, 3, 4, 5}.

Ahora analicémoslo. Primero, este método necesita indicar los tipos de los dos parámetros, que se definen como tipos genéricos T1 y T2 respectivamente. La calificación aquí es IEnumerable, para que podamos enumerar los elementos de estos dos parámetros a voluntad.

Debido a que es necesario comparar el tamaño de los elementos y el tipo de los elementos es incierto, se necesita un tipo general para especificar el tipo de los elementos en los dos parámetros. Se utiliza el tipo general TElement. aquí. Debido a que es necesario comparar el tamaño, aquí se agrega el calificador IComparable para evitar que la persona que llama pase un tipo de elemento que no se puede comparar en absoluto.

Junto con el resultado esperado, las características de este método son:

List ltRemoteMonitoringgtElementsMax ltTParam1, TParam2, TElement gt(TParam1 p1, TParam2 p2)

Donde tparam 1: IEnumerable lt; monitoreo remoto gt

Donde tparam 2: IEnumerable lt; monitoreo remoto gt

donde TElement: I comparable lt; Escribiré el método directamente aquí, no es necesario leerlo detenidamente. La idea básica es comparar los elementos de las dos secuencias de parámetros uno por uno y completar la nueva secuencia. Lo único que hay que tener en cuenta es que las longitudes de las dos secuencias de parámetros no son necesariamente iguales.

Método probado completo:

List ltremotemonitoringgtElementsMax ltTParam1, TParam2, TElement gt(TParam1 p1, TParam2 p2)

donde tparam 1: IEnumerable lt;monitoreo remoto gt

donde tparam 2: IEnumerable lt;monitoreo remotogt

donde TElemento: I comparable lt;monitoreo remotogt

{

Listado lt remoto monitoreo gtrtn = nueva lista lt monitoreo remoto gt();

int p1Length = p1count()

int p2Length = p2. contar();

for(int index = 0; index lt math.max(p1. Count(), p2. count()); index )

{

//Si p1 y p2 tienen elementos en la posición del índice, la relación es mayor que el tamaño.

// Si una secuencia está vacía, se considera que el elemento en la posición de índice de la secuencia no vacía es más grande.

TElemento compRslt = default(remoto);

if(index lt;p 1 longitud y longitud. ampindex ltp2Longitud)

compRslt = p1. ElementoEn(índice). CompareTo(p2.element at(index)) gt;= 0 ?p1. ElementoAt(índice): p2. ElementAt(index);

else if(index lt; p 1 longitud y longitud. ampindex gt = p2Length)

compRslt = p1. ElementAt(index);

else if(index gt; = p 1 longitud amp ampindex ltp2Length)

compRslt = p2. ElementAt(index);

//Si el valor de compRslt no es el valor predeterminado que construimos al principio, significa que hay un resultado y se almacena.

if (compRslt.CompareTo(default(remote))!=0)

rtn. add(compRslt);

}

// Por cierto, ICollection tiene un método Zip en Linq, que puede fusionar condicionalmente dos secuencias.

Regresar rtn

}

Luego intentamos llamar, podemos ver intuitivamente los beneficios de usar métodos genéricos.

cadena salidaStr

//int prueba

int[] matriz = new int[] { 2, 1, 1, 6 };

Lista ltint gtlst = nueva lista ltint gt{3, 1, 5, 5, 9};

Lista ltint gtresult = ElementsMax ltint[], Lista ltint gt, int gt(array, lst) ;

outputStr =

for(int index = 0; index lt resultado.

count();outputStr = resultado[índice]. ToString() ",";

MessageBox. show(output str);

//Prueba de caracteres

string s 1 = "Hola mundo";

Cola ltchar gts2 = nueva cola ltchar gt(< Feliz año nuevo");

Lista ltchar gt resultado = ElementsMax lt cadena, cola ltchar gt, char gt(s1, S2);

outputStr =

for(int index = 0; index lt resultado 2. count(); outputStr = result2[index]. ToString() ",";

MessageBox. show(output str);

//También se puede utilizar de forma iterativa

int[] a1 = new int[] { 1, 3, 5, 7, 9 }

int[] a2 = nuevo int[] { 2, 4, 6, 8 };

int[] a3=nuevo int[]{8, 8, 8, 8 }; ltint gt resultado = ElementsMax lt lista ltint gt, int[], int gt(ElementsMax ltint[], int[], int gt(a1, a2), a3

outputStr =

for(int index = 0; index lt resultado 3. count(); outputStr = result3[index]. ToString() ",";

MessageBox. show(output str);

Los tres conjuntos reales de salida son:

3, 1, 5, 6, 9,

h, e, p, p, y,, w, o, w, l, y, e, a, r,

8, 8, 8, 8, 9,

Cumple nuestras expectativas.

Sólo eso es todo. Si tienes alguna pregunta, envíame un mensaje privado.