EnumerableComparer

EnumerableComparer<T> compares elements of an enumerable for sorting order.

// Init enumerables
IEnumerable<string> strings1 = new String[] { "a100", "B1", "a5", "A1" };
IEnumerable<string> strings2 = new String[] { "a100", "B1", "a5", "A1", "_00" };
IEnumerable<string>[] strarrays = new IEnumerable<string>[] { strings1, strings2 };
// Create comparer
IComparer<IEnumerable<string>> comparer =
    new EnumerableComparer<string>(StringComparer.InvariantCultureIgnoreCase);
// Compare
Array.Sort(strarrays, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]

EnumerableComparer.Create(elementType, elementComparer) creates enumerable comparer with run-time type argument.

// Init enumerables
IEnumerable<string> strings1 = new String[] { "a100", "B1", "a5", "A1" };
IEnumerable<string> strings2 = new String[] { "a100", "B1", "a5", "A1", "_00" };
IEnumerable<string>[] strarrays = new IEnumerable<string>[] { strings1, strings2 };
// Create comparer
IComparer<IEnumerable<string>> comparer =
    (EnumerableComparer<string>)
    EnumerableComparer.Create(typeof(string), StringComparer.InvariantCultureIgnoreCase);
// Compare
Array.Sort(strarrays, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]

EnumerableComparer<L, T> compares elements of an enumerable for sorting order.

// Init enumerables
List<string> strings1 = new List<String> { "a100", "B1", "a5", "A1" };
List<string> strings2 = new List<String> { "a100", "B1", "a5", "A1", "_00" };
List<string>[] strlists = new List<string>[] { strings1, strings2 };
// Create comparer
IComparer<List<string>> comparer =
    new EnumerableComparer<List<string>, string>(StringComparer.InvariantCultureIgnoreCase);
// Compare
Array.Sort(strlists, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]

EnumerableComparer.Create(listType, elementType, elementComparer) creates enumerable comparer with run-time type argument.

// Init enumerables
List<string> strings1 = new List<String> { "a100", "B1", "a5", "A1" };
List<string> strings2 = new List<String> { "a100", "B1", "a5", "A1", "_00" };
List<string>[] strlists = new List<string>[] { strings1, strings2 };
// Create comparer
IComparer<List<string>> comparer =
    (EnumerableComparer<string>)
    EnumerableComparer.Create(typeof(List<string>), typeof(string), StringComparer.InvariantCultureIgnoreCase);
// Compare
Array.Sort(strlists, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]

ArrayComparer<T> compares elements of an array for sorting order.

String[] strings1 = { "a100", "B1", "a5", "A1" };
String[] strings2 = { "a100", "B1", "a5", "A1", "_00" };
string[][] strarrays = { strings1, strings2 };
IComparer<string[]> comparer = new ArrayComparer<string>(StringComparer.InvariantCultureIgnoreCase);
Array.Sort(strarrays, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]

ArrayComparer.Create(type, elementComparer) creates array comparer with run-time type argument.

// Init arrays
String[] strings1 = { "a100", "B1", "a5", "A1" };
String[] strings2 = { "a100", "B1", "a5", "A1", "_00" };
string[][] strarrays = { strings1, strings2 };
// Create comparer
IComparer<string[]> comparer =
    (ArrayComparer<string>)
    ArrayComparer.Create(typeof(string), StringComparer.InvariantCultureIgnoreCase);
// Compare
Array.Sort(strarrays, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]

EnumerableEqualityComparer

EnumerableEqualityComparer<T> compares elements of an enumerable for equality.

// Init enumerables
IEnumerable<string> strings1 = new String[] { "a100", "B1", "a5", "A1" };
IEnumerable<string> strings2 = new String[] { "a100", "B1", "a5", "A1", "_00" };
// Create comparer
IEqualityComparer<IEnumerable<string>> comparer =
    new EnumerableEqualityComparer<string>(StringComparer.InvariantCultureIgnoreCase);
// Compare
comparer.Equals(strings1, strings2);

EnumerableEqualityComparer.Create(elementType, elementComparer) creates enumerable comparer with run-time type argument.

// Init enumerables
IEnumerable<string> strings1 = new String[] { "a100", "B1", "a5", "A1" };
IEnumerable<string> strings2 = new String[] { "a100", "B1", "a5", "A1", "_00" };
// Create comparer
IEqualityComparer<IEnumerable<string>> comparer =
    (EnumerableEqualityComparer<string>)
    EnumerableEqualityComparer.Create(typeof(string), StringComparer.InvariantCultureIgnoreCase);
// Compare
comparer.Equals(strings1, strings2);

EnumerableEqualityComparer<L, T> compares elements of an enumerable for equality.

// Init enumerables
List<string> strings1 = new List<String> { "a100", "B1", "a5", "A1" };
List<string> strings2 = new List<String> { "a100", "B1", "a5", "A1", "_00" };
// Create comparer
IEqualityComparer<List<string>> comparer =
    new EnumerableEqualityComparer<List<string>, string>(StringComparer.InvariantCultureIgnoreCase);
// Compare
comparer.Equals(strings1, strings2);

EnumerableEqualityComparer.Create(listType, elementType, elementComparer) creates enumerable comparer with run-time type argument.

// Init enumerables
List<string> strings1 = new List<String> { "a100", "B1", "a5", "A1" };
List<string> strings2 = new List<String> { "a100", "B1", "a5", "A1", "_00" };
// Create comparer
IEqualityComparer<List<string>> comparer =
    (EnumerableEqualityComparer<List<string>, string>)
    EnumerableEqualityComparer.Create(typeof(List<string>), typeof(string), StringComparer.InvariantCultureIgnoreCase);
// Compare
comparer.Equals(strings1, strings2);

ArrayEqualityComparer<T> compares elements of an array for equality.

// Init arrays
String[] strings1 = { "a100", "B1", "a5", "A1" };
String[] strings2 = { "a100", "B1", "a5", "A1", "_00" };
// Create comparer
IEqualityComparer<string[]> comparer =
    new ArrayEqualityComparer<string>(StringComparer.InvariantCultureIgnoreCase);
// Compare
comparer.Equals(strings1, strings2);

ArrayEqualityComparer.Create(type, elementComparer) creates array comparer with run-time type argument.

// Init arrays
String[] strings1 = { "a100", "B1", "a5", "A1" };
String[] strings2 = { "a100", "B1", "a5", "A1", "_00" };
// Create comparer
IEqualityComparer<string[]> comparer =
    (ArrayEqualityComparer<string>)
    ArrayEqualityComparer.Create(typeof(string), StringComparer.InvariantCultureIgnoreCase);
// Compare
comparer.Equals(strings1, strings2);

Full Example

Full example

using System;
using System.Collections.Generic;
using System.Linq;
using Avalanche.Utilities;

class enumerablecomparer
{
    public static void Run()
    {
        {
            // <00>
            // Init enumerables
            IEnumerable<string> strings1 = new String[] { "a100", "B1", "a5", "A1" };
            IEnumerable<string> strings2 = new String[] { "a100", "B1", "a5", "A1", "_00" };
            IEnumerable<string>[] strarrays = new IEnumerable<string>[] { strings1, strings2 };
            // Create comparer
            IComparer<IEnumerable<string>> comparer =
                new EnumerableComparer<string>(StringComparer.InvariantCultureIgnoreCase);
            // Compare
            Array.Sort(strarrays, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]
            // </00>
            PrintArray(strarrays);
        }
        {
            // <01>
            // Init enumerables
            IEnumerable<string> strings1 = new String[] { "a100", "B1", "a5", "A1" };
            IEnumerable<string> strings2 = new String[] { "a100", "B1", "a5", "A1", "_00" };
            IEnumerable<string>[] strarrays = new IEnumerable<string>[] { strings1, strings2 };
            // Create comparer
            IComparer<IEnumerable<string>> comparer =
                (EnumerableComparer<string>)
                EnumerableComparer.Create(typeof(string), StringComparer.InvariantCultureIgnoreCase);
            // Compare
            Array.Sort(strarrays, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]
            // </01>
            PrintArray(strarrays);
        }
        {
            // <02>
            // Init enumerables
            List<string> strings1 = new List<String> { "a100", "B1", "a5", "A1" };
            List<string> strings2 = new List<String> { "a100", "B1", "a5", "A1", "_00" };
            List<string>[] strlists = new List<string>[] { strings1, strings2 };
            // Create comparer
            IComparer<List<string>> comparer =
                new EnumerableComparer<List<string>, string>(StringComparer.InvariantCultureIgnoreCase);
            // Compare
            Array.Sort(strlists, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]
            // </02>
            PrintArray(strlists);
        }
        {
            // <03>
            // Init enumerables
            List<string> strings1 = new List<String> { "a100", "B1", "a5", "A1" };
            List<string> strings2 = new List<String> { "a100", "B1", "a5", "A1", "_00" };
            List<string>[] strlists = new List<string>[] { strings1, strings2 };
            // Create comparer
            IComparer<List<string>> comparer =
                (EnumerableComparer<string>)
                EnumerableComparer.Create(typeof(List<string>), typeof(string), StringComparer.InvariantCultureIgnoreCase);
            // Compare
            Array.Sort(strlists, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]
            // </03>
            PrintArray(strlists);
        }
        {
            // <04>
            String[] strings1 = { "a100", "B1", "a5", "A1" };
            String[] strings2 = { "a100", "B1", "a5", "A1", "_00" };
            string[][] strarrays = { strings1, strings2 };
            IComparer<string[]> comparer = new ArrayComparer<string>(StringComparer.InvariantCultureIgnoreCase);
            Array.Sort(strarrays, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]
            // </04>
            PrintArray(strarrays);
        }
        {
            // <05>
            // Init arrays
            String[] strings1 = { "a100", "B1", "a5", "A1" };
            String[] strings2 = { "a100", "B1", "a5", "A1", "_00" };
            string[][] strarrays = { strings1, strings2 };
            // Create comparer
            IComparer<string[]> comparer =
                (ArrayComparer<string>)
                ArrayComparer.Create(typeof(string), StringComparer.InvariantCultureIgnoreCase);
            // Compare
            Array.Sort(strarrays, comparer); // [a100, B1, a5, A1], [a100, B1, a5, A1, _00]
            // </05>
            PrintArray(strarrays);
        }


        {
            // <10>
            // Init enumerables
            IEnumerable<string> strings1 = new String[] { "a100", "B1", "a5", "A1" };
            IEnumerable<string> strings2 = new String[] { "a100", "B1", "a5", "A1", "_00" };
            // Create comparer
            IEqualityComparer<IEnumerable<string>> comparer =
                new EnumerableEqualityComparer<string>(StringComparer.InvariantCultureIgnoreCase);
            // Compare
            comparer.Equals(strings1, strings2);
            // </10>
        }
        {
            // <11>
            // Init enumerables
            IEnumerable<string> strings1 = new String[] { "a100", "B1", "a5", "A1" };
            IEnumerable<string> strings2 = new String[] { "a100", "B1", "a5", "A1", "_00" };
            // Create comparer
            IEqualityComparer<IEnumerable<string>> comparer =
                (EnumerableEqualityComparer<string>)
                EnumerableEqualityComparer.Create(typeof(string), StringComparer.InvariantCultureIgnoreCase);
            // Compare
            comparer.Equals(strings1, strings2);
            // </11>
        }
        {
            // <12>
            // Init enumerables
            List<string> strings1 = new List<String> { "a100", "B1", "a5", "A1" };
            List<string> strings2 = new List<String> { "a100", "B1", "a5", "A1", "_00" };
            // Create comparer
            IEqualityComparer<List<string>> comparer =
                new EnumerableEqualityComparer<List<string>, string>(StringComparer.InvariantCultureIgnoreCase);
            // Compare
            comparer.Equals(strings1, strings2);
            // </12>
        }
        {
            // <13>
            // Init enumerables
            List<string> strings1 = new List<String> { "a100", "B1", "a5", "A1" };
            List<string> strings2 = new List<String> { "a100", "B1", "a5", "A1", "_00" };
            // Create comparer
            IEqualityComparer<List<string>> comparer =
                (EnumerableEqualityComparer<List<string>, string>)
                EnumerableEqualityComparer.Create(typeof(List<string>), typeof(string), StringComparer.InvariantCultureIgnoreCase);
            // Compare
            comparer.Equals(strings1, strings2);
            // </13>
        }
        {
            // <14>
            // Init arrays
            String[] strings1 = { "a100", "B1", "a5", "A1" };
            String[] strings2 = { "a100", "B1", "a5", "A1", "_00" };
            // Create comparer
            IEqualityComparer<string[]> comparer =
                new ArrayEqualityComparer<string>(StringComparer.InvariantCultureIgnoreCase);
            // Compare
            comparer.Equals(strings1, strings2);
            // </14>
        }
        {
            // <15>
            // Init arrays
            String[] strings1 = { "a100", "B1", "a5", "A1" };
            String[] strings2 = { "a100", "B1", "a5", "A1", "_00" };
            // Create comparer
            IEqualityComparer<string[]> comparer =
                (ArrayEqualityComparer<string>)
                ArrayEqualityComparer.Create(typeof(string), StringComparer.InvariantCultureIgnoreCase);
            // Compare
            comparer.Equals(strings1, strings2);
            // </15>
        }


    }

    static void PrintArray<T>(IEnumerable<IEnumerable<T>> enumr) => Console.WriteLine($"[{String.Join("], [", enumr.Select(array => String.Join(", ", array)))}]");
}