处理泛型和静态类型之间的交互

Question

I am writing a generic method where I would like a different execution path to occur based on the type of the generic Type parameter. The different execution paths are statically typed, eg

public static T Get<T>(this NameValueCollection collection, string name) where T : struct
{
    //Perform test on type, if it matches, delegate to statically typed method.
    if (typeof(T) == typeof(int)) return (T)(object)GetInt32(collection, name);
    else if (typeof(T) == typeof(DateTime)) return (T) (object) GetDateTime(collection, name);

    //Other types parsed here...

    //If nothing matched, return default.
    return default(T);
}

The only way I've found to be able to use the return result of the static execution path is to box it as an object, and then cast it to 'T'.

To me this defeats the purpose of using a generic method in the first place (other than gaining some syntactical sugar). Does anyone know a way of being able to return the int value as T, in cases where we have already established that T is of type int?

I was looking at using a var of type 'dynamic' but read that it just end sup using object behind the scenes anyway.

Is this, perhaps, the extent of generics?

--

Updated to include my final approach, based on smartcaveman's reply, which uses the type resolution of generic static classes to determine which 'parsing' method to use, without boxing or using dynamic.

public class StringParser
{
    private class Getter<T>
    {
        private static readonly ConcurrentDictionary<StringParser, Getter<T>> Getters = new ConcurrentDictionary<StringParser, Getter<T>>();

        public Func<string, T> Get { get; set; }

        private Getter() {}

        public static Getter<T> For(StringParser stringParser)
        {
            return Getters.GetOrAdd(stringParser, x => new Getter<T>());
        }
    }

    public virtual T Get<T>(string value)
    {
        var get = Getter<T>.For(this).Get;

        if (get == null) throw new InvalidOperationException(string.Format("No 'get' has been configured for values of type '{0}'.", typeof (T).Name));

        return get(value);
    }

    public void SetupGet<T>(Func<string, T> get)
    {
        Getter<T>.For(this).Get = get;
    }
}

Fairly simple to use:

public static void Usage()
{
    StringParser parser = new StringParser();
    parser.SetupGet(Int32.Parse);            
    int myInt = parser.Get<int>("3");            
}

The trick of smartcaveman's method is that generic static classes with different type parameters are actually considered different Types, and do not share static members.

Very cool stuff, thank you!

Answer 1

Unless you can use a strongly typed keyed collection (eg Dictionary<string,int> ), you're going to have to box the value. There is not a work around.

That being said, it is not clear how your method is anymore useful than a non-generic version. I'm not seeing the calling code, but it seems like the only relevant case is the int, since every other case just returns the default value.

Also, you're correct about dynamic .

Update

The idea of using a dictionary would apply if there were not multiple possible types of value. However, if there were only 1 possible type of value (eg int) then you could use a Dictionary<string,int> instead of a NameValueCollection .

I wrote a small sample that might give you ideas as to how you could keep strong typing with a custom class. I have omitted null-checking and argument validation logic, and this has neither been tested nor compiled. However, the basic idea should be clear. You could use the ValueRegistry class with your NameValueCollection as follows.

 //  around application start, configure the way values are retrieved   
 //  from names for different types.  Note that this doesn't need to use
 //  a NameValueCollection, but I did so to stay consistent.

 var collection = new NameValueCollection();
 ValueRegistry.Configure<int>(name => GetInt32(collection,name));
 ValueRegistry.Configure<DateTime>(name => GetDateTime(collection,name));

 // where you are going to need to get values
 var values = new ValueRegistry();      
 int value = values.Get<int>("the name"); // nothing is boxed

public class ValueRegistry
{
       private class Provider<T> 
            where T : struct
       {
             private static readonly ConcurrentDictionary<ValueRegistry,Provider<T>> Providers = new ConcurrentDictionary<ValueRegistry,Provider<T>>();
              public static Provider<T> For(ValueRegistry registry)
              {
                  return Providers.GetOrAdd(registry, x => new Provider<T>());
              }
              private Provider(){
                 this.entries = new Dictionary<string,T>();
              }
              private readonly Dictionary<string,T> entries;
              private static Func<string,T> CustomGetter;
              public static void Configure(Func<string,T> getter) { CustomGetter = getter;}

              public static T GetValueOrDefault(string name)
              {
                   T value;
                    if(!entries.TryGetValue(name, out value))
                       entries[name] = value = CustomGetter != null ? CustomGetter(name) : default(T);
                     return value;
              }
       }

       public T Get<T>(string name) 
          where T : struct
       {
           return Provider<T>.For(this).GetValueOrDefault(name);
       }

       public static void Configure<T>(Func<string,T> customGetter)
                  where T : struct
       {
          Provider<T>.Configure(customGetter);      
       }

}

Answer 2

That kind of dispatch is possible using dynamic features introduced in C# 4.0 (and next versions support it too).

This code does what you've expressed here:

public static T Get<T>(this NameValueCollection collection, string name) where T : struct
{
    T v = default(T);
    dynamic indicator = v;

    return GetValue(collection, name, indicator);
}

static int GetValue(NameValueCollection collection, string name, int indicator)
{
    return 110;
}

static DateTime GetValue(NameValueCollection collection, string name, DateTime indicator)
{
    return DateTime.Now;
}

// ... other helper parsers

// if nothing else matched
static object GetValue(NameValueCollection collection, string name, object indicator)
{
    return indicator;
}

To perform a smoke test:

Console.WriteLine(Get<int>(null, null));
Console.WriteLine(Get<DateTime>(null, null));
Console.WriteLine(Get<double>(null, null));

Answer 3

Yes you have to box (cast value type to object) explicitly before casting it to generic T even you have stated where T : struct . You can do something like below but I can not say it is more elegant.

return (T) Convert.ChangeType(GetInt32(collection, name), typeof (int));

Answer 4

You could use a Dictionary to handle this.

private static Dictionary<Type, Func<NameValueCollection, string, T>> _typeMap = new Dictionary<Type, Func<NameValueCollection, string, T>>();

static Constructor()
{
    _typeMap[typeof(DateTime)] = (nvc, name) => { return (T)GetDateTime(nvc, name); };
    // etc
}


public static T Get<T>(this NameValueCollection collection, string name) where T : struct
{
    return _typeMap[typeof(T)](collection, name);
}