Strategy: improve conceptual example

Author: lex111

Strategy.Conceptual/Program.cs

@@ -1,48 +1,103 @@
-using System;
+// EN: Strategy Design Pattern
+//
+// Intent: Define a family of algorithms, encapsulate each one, and make them
+// interchangeable. Strategy lets the algorithm vary independently from clients
+// that use it.
+//
+// RU: Паттерн Стратегия
+//
+// Назначение: Определяет семейство алгоритмов, инкапсулирует каждый из них и
+// делает взаимозаменяемыми. Стратегия позволяет изменять алгоритм независимо от
+// клиентов, которые его используют.
+
+using System;
 using System.Collections.Generic;
 
 namespace RefactoringGuru.DesignPatterns.Strategy.Conceptual
 {
+    // EN: The Context defines the interface of interest to clients.
+    //
+    // RU: Контекст определяет интерфейс, представляющий интерес для клиентов.
     class Context
     {
+        // EN: The Context maintains a reference to one of the Strategy objects.
+        // The Context does not know the concrete class of a strategy. It should
+        // work with all strategies via the Strategy interface.
+        //
+        // RU: Контекст хранит ссылку на один из объектов Стратегии. Контекст не
+        // знает конкретного класса стратегии. Он должен работать со всеми
+        // стратегиями через интерфейс Стратегии.
         private Strategy _strategy;
 
         public Context()
         { }
 
+        // EN: Usually, the Context accepts a strategy through the constructor,
+        // but also provides a setter to change it at runtime.
+        //
+        // RU: Обычно Контекст принимает стратегию через конструктор, а также
+        // предоставляет сеттер для её изменения во время выполнения.
         public Context(Strategy strategy)
         {
             this._strategy = strategy;
         }
 
-        public void setStrategy(Strategy strategy)
+        // EN: Usually, the Context allows replacing a Strategy object at
+        // runtime.
+        //
+        // RU: Обычно Контекст позволяет заменить объект Стратегии во время
+        // выполнения.
+        public void SetStrategy(Strategy strategy)
         {
             this._strategy = strategy;
         }
 
-        public void doSomeBusinessLogic()
+        //
+        // EN: The Context delegates some work to the Strategy object instead of
+        // implementing multiple versions of the algorithm on its own.
+        //
+        // RU: Вместо того, чтобы самостоятельно реализовывать множественные версии
+        // алгоритма, Контекст делегирует некоторую работу объекту Стратегии.
+        ///
+        public void DoSomeBusinessLogic()
         {
-            Console.Write("Context: Sorting data using the strategy (not sure how it'll do it)\n");
-            var result = this._strategy.doAlgorithm(new List<string> { "a", "b", "c", "d", "e" });
+            Console.WriteLine("Context: Sorting data using the strategy (not sure how it'll do it)");
+            var result = this._strategy.DoAlgorithm(new List<string> { "a", "b", "c", "d", "e" });
 
-            string result_str = string.Empty;
+            string resultStr = string.Empty;
             foreach (var element in result as List<string>)
             {
-                result_str += element + ",";
+                resultStr += element + ",";
             }
 
-            Console.Write(result_str);
+            Console.WriteLine(resultStr);
         }
     }
 
+    // EN: The Strategy interface declares operations common to all supported
+    // versions of some algorithm.
+    //
+    // The Context uses this interface to call the algorithm defined by Concrete
+    // Strategies.
+    //
+    // RU: Интерфейс Стратегии объявляет операции, общие для всех поддерживаемых
+    // версий некоторого алгоритма.
+    //
+    // Контекст использует этот интерфейс для вызова алгоритма, определённого
+    // Конкретными Стратегиями.
     interface Strategy
     {
-        object doAlgorithm(object data);
+        object DoAlgorithm(object data);
     }
 
+    // EN: Concrete Strategies implement the algorithm while following the base
+    // Strategy interface. The interface makes them interchangeable in the Context.
+    //
+    // RU: Конкретные Стратегии реализуют алгоритм, следуя базовому интерфейсу
+    // Стратегии. Этот интерфейс делает их взаимозаменяемыми в Контексте.
     class ConcreteStrategyA : Strategy
     {
-        public object doAlgorithm(object data)
+        public object DoAlgorithm(object data)
         {
             var list = data as List<string>;
             list.Sort();
@@ -53,7 +108,7 @@ public object doAlgorithm(object data)
 
     class ConcreteStrategyB : Strategy
     {
-        public object doAlgorithm(object data)
+        public object DoAlgorithm(object data)
         {
             var list = data as List<string>;
             list.Sort();
@@ -67,17 +122,24 @@ class Client
     {
         public static void ClientCode()
         {
+            // EN: The client code picks a concrete strategy and passes it to
+            // the context. The client should be aware of the differences
+            // between strategies in order to make the right choice.
+            //
+            // RU: Клиентский код выбирает конкретную стратегию и передаёт её в
+            // контекст. Клиент должен знать о различиях между стратегиями,
+            // чтобы сделать правильный выбор.
             var context = new Context();
 
-            Console.Write("Client: Strategy is set to normal sorting.\n");
-            context.setStrategy(new ConcreteStrategyA());
-            context.doSomeBusinessLogic();
-            Console.Write("\n");
-            Console.Write("Client: Strategy is set to reverse sorting.\n");
-            context.setStrategy(new ConcreteStrategyB());
-            context.doSomeBusinessLogic();
-
-            Console.Write("\n");
+            Console.WriteLine("Client: Strategy is set to normal sorting.");
+            context.SetStrategy(new ConcreteStrategyA());
+            context.DoSomeBusinessLogic();
+            
+            Console.WriteLine();
+            
+            Console.WriteLine("Client: Strategy is set to reverse sorting.");
+            context.SetStrategy(new ConcreteStrategyB());
+            context.DoSomeBusinessLogic();
         }
     }