当我传递HashSet时，为什么我的泛型类型方法认为T是system.object

Question

So I'm trying to figure out why my generic method is losing type information.

When I pass in reflected data (in this example T = HashSet) the code thinks T = system.object. When I pass in non-reflected data, my T is correctly typed as HashSet type.

The only difference in my example is that in my first call I am passing directly a HashSet, and in my second call I am passing in an object with a HashSet property, and using reflection to get the HashSet and pass it in.

Both HashSets get executed by the exact same code, yet T is different each time.

I've managed to hack together a "workaround" where I pass in as a second parameter, the correct type, and from there I can get my desired results.

However, this seems hacky and I'd like to know why I have to do this workaround to get my desired results.

Can anybody explain why I am observing what I'm observing and how I can get my T type to be correct each and every time without passing in the type twice?

using System;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json;

public class Program
{
    public static void Main()
    {
        var simple = new HashSet<string>();
        simple.Add("1");
        simple.Add(" 1 ");
        Console.WriteLine("Simple Before => " + JsonConvert.SerializeObject(simple));
        simple = simple.DeepTrimAll();
        Console.WriteLine("Simple After => " + JsonConvert.SerializeObject(simple));
        Console.WriteLine();
        var complex = new Complex();
        complex.HS = new HashSet<string>();
        complex.HS.Add("1");
        complex.HS.Add(" 1 ");
        Console.WriteLine("Complex Before => " + JsonConvert.SerializeObject(complex));
        complex = complex.DeepTrimAll();
        Console.WriteLine("Complex After => " + JsonConvert.SerializeObject(complex));
    }
}

public class Complex
{
    public HashSet<string> HS
    {
        get;
        set;
    }
}

public static class Ext
{
    public static T DeepTrimAll<T>(this T context, Type t)where T : class
    {
        if (context is IEnumerable<string>)
        {
            var type = typeof (T);
            Console.WriteLine("T = " + type.ToString() + " , t = " + t.ToString());
            var list = new List<string>(context as IEnumerable<string>);
            for (int i = 0; i < list.Count(); i++)
            {
                list[i] = list[i].Trim();
            }

            var res = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(list), t);
            return (T)res;
        }

        var properties = typeof (T).GetProperties().Where(x => x.CanRead && x.CanWrite).ToList();
        foreach (var propertyInfo in properties)
        {
            var propType = propertyInfo.PropertyType;
            var value = propertyInfo.GetValue(context, null);
            if (propType == typeof (string))
            {
                if (!string.IsNullOrWhiteSpace(value.ToString()))
                {
                    propertyInfo.SetValue(context, value.ToString().Trim());
                }
            }
            else if (!propType.IsEnum && !propType.IsPrimitive)
            {
                var newValue = value.DeepTrimAll(propType);
                propertyInfo.SetValue(context, newValue);
            }
        }

        return context;
    }

    public static T DeepTrimAll<T>(this T context)where T : class
    {
        return context.DeepTrimAll(typeof (T));
    }
}

This example produces the following results:

Simple Before => ["1"," 1 "]
T = System.Collections.Generic.HashSet`1[System.String] , t = System.Collections.Generic.HashSet`1[System.String]
Simple After => ["1"]

Complex Before => {"HS":["1"," 1 "]}
T = System.Object , t = System.Collections.Generic.HashSet`1[System.String]
Complex After => {"HS":["1"]}

dotNetFiddle

Answer 1

Type arguments are inferred at compile time, not at execution time (usually - see later).

When you call complex.DeepTrimAll() , it's equivalent to:

Ext.DeepTrimAll<Complex>(complex);

That then calls DeepTrimAll<Complex>(complex, typeof(Complex)) .

Now Complex doesn't implement IEnumerable<string> , so the code goes into the else branch of your if statement, which calls DeepTrimAll recursively, like this:

var propType = propertyInfo.PropertyType;
var value = propertyInfo.GetValue(context, null);
...
var newValue = value.DeepTrimAll(propType);

Now the compile-time type of value here is object , so type inference kicks in at compile time and converts that to:

var newValue = DeepTrimAll<object>(value, propType);

That's why you're getting the output you are.

Now, you could use dynamic typing here instead:

var propType = propertyInfo.PropertyType;
dynamic value = propertyInfo.GetValue(context, null);
...
var newValue = DeepTrimAll(value, propType);

That's no longer calling DeepTrimAll as an extension method, because dynamic typing doesn't handle extension methods. But now type inference is performed dynamically, so it will call DeepTrimAll<HashSet<string>>(value, propType) .

I would not suggest doing this though - I'd probably change your DeepTrimAll(T context, Type t) to just DeepTrimAll(object context, Type t) and always use t instead of typeof(T) .