Showing posts with label Patterns. Show all posts
Showing posts with label Patterns. Show all posts

Monday, 29 July 2013

Dependency Injection та Inversion of Control контейнер

Одним з найпоширеніших методів зменешення звязаності компонентів алпікації є заміна обєктів конкретного типу на інтерфейси, що сьогодні я постараюсь коротенько описати.

Dependency Injection

Отож наша тестова аплікація умовно працюватиме з базою даних, відповідно маємо клас DbRepository який начебто реалізує роботу з базою даних та клас WithoutDI який як понятно з назви не використовує фічу про яку я сьогодні пишу, а умовно містить в собі певну логіку яка виконується перед тим як працювати з даними збереженими в БД.

На прикладі ци виглядатиме наступним чином:

   1: /// <summary>
   2: /// Class without Dependency Injection
   3: /// </summary>
   4: class WithoutDI
   5: {
   6:     DbRepository _repository = new DbRepository();
   7:  
   8:     public void UseRepo()
   9:     {
  10:         // Dummy logic.
  11:  
  12:         Console.WriteLine("I am " + this.GetType().Name + " and I work with " + _repository.GetType().Name);
  13:     }
  14: }

Як видно з коду наш клас має жорстку привязку до класу DbRepository і відповідно, якщо ми захочемо замінити репозиторій на інший то нам також придеться зайти в клас WithoutDI і змінити назву класу(DbRepository ) на нову. Ще одна проблема, яка не одразу кидається в очі, це те, що відтестуватитакий клас складно так як він в теорії працює з реальною базою даних і відповідно виклик любого з методів буде мати вплив на дані в базі. Отож ми трохи змінюємо код і в результаті отримуємо щось типу:

   1: /// <summary>
   2: /// Class with Dependency Injection
   3: /// </summary>
   4: class WithDI
   5: {
   6:     private IRepository _repository;
   7:  
   8:     public WithDI(IRepository repository)
   9:     {
  10:         _repository = repository;
  11:     }
  12:  
  13:     public void UseRepo()
  14:     {
  15:         // Dummy logic.
  16:  
  17:         Console.WriteLine("I am " + this.GetType().Name + " and I work with " + _repository.GetType().Name);
  18:     }
  19: }

В даному випадку ми приймаємо репозиторій з яким ми будемо працювати в конструкторі, при цьому не конкретний а інтерфейс, що в свою чергу дозволяє передати туди любий обєкт який наслідує цей інтерфейс. Наприклад якщо в нас є декілька реалізацій репозиторіїв то ми можемо використати їх наступним чином:

   1: WithDI withDbDi = new WithDI(new DbRepository());
   2: WithDI withFileDi = new WithDI(new FileRepository());
   3:  
   4: withDbDi.UseRepo();
   5: withFileDi.UseRepo();

В першому випадку ми будемо працювати з репозиторієм бази даних, а в другому з репозиторієм який зберігає дані в файл.

Inversion of Control

IOC контейнер це абстракція яка виносить реєстрацію всіх залежностей в одне місце і автоматично створює необхідні обєкти там де вони потрібні. Опис в мене получився не дуже зрозумілий так що краще розглянемо на прикладі. Я створив простенький клас основною метою якого є реєстрація та повернення створених обєктів. Ось його код:

   1: /// <summary>
   2: /// My as simple as possible IOC 
   3: /// </summary>
   4: class IOC
   5: {
   6:     Dictionary<string, object> dependencies = new Dictionary<string, object>();
   7:  
   8:     public void Register(string name, object obj)
   9:     {
  10:         dependencies.Add(name, obj);
  11:     }
  12:  
  13:     public object Resolve(string name)
  14:     {
  15:         return dependencies[name];
  16:     }
  17: }

Код не містить жодних перевірок і тд для того щоб була зрозуміла основна ідея.

Використати його дуже просто

   1: IOC ioc = new IOC();
   2:  
   3: ioc.Register("someRepo", new DbRepository());
   4: ioc.Register("OtherRepo", new FileRepository());

В місці де нам потрібний обєкт просто викликаємо метод Resolve з іменем обєкту який ми хочемо отримати.

   1: /// <summary>
   2: /// Class with Dependency Injection
   3: /// </summary>
   4: class WithIOC
   5: {
   6:     private IRepository _repository;
   7:  
   8:     public WithIOC(IOC ioc)
   9:     {
  10:         _repository = (IRepository)ioc.Resolve("someRepo");
  11:     }
  12:  
  13:     public void UseRepo()
  14:     {
  15:         // Dummy logic.
  16:  
  17:         Console.WriteLine("I am " + this.GetType().Name + " and I work with " + _repository.GetType().Name + "recieved from IOC");
  18:     }
  19: }

Таким чином в нас для того щоб змінити один репозиторій на інший треба просто зарєеструвати в одному місці той обєкт якй нам потрібно і відповідно всюди по коду де витягується обєкт за цим іменем буде повернено інший обєкт.

Тобто в нас в коді є одне місце в якому можна керувати тим яким репозиторієм ми будемо користуватись і в випадку коли ми тестуємо код або змінюємо тип репозиторія ми можемо зробити це в одному місці, простою зміною обєкту який пхається в ІОС. Спільне використання цих технік сприєя не лише кращому тестуванню, але й має багато інших позитивних моментів Улыбка Для кращого розуміння вартує перечитати ще декілька статей на тему, бо головною метою для себе поставив лише короткий опис, а сама тема досить фундаментальна і її знання обовязкове.

Стаття Мартіна Фовлера: http://martinfowler.com/articles/injection.html

Код: https://github.com/BatsIhor/DI_and_IOC_demo/

Saturday, 30 July 2011

Що таке патерни в програмуванні (II)

В минулому пості, я намагався обяснити що таке патерни в програмуванні, я назвав три види патернів і привів приклад патерну “стратегія”. Метою цього посту буде заповнити пробіли які залишились та виправити деякі проблеми з кодом.

Теорія

Патерн – це підхід до вирішення частих задач в програмуванні.
Програміст пишучи код може організувати його так як треба навіть незнаючи про патерни але це зазвичай займає більше часу, тому всі найбільш часті проблеми та способи їх вирішення були описані в книзі “банди чотирьох”. До цього їх використовували але автори першими додумались обєднати найкращі практики програмування в одній книзі за що й здобули всесвітню славу. Серед основних переваг які дає знання патернів, є те, що вам не треба довго описувати те, що ви хочете зробити і як ви це будете реалізовувати, вам необхідно лише вказати назву патерну і все, для всіх зразу ж стане зрозуміло що ви маєте на увазі. Також ці знання дають можливість краще зрозуміти сам принцип роботи деяких механізмів .NET. Дуже часто просто їхнє перечитування не дає жодного ефекту до того часу, поки ви самі не захочете їх реалізувати в конкретному прикладі…
Отож повертаємось до типів патернів, в нас як я вже писав є три типи: породжувальні, поведінкові та структурні.
Породжувальні патерни використовують для створення екземплярів обєктів. Наприклад іноді для більшої гнучкості створення всіх обєктів ми виносимо в один класс. Маючи доступ до цього класу в любому місці програми ми можемо отримати необхідний нам обєкт. Це знову ж таки в простих прикладах буде вимагати багато “лишнього” коду, але такі практики досить часто використовуються в великих системах і саме там вони дозволяють полегшити життя.
Поведінкові патерни використовують для того щоб запрограмувати певну поведінку обєкту, наприклад ця ж стратегія, в якій працюючи з обєктом приведеним до базового ми можемо досягати різної поведінки, хочемо добавити новий функціонал – без проблем пронаслідувались від базового класу, реалізували те що нам треба і добавили в список з іншими обєктами.
Структурні патерни описують те як можна на основі декількох малих обєктів створити більший, призначений для конкретної цілі.
Повертаємось до нашого славнозвісного проекту. Сьогодні я постарюсь обяснити чому той “лишній код” насправді не є лишнім і ми попробуємо виділити з нашої прорами той код який би можна було перевикористовувати.
Отож спочатку приведемо наш код до такого вигляду:
Program.cs
using System;
 
namespace StringValidator
{
    internal class Program
    {
        private static string[] strings = { "one", "two", "three", "four" };
 
        private static void Main(string[] args)
        {
            Console.WriteLine("Введіть одне з правил валідації (length, space, other)");
 
            string validationType = Console.ReadLine();
 
            Validate(validationType);
        }
 
        private static void Validate(string validationType)
        {
            Logic logic = new Logic();
            BaseValidation validator = logic.GetRule(validationType);
 
            foreach (string s in strings)
            {
                validator.CheckString(s);
            }
        }
    }
}
BaseValidation.cs
namespace StringValidator
{
    public abstract class BaseValidation
    {
        public abstract bool CheckString(string s);
    }
}
Logic.cs
namespace StringValidator
{
    public class Logic
    {
        public BaseValidation GetRule(string pravylo)
        {
            if (pravylo == "length")
            {
                return new LengthValidation();
            }
            if (pravylo == "space")
            {
                return new SpaceValidation();
            }
            if (pravylo == "other")
            {
                return new OtherValidation();
            }
            return null;
        }
    }
}
LengthValidatoin.cs
using System;
 
namespace StringValidator
{
    public class LengthValidation : BaseValidation
    {
        public override bool CheckString(string s)
        {
            Console.WriteLine("Check length");
            return true;
        }
    }
}
SpaceValidation.cs
using System;
 
namespace StringValidator
{
    public class SpaceValidation: BaseValidation
    {
        public override bool CheckString(string s)
        {
            Console.WriteLine("Check space");
            return true;
        }
    }
}
OtherValidation.cs
using System;
 
namespace StringValidator
{
    public class OtherValidation: BaseValidation
    {
        public override bool CheckString(string s)
        {
            Console.WriteLine("Check other");
            return true;
        }
    }
}
В принципі я лише перейменовував змінні та назви класів, так що відслідкувати, що де змінилось важко не буде.
Тепер попробуємо з нашого проекту виділити ту частину яка б відповідала за валідацію. Нашим завданням буде розробка бібліотеки, яка б могла валідувати стрічки по певним правилам. Самі правила можуть добавлятись до неї динамічно в залежності від того що нам треба в даному випадку. Отож додаємо новий проект до солюшина типу ClassLibrary і називаємо його StringValidatorLib. В нього переносимо всі файли окрім Program.cs . В перенесених файлах міняємо неймспейси, для того щоб вони відповідали новій локації.
В результаті ми отримуємо :
image
Не забуваємо про референс з нашої консольної аплікації на нашу бібліотеку.
Тепер давайте зробимо наш клас з логікою універсальним, щоб він нічого не знав про існуючі рули.
using System.Collections.Generic;
 
namespace StringValidatorLib
{
    public class Logic
    {
        Dictionary<string, object> rules = new Dictionary<string, object>(); 
 
        public void AddRule(string ruleName, object rule)
        {
            if(!rules.ContainsKey(ruleName))
            {
                rules.Add(ruleName, rule);
            }
        }
 
        public BaseValidation GetRule(string ruleName)
        {
            if(rules.ContainsKey(ruleName))
            {
                return (BaseValidation)rules[ruleName];
            }
            return null;
        }
    }
}
Тепер ми зможемо додавати нові рули і отримувати рули по назві. Погодьтесь це досить гнучко так як наша логіка нічого про те з якими обєктами вона працює не знає(далі можна буде приймати не object а нащадків BaseValidation і це забезпечить нас від хибних обєктів в словнику).
Для того щоб використати нашу логіку нам тепер спочатку треба зареєструвати всі необхідні правила, тобто ми можемо на підставі певних умов додавати ті чи інші рули при тому логіка в нас абсолютно незмінна і відповідно ймовірність нових помилок зменшується в рази. Виглядає це наступним чином:
using System;
using StringValidatorLib;
 
namespace StringValidator
{
    internal class Program
    {
        private static string[] strings = { "one", "two", "three", "four" };
 
        private static void Main(string[] args)
        {
            Console.WriteLine("Введіть одне з правил валідації (length, space, other)");
 
            Logic logic = new Logic();
            logic.AddRule("length", new LengthValidation());
            logic.AddRule("space", new SpaceValidation());
            logic.AddRule("other", new OtherValidation());
 
            string validationType = Console.ReadLine();
 
            Validate(validationType);
        }
 
        private static void Validate(string validationType)
        {
            Logic logic = new Logic();
            BaseValidation validator = logic.GetRule(validationType);
            if (validator != null)
            {
                foreach (string s in strings)
                {
                    validator.CheckString(s);
                }
            }
        }
    }
}
Також слід зазначити що навіть у випадку втрати коду бібліотеки, ми всеодно зможемо розширювати її новими правилами а це дуже великий плюс.
PS
Це далеко не вершина оптимізації та гнучкості і тут ще багато чого можна спростити та вдосконалити але на даному кроці я думаю варто зупинитись, тому що метою є показати те як застосовують паттерни і надіюсь і цією задачою я справився. На часте питання “як взанти який патерн використати?” відповідь досить проста -- знаючи їх просто треба знати. Якщо щось висвітлив недостатньо буду радий доповнити і тд.