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

Non vous ne pouvez pas. C # n’implémente pas la frappe de canard .

Vous devez implémenter une interface et y lancer un cast.

(Cependant, il existe des tentatives pour le faire. Regardez Duck Typing Project pour un exemple.)

Vous pouvez utiliser la méthode Convert.ChangeType .

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

Votre question initiale était erronée en ce sens que vous demandiez de traiter une variable comme un type inconnu à la compilation, mais notez que vous avez défini une chaîne à gauche lorsque vous déclarez votre variable. C # à partir de 3.5 est typé statiquement.

Une fois que dynamic est disponible, vous pouvez faire quelque chose comme ceci:

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

Car si vous ne connaissez pas le type mais que vous savez qu’il prendra toujours en charge la méthode d’instance FunctionThatExistsInBarType ();

pour le moment, vous êtes obligé d’utiliser la reflection (ou le code gen, qui revient à peu près à la même chose mais qui coûte plus cher à l’avance et plus rapidement plus tard).

 // any of these can be determined at runtime Type t = typeof(Bar); ssortingng 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); 

Puisque la dynamic a été ajoutée à c #, je pense que nous pouvons le faire de cette façon:

 class Program { static void Main(ssortingng[] args) { List c = new List(); 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(object src) { return (T)Convert.ChangeType(src, typeof(T)); } } 

Si vous connaissez tous les types requirejs au moment de la compilation, la saisie de type de canard est (en quelque sorte) 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 ssortingng DoStuff(Foo foo) { return "DoStuff(Foo foo)"; } static ssortingng DoStuff(Bar bar) { return "DoStuff(Bar bar)"; } static ssortingng DoStuff(Base fb) { return "DoStuff(object fb)"; } } 

Sortie:

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

Si vous finissez par implémenter un grand nombre de méthodes qui font exactement la même chose, envisagez de mettre en place une interface.