SQL の外部結合を LINQ で表現する — LeftJoin・RightJoin・Shuffle の実装

// LINQ (.NET 9 以前): GroupJoin + SelectMany + DefaultIfEmpty の合成
var result = employees
    .GroupJoin(departments, e => e.DeptId, d => d.DeptId, (e, ds) => new { e, ds })
    .SelectMany(g => g.ds.DefaultIfEmpty(), (g, d) => new { g.e.Name, d?.DeptName });

#nullable enable

using System;
using System.Collections.Generic;

#if !NET10_0_OR_GREATER // .NET 10.0 未満の環境（.NET Framework など）のみ有効化

namespace System.Linq
{
    /// <summary>
    /// .NET 10.0 で追加された LINQ メソッドを古いターゲットフレームワーク向けに補完する拡張メソッドを提供します。
    /// </summary>
    public static partial class LinqExtensions
    {
        // ==========================================
        // 1. LeftJoin（左外部結合）
        // ==========================================
        public static IEnumerable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner?, TResult> resultSelector)
            => outer.LeftJoin(inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);

        public static IEnumerable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter, TInner?, TResult> resultSelector,
            IEqualityComparer<TKey>? comparer)
        {
            if (outer == null) throw new ArgumentNullException(nameof(outer));
            if (inner == null) throw new ArgumentNullException(nameof(inner));
            if (outerKeySelector == null) throw new ArgumentNullException(nameof(outerKeySelector));
            if (innerKeySelector == null) throw new ArgumentNullException(nameof(innerKeySelector));
            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));

            // 外部要素ごとに一致する内部要素をまとめ、無ければ default(TInner) を 1 件補う。
            return outer
                .GroupJoin(inner, outerKeySelector, innerKeySelector, (o, inners) => new { o, inners }, comparer)
                .SelectMany(g => g.inners.DefaultIfEmpty(), (g, i) => resultSelector(g.o, i));
        }

        // ==========================================
        // 2. RightJoin（右外部結合）
        // ==========================================
        public static IEnumerable<TResult> RightJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter?, TInner, TResult> resultSelector)
            => outer.RightJoin(inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);

        public static IEnumerable<TResult> RightJoin<TOuter, TInner, TKey, TResult>(
            this IEnumerable<TOuter> outer,
            IEnumerable<TInner> inner,
            Func<TOuter, TKey> outerKeySelector,
            Func<TInner, TKey> innerKeySelector,
            Func<TOuter?, TInner, TResult> resultSelector,
            IEqualityComparer<TKey>? comparer)
        {
            if (outer == null) throw new ArgumentNullException(nameof(outer));
            if (inner == null) throw new ArgumentNullException(nameof(inner));
            if (outerKeySelector == null) throw new ArgumentNullException(nameof(outerKeySelector));
            if (innerKeySelector == null) throw new ArgumentNullException(nameof(innerKeySelector));
            if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector));

            // 内部シーケンスを軸にして GroupJoin し、無ければ default(TOuter) を 1 件補う。
            return inner
                .GroupJoin(outer, innerKeySelector, outerKeySelector, (i, outers) => new { i, outers }, comparer)
                .SelectMany(g => g.outers.DefaultIfEmpty(), (g, o) => resultSelector(o, g.i));
        }

        // ==========================================
        // 3. Shuffle（ランダム並べ替え）
        // ==========================================
        public static IEnumerable<TSource> Shuffle<TSource>(this IEnumerable<TSource> source)
        {
            if (source == null) throw new ArgumentNullException(nameof(source));
            return ShuffleIterator(source);
        }

        private static IEnumerable<TSource> ShuffleIterator<TSource>(IEnumerable<TSource> source)
        {
            var buffer = source.ToArray();

            // Fisher–Yates 法で末尾から未確定要素と交換していく。
            for (int i = buffer.Length - 1; i > 0; i--)
            {
                int j = SharedRandom.Next(i + 1);
                if (j != i)
                {
                    (buffer[i], buffer[j]) = (buffer[j], buffer[i]);
                }
            }

            foreach (var item in buffer)
            {
                yield return item;
            }
        }

#if NET6_0_OR_GREATER
        // .NET 6 以降にはスレッド安全な共有インスタンスがある。
        private static Random SharedRandom => Random.Shared;
#else
        // .NET Framework には Random.Shared が無いため、スレッドごとにインスタンスを持つ。
        [ThreadStatic]
        private static Random? _threadRandom;
        private static Random SharedRandom => _threadRandom ??= new Random();
#endif
    }
}

#endif

var employees = new[]
{
    new { Name = "佐藤", DeptId = 10 },
    new { Name = "鈴木", DeptId = 20 },
    new { Name = "高橋", DeptId = 99 }, // 対応する部署が無い
};

var departments = new[]
{
    new { DeptId = 10, DeptName = "営業部" },
    new { DeptId = 20, DeptName = "開発部" },
};

var result = employees.LeftJoin(
    departments,
    e => e.DeptId,
    d => d.DeptId,
    (e, d) => $"{e.Name}: {d?.DeptName ?? "(未所属)"}");
// 佐藤: 営業部
// 鈴木: 開発部
// 高橋: (未所属)

var employees = new[]
{
    new { Name = "佐藤", DeptId = 10 },
    new { Name = "鈴木", DeptId = 20 },
};

var departments = new[]
{
    new { DeptId = 10, DeptName = "営業部" },
    new { DeptId = 20, DeptName = "開発部" },
    new { DeptId = 30, DeptName = "総務部" }, // 所属する社員が居ない
};

var result = employees.RightJoin(
    departments,
    e => e.DeptId,
    d => d.DeptId,
    (e, d) => $"{d.DeptName}: {e?.Name ?? "(在籍なし)"}");
// 営業部: 佐藤
// 開発部: 鈴木
// 総務部: (在籍なし)

var deck = Enumerable.Range(1, 52);

var shuffled = deck.Shuffle().ToArray();
// 例: [17, 3, 50, 28, ...]（呼び出しごとに異なる）

var query = Enumerable.Range(1, 3).Shuffle();

var first = query.ToArray();  // ここでソースが列挙・並べ替えされる
var second = query.ToArray(); // 再列挙すると別の順序になる