Caster un type générique

Version imprimable

Salut,

j'ai un type générique et je voudrais le caster. est-ce que vous pensez que c'est possible ? Je comptais faire un truc du genre :
Code:

1 2 3 4 5 6 7 8 9 10 private T convertStringTo<T>(string value) { if (typeof(T).Equals(typeof(string))) return value; if (typeof(T).Equals(typeof(int))) return int.parse(value); // etc, etc. throw new Exception ("unhandle type"); }
Mais ça me marche pas, erreur à la compilation parce qu'il refuse de comprendre que j'ai vérifié le type T avant le return...

Des idées ?

13/10/2008, 16h55
StormimOn

Ta méthode doit renvoyer un objet de type T alors que tu renvoies une string, un int, ... bref tout sauf un objet de type T. Normal que ça gueule.

Bah oui, j'avais compris le problème, merci pour l'aide :)

Non, plus franchement, je trouve toujours pas, du coup je complexifie un peu plus, mais ça "gueule" au même endroit :(, enfin dans le même style...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
/// <summary>
/// get a configuration as a int, store into the cache
/// </summary>
/// <param name="key">the name of the config</param>
/// <param name="defaultValue">the default value if any problem occurs</param>
/// <returns></returns>
public T getConfiguration<T>(string key, T defaultValue)
{
   if (typeof(T).Equals(typeof(int)))
   {
      converter<int> deleg = int.Parse;
      return cacheConfig<int>(_iConfigurations, key, defaultValue, deleg);
   }
}
 
/// <summary>
/// Convertit un string dans un type donné
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="value"></param>
/// <returns></returns>
private delegate T converter<T>(string value);
 
/// <summary>
/// cache the configuration into the right cache
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cache"></param>
/// <param name="key"></param>
/// <param name="defaultValue"></param>
/// <param name="convert"></param>
/// <returns></returns>
private T cacheConfig<T>(IDictionary<string, T> cache, string key, T defaultValue, converter<T> convert)
{
   try 
   {
      if (!cache.ContainsKey(key))
         cache[key] = convert(_controller.AskConfiguration(key));
      return cache[key];
   }
   catch(Exception)
   {
      return defaultValue;
   }
}

Bon finalement je recupère mon delegate et la méthode cacheConfig<T> et je crée autant de méthode GetConfiguration que nécessaire :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 /// <summary>
/// get a configuration as a int, store into the cache
/// </summary>
/// <param name="key">the name of the config</param>
/// <param name="defaultValue">the default value if any problem occurs</param>
/// <returns></returns>
public int GetConfiguration(string key, int defaultValue)
{
    return cacheConfig(_iConfigurations, key, defaultValue, int.Parse);
}
 
/// <summary>
/// get a configuration as a bool, store into the cache
/// </summary>
/// <param name="key">the name of the config</param>
/// <param name="defaultValue">the default value if any problem occurs</param>
/// <returns></returns>
public bool GetConfiguration(string key, bool defaultValue)
{
    return cacheConfig(_bConfigurations, key, defaultValue, bool.Parse);
}

Voili voilou

A+

13/10/2008, 20h17
ThomasR

et Direcast(T,value) ?
Sinon pourquoi ne pas créé un constructeur de T à partir d'une string ?

Code:

1 2 3 4 5 6 7 8 9 public T getConfiguration<T>(string key, T defaultValue) { if (typeof(T).Equals(typeof(int))) { converter<int> deleg = int.Parse; return cacheConfig<int>(_iConfigurations, key, defaultValue, deleg); } }
Ici tu essaye de renvoyer un objet de type cachedConfig alors que la méthode attends un objet de type T. Si tu as défini que ta méthode renverra un objet de type T alors elle doit renvoyer un objet de ce type...

Par contre tu dois envoyer quelquechose quoi qu'il se passe...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 private T cacheConfig<T>(IDictionary<string, T> cache, string key, T defaultValue, converter<T> convert) { try { if (!cache.ContainsKey(key)) cache[key] = convert(_controller.AskConfiguration(key)); return cache[key]; } catch(Exception) { return defaultValue; } }
tu peux renvoyer default(T) à la place de defaultValue.