c# - tipos - ¿Es posible emitir una variable a un tipo almacenado en otra variable?

tipos de datos en c# pdf

Question

Esto es lo que necesito hacer:

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

¿Se puede hacer algo como esto?

Answer 1

Puede usar el método Convert.ChangeType .

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

Answer 2

Tu pregunta original fue defectuosa porque pides tratar una variable como un tipo que no se conoce en tiempo de compilación, pero ten en cuenta que tienes cadena definida en el lado izquierdo cuando declaras tu variable. C # a partir de 3.5 está tipado estáticamente.

Una vez que la dinámica esté disponible, podrías hacer algo como esto:

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

Para cuando no sabes de qué tipo es, pero sabes que siempre admitirá el método de instancia FunctionThatExistsInBarType ();

por ahora estás obligado a usar la reflexión (o código gen que realmente equivale a más o menos lo mismo, pero más caro por adelantado y más rápido más adelante).

// 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 3

No, no puedes. C # no implementa la tipificación de pato .

Debe implementar una interfaz y transmitirlo.

(Sin embargo, hay intentos de hacerlo. Consulte Duck Typing Project para ver un ejemplo).

Answer 4

Siempre que conozca todos los tipos requeridos en tiempo de compilación, la tipificación de pato es (algo así) posible:

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)"; }
}

Salida:

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

Si termina implementando muchos métodos que básicamente hacen exactamente lo mismo, considere implementar una interfaz.

Answer 5

Dado que la dinámica se agregó a c #, creo que podemos hacerlo de esta manera:

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));
}
}