Union Vs Concat en Linq

Tengo una pregunta sobre Uniony Concat. Supongo que ambos se comportan igual en el caso de List<T>.

var a1 = (new[] { 1, 2 }).Union(new[] { 1, 2 });             // O/P : 1 2
var a2 = (new[] { 1, 2 }).Concat(new[] { 1, 2 });            // O/P : 1 2 1 2

var a3 = (new[] { "1", "2" }).Union(new[] { "1", "2" });     // O/P : "1" "2"
var a4 = (new[] { "1", "2" }).Concat(new[] { "1", "2" });    // O/P : "1" "2" "1" "2"

Se espera el resultado anterior,

Pero en caso de que obtengo el List<T>mismo resultado.

class X
{
    public int ID { get; set; }
}

class X1 : X
{
    public int ID1 { get; set; }
}

class X2 : X
{
    public int ID2 { get; set; }
}

var lstX1 = new List<X1> { new X1 { ID = 10, ID1 = 10 }, new X1 { ID = 10, ID1 = 10 } };
var lstX2 = new List<X2> { new X2 { ID = 10, ID2 = 10 }, new X2 { ID = 10, ID2 = 10 } };

var a5 = lstX1.Cast<X>().Union(lstX2.Cast<X>());     // O/P : a5.Count() = 4
var a6 = lstX1.Cast<X>().Concat(lstX2.Cast<X>());    // O/P : a6.Count() = 4

Pero ambos se comportan igual en el caso de List<T>.

¿Alguna sugerencia por favor?

Union devuelve Distinctvalores. De forma predeterminada, comparará referencias de artículos. Sus artículos tienen diferentes referencias, por lo que todos se consideran diferentes. Cuando lanza a tipo base X, la referencia no cambia.

Si anula Equalsy GetHashCode(utilizado para seleccionar elementos distintos), los elementos no se compararán por referencia:

class X
{
    public int ID { get; set; }

    public override bool Equals(object obj)
    {
        X x = obj as X;
        if (x == null)
            return false;
        return x.ID == ID;
    }

    public override int GetHashCode()
    {
        return ID.GetHashCode();
    }
}

Pero todos sus artículos tienen un valor diferente de ID. Así que todos los elementos se siguen considerando diferentes. Si proporciona varios artículos con el mismo ID, verá la diferencia entre Uniony Concat:

var lstX1 = new List<X1> { new X1 { ID = 1, ID1 = 10 }, 
                           new X1 { ID = 10, ID1 = 100 } };
var lstX2 = new List<X2> { new X2 { ID = 1, ID2 = 20 }, // ID changed here
                           new X2 { ID = 20, ID2 = 200 } };

var a5 = lstX1.Cast<X>().Union(lstX2.Cast<X>());  // 3 distinct items
var a6 = lstX1.Cast<X>().Concat(lstX2.Cast<X>()); // 4

Su muestra inicial funciona, porque los números enteros son tipos de valor y se comparan por valor.

Concatliteralmente devuelve los elementos de la primera secuencia seguidos de los elementos de la segunda secuencia. Si utiliza Concaten dos secuencias de 2 elementos, siempre obtendrá una secuencia de 4 elementos.

Uniones Concatseguido esencialmente por Distinct.

En sus dos primeros casos, termina con secuencias de 2 elementos porque, entre ellos, cada par de secuencias de entrada tiene exactamente dos elementos distintos.

En su tercer caso, termina con una secuencia de 4 elementos porque los cuatro elementos en sus dos secuencias de entrada son distintos .

Uniony se Concatcomportan igual ya Unionque no se pueden detectar duplicados sin una costumbre IEqualityComparer<X>. Solo busca si ambos son la misma referencia.

public class XComparer: IEqualityComparer<X>
{
    public bool Equals(X x1, X x2)
    {
        if (object.ReferenceEquals(x1, x2))
            return true;
        if (x1 == null || x2 == null)
            return false;
        return x1.ID.Equals(x2.ID);
    }

    public int GetHashCode(X x)
    {
        return x.ID.GetHashCode();
    }
}

Ahora puedes usarlo en la sobrecarga de Union:

var comparer = new XComparer();
a5 = lstX1.Cast<X>().Union(lstX2.Cast<X>(), new XComparer());