Общие ограничения типа на практике KeyValue не сопоставимы

Question

Итак, я реализовал программу KeyValue, по сути, ручной словарь, и теперь я пытаюсь сделать его универсальным.Я сталкиваюсь с одной проблемой с моим оператором if и понимаю, что мне нужно определить ограничение типа, но не могу понять, как это правильно сделать, поскольку мое хранилище KeyValue имеет 2 типа.

 class Generic_Key_Value
    {
        public struct KeyValueGeneric<T>
        {
            public readonly T Key;
            public readonly T Value;

            public KeyValueGeneric(T x, T y) 
            {
                Key = x;
                Value = y;
            }

        }
        public class MyDictionaryGenerics <T> 

        {
            public KeyValueGeneric<T>[] keyArray = new KeyValueGeneric<T>[20]; 

            public int Counter = 0;
            public bool matchFound = false;

            public T this[ T key]
            {
                set
                {
                    bool matchFound = false;
                    for (int i = 0; i < Counter; i++)
                    {

                        if (keyArray[i].Key == key) 
                        {
                            keyArray[i] = new KeyValueGeneric<T>(key, value);
                            matchFound = true;
                        }


                    }
                    if (matchFound == false)
                    {
                        keyArray[Counter] = new KeyValueGeneric<T>(key, value);
                        Counter++;
                    }

                }
                get
                {

                    for (int i = 0; i < keyArray.Length; i++)
                    {
                        if (key == keyArray[i].Key)
                        {

                            return keyArray[i].Value;


                        }

                    }

                    throw new KeyNotFoundException();


                }
            }
        }
    }

Не могу сравнить

if (keyArray[i].Key == key) //THIS IS STATED AS NOT COMPARABLE
          {
              keyArray[i] = new KeyValueGeneric<T>(key, value);
              matchFound = true;
          }

Answer 1

Используйте два параметра универсального типа, потому что, вероятно, вы хотите иметь разные типы ключей и типов значений.

public struct KeyValueGeneric<TKey, TValue>
{
    public readonly TKey Key;
    public readonly TValue Value;

    public KeyValueGeneric(TKey key, TValue value)
    {
        Key = key;
        Value = value;
    }
}

Хороший выбор - использовать значение по умолчанию EqualityComparer<TKey>:

if (EqualityComparer<TKey>.Default.Equals(keyArray[i].Key, key))
{
    keyArray[i] = new KeyValueGeneric<TKey, TValue>(key, value);
    matchFound = true;
}

Как указал @madreflection, EqualityComparer работает со значениями null и избегает упаковки типов значений.

Answer 2

В вашем случае T является универсальным и имеет любой тип, в вашем случае, если проверка состояния keyArray[i].Key, т.е. Type равна типу ввода, который хранится в переменной key.

Если это так, то вы можете использовать метод Type.Equal.

Как,

if (keyArray[i].Key.Equal(key))  //Use ".Equals()" instead of "=="
   {
       keyArray[i] = new KeyValueGeneric<T>(key, value);
       matchFound = true;
   }