{"id":1445,"date":"2023-04-10T14:14:53","date_gmt":"2023-04-10T07:14:53","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1445"},"modified":"2024-12-14T23:14:05","modified_gmt":"2024-12-14T16:14:05","slug":"csharp-strategy-pattern","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-design-patterns\/csharp-strategy-pattern\/","title":{"rendered":"C# Strategy Pattern"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about the C# strategy pattern that allows you to change the behavior of an object at runtime.<\/p>\n\n\n\n

Introduction to the C# strategy pattern<\/h2>\n\n\n\n

The strategy design pattern allows you to choose an algorithm from a family of algorithms at runtime by encapsulating each algorithm in a class and making them interchangeable.<\/p>\n\n\n\n

The strategy design pattern solves the problem of selecting one algorithm from a set of algorithms based on a condition, without tightly coupling the client code to the selected algorithm.<\/p>\n\n\n\n

Suppose you have a program that performs an operation. But there are multiple ways to perform the same operation. <\/p>\n\n\n\n

To do that, you can implement each algorithm as a separate method of a class. But that would make the code difficult to maintain and more complex if you want to add more algorithms. In other words, this design doesn’t conform to the open-closed principle<\/a>. <\/p>\n\n\n\n

The strategy pattern solves this problem by allowing you to encapsulate each algorithm in a separate class and make them interchangeable.<\/p>\n\n\n\n

The strategy pattern is useful when you want to support different variants of an algorithm. And it is not practical to implement each algorithm as a separate method. <\/p>\n\n\n\n

The strategy pattern is also useful when you want to select an algorithm at run time from a set of related algorithms.<\/p>\n\n\n\n

Strategy pattern structure<\/h3>\n\n\n\n

The following UML diagram illustrates the strategy pattern:<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

The strategy pattern consists of three main elements:<\/p>\n\n\n\n

    \n
  • Context<\/strong>: the class that holds a reference to the strategy object and is responsible for executing the algorithm.<\/li>\n\n\n\n
  • Strategy<\/strong>: the interface that defines the methods which must be implemented by each concrete strategy.<\/li>\n\n\n\n
  • Concrete Strategy<\/strong>: the classes that implement the strategy interface by providing their implementations of the algorithm.<\/li>\n<\/ul>\n\n\n\n

    In this structure, the context object holds a reference to a strategy object. When the context object needs to perform the algorithm, it delegates the task to the strategy object.<\/p>\n\n\n\n

    Benefits of the strategy pattern<\/h2>\n\n\n\n
      \n
    • The strategy pattern allows the client to select the algorithm to use at runtime.<\/li>\n\n\n\n
    • The strategy pattern encapsulates each algorithm in a class, making it easy to modify and extend without affecting the other algorithms.<\/li>\n\n\n\n
    • The strategy pattern decouples the algorithm from the client code, reducing coupling and promoting code reuse.<\/li>\n<\/ul>\n\n\n\n

      But strategy patterns can increase the complexity of the codebase by adding extra classes.<\/p>\n\n\n\n

      C# Strategy pattern implementation<\/h2>\n\n\n\n

      The following example shows an implementation of the strategy pattern in C#:<\/p>\n\n\n

      namespace<\/span> StrategyPattern<\/span>;\n\n\/\/ Strategy interface<\/span>\npublic<\/span> interface<\/span> IStrategy<\/span>\n{\n    void<\/span> Execute<\/span>(<\/span>)<\/span>;\n}\n\n\/\/ Concrete strategy A<\/span>\npublic<\/span> class<\/span> ConcreteStrategyA<\/span> : IStrategy<\/span>\n{\n    public<\/span> void<\/span> Execute<\/span>(<\/span>)<\/span>\n    {\n        Console.WriteLine(\"Executing strategy A\"<\/span>);\n    }\n}\n\n\/\/ Concrete strategy B<\/span>\npublic<\/span> class<\/span> ConcreteStrategyB<\/span> : IStrategy<\/span>\n{\n    public<\/span> void<\/span> Execute<\/span>(<\/span>)<\/span>\n    {\n        Console.WriteLine(\"Executing strategy B\"<\/span>);\n    }\n}\n\n\/\/ Context<\/span>\npublic<\/span> class<\/span> Context<\/span>\n{\n    private<\/span> IStrategy? _strategy;\n\n    public<\/span> void<\/span> SetStrategy<\/span>(IStrategy strategy<\/span>)<\/span>\n    {\n        _strategy = strategy;\n    }\n\n    public<\/span> void<\/span> ExecuteStrategy<\/span>(<\/span>)<\/span>\n    {\n        _strategy?.Execute();\n    }\n}\n\npublic<\/span> class<\/span> Program<\/span>\n{\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        var<\/span> context = new<\/span> Context();\n\n        \/\/ Use the strategy A<\/span>\n        context.SetStrategy(new<\/span> ConcreteStrategyA());\n        context.ExecuteStrategy();\n\n        \/\/ Use the strategy B<\/span>\n        context.SetStrategy(new<\/span> ConcreteStrategyB());\n        context.ExecuteStrategy();\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
      Known Uses of the Strategy Pattern in .NET<\/h3>\n\n\n\n
      The strategy pattern is widely used in .NET, including: <\/p>\n\n\n\n
        \n
      • The IComparer<\/code> interface in the System.Collections<\/code> namespace. <\/li>\n\n\n\n
      • The SortedList<\/code> class in the System.Collections.Specialized<\/code> namespace.<\/li>\n<\/ul>\n\n\n\n
        Summary<\/h2>\n\n\n\n
          \n
        • The Strategy pattern enables clients to select a specific algorithm from a family of algorithms at runtime, without tightly coupling the client code to the selected algorithm.<\/li>\n<\/ul>\n
          \n\t
          \n\t\t
          Was this tutorial helpful ?<\/div>\n\t\t
          \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
          \n\t\t
          \n\t\t\t
          <\/div>\n\t\t\t\n\t\t\t