使用接口作为通用类型约束来编译错误

Question

Update:

I'll accept that to get the code to work Jon's answer to this other question is correct. And this answer answers why an interface is treated like a reference type.

I'd still like to know what the difference is though. Why is an interface not treated like a reference type when it is a generic type constraint? Is their some design reason for this? I have a feeling the only reason may be "they just are".

Original question:

I am converting a class into a generic class but I found some strange behaviour with using an interface as a type parameter. The class has a field and property which are a type of interface, for example IMagic.

public interface IMagic
{
    bool Magic { get; }
}

public class HasMagic
{
    private IMagic _magic;
    public IMagic Magic
    {
        get { return _magic; }
        set
        {
            if (value != _magic)
                _magic = value;
        }
    }

    public bool IsMagical
    {
        get { return _magic != null ? _magic.Magic : true; }
    }
}

I want to change them to instead be type T and have the class defined with the type parameter where T : IMagic . Doing this though gave me a compiler error Operator '!=' cannot be applied to operands of type 'T' and 'T' .

public class HasMagic<T> where T : IMagic
{
    private T _magic;
    public T Magic
    {
        get { return _magic; }
        set
        {
            // Compiler error here!
            if (value != _magic)
                _magic = value;
        }
    }

    public bool IsMagical
    {
        // But no error here!?
        get { return _magic != null ? _magic.Magic : true; }
    }
}

So why doesn't the generic version work? Shouldn't == and != operators work for all types?

The error only occurs in the property setter though, so it got me thinking, is the _magic field actually really a boxed IMagic or some other reference type? Indeed it can be set to null which should only work with nullable types. As the test below shows an IMagic struct (MagicStruct) works fine, but why? Changing the field and property in HasMagic to a MagicStruct gives compile errors, as you'd expect.

public class MagicTests
{
    [Fact]
    public void SomeMagicTest()
    {
        var mag = new HasMagic();
        Assert.True(mag.IsMagical);

        mag.Magic = new MagicClass();
        Assert.False(mag.IsMagical);

        mag.Magic = new MagicStruct();
        Assert.True(mag.IsMagical);

        mag.Magic = null;
        Assert.True(mag.IsMagical);
    }
}

public class MagicClass : IMagic
{
    public bool Magic { get { return false; } }
}

public struct MagicStruct : IMagic
{
    public bool Magic { get { return true; } }
}

If it's of any relevance I'm using .Net framework v4.5.2.

Answer 1

T is a type argument and can be a class or a struct, because of that the compiler won't let you perform actions that doesn't exist in a class or a struct. You can try it like this:

public T Magic
    {
        get { return _magic; }
        set
        {
            // Compiler error here!
              if (!EqualityComparer<T>.Default.Equals(_magic, value))
                _magic = value;
        }
    }

Or you can just use Equals inside your code

 public T Magic
    {
        get { return _magic; }
        set
        {
            // Compiler error here!
            if (!value.Equals(_magic))
                _magic = value;
        }
    }

Answer 2

You cannot use != ( == ) on generic types.

a possible solution would be made IMagic to implement IComparable

public interface IMagic : IComparable

and then use CompareTo

 if (value.CompareTo(_magic) != 0)

you can write your own implementation of CompareTo method

 public int CompareTo(object obj) {

    }

update

if you can't edit IMagic try adding a property to HasMagic class like this

public Func<T, T, bool> FuncEvaluate { get; set; } 

and then check in this way

  public T Magic
    {
        get { return _magic; }
        set
        {
            if (FuncEvaluate != null)
            {
                if (!FuncEvaluate(value, _magic))
                {
                    _magic = value;
                }
            }
            else
            {
                throw new NotImplementedException();
            }
        }
    }

and when you decide to use the class you should set the function to compare objects maybe checking typeof(T).IsValueType

Answer 3

T can be a value type or a reference type; you didn't contrain it. The != (and ==) operator (reference comparison) is only defined for reference types, not for value types.

There are several solutions; You can constrain T to be a reference type:

public class HasMagic<T> where T : IMagic, class

You can also use Equals(). or object.ReferenceEquals(). And maybe some other solutions I didn't think of.

Edit: I just noticed you don't even need != in the setter, so this whole problem becomes mute.