C#enciende el tipo

Question

Posible duplicado:
C # - ¿Hay una mejor alternativa que esta para ''encender el tipo''?

C # no admite el encendido del tipo de un objeto. ¿Cuál es el mejor patrón para simular esto?

switch (typeof(MyObj))
case Type1:
case Type2:
case Type3:

¡Gracias!

Answer 1

Es un agujero en el juego de C #, no hay una bala de plata todavía.

Debes buscar en Google el "patrón de visitante" pero puede ser un poco pesado para ti, pero aún así debes saber algo.

Aquí hay otra opinión sobre el tema usando Linq: http://community.bartdesmet.net/blogs/bart/archive/2008/03/30/a-functional-c-type-switch.aspx

De lo contrario, algo en esta línea podría ayudar

// nasty..
switch(MyObj.GetType.ToString()){
case "Type1": etc
}
// clumsy...
if myObj is Type1 then
if myObj is Type2 then

etc.

Answer 2

Hay una respuesta simple a esta pregunta en Switch case en type c # que usa un diccionario de tipos para buscar una función lambda.

Aquí es cómo se podría usar

 var ts = new TypeSwitch()
.Case((int x) => Console.WriteLine("int"))
.Case((bool x) => Console.WriteLine("bool"))
.Case((string x) => Console.WriteLine("string"));
ts.Switch(42);
ts.Switch(false);
ts.Switch("hello");
}

También hay una solución generalizada a este problema en términos de coincidencia de patrones (ambos tipos y condiciones comprobadas en tiempo de ejecución) en la idea de coincidencia de cambio / patrón

 var getRentPrice = new PatternMatcher<int>()
.Case<MotorCycle>(bike => 100 + bike.Cylinders * 10)
.Case<Bicycle>(30)
.Case<Car>(car => car.EngineType == EngineType.Diesel, car => 220 + car.Doors * 20)
.Case<Car>(car => car.EngineType == EngineType.Gasoline, car => 200 + car.Doors * 20)
.Default(0);
var vehicles = new object[] {
new Car { EngineType = EngineType.Diesel, Doors = 2 },
new Car { EngineType = EngineType.Diesel, Doors = 4 },
new Car { EngineType = EngineType.Gasoline, Doors = 3 },
new Car { EngineType = EngineType.Gasoline, Doors = 5 },
new Bicycle(),
new MotorCycle { Cylinders = 2 },
new MotorCycle { Cylinders = 3 },
};
foreach (var v in vehicles)
{
Console.WriteLine("Vehicle of type {0} costs {1} to rent", v.GetType(), getRentPrice.Match(v));
}

Answer 3

He usado esta forma de switch-case en raras ocasiones. Incluso entonces he encontrado otra manera de hacer lo que quería. Si encuentra que esta es la única forma de lograr lo que necesita, le recomendaría la solución de @Mark H.

Si esto pretende ser una especie de proceso de decisión de creación de fábrica, existen mejores formas de hacerlo. De lo contrario, realmente no puedo ver por qué quieres usar el interruptor en un tipo.

Aquí hay un pequeño ejemplo que se expande en la solución de Mark. Creo que es una excelente manera de trabajar con tipos:

Dictionary<Type, Action> typeTests;
public ClassCtor()
{
typeTests = new Dictionary<Type, Action> ();
typeTests[typeof(int)] = () => DoIntegerStuff();
typeTests[typeof(string)] = () => DoStringStuff();
typeTests[typeof(bool)] = () => DoBooleanStuff();
}
private void DoBooleanStuff()
{
//do stuff
}
private void DoStringStuff()
{
//do stuff
}
private void DoIntegerStuff()
{
//do stuff
}
public Action CheckTypeAction(Type TypeToTest)
{
if (typeTests.Keys.Contains(TypeToTest))
return typeTests[TypeToTest];
return null; // or some other Action delegate
}

Answer 4

Lo hice una vez con una solución, espero que ayude.

string fullName = typeof(MyObj).FullName;
switch (fullName)
{
case "fullName1":
case "fullName2":
case "fullName3":
}

Answer 5

Usualmente uso un diccionario de tipos y delegados.

var @switch = new Dictionary<Type, Action> {
{ typeof(Type1), () => ... },
{ typeof(Type2), () => ... },
{ typeof(Type3), () => ... },
};
@switch[typeof(MyType)]();

Es un poco menos flexible ya que no puede pasar por casos, continuar, etc. Pero rara vez lo hago de todos modos.