Нулевое или стандартное сравнение универсального аргумента в C #

У меня есть общий метод, определенный следующим образом:

public void MyMethod<T>(T myArgument)

Первое, что я хочу сделать, это проверить, является ли значение myArgument значением по умолчанию для этого типа, примерно так:

if (myArgument == default(T))

Но это не компилируется, потому что я не гарантировал, что T будет реализовывать оператор ==. Поэтому я переключил код на это:

if (myArgument.Equals(default(T)))

Теперь это скомпилируется, но потерпит неудачу, если myArgument будет нулевым, что является частью того, что я тестирую. Я могу добавить явную проверку нуля следующим образом:

if (myArgument == null || myArgument.Equals(default(T)))

Теперь это кажется мне излишним. ReSharper даже предлагает заменить часть myArgument == null на myArgument == default (T), с которой я начал. Есть ли лучший способ решить эту проблему?

Мне нужно поддерживать как ссылочные типы, так и типы значений.

Чтобы избежать бокса, лучше всего сравнивать генерики на равенство EqualityComparer<T>.Default. Это учитывает IEquatable<T>(без бокса), а также object.Equalsобрабатывает все Nullable<T>«поднятые» нюансы. Следовательно:

if(EqualityComparer<T>.Default.Equals(obj, default(T))) {
    return obj;
}

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

• нуль для классов
• пустой (пустой) для Nullable<T>
• ноль / ложь / и т. д. для других структур

Как насчет этого:

if (object.Equals(myArgument, default(T)))
{
    //...
}

Использование static object.Equals()метода избавляет вас от необходимости выполнять nullпроверку самостоятельно. Явно квалифицировать вызов с помощью, object.вероятно, нет необходимости, в зависимости от вашего контекста, но я обычно префиксы staticвызовов с именем типа, просто чтобы сделать код более разрешимым.

Мне удалось найти статью Microsoft Connect, в которой эта проблема обсуждается более подробно:

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

Если известно, что типы являются ссылочными типами, перегрузка по умолчанию для определенных в объекте тестирует переменные на равенство ссылок, хотя тип может указывать свою собственную пользовательскую перегрузку. Компилятор определяет, какую перегрузку использовать, основываясь на статическом типе переменной (определение не является полиморфным). Поэтому, если вы измените свой пример, чтобы ограничить параметр универсального типа T незапечатанным ссылочным типом (таким как Exception), компилятор может определить конкретную перегрузку, которую нужно использовать, и будет скомпилирован следующий код:

public class Test<T> where T : Exception

Если известно, что типы являются типами значений, выполняются специальные тесты на равенство значений на основе конкретных используемых типов. Здесь нет хорошего сравнения «по умолчанию», так как ссылочные сравнения не имеют смысла для типов значений, и компилятор не может знать, какое конкретное сравнение значений вывести. Компилятор может генерировать вызов ValueType.Equals (Object), но этот метод использует отражение и является довольно неэффективным по сравнению со сравнениями конкретных значений. Следовательно, даже если бы вы указали ограничение типа значения для T, компилятору не следует создавать здесь ничего разумного:

public class Test<T> where T : struct

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

Вот что вы можете сделать ...

Я подтвердил, что оба эти метода работают для общего сравнения ссылочных типов и типов значений:

object.Equals(param, default(T))

или

EqualityComparer<T>.Default.Equals(param, default(T))

Для сравнения с оператором "==" вам необходимо использовать один из следующих методов:

Если все случаи T происходят из известного базового класса, вы можете сообщить об этом компилятору, используя ограничения универсального типа.

public void MyMethod<T>(T myArgument) where T : MyBase

Затем компилятор распознает, как выполнять операции над MyBase и не будет выдавать «Оператор» ==. Его нельзя применить к операндам типа «Т» и «Т», которые вы видите сейчас.

Другим вариантом будет ограничение T любым типом, который реализует IComparable.

public void MyMethod<T>(T myArgument) where T : IComparable

А затем используйте CompareToметод, определенный интерфейсом IComparable .

Попробуй это:

if (EqualityComparer<T>.Default.Equals(myArgument, default(T)))

это должно скомпилировать, и делать то, что вы хотите.

(Edited)

У Марка Гравелла лучший ответ, но я хотел опубликовать простой фрагмент кода, над которым я работал, чтобы продемонстрировать его. Просто запустите это в простом консольном приложении C #:

public static class TypeHelper<T>
{
    public static bool IsDefault(T val)
    {
         return EqualityComparer<T>.Default.Equals(obj,default(T));
    }
}

static void Main(string[] args)
{
    // value type
    Console.WriteLine(TypeHelper<int>.IsDefault(1)); //False
    Console.WriteLine(TypeHelper<int>.IsDefault(0)); // True

    // reference type
    Console.WriteLine(TypeHelper<string>.IsDefault("test")); //False
    Console.WriteLine(TypeHelper<string>.IsDefault(null)); //True //True

    Console.ReadKey();
}

Еще одна вещь: может кто-то с VS2008 попробовать это в качестве метода расширения? Я застрял здесь с 2005 годом, и мне любопытно посмотреть, будет ли это разрешено.

Редактировать: Вот как заставить его работать как метод расширения:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // value type
        Console.WriteLine(1.IsDefault());
        Console.WriteLine(0.IsDefault());

        // reference type
        Console.WriteLine("test".IsDefault());
        // null must be cast to a type
        Console.WriteLine(((String)null).IsDefault());
    }
}

// The type cannot be generic
public static class TypeHelper
{
    // I made the method generic instead
    public static bool IsDefault<T>(this T val)
    {
        return EqualityComparer<T>.Default.Equals(val, default(T));
    }
}

Для обработки всех типов T, включая те, где T является примитивным типом, вам нужно скомпилировать оба метода сравнения:

    T Get<T>(Func<T> createObject)
    {
        T obj = createObject();
        if (obj == null || obj.Equals(default(T)))
            return obj;

        // .. do a bunch of stuff
        return obj;
    }

Здесь будет проблема -

Если вы хотите, чтобы это работало для любого типа, default (T) всегда будет нулевым для ссылочных типов и 0 (или структура, полная 0) для типов значений.

Это, вероятно, не поведение, которое вы после, хотя. Если вы хотите, чтобы это работало универсальным образом, вам, вероятно, нужно использовать отражение для проверки типа T и обработки типов значений, отличных от ссылочных типов.

В качестве альтернативы, вы можете наложить ограничение интерфейса на это, и интерфейс может обеспечить способ проверки по умолчанию класса / структуры.

Я думаю, что вам, вероятно, нужно разделить эту логику на две части и сначала проверить на нулевое значение.

public static bool IsNullOrEmpty<T>(T value)
{
    if (IsNull(value))
    {
        return true;
    }
    if (value is string)
    {
        return string.IsNullOrEmpty(value as string);
    }
    return value.Equals(default(T));
}

public static bool IsNull<T>(T value)
{
    if (value is ValueType)
    {
        return false;
    }
    return null == (object)value;
}

В методе IsNull мы полагаемся на тот факт, что объекты ValueType не могут быть нулевыми по определению, поэтому, если значение оказывается классом, производным от ValueType, мы уже знаем, что он не равен нулю. С другой стороны, если это не тип значения, мы можем просто сравнить приведенное значение для объекта с нулевым значением. Мы могли бы избежать проверки ValueType, перейдя прямо к приведению к объекту, но это означало бы, что тип значения будет упакован, что мы, вероятно, хотим избежать, поскольку это подразумевает, что новый объект создается в куче.

В методе IsNullOrEmpty мы проверяем особый случай строки. Для всех других типов мы сравниваем значение (которое уже известно не нулю) со значением по умолчанию, которое для всех ссылочных типов равно нулю, а для типов значений обычно это какая-то форма нуля (если они целочисленные).

Используя эти методы, следующий код ведет себя так, как вы могли ожидать:

class Program
{
    public class MyClass
    {
        public string MyString { get; set; }
    }

    static void Main()
    {
        int  i1 = 1;    Test("i1", i1); // False
        int  i2 = 0;    Test("i2", i2); // True
        int? i3 = 2;    Test("i3", i3); // False
        int? i4 = null; Test("i4", i4); // True

        Console.WriteLine();

        string s1 = "hello";      Test("s1", s1); // False
        string s2 = null;         Test("s2", s2); // True
        string s3 = string.Empty; Test("s3", s3); // True
        string s4 = "";           Test("s4", s4); // True

        Console.WriteLine();

        MyClass mc1 = new MyClass(); Test("mc1", mc1); // False
        MyClass mc2 = null;          Test("mc2", mc2); // True
    }

    public static void Test<T>(string fieldName, T field)
    {
        Console.WriteLine(fieldName + ": " + IsNullOrEmpty(field));
    }

    // public static bool IsNullOrEmpty<T>(T value) ...

    // public static bool IsNull<T>(T value) ...
}

Метод расширения на основе принятого ответа.

   public static bool IsDefault<T>(this T inObj)
   {
       return EqualityComparer<T>.Default.Equals(inObj, default);
   }

Использование:

   private bool SomeMethod(){
       var tValue = GetMyObject<MyObjectType>();
       if (tValue == null || tValue.IsDefault()) return false;
   }

Заменить на ноль для упрощения:

   public static bool IsNullOrDefault<T>(this T inObj)
   {
       if (inObj == null) return true;
       return EqualityComparer<T>.Default.Equals(inObj, default);
   }

Использование:

   private bool SomeMethod(){
       var tValue = GetMyObject<MyObjectType>();
       if (tValue.IsNullOrDefault()) return false;
   }

Я использую:

public class MyClass<T>
{
  private bool IsNull() 
  {
    var nullable = Nullable.GetUnderlyingType(typeof(T)) != null;
    return nullable ? EqualityComparer<T>.Default.Equals(Value, default(T)) : false;
  }
}

Не знаю, работает ли это с вашими требованиями или нет, но вы можете ограничить T типом, который реализует интерфейс, такой как IComparable, а затем использовать метод ComparesTo () из этого интерфейса (который IIRC поддерживает / обрабатывает нулевые значения), как это :

public void MyMethod<T>(T myArgument) where T : IComparable
...
if (0 == myArgument.ComparesTo(default(T)))

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

@ilitirit:

public class Class<T> where T : IComparable
{
    public T Value { get; set; }
    public void MyMethod(T val)
    {
        if (Value == val)
            return;
    }
}

Оператор '==' не может быть применен к операндам типа 'T' и 'T'

Я не могу придумать способ сделать это без явного нулевого теста с последующим вызовом метода или объекта Equals.Equals, как предложено выше.

Вы можете разработать решение, используя System.Comparison, но на самом деле это приведет к увеличению количества строк кода и существенному увеличению сложности.

Я думаю, что вы были близки.

if (myArgument.Equals(default(T)))

Теперь это компилируется, но потерпит неудачу, если myArgument имеет значение null, что является частью того, что я тестирую. Я могу добавить явную проверку нуля следующим образом:

Вам просто нужно поменять объект, на котором вызывается метод equals, на элегантный нуль-безопасный подход.

default(T).Equals(myArgument);