Las colecciones son un concepto importante en POO, y el soporte completo para colecciones en C# es uno de los mejores del lenguaje.
¿Por qué usar sets genéricos?
Antes de C# 2.0, las colecciones podían implementarse de dos maneras principales:
a. Usar ArrayList
Poner objetos directamente en la ArrayList es intuitivo, pero como los elementos de la colección son de tipo Objecto, tienes que hacer una conversión de tipos tediosa cada vez que la usas.
b. Utilizar clases personalizadas de colección
Una práctica común es heredar una clase personalizada de la clase abstracta CollectionBase e implementar una colección de tipos fuerte encapsulando el objeto IList. Este método requiere escribir una clase personalizada correspondiente para cada tipo de colección, lo cual es mucho trabajo. La aparición de colecciones genéricas resuelve bien los problemas anteriores, y solo se puede usar una línea de código para crear un conjunto de un tipo especificado. ¿Qué es genérico?
Los genéricos son elementos nuevos en C# 2.0 (llamados plantillas en C++) que se utilizan principalmente para resolver una serie de problemas similares. Este mecanismo permite que el nombre de la clase se pase como argumento al tipo genérico y se genere el objeto correspondiente. Puede ser mejor pensar en los genéricos (incluyendo clases, interfaces, métodos, delegados, etc.) como plantillas, donde la parte variante se reemplaza por el nombre de clase que se pasa como argumento, resultando en una nueva definición de tipo. El genérico es un tema relativamente amplio, y no lo analizaré en detalle aquí, y quienes estén interesados pueden consultar la información relevante. ¿Cómo puedo crear una colección genérica?
La clase genérica List bajo el espacio de nombres System.Collections.Generic <T>se utiliza para crear colecciones, y la sintaxis es la siguiente: [mw_shl_code=csharp,true] <T> Lista ListaOfT = nueva lista<T>(); [/mw_shl_code] La "T" es el tipo que se va a usar, que puede ser de tipos simples, como cadena, int o tipos definidos por el usuario. Veamos un ejemplo concreto.
La clase Persona se define de la siguiente manera: [mw_shl_code=csharp,true] clase Persona
{
_name de cadena privada; Nombre
Private Int _age; Edad
Crear un objeto Persona
Persona pública (nombre de cadena, int edad)
{
this._name= Nombre;
this._age = Edad;
}
Nombre
Nombre de la cuerda pública
{
get { return _name; }
}
Edad
public int Age
{
get { return _age; }
}
}
//创建Person对象
Persona p1 = nueva persona ("Zhang San", 30);
Persona p2 = nueva persona ("Li Si", 20);
Persona p3 = nueva persona("Wang Wu", 50);
//创建类型为Person的对象集合
Personas de la<Person> lista = nueva Lista<Person>();
//将Person对象放入集合
personas. Añadir (p1);
personas. Add(p2);
personas. Add(p3);
//输出第2个人的姓名
Console.Write(personas[1]. Nombre); [/mw_shl_code] Como puedes ver, las colecciones genéricas simplifican enormemente el código de implementación de las colecciones, a través del cual puedes crear fácilmente colecciones de tipos específicos. No solo eso, sino que las colecciones genéricas también ofrecen funciones más potentes, echemos un vistazo a la ordenación y búsqueda en ellas. Ordenamiento de colecciones genéricas
La clasificación se basa en la comparación, y para ordenar, primero debes comparar. Por ejemplo, si hay dos números 1 y 2, para ordenarlos, primero debemos comparar estos dos números y ordenarlos según los resultados de la comparación. Si quieres comparar objetos, la situación es un poco más complicada, por ejemplo, si comparas objetos Persona, puedes comparar por nombre o edad, lo que requiere determinar las reglas de comparación. Un objeto puede tener múltiples reglas de comparación, pero solo una regla por defecto, que se coloca en la clase que define el objeto. Las reglas de comparación por defecto se definen en el método CompareTo, que pertenece a la <T>interfaz genérica IComparable. Consulta el código a continuación: [mw_shl_code=csharp,true]clase Persona :IComable<Person>
{
Comparar por edad
public int CompareTo(Persona p)
{
Devuélvelo esto. Edad - p.Edad;
}
}[/mw_shl_code] Los parámetros del método CompareTo son otro objeto del mismo tipo con el que compararse, el valor de retorno es tipo int; si el valor de retorno es mayor que 0, significa que el primer objeto es mayor que el segundo; si el valor de retorno es menor que 0, significa que el primer objeto es menor que el segundo, y si devuelve 0, los dos objetos son iguales.
Tras definir las reglas de comparación por defecto, puedes ordenar la colección usando el método Sort sin parámetros, de la siguiente manera: [mw_shl_code=csharp,true]// Ordenar la colección según las reglas predeterminadas
personas. Sort();
//输出所有人姓名
foreach (Persona p en personas)
{
Consola.WriteLine(p.Name); El orden de salida es "Li Si", "Zhang San" y "Wang Wu"
}[/mw_shl_code] En la práctica, a menudo es necesario ordenar la colección según una variedad de reglas diferentes, lo que requiere la definición de otras reglas de comparación, que pueden definirse en el método Comparación, que pertenece a la <T>interfaz genérica de IComparer; consulte el siguiente código: [mw_shl_code=csharp,true]clase NombreComparador : IComparer<Person>
{
Instancias de secuenciador de almacenamiento
NameComparer Default estático público = nuevo NameComparer();
Comparar por nombre
int público Comparar (Persona p1, Persona p2)
{
return System.Collections.Comparer.Default.Compare(p1. Nombre, p2. Nombre);
}
}[/mw_shl_code] Los parámetros del método Compare son dos objetos del mismo tipo que deben compararse, y el valor de retorno es de tipo int, y las reglas de procesamiento de valores de retorno son las mismas que las del método CompareTo. Comparer.Default devuelve un objeto Comparer incorporado para comparar dos objetos del mismo tipo. Así es como ordenar la colección con este comparador recién definido: [mw_shl_code=csharp,true]//Ordenar la colección por nombre
personas. Ordenar(NombreComparer.Default);
//输出所有人姓名
foreach (Persona p en personas)
{
Consola.WriteLine(p.Name); El orden de salida es "Li Si", "Wang Wu" y "Zhang San"
}[/mw_shl_code] También puedes ordenar la colección delegando, primero, definir un método que el delegado llame para almacenar las reglas de comparación, y puedes usar un método estático. Consulta el código a continuación: [mw_shl_code=csharp,true]clase Comparación de personas
{
Comparar por nombre
estática pública int Nombre(Persona p1, Persona p2)
{
return System.Collections.Comparer.Default.Compare(p1. Nombre, p2. Nombre);
}
}[/mw_shl_code] Los parámetros del método son dos objetos del mismo tipo que se comparan, el valor de retorno es de tipo int, y la regla de procesamiento de valores de retorno es la misma que la del método CompareTo.Luego ordena la colección mediante el sistema genérico de delegados incorporado. <T>Comparación: [mw_shl_code=csharp,true] <Person> NombreComparaciónComparaciónSistemaComparación = nuevo <Person>Sistema.Comparación(PersonComparison.Name);
personas. Orden(ComparaciónNombre);
//输出所有人姓名
foreach (Persona p en personas)
{
Consola.WriteLine(p.Name); El orden de salida es "Li Si", "Wang Wu" y "Zhang San"
}[/mw_shl_code] Se puede ver que estos dos últimos métodos pueden ordenar la colección según las reglas especificadas, pero el autor prefiere usar el método de delegación y puede considerar poner varias reglas de comparación en una clase y luego llamarlas de forma flexible. Buscar colecciones genéricas
La búsqueda consiste en encontrar elementos que cumplan condiciones específicas de la colección, y se pueden definir y llamar múltiples condiciones de búsqueda según sea necesario. Primero, definan los criterios de búsqueda de la siguiente manera: [mw_shl_code=csharp,true]clase Predicado de Persona
{
Encuentra personas de mediana edad (mayores de 40)
bool estático público Mediana Edad (Persona p)
{
si (p.Edad >= 40)
regreso fiel;
si no,
return false;
}
}[/mw_shl_code] Los criterios de búsqueda anteriores se colocan en un método estático con un tipo de retorno booleano, y los elementos de la colección que cumplen ciertas condiciones devuelven verdadero o falso.Luego busca en la colección a través del sistema de delegados genéricos incorporado. Predicado<T>: [mw_shl_code=csharp,true] Sistema.Predicado<Person> MediaEdad = nuevo <Person>Sistema.Predicado(PersonaPredicado.MediaEdad);
Lista<Person>: Personas de mediana edad = personas. FindAll(MediaEdadPredicado);
//输出所有的中年人姓名
foreach (Persona p en MidAgePersons)
{
Consola.WriteLine(p.Name); Salida "Wang Wu"
}[/mw_shl_code] Extensión de colecciones genéricas
¿Y si quieres obtener los nombres de todas las personas del set, separados por una coma?
Teniendo en cuenta que la funcionalidad que puede proporcionar una sola clase es limitada, es natural pensar <T>en extender la clase List, que también es una clase y por tanto puede extenderse por herencia. Consulta el código a continuación: [mw_shl_code=csharp,true]// Definir la clase de colección Persons
Personas de la clase: Lista<Person>
{
Consigue los nombres de todos los miembros de la colección
cadena pública GetAllNames()
{
si (esto. Cuenta == 0)
return "";
string val = "";
foreach (Persona p en esto)
{
val += p.Name + ",";
}
Devuelve Val. Substring(0, val. Longitud - 1);
}
}
//创建并填充Persons集合
Personas PersonaCol = nuevas personas();
PersonaCol.Add(p1);
PersonaCol.Add(p2);
PersonaCol.Add(p3);
//输出所有人姓名
Consola.Escribe(PersonaCol.NombresDeTodos()); Salida "Zhang San, Li Si, Wang Wu"[/mw_shl_code] Resumen:
Este artículo se centra en el uso de genéricos en C# 2.0 para implementar colecciones, así como para ampliar la función de colección, y el uso adecuado de colecciones genéricas puede reducir mucha duplicación de trabajo y mejorar considerablemente la eficiencia del desarrollo. De hecho, los sets son solo una aplicación típica de los genéricos, y si quieres saber más sobre genéricos, puedes consultar otros materiales relevantes. Espero que este artículo te haya sido útil :-)
| 
Publicado en 11/11/2014 8:56:04
|
|
|
Publicado en 24/11/2014 11:48:29
