Получение универсального класса, назначенного данному типу объекта

Я думаю, вам нужно прочитать о Factory Pattern. Он поможет вам заменить класс в зависимости от валюты и актива.

Не внося изменений в определенные абстракции, вы можете изменить TotalWorthCalculator на следующее:

public class TotalWorthCalculator
{
    private readonly IList<object> calculators;

    public TotalWorthCalculator(IList<object> calculators)
    {
        this.calculators = calculators;
    }

    public decimal GetTotalWorth(IList<IAssetId> assetIds) =>
        assetId.Select(this.Calculate).Sum();
    
    private double Calculate(IAssetId id)
    {
        Type calculatorType =
            typeof(IAssetWorthCalculator<>).MakeGenericType(id.GetType());
    
        dynamic calculator = this.calculators
            .Single(c => calculatorType.IsAssignableFrom(c.GetType());
            
        return calculator.CalculateWorth((dynamic)id);
    }
}

В этом решении используется отражение и динамическая типизация. Вы можете создать экземпляр TotalWorthCalculator следующим образом:

var calculator = new TotalWorthCalculator(new List<object>()
{
    new MoneyWorthCalculator(),
    new EtfWorthCalculator()
});

Что ж, если вы используете контравариантность с ключевым словом in, вы фактически говорите, что для IAssetWorthCalculator не допускается подкласс.

Таким образом, даже если бы у вас был способ сделать то, что вам нужно, в конечном итоге вы получили бы ошибки.

Этот код не будет соответствовать:

AssetWorthCalculator<IAssetId> generic = null;
AssetWorthCalculator<Currency> lessGeneric = null;

generic = lessGeneric;

с ошибкой:

Невозможно неявно преобразовать тип «console.AssetWorthCalculator<console.Currency>» в «console.AssetWorthCalculator<console.IAssetId>». Существует явное преобразование (вам не хватает приведения?)

в то время как lessGeneric = generic было бы прекрасно.

Поэтому вам нужно переосмыслить свой дизайн.

Вам нужна ковариация, но вы используете параметр типа для аргументации, для которой требуется контравариация.

Я думаю, вам нужен тип интерфейса для List<T>, например:

public interface IAmAnAssetAndIKnowMyWorth {
    decimal CalculateWorth();
}

и общий класс, который его реализует:

public class GenericKnowsItsWorth<TAssetId>(
TAssetId assetId, ICalculator<TAssetId> calculator) :
IAmAnAssetAndIKnowMyWorth
where TAssetId : IAssetId {
    public decimal CalculateWorth() => calculator.CalculateWorth(assetId);
}

в который вы можете внедрить различные калькуляторы, реализующие

public interface ICalculator<T> where T : IAssetId {
    public decimal CalculateWorth(T assetId);
}

за T быть Currency например

public class MoneyWorthCalculator : ICalculator<Currency> {
    public decimal CalculateWorth(Currency assetId) {
       return default;
    }
}

мы можем создавать такие экземпляры:

IAmAnAssetAndIKnowMyWorth currencyKnowsItsWorth = new GenericKnowsItsWorth<Currency>(
new Currency("EUR"), 
    new MoneyWorthCalculator());

это облегчит задачу в конце:

public decimal GetTotalWorth(IList<IAmAnAssetAndIKnowMyWorth assets)
{
    decimal sum = 0;
    foreach (IAmAnAssetAndIKnowMyWorth asset in assets)
    {
        sum += asset.CalculateWorth();
    }

    return sum;
}

Это приведет к тому, что потребуется немного больше работы по построению IList<IAmAnAssetAndIKnowMyWorth> с объединением AssetIds и Calculators, но, по моему мнению, это не должно вызвать особых проблем.