c# - situacion - planificacion de preescolar sobre los numeros

¿Hay un método incorporado para comparar colecciones en C#?

Question

Me gustaría comparar los contenidos de un par de colecciones en mi método Equals. Tengo un diccionario y un IList. ¿Hay un método incorporado para hacer esto?

Editado: quiero comparar dos diccionarios y dos ILists, así que creo que lo que significa igualdad es claro: si los dos diccionarios contienen las mismas claves asignadas a los mismos valores, entonces son iguales.

Answer 1

¿Qué tal este ejemplo?

 static void Main()
{
    // Create a dictionary and add several elements to it.
    var dict = new Dictionary<string, int>();
    dict.Add("cat", 2);
    dict.Add("dog", 3);
    dict.Add("x", 4);

    // Create another dictionary.
    var dict2 = new Dictionary<string, int>();
    dict2.Add("cat", 2);
    dict2.Add("dog", 3);
    dict2.Add("x", 4);

    // Test for equality.
    bool equal = false;
    if (dict.Count == dict2.Count) // Require equal count.
    {
        equal = true;
        foreach (var pair in dict)
        {
            int value;
            if (dict2.TryGetValue(pair.Key, out value))
            {
                // Require value be equal.
                if (value != pair.Value)
                {
                    equal = false;
                    break;
                }
            }
            else
            {
                // Require key be present.
                equal = false;
                break;
            }
        }
    }
    Console.WriteLine(equal);
}

Cortesía: https://www.dotnetperls.com/dictionary-equals

Answer 2

.NET carece de herramientas potentes para comparar colecciones. Desarrollé una solución simple que puedes encontrar en el siguiente enlace:

http://robertbouillon.com/2010/04/29/comparing-collections-in-net/

Esto realizará una comparación de igualdad independientemente del orden:

var list1 = new[] { "Bill", "Bob", "Sally" };
var list2 = new[] { "Bob", "Bill", "Sally" };
bool isequal = list1.Compare(list2).IsSame;

Esto verificará si los elementos se agregaron / eliminaron:

var list1 = new[] { "Billy", "Bob" };
var list2 = new[] { "Bob", "Sally" };
var diff = list1.Compare(list2);
var onlyinlist1 = diff.Removed; //Billy
var onlyinlist2 = diff.Added;   //Sally
var inbothlists = diff.Equal;   //Bob

Esto verá qué elementos del diccionario cambiaron:

var original = new Dictionary<int, string>() { { 1, "a" }, { 2, "b" } };
var changed = new Dictionary<int, string>() { { 1, "aaa" }, { 2, "b" } };
var diff = original.Compare(changed, (x, y) => x.Value == y.Value, (x, y) => x.Value == y.Value);
foreach (var item in diff.Different)
  Console.Write("{0} changed to {1}", item.Key.Value, item.Value.Value);
//Will output: a changed to aaa

Answer 3

Además del mencionado Enumerable.SequenceEqual , que

es verdadero si dos listas son de la misma longitud y sus elementos correspondientes se comparan iguales según un comparador

(que puede ser el comparador por defecto, es decir, un Equals()

vale la pena mencionar que en .Net4 hay SetEquals en objetos SetEquals , que

ignora el orden de los elementos y cualquier elemento duplicado.

Entonces, si desea tener una lista de objetos, pero no es necesario que estén en un orden específico, considere que un ISet (como un HashSet ) puede ser la opción correcta.

Answer 4

Como otros han sugerido y anotado, SequenceEqual es sensible al orden. Para resolver eso, puede ordenar el diccionario por clave (que es único, y por lo tanto, el género es siempre estable) y luego usar SequenceEqual . La siguiente expresión verifica si dos diccionarios son iguales independientemente de su orden interno:

dictionary1.OrderBy(kvp => kvp.Key).SequenceEqual(dictionary2.OrderBy(kvp => kvp.Key))

EDITAR: Como señaló Jeppe Stig Nielsen, algunos objetos tienen un IComparer<T> que es incompatible con su IEqualityComparer<T> , y arroja resultados incorrectos. Al usar claves con dicho objeto, debe especificar un IComparer<T> correcto para esas claves. Por ejemplo, con las teclas de cadena (que muestran este problema), debe hacer lo siguiente para obtener resultados correctos:

dictionary1.OrderBy(kvp => kvp.Key, StringComparer.Ordinal).SequenceEqual(dictionary2.OrderBy(kvp => kvp.Key, StringComparer.Ordinal))

Answer 5

Eche un vistazo al método Enumerable.SequenceEqual

var dictionary = new Dictionary<int, string>() {{1, "a"}, {2, "b"}};
var intList = new List<int> {1, 2};
var stringList = new List<string> {"a", "b"};
var test1 = dictionary.Keys.SequenceEqual(intList);
var test2 = dictionary.Values.SequenceEqual(stringList);

Answer 6

Esto no responde directamente a sus preguntas, pero tanto TestTools de MS como NUnit brindan

 CollectionAssert.AreEquivalent

que hace más o menos lo que quieres

Answer 7

No sabía acerca del método Enumerable.SequenceEqual (aprendes algo todos los días ...), pero sugerí usar un método de extensión; algo como esto:

    public static bool IsEqual(this List<int> InternalList, List<int> ExternalList)
    {
        if (InternalList.Count != ExternalList.Count)
        {
            return false;
        }
        else
        {
            for (int i = 0; i < InternalList.Count; i++)
            {
                if (InternalList[i] != ExternalList[i])
                    return false;
            }
        }

        return true;

    }

Curiosamente, después de tomar 2 segundos para leer acerca de SequenceEqual, parece que Microsoft ha construido la función que describí para usted.

Answer 8

No, porque el marco no sabe cómo comparar los contenidos de sus listas.

Echa un vistazo a esto:

http://blogs.msdn.com/abhinaba/archive/2005/10/11/479537.aspx

Answer 9

No. El marco de recopilación no tiene ningún concepto de igualdad. Si lo piensas, no hay forma de comparar colecciones que no sean subjetivas. Por ejemplo, comparando su IList con su Diccionario, ¿serían iguales si todas las claves estuvieran en IList, todos los valores estuvieran en IList o si ambos estuvieran en IList? No hay una manera obvia de comparar estas dos colecciones sin el conocimiento de para qué se van a usar, por lo que un método de igual propósito general no tiene sentido.

Answer 10

Para comparar colecciones también puede usar LINQ. Enumerable.Intersect devuelve todos los pares que son iguales. Puede comparar dos diccionarios como este:

(dict1.Count == dict2.Count) && dict1.Intersect(dict2).Count() == dict1.Count

La primera comparación es necesaria porque dict2 puede contener todas las claves de dict1 y más.

También puede usar variaciones utilizando Enumerable.Except y Enumerable.Union que conducen a resultados similares. Pero se puede usar para determinar las diferencias exactas entre los conjuntos.

Answer 11

Enumerable.SequenceEqual

Determina si dos secuencias son iguales comparando sus elementos utilizando un IEqualityComparer (T) especificado.

No puede comparar directamente la lista y el diccionario, pero podría comparar la lista de valores del diccionario con la lista

Answer 12

public bool CompareStringLists(List<string> list1, List<string> list2)
{
    if (list1.Count != list2.Count) return false;

    foreach(string item in list1)
    {
        if (!list2.Contains(item)) return false;
    }

    return true;
}