DataGridView で List<T> をソートする（SortableBindingList の実装）

public class SortableBindingList<T> : BindingList<T>
{
    protected override bool SupportsSortingCore => true;
    protected override bool IsSortedCore => _isSorted;
    protected override PropertyDescriptor SortPropertyCore => _sortProperty;
    protected override ListSortDirection SortDirectionCore => _sortDirection;

    // ApplySortCore / RemoveSortCore は後述
}

var products = productRepository.GetAll(); // List<Product>

bindingSource1.DataSource = new SortableBindingList<Product>(products);
dataGridView1.DataSource = bindingSource1;

// BindingList<T> の既定実装（イメージ）
protected virtual bool SupportsSortingCore => false;

// ApplySortCore も既定では例外を投げる
protected virtual void ApplySortCore(
    PropertyDescriptor prop, ListSortDirection direction)
{
    throw new NotSupportedException();
}

bindingSource1.DataSource = new List<Product>();

// false が返る
Debug.WriteLine(((IBindingList)bindingSource1).SupportsSorting);

// 例外：InvalidOperationException
bindingSource1.Sort = "Name ASC";

// データバインド中に SupportsSorting が false だと例外
dataGridView1.Sort(dataGridView1.Columns["Name"], ListSortDirection.Ascending);
// System.InvalidOperationException:
// 'DataGridView コントロールは、データ連結されている場合、並べ替えできません。'

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;

public class SortableBindingList<T> : BindingList<T>
{
    private bool _isSorted;
    private PropertyDescriptor _sortProperty;
    private ListSortDirection _sortDirection = ListSortDirection.Ascending;

    public SortableBindingList()
    {
    }

    public SortableBindingList(IList<T> list)
        : base(new List<T>(list))
    {
    }

    // --- 並べ替えのサポートを宣言する ---

    protected override bool SupportsSortingCore => true;

    protected override bool IsSortedCore => _isSorted;

    protected override PropertyDescriptor SortPropertyCore => _sortProperty;

    protected override ListSortDirection SortDirectionCore => _sortDirection;

    // --- 並べ替えの実処理 ---

    protected override void ApplySortCore(
        PropertyDescriptor prop, ListSortDirection direction)
    {
        if (!(Items is List<T> items))
        {
            return;
        }

        var sorted = direction == ListSortDirection.Ascending
            ? items.OrderBy(x => prop.GetValue(x), NullSafeComparer.Instance).ToList()
            : items.OrderByDescending(x => prop.GetValue(x), NullSafeComparer.Instance).ToList();

        items.Clear();
        items.AddRange(sorted);

        _isSorted = true;
        _sortProperty = prop;
        _sortDirection = direction;

        OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
    }

    protected override void RemoveSortCore()
    {
        _isSorted = false;
        _sortProperty = null;

        OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
    }

    // --- null と非 IComparable を安全に扱う比較子 ---

    private sealed class NullSafeComparer : IComparer<object>
    {
        public static readonly NullSafeComparer Instance = new NullSafeComparer();

        public int Compare(object x, object y)
        {
            if (ReferenceEquals(x, y))
            {
                return 0;
            }

            // null は常に先頭へ寄せる
            if (x == null)
            {
                return -1;
            }

            if (y == null)
            {
                return 1;
            }

            if (x is IComparable comparable)
            {
                return comparable.CompareTo(y);
            }

            // 比較不能な型は文字列表現で代替する
            return string.Compare(
                x.ToString(), y.ToString(), StringComparison.CurrentCulture);
        }
    }
}

// NG：1件ごとに ListChanged が飛び、グリッドが激しくちらつく
for (int i = 0; i < sorted.Count; i++)
{
    this[i] = sorted[i];
}

// OK：Items 経由で入れ替え、最後に Reset を1回だけ通知
items.Clear();
items.AddRange(sorted);
OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));

private SortableBindingList<Product> _products;

private void LoadData()
{
    _products = new SortableBindingList<Product>(productRepository.GetAll());

    bindingSource1.DataSource = _products;
    dataGridView1.DataSource = bindingSource1;
}

foreach (DataGridViewColumn column in dataGridView1.Columns)
{
    column.SortMode = DataGridViewColumnSortMode.Automatic;
}

dataGridView1.Sort(
    dataGridView1.Columns[nameof(Product.Name)],
    ListSortDirection.Ascending);

bindingSource1.Sort = "Name ASC";

private void SortWithSelectionKept(string columnName, ListSortDirection direction)
{
    // ソート前にキーを退避
    var current = bindingSource1.CurrentOrDefault<Product>();
    var keptId = current?.Id;

    dataGridView1.Sort(dataGridView1.Columns[columnName], direction);

    if (keptId == null)
    {
        return;
    }

    // ソート後にキーで探し直す
    var index = _products
        .Select((item, i) => new { item, i })
        .FirstOrDefault(x => x.item.Id == keptId.Value)?.i ?? -1;

    if (index >= 0)
    {
        bindingSource1.Position = index;
    }
}

private readonly List<T> _originalOrder;

public SortableBindingList(IList<T> list) : base(new List<T>(list))
{
    _originalOrder = new List<T>(list);
}

protected override void RemoveSortCore()
{
    if (Items is List<T> items)
    {
        items.Clear();
        items.AddRange(_originalOrder);
    }

    _isSorted = false;
    _sortProperty = null;

    OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}

var sw = Stopwatch.StartNew();
dataGridView1.Sort(dataGridView1.Columns["Name"], ListSortDirection.Ascending);
sw.Stop();
Debug.WriteLine($"sort: {sw.ElapsedMilliseconds} ms");

public Comparison<T> CustomComparison { get; set; }

protected override void ApplySortCore(
    PropertyDescriptor prop, ListSortDirection direction)
{
    if (!(Items is List<T> items))
    {
        return;
    }

    List<T> sorted;

    if (CustomComparison != null)
    {
        sorted = new List<T>(items);
        sorted.Sort(CustomComparison);

        if (direction == ListSortDirection.Descending)
        {
            sorted.Reverse();
        }
    }
    else
    {
        sorted = direction == ListSortDirection.Ascending
            ? items.OrderBy(x => prop.GetValue(x), NullSafeComparer.Instance).ToList()
            : items.OrderByDescending(x => prop.GetValue(x), NullSafeComparer.Instance).ToList();
    }

    items.Clear();
    items.AddRange(sorted);

    _isSorted = true;
    _sortProperty = prop;
    _sortDirection = direction;

    OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}

private void DataGridView1_ColumnHeaderMouseClick(
    object sender, DataGridViewCellMouseEventArgs e)
{
    _ascending = !_ascending;

    var sorted = _ascending
        ? _products.OrderBy(p => p.Name).ToList()
        : _products.OrderByDescending(p => p.Name).ToList();

    bindingSource1.DataSource = new BindingList<Product>(sorted);
}