在C＃中安全地转换泛型类型

Question

How can I safely cast and return m_obj depending on the given Generic type.

private IObject m_obj;
public bool TryGetAs<T>(out T value) where T :IObject
{
    value = m_obj as T; // The type parameter 'T' cannot be used with the 'as' operator because it does not have a class type constraint nor a 'class' constraint

    // value = (T)m_obj; This compiles!

    if (value != null)
        return true;

    return false;
}

I know that if instead if m_obj I had a list I could simply do this:

private readonly IList<Object> m_objects;

internal IList<T> Collect<T>() where T : IObject
{
    return m_objects.OfType<T>().ToList();
}

But I cannot find a solution for the former code.

public interface IObject
{

}

My answer:

    public bool TryGetAs<T>(out T value) where T :IObject
    {
        value = default(T);
        if (!(m_obj is T))
            return false;

        value = (T)m_obj;
        return true;
    }

Answer 1

The as keyword works with reference types.

The compiler doesn't know that T is indeed a reference type, so it shouts at you and won't compile.
You can tell the compiler that it's a reference type by adding the class constraint before the IObject constraint. Now you can safely cast.

Answer 2

The as operator is reserved for reference types. If T is always a reference type, the solution is to add a class constraint to TryGetAs<T> . If T can also be a value type, this is not an option. In this case you can use the is operator:

public bool TryGetAs<T>(out T value) where T : IObject
{
    if(m_obj is T)
    {
        value = (T)m_obj;
        return true;
    }
    else
    {
        value = default(T);
        return false;
    }
}

In C# 7.0 you can simplify it like this (and improve performance since you don't need an is cast and then another type cast):

public bool TryGetAs<T>(out T value) where T : IObject
{
    if(m_obj is T tValue)
    {
        value = tValue;
        return true;
    }
    else
    {
        value = default(T);
        return false;
    }
}

Answer 3

public bool TryGetAs<T>(out T value) where T : class, IObject
{
    value = m_obj as T;

    return (value != null);
}

will act the same as your final solution, as well as likely being faster (since a null check is faster than an is check).

There is no benefit in not including the class modifier, if all of your IObject implementations are reference types ( class ) not value types ( struct ).