Cómo implementar valores clave repetibles en C#
Múltiples listas ordenadasltOrdenar por palabra clave
///Lista Ordenada que se ordena primero por clave y luego por valor. Tanto las claves como los valores se pueden repetir, pero los pares clave-valor. no se permite que sean idénticos.
///lt;/summary gt;
Lista de categorías múltiples de clase pública ltTKey, TValue gt: SortedList ltTKey, TValue gt donde TKey: IComparable
{
/// lt; Resumen gt
///La clave Igual también devuelve una desigualdad.
///lt;/summary gt;
Clase privada MyComparer ltTCKey gt: IComparer ltTCKey gtwhere TCKey: IComparable
{
Comparación int pública (TCKey x, TCKey y)
{
int I = x comparar con (y);
//(-1) x. antes de y//? (1) x viene después de y.
if (I == 0) {retorno (-1); más {retorno I}
}
}
lista ordenada múltiple pública(): base(nuevo mi comparador lt; TKey gt()) { }
Nuevo vacío público Agregar (clave TKey, valor de TValue)
{ ?
foreach (par clave-valor ltTKey, elemento TValue gt en este libro)
{//Compruebe si la clave está disponible y si el valor se repite.
if (item.Equals(key) y amp item.value.Equals(value)){ return;}
}
base. Agregar(clave, valor);
}
Eliminación pública de nuevo vacío (clave TKey)
{
for(int I = 0; lt esto. cuenta; i )
{
if (clave [I]. es igual a (clave)) { base. eliminar en㈠;}
}
}
Eliminar vacío público (valor t)
{
for(int I = 0; i lt this. count; i )
{
if (valor [I]. es igual a (valor)) { base. eliminar en㈠;}
}
}
Eliminación de anulación pública (clave TKey, valor TValue)
{
for(int I = 0; i lt this. count; i )
{
if (clave [I]. es igual a (clave) valores de amplificador [I] . es igual(valor)) { base. eliminar en㈠;}
}
}
Nuevo valor público esta [tecla t]
{
get { return base【key】;}
}
/// lt; Resumen gt
///Devuelve la lista de valores correspondientes a la clave.
///lt;/summary gt;
/// lt;param name="key" gt;lt/param gt;
// / lt; nombre del parámetro = "Orden ascendente" > lt / param gt;
/// Devuelve gt devuelve IList (de valor).
¿IListltTValue público gtThis [tecla TKey, orden ascendente bool]?
{
Obtener{
Var resultado = nueva lista
for(int I = 0; i lt count; i )
{
si (clave [I]. es igual a (clave))
{resultado. add(Values[I]);}
}
Devolver resultados;
}
}
}
Si no está ordenado, en realidad está empaquetado con tuplas, que utilizan el Elemento1 y el Elemento 2 //
/// Un diccionario, claves y valores ordenados en el orden predeterminado Duplicación está permitido, pero se prohíben pares clave-valor idénticos.
/// lt;para》gt;Heredado de
/// lt;/summary gt;
Lista de tuplas de clases públicas ltTKey, TValue gt : List lt tuple ltTKey, TValue gt gt{
Public void Add (clave TKey, valor de t) {
foreach (elemento var en esto){//Compruebe si existe esto clave y comprobar si el valor está duplicado?
if (item. item1. Equals(key) amp amp item. item2. Equals(value)) { return;}
}
base . add(new tuple ltTKey, TValue gt(key, value));
}
public void eliminar(tecla TKey) {
foreach(este elemento var ) {
if (elemento. elemento1. es igual(clave)) { Eliminar(elemento);}
}
}
/// lt; resumen gt
///Devuelve una lista de múltiples valores correspondientes a la clave / //lt;/summary gt; ///lt;param name="key" gt;lt/param gt; ///lt;Param name="Ascendente "》lt/param gt; /// lt;Devuelve gtreturns IList(De valor). public IListltTValue gtthis [tecla TKey, bool orden ascendente = false] { Obtener { Var resultado = nueva lista foreach (elemento var en esto) {//Compruebe si existe esta clave y compruebe si el valor se repite. if(item.item1.equals(key)){result.add(item.item2);} } Devuelve resultado; } } }