TryCast<T> method

Question

This isn't urgent, it is more along the lines of trivia or a challenge. The solution works fine as it is, but I suspect it could be better.

What follows is a method I came up with a while back in a rather ugly situation where I need to make a "best effort" to try casting an object of an unrestricted unknown type TO an unrestricted unknown type. The code has just been bugging me. It seems that there should be a more elegant way to do this, but I wanted to get that "Best Effort" part right.

The methods follows the "Try" convention. It accepts an object "value" and an out param of type T, "result." It attempts to cast value into result as type T. If it succeeds, it returns true. If it cannot, it sets result = default(T) and returns false.

It feels like I'm going to lots of trouble in the method. I'd be open to suggestions to streamline this a bit. Comments included here are mostly not in the original... just to explain why a few things were done the way they were done.

/// <summary>
///   Tries to cast <paramref name="value" /> to an instance of type <typeparamref name="T" /> .
/// </summary>
/// <typeparam name="T"> The type of the instance to return. </typeparam>
/// <param name="value"> The value to cast. </param>
/// <param name="result"> When this method returns true, contains <paramref name="value" /> cast as an instance of <typeparamref
///    name="T" /> . When the method returns false, contains default(T). </param>
/// <returns> True if <paramref name="value" /> is an instance of type <typeparamref name="T" /> ; otherwise, false. </returns>
public static bool TryCast<T>(this object value, out T result)
{
    var destinationType = typeof(T);
    var inputIsNull = (value == null || value == DBNull.Value);

    /*
     * If the given value is null, we'd normally set result to null and be done with it.
     * HOWEVER, if T is not a nullable type, then we can't REALLY cast null to that type, so
     * TryCast should return false.
     */
    if (inputIsNull)
    {
        // If T is nullable, this will result in a null value in result.
        // Otherwise this will result in a default instance in result.
        result = default(T);

        // If the input is null and T is nullable, we report success.  Otherwise we report failure.
        return destinationType.IsNullable();
    }

    // Convert.ChangeType fails when the destination type is nullable.  If T is nullable we use the underlying type.
    var underlyingType = Nullable.GetUnderlyingType(destinationType) ?? destinationType;

    try
    {
        /*
         * At the moment I cannot remember why I handled Guid as a separate case, but
         * I must have been having problems with it at the time or I'd not have bothered.
         */
        if (underlyingType == typeof(Guid))
        {
            if (value is string)
            {
                value = new Guid(value as string);
            }
            if (value is byte[])
            {
                value = new Guid(value as byte[]);
            }

            result = (T)Convert.ChangeType(value, underlyingType);
            return true;
        }

        result = (T)Convert.ChangeType(value, underlyingType);
        return true;
    }
    catch (Exception ex)
    {
        // This was originally used to help me figure out why some types weren't casting in Convert.ChangeType.
        // It could be removed, but you never know, somebody might comment on a better way to do THAT to.
        var traceMessage = ex is InvalidCastException || ex is FormatException || ex is OverflowException
                                ? string.Format("The given value {0} could not be cast as Type {1}.", value, underlyingType.FullName)
                                : ex.Message;
        Trace.WriteLine(traceMessage);

        result = default(T);
        return false;
    }
}

Answer 1

For casting, I have a much simpler method in mind:

public static bool TryCast<T>(this object obj, out T result)
{
    if (obj is T)
    {
        result = (T)obj;
        return true;
    }

    result = default(T);
    return false;
}

You don't need to detect nullable types manually since is operator already checks for it: 5 is int? returns true, so the following code writes 5 to the console.

int value = 5;
int? result;
if (value.TryCast(out result))
    Console.WriteLine(result);

The following writes nothing because TryCast returns false.

string value = "5";
int? test;
if (value.TryCast(out test))
    Console.WriteLine(test);

Lastly, the following should write two lines that are "test 1" and "test 2".

var list = new List<string>();
list.Add("test 1");
list.Add("test 2");

IEnumerable<string> enumerable;
if (list.TryCast(out enumerable))
    foreach (var item in enumerable)
        Console.WriteLine(item);

I'm really against this approach:

if (underlyingType == typeof(Guid))
{
    if (value is string)
    {
        value = new Guid(value as string);
    }
    else if (value is byte[])
    {
        value = new Guid(value as byte[]);
    }

    //...

If you want this kind of custom conversion features, my suggestion would be to keep your converters in a static, thread-safe Converter collection. A sample converter class can be like this:

public abstract class Converter
{
    private readonly Type from; // Type of the instance to convert.
    private readonly Type to;   // Type that the instance will be converted to.

    // Internal, because we'll provide the only implementation...
    // ...that's also why we don't check if the arguments are null.
    internal Converter(Type from, Type to)
    {
        this.from = from;
        this.to = to;
    }

    public Type From { get { return this.from; } }
    public Type To { get { return this.to; } }

    public abstract object Convert(object obj);
}

And the implementation is:

// Sealed, because this is meant to be the only implementation.
public sealed class Converter<TFrom, TTo> : Converter
{
    Func<TFrom, TTo> converter; // Converter is strongly typed.

    public Converter(Func<TFrom, TTo> converter)
        : base(typeof(TFrom), typeof(TTo)) // Can't send null types to the base.
    {
        if (converter == null)
            throw new ArgumentNullException("converter", "Converter must not be null.");

        this.converter = converter;
    }

    public override object Convert(object obj)
    {
        if (!(obj is TFrom))
        {
            var msg = string.Format("Object is not of the type {0}.", this.From.FullName);
            throw new ArgumentException(msg, "obj");
        }

        // Can throw exception, it's ok.
        return this.converter.Invoke((TFrom)obj);
    }
}

To initialize it:

var int32ToString = new Converter<int, string>(i => i.ToString());
var stringToInt32 = new Converter<string, int>(s => int.Parse(s));

// Converters should be a thread-safe collection of our abstract `Converter` type.
Converters.Add(int32ToString);
Converters.Add(stringToInt32);

With support for the custom converters, the final TryCast method becomes this:

public static bool TryCast<T>(this object obj, out T result)
{
    if (obj is T)
    {
        result = (T)obj;
        return true;
    }

    // If it's null, we can't get the type.
    if (obj != null)
    {
        var converter = Converters.FirstOrDefault(c =>
            c.From == obj.GetType() && c.To == typeof(T));

        // Use the converter if there is one.
        if (converter != null)
            try
            {
                result = (T)converter.Convert(obj);
                return true;
            }
            catch (Exception)
            {
                // Ignore - "Try*" methods don't throw exceptions.
            }
    }

    result = default(T);
    return false;
}

Answer 2

There are built-in converters in System.ComponentModel.TypeDescriptor namespace (System.dll). You don't have to write your own array and you have access to a bunch of pre-existing converters as well.

This is a modified version to account for this:

public static bool TryCast<T>(object obj, out T result)
{
    result = default(T);
    if (obj is T)
    {
        result = (T)obj;
        return true;
    }

    // If it's null, we can't get the type.
    if (obj != null)
    {
        var converter = TypeDescriptor.GetConverter(typeof (T));
        if(converter.CanConvertFrom(obj.GetType()))
            result = (T) converter.ConvertFrom(obj);
        else
            return false;

        return true;
    }

    //Be permissive if the object was null and the target is a ref-type
    return !typeof(T).IsValueType; 
}

(of course the permissiveness depends on how you plan yo use it, I rather not have a try around the conversion, since I check for it)

Answer 3

I used GettnDer's answer and updated it to make use of the c# 8 language features eliminating some of the need for casting as well as show how one can enable "123" to be parsed and test for type, same goes for IP addresses etc, lots of things support parsing. I have an interface that denotes something implements IParse so I test if

if(T is IParse parse)
{
 return parse.TryParse<T>(obj.ToString(),out result );
}

There are lots of "helpers" you can think of... The tryCast method that I think solves the question and most comments using the new features efficiently could be like:

public static bool TryCast<T>(object obj, out T result)
{
    //will cover 99%
    if (obj is T value)
    {
        result = value;
        return true;
    }

    // will cover most plausible data type
    if (obj is not null)
    {
        var str = obj.ToString();
        switch (true)
        {
            case var _ when typeof(T) == typeof(string):
                result = (T)obj;
                return true;
            case var _ when typeof(T) == typeof(int) && int.TryParse(str, out var aValue):
                result = (T)(object)aValue;
                return true;
            case var _ when typeof(T) == typeof(long) && long.TryParse(str, out var aValue):
                result = (T)(object)aValue;
                return true;
            case var _ when typeof(T) == typeof(DateTime) && DateTime.TryParse(str, out var aValue):
                result = (T)(object)aValue;
                return true;
            case var _ when typeof(T) == typeof(byte) && byte.TryParse(str, out var aValue):
                result = (T)(object)aValue;
                return true;
            case var _ when typeof(T) == typeof(short) && short.TryParse(str, out var aValue):
                result = (T)(object)aValue;
                return true;
        }

    }

This will work in all frameworks that support c# 8 so .net core 3.1 Net 5.0 and .net standard 2.1