Question

I am having an issue trying to recursively use a generic function for a deserialization algorithm. I am loading in the variables from an XElement by their value. However, if they are no a primitive, I have to recursively do the same operation on that object. However, that object is not the same type as the current one being processed. So for instance if I have

 class someObject
 {
      otherObject obj = new otherObject();
 }

 class otherObject
 {
     int someInt = 123;
 }

the deserializer recursively goes into the other object. However, the issue is that I have to change the type of the generic method dynamically (ie. I do not know what type it will be at compile time). The algorithm is as follows:

public static T deserialize<T>(XNode element)
    where T : new()
{
    XElement currentNode = (XElement)element;

    FieldInfo[] fields = getFields<T>();

    T returnValue = new T();

    foreach (FieldInfo field in fields)
    {
        if (field.FieldType.IsPrimitive)
        {
            field.SetValue(returnValue, currentNode.Element(field.Name).Value);
        }
        else
        {
            //The issue is on the following line
            field.SetValue(returnValue, deserialize<???>(currentNode.Element(field.Name).Value));
        }
    }
}

I have seen plenty of documentation on how to dynamically create typed lists and objects. However, I cannot find anything that deals with dynamically switching the type on a generic method call.

Any help is greatly appreciated! Let me know if am not being clear…

Answer 1

I would make the generic method call another private non-generic method that uses a different means of creating the instance instead of new T(). The outer generic method will be convenient for a caller of the method, so they don’t have to cast the response. Internally, your code will be simpler.

Note that the .NET framework’s deserialisation methods all at least have overloads that take a Type instance instead of a generic type parameter (<T>). This is for the reason you’re discovering — sometimes you have the type as an object, and then you can’t (sensibly) call a generic method and pass that type parameter.