Sélection d'une fonction à appeler basée sur une énumération sans if-else (ou un commutateur)

Bien que je ne le recommande pas, vous pouvez utiliser la réflexion pour créer une instance de la classe par son nom. Quelque chose comme ça (non testé):

var draw = (IDrawingObject)Activator.CreateInstance("AssemblyName", "Draw" + shape.ToString());
draw.Draw();

Ce code n'est pas vraiment plus propre qu'un commutateur , sauf si le dictionnaire est utilisé par plusieurs méthodes. La façon dont les objets de dessin et les interfaces sont utilisés, toutes les méthodes Draw pourraient facilement être des méthodes statiques sur une classe.

Pour répondre à la question exacte, on pourrait utiliser Dictionary.TryGetValue :

var drawer= shapes switch 
            {
                Shapes.Circle   =>new DrawingTriangle(),
                Shapes.Rectangle=>new DrawingRectangle(),
                Shapes.Triangle =>new DrawingCircle(),
                _ => ???
            };
drawer.Draw(c);

Toutes les méthodes Draw peuvent devenir des méthodes statiques puisqu'elles n'utilisent aucun membre d'instance:

private static IDictionary<Shapes, Action<Color>> Mapper = new Dictionary<Shapes, Action<Color>>
{
    [Shapes.Circle]    = DrawTriangle.Draw,
    [Shapes.Rectangle] = DrawRectangle.Draw,
    [Shapes.Triangle]  = DrawCircle.Draw
};

Sinon:

private static IDictionary<Shapes, Action<Color>> Mapper = new Dictionary<Shapes, Action<Color>>
{
    [Shapes.Circle]= (Color c) => DrawTriangle.Draw(c),
    [Shapes.Rectangle]= (Color c) => DrawRectangle.Draw(c),
    [Shapes.Triangle]=(Color c) => DrawCircle.Draw(c)
};

Mise à jour

BTW que la syntaxe montre, il se passe quelque chose de bizarre . L'utilisation de types au lieu d'une énumération aurait empêché de dessiner des cercles lorsqu'un cercle est demandé

Nous aurions besoin d'en savoir plus sur l'origine de Shapes , ou pourquoi les interfaces sont utilisées pour créer une meilleure implémentation, et évitez d'utiliser la mauvaise implémentation

Juste pour le plaisir d'ailleurs, on pourrait utiliser les expressions de commutation de C # 8 avec les interfaces:

public static void Draw(Shapes s, Color c)
{
    if (Mapper.TryGetValue(s,out var act))
    {
        act(c);
    }
 }

Jetez un œil à vos méthodes Draw : changent-elles réellement quelque chose sur l'une des classes DrawTriangle , DrawRectangle , etc.? Sinon, vous n'avez pas besoin de créer une nouvelle instance à chaque fois que vous voulez dessiner quelque chose. Au lieu de cela, vous pouvez simplement stocker une seule instance de DrawTriangle dans votre dictionnaire Mapper :

public static void Draw(Shapes s, Color c)
{
    if (Mapper.TryGetValue(s, out Func<IDrawingObject> drawingObjectFactory))
    {
        IDrawingObject drawingObject = drawingObjectFactory();
        drawingObject.Draw(c);
    }
}

Ensuite, vous récupérez le dictionnaire approprié IDrawingObject pour un Shapes donné, et appelez sa méthode Draw :

private static Dictionary<Shapes, Func<IDrawingObject>> Mapper = new Dictionary<Shapes, IDrawingObject>()
{
    { Shapes.Circle, () => new DrawCircle() },
    { Shapes.Rectangle, () => new DrawRectangle() },
    { Shapes.Triangle, () => new DrawTriangle() },
};

Si, pour une raison quelconque, vous avez besoin de créer un nouveau DrawTriangle au moment même où vous voulez dessiner un triangle, vous pouvez à la place mettre Func code > délégués dans votre dictionnaire, mais appelez toujours IDrawingObject.Draw dans votre méthode Draw statique:

public static void Draw(Shapes s, Color c)
{
    if (Mapper.TryGetValue(s, out IDrawingObject drawingObject))
    {
        drawingObject.Draw(c);
    }
}

Ensuite:

private static Dictionary<Shapes, IDrawingObject> Mapper = new Dictionary<Shapes, IDrawingObject>()
{
    { Shapes.Circle, new DrawCircle() },
    { Shapes.Rectangle, new DrawRectangle() },
    { Shapes.Triangle, new DrawTriangle() },
};

C'est pratiquement ce que vous avez!

vous pouvez faire en sorte que votre mauvaise énumération ressemble à un objet "correct" en utilisant des méthodes d'extension. (bien que ce soit un mirage .... exposé en ayant l'exception dans la méthode MkShape)

donc la grande objection à cela n'est pas de type sécurisé, si vous ajoutez de nouvelles énumérations et oubliez de mettre à jour MkShape, votre code tombera en panne ... un langage fonctionnel comme F #, Scala, etc. vous avertirait que c'était mauvais.

votre dictionnaire ne fait rien sauf permuter un peu de complexité pour un petit avantage de performance de l'instruction switch .. .c'est à dire ne vous dérangez pas à moins que vous n'ayez des centaines de valeurs d'énumération, cela peut même vous coûter des performances (pour les petits n)

public enum Shapes
{
    Circle,
    Rectangle,
    Triangle
}

public interface IShape
{
    void Draw(Color c);
}

public static class Shape
{
    public static void ExampleClientCode()
    {
        var s = Shapes.Circle;
        // your enum looks like a "proper" object
        s.Draw(Color.AliceBlue);
    }

    public static IShape MkShape(this Shapes s)
    {
        switch (s)
        {
            case Shapes.Circle:
                return new Circle();
            case Shapes.Rectangle:
                return new Rectangle();
            case Shapes.Triangle:
                return new Triangle();
            default:
                throw new Exception("nasty enum means I can't have typesafe switch statement");
        }
    }

    public static void Draw(this Shapes s,Color c)
    {
        s.MkShape().Draw(c);
    }
}

public class Triangle : IShape
{
    public void Draw(Color c)
    {
        //for demo purpose
        Console.WriteLine("Drawing Triangle with color " + c.Name);

    }
}

public class Circle : IShape
{
    public void Draw(Color c)
    {
        //for demo purpose
        Console.WriteLine("Drawing Circle with color " + c.Name);
    }
}

public class Rectangle : IShape
{
    public void Draw(Color c)
    {
        //for demo purpose
        Console.WriteLine("Drawing Rectangle with color " + c.Name);
    }
}

PS

Je soupçonne qu'il peut être utile de stocker la couleur dans la forme, mais si vous êtes lié à l'énumération, alors vous êtes lié à la simple connaissance de la forme et rien d'autre