Union Vs Concat у Linq

Question 1

У мене є запитання щодо Unionі Concat. Я думаю, обидва поводяться однаково у випадку 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"

Очікується вищезазначений результат,

Але у випадку List<T>я отримую той самий результат.

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

Але обидва поводяться однаково List<T>.

Будь-які пропозиції, будь ласка?

Question 2

Союз повертає Distinctзначення. За замовчуванням він порівнює посилання на елементи. Ваші предмети мають різні посилання, тому всі вони вважаються різними. При передачі на базовий тип Xпосилання не змінюється.

Якщо ви заміните Equalsта GetHashCode(використовуєтеся для вибору окремих елементів), тоді елементи не будуть порівнюватися за посиланням:

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();
    }
}

Але всі ваші предмети мають різну вартість ID. Тож усі предмети досі вважалися різними. Якщо ви надасте кілька предметів з однаковими, IDтоді ви побачите різницю між Unionі 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

Ваш початковий зразок працює, оскільки цілі числа є типами значень і їх порівнюють за значенням.

Question 3

Concatбуквально повертає елементи з першої послідовності, за якими слідують елементи з другої послідовності. Якщо ви використовуєте Concatдві послідовності з 2 елементів, ви завжди отримаєте послідовність із 4 елементів.

Unionпо суті Concatслідує Distinct.

У перших двох випадках ви отримуєте послідовності з 2 елементів, оскільки між ними кожна пара вхідних оцінок має рівно два різних елементи.

У третьому випадку ви отримуєте послідовність із 4 елементів, оскільки всі чотири елементи у ваших двох послідовностях введення відрізняються .

Question 4

Unionі Concatповодяться однаково, оскільки Unionне можуть виявити дублікати без користувацьких налаштувань IEqualityComparer<X>. Це просто дивиться, якщо обидва є однаковими посиланнями.

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();
    }
}

Тепер ви можете використовувати його при перевантаженні Union:

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