Est-il possible de convertir une variable en type stocké dans une autre variable?

Question

C'est ce que je dois faire:

object foo = GetFoo(); 
Type t = typeof(BarType); 
(foo as t).FunctionThatExistsInBarType(); 

Peut-être quelque chose comme ça fait?

Answer 1

Non, vous ne pouvez pas. C# n'implémente pas duck typing.

Vous devez implémenter une interface et lancer la conversion.

(Cependant, il y a des tentatives de le faire. Regardez Duck Typing Project un exemple.)

Answer 2

Vous pouvez utiliser la méthode Convert.ChangeType.

object foo = GetFoo(); 
Type t = typeof(string); 
string bar = (string)Convert.ChangeType(foo, t); 

Answer 3

Votre question était entachée d'erreurs dans ce que vous demandez de traiter une variable comme un type qui ne sait pas au moment de la compilation, mais notez que vous avez chaîne définie sur le côté gauche lorsque vous déclarez votre variable. C# à partir de 3.5 est typé statiquement.

vous pourriez Une fois dynamique est disponible faire quelque chose comme ceci:

dynamic foo = GetFoo(); 
foo.FunctionThatExistsInBarType(); 

lorsque vous ne savez pas ce que le type est mais vous savez qu'il soutiendra toujours la méthode d'instance FunctionThatExistsInBarType(); Pour l'instant vous êtes obligé d'utiliser la réflexion (ou le code gen qui revient à peu près la même chose mais plus cher à l'avant et plus vite plus tard).

// any of these can be determined at runtime 
Type t = typeof(Bar); 
string methodToCall = "FunctionThatExistsInBarType"; 
Type[] argumentTypes = new Type[0]; 
object[] arguments = new object[0]; 
object foo; 
// invoke the method - 
// example ignores overloading and exception handling for brevity 
// assumption: return type is void or you don't care about it 
t.GetMethod(methodToCall, BindingFalgs.Public | BindingFlags.Instance) 
    .Invoke(foo, arguments); 

Answer 4

A condition que vous connaissez tous les types nécessaires à la compilation, duck typing est (un peu) possible:

class BarFoo {} 
class Foo {} 
class Bar {} 

class Program 
{ 
    static void Main() 
    { 
     var foo = new Foo(); 
     var bar = new Bar(); 
     var barfoo = new BarFoo(); 

     Console.WriteLine(DoStuff(foo)); 
     Console.WriteLine(DoStuff(bar)); 
     Console.WriteLine(DoStuff(barfoo)); 

    } 

    static string DoStuff(Foo foo) { return "DoStuff(Foo foo)"; } 
    static string DoStuff(Bar bar) { return "DoStuff(Bar bar)"; } 
    static string DoStuff(Base fb) { return "DoStuff(object fb)"; } 
} 

Sortie:

Dostuff(Foo foo) 
Dostuff(Bar bar); 
DoStuff(object fb); 

Si vous finissez par mettre en œuvre un grand nombre de méthodes qui font exactement la même chose, envisager d'implémenter une interface.

Answer 5

Depuis la dynamique ont été ajoutés à C#, je pense que nous pouvons le faire de cette façon:

class Program { 
    static void Main(string[] args) { 
     List<int> c = new List<int>(); 
     double i = 10.0; 
     Type intType = typeof(int); 
     c.Add(CastHelper.Cast(i, intType)); // works, no exception! 
    } 
} 

class CastHelper { 
    public static dynamic Cast(object src, Type t) { 
     var castMethod = typeof(CastHelper).GetMethod("CastGeneric").MakeGenericMethod(t); 
     return castMethod.Invoke(null, new[] { src }); 
    } 
    public static T CastGeneric<T>(object src) { 
     return (T)Convert.ChangeType(src, typeof(T)); 
    } 
}