从基泛型类型转换为派生泛型类型，其中派生类型具有附加的类型约束。

Question

实际上，当转换是理想的，甚至是"newing up“时，派生类型将在我的特定场景中工作。当我无法访问泛型参数的具体类型时，我怀疑这是不可能的。

public class OrderableCollection<T> : Collection<T> where T : IOrderable, new()
{
...
}

public class ArchivableOrderableCollection<T> : OrderableCollection<T> where T : IOrderable, IArchivable, new()
{
...
}

public class OrderableListDisplay<TItem> where TItem : IOrderable, new()
{
    protected OrderableCollection<TItem> orderableItems { get; set; }

    protected virtual async Task RestoreItem(TItem item)
    {
        if (item is not IArchivable)
        {
            throw new ArgumentException();
        }

        // None of these compile
        var aoc1 = orderableItems as ArchivableOrderableCollection<TItem>;
        var aoc2 = new ArchivableOrderableCollection<TItem>(orderableItems);
        var aoc3 = (ArchivableOrderableCollection<TItem>)(object)(OrderableItems);

        // I think I need something like
        var aoc4 = orderableItems as ArchivableOrderableCollection<TItem> where TItem : IArchivable
    }  
}

Answer 1

可以向RestoreItem方法中添加泛型参数w/约束。

protected virtual async Task RestoreItem<T>(T item)
    where T : TItem, IArchivable
{
    if( orderableItems is not ArchivableOrderableCollection<T> items )
    {
        throw new InvalidOperationException();
    }

    // do what you need to here
    items.Restore( item );
}

不过，我认为你应该重新考虑你的设计。为OrderableListDisplay<T>实现基类和派生类，以便派生版本可以适当地将TItem约束为IArchivable，并期望和实现ArchivableOrderableCollection<T>

public class OrderableListDisplay<TItem>
    where TItem : IOrderable, new()
{
    private readonly OrderableCollection<TItem> _items = null;

    public OrderableListDisplay( OrderableCollection<TItem> items )
    {
        _items = items ?? throw new ArgumentNullException( nameof( items ) );
    }
}

public class ArchivableOrderableListDisplay<TItem>
    : OrderableListDisplay<TItem>
    where TItem : IArchivable
{
    private readonly ArchivableOrderableCollection<TItem> _items = null;

    public ArchivableOrderableListDisplay( ArchivableOrderableCollection<TItem> items )
        : base( items )
    {
        _items = items;
    }

    protected async Task RestoreItem( TItem item )
    {
        _items.Restore( item );
    }
}

Answer 2

这对我来说很管用

protected virtual async Task RestoreItem<T>(T item)
    where T : TItem, IArchivable
{
    if( orderableItems is not ArchivableOrderableCollection<T> items )
    {
        throw new InvalidOperationException();
    }

   
    items.Restore( item );
}