Как добавить числа общего типа

Вы действительно можете использовать здесь общие математические API, но вам все равно понадобится какой-то способ убедить компилятор, что TKey — это число. В случае string вы можете просто проверить typeof(TKey) == typeof(string) и выполнить несколько преобразований.

Вот пример того, как это делается путем dynamicпривязки к вспомогательному методу:

частный словарь<TKey, TObject> items = ...;

public TKey GetUniqueKey()
{
    if (typeof(TKey).GetInterface("System.Numerics.INumber`1") != null)
        return GetNumericUniqueKey((dynamic)items.Keys);
    if (typeof(TKey) == typeof(string))
        return (TKey)(object)Guid.NewGuid().ToString();
    throw new NotSupportedException("Key type not supported.");
}

private static T GetNumericUniqueKey<T>(ICollection<T> existingKeys) where T: INumber<T> {
    if (existingKeys.Any()) {
        return (existingKeys.Max() ?? T.Zero) + T.One;
    }
    return T.Zero;
}

Другой подход — абстрагироваться от идеи, что ключи должны быть строками или числами. Создайте интерфейс IKey, который требует, чтобы его реализации имели необходимое вам поведение:

interface IKey<TSelf> where TSelf: IKey<TSelf> {
    static abstract TSelf GetUniqueKey(ICollection<TSelf> existingKeys);
    
    // declare other useful things you might want a key to have here
}

Тогда MyCollection может быть таким простым, как:

class MyCollection<TKey, TObject>
    where TObject : class
    where TKey : IKey<TKey>
{
    private Dictionary<TKey, TObject> items = ...;

    public TKey GetUniqueKey()
    {
        return TKey.GetUniqueKey(items.Keys);
    }
}

Теперь вам просто нужно реализовать числовые и строковые клавиши как простые оболочки числовых типов и string. Опять же, вы можете использовать общие математические методы для реализации числовых ключей.

record struct NumericKey<T>(T number): IKey<NumericKey<T>> where T: INumber<T> {
    
    public static NumericKey<T> GetUniqueKey(ICollection<NumericKey<T>> existingKeys) {
        if (existingKeys.Any()) {
            var newKey = (existingKeys.Max(x => x.number) ?? T.Zero) + T.One;
            return new NumericKey<T>(newKey);
        }
        return new NumericKey<T>(T.Zero);
    }
    
    // add implicit conversions perhaps...
}

record struct StringKey(string str): IKey<StringKey> {
    public static StringKey GetUniqueKey(ICollection<StringKey> existingKeys) {
        return new StringKey(Guid.NewGuid().ToString());
    }
    
    // add implicit conversions perhaps...
}

Если вы не против MyCollection иметь 3 параметра типа, вы можете сделать это, не меняя TKey на типы-оболочки.

class MyCollection<TKey, TFactory, TObject>
    where TObject : class
    where TKey : notnull, IComparable, IConvertible, IEquatable<TKey>
    where TFactory: IKeyFactory<TKey>
{
    private Dictionary<TKey, TObject> items = new();

    public TKey GetUniqueKey()
    {
        return TFactory.GetUniqueKey(items.Keys);
    }
}

interface IKeyFactory<TKey> {
    static abstract TKey GetUniqueKey(ICollection<TKey> existingKeys);
}

sealed class NaximumPlusOneFactory<T>: IKeyFactory<T> where T: INumber<T> {
    private NaximumPlusOneFactory() {}
    public static T GetUniqueKey(ICollection<T> existingKeys) {
        if (existingKeys.Any()) {
            var newKey = (existingKeys.Max() ?? T.Zero) + T.One;
            return newKey;
        }
        return T.Zero;
    }
}
sealed class GuidFactory: IKeyFactory<string> {
    private GuidFactory() {}
    public static string GetUniqueKey(ICollection<string> existingKeys) {
        return Guid.NewGuid().ToString();
    }
}

Мне кажется, что весь фокус в том, чтобы использовать фабрику Create, которая передает соответствующий метод GetUniqueKey в качестве делегата.

public MyCollection<TKey, TObject> CreateNumberCollection<TKey, TObject>()
        where TKey : INumberBase<TKey> =>
    new MyCollection<TKey, TObject>(lastKey => lastKey++);

public MyCollection<string, TObject> CreateStringCollection<TObject>() =>
    new MyCollection<string, TObject>(lastKey => Guid.NewGuid().ToString());

public MyCollection<Guid, TObject> CreateGuidCollection<TObject>() =>
    new MyCollection<Guid, TObject>(lastKey => Guid.NewGuid());


public class MyCollection<TKey, TObject>
    where TObject : class
    where TKey : notnull, IComparable, IConvertible, IEquatable<TKey>
{
    private Dictionary<TKey, TObject> _items = new();

    private TKey _lastKey;

    private Func<TKey, TKey> _uniqueKeyFactory;

    public MyCollection(Func<TKey, TKey> uniqueKeyFactory)
    {
        _uniqueKeyFactory = uniqueKeyFactory;
    }

    public TKey GetUniqueKey() =>
        _lastKey = _uniqueKeyFactory(_lastKey);
}

Если вы хотите сделать это полностью с помощью одной функции, вы можете сохранить эти делегаты в словаре.

private static Dictionary<Type, Delegate> _factories = new(){
    { typeof(int), new Func<int, int>(lastKey => lastKey++) },
    { typeof(byte), new Func<int, byte>(lastKey => lastKey++) },
    { typeof(double), new Func<int, double>(lastKey => lastKey++) },
    { typeof(Guid), new Func<int, Guid>(lastKey => Guid.NewGuid().ToString()) },
    { typeof(string), new Func<int, string>(lastKey => Guid.NewGuid()) },
};

А потом

    public MyCollection()
    {
        if (!_factories.TryGetValue(typeof(TKey), out var uniqueKeyFactory))
            throw new Exception("Invaid type");

        _uniqueKeyFactory = (Func<TKey, TKey>)uniqueKeyFactory;
    }

Вот что я придумал:

// Restrict TKey to numbers or strings: https://stackoverflow.com/a/30660880
public class MyCollection<TObject, TKey>
    where TObject : class
    where TKey : notnull, IComparable, IConvertible, IEquatable<TKey>
{
    private readonly Dictionary<TKey, TObject> objects = [];

    public TKey GetUniqueKey()
    {
        switch (Type.GetTypeCode(typeof(TKey)))
        {
            case TypeCode.SByte:
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.UInt16:
            case TypeCode.Int32:
            case TypeCode.UInt32:
            case TypeCode.Int64:
                if (Count == 0)
                    return (TKey)Convert.ChangeType(1, typeof(TKey));
                return (TKey)Convert.ChangeType(Convert.ToInt64(objects.Keys.Max()) + 1, typeof(TKey));
            case TypeCode.UInt64:
                if (Count == 0)
                    return (TKey)Convert.ChangeType(1, typeof(TKey));
                return (TKey)Convert.ChangeType(Convert.ToUInt64(objects.Keys.Max()) + 1, typeof(TKey));
            case TypeCode.String:
                return (TKey)(object)Guid.NewGuid().ToString();
            default:
                throw new NotSupportedException($"Key type {typeof(TKey).Name} not supported.");
        }
    }
}

Я использую IConvertible для всех чисел для преобразования типов, а также IComparable для Max().