Четох Loose Coupling и неговите предимства, които са наистина добри неща, но започнах да се чудя кои инструменти са чудесни за създаване на слабо свързани решения? Първото, което ми хрумна, са типове и интерфейси и абстрактни класове, но съм сигурен, че има толкова много начини за осигуряване на хлабаво свързване. Може би полиморфизмът помага за създаването на слабо свързани обекти и системи.
Благодаря.
Това е много широк въпрос - вероятно твърде широк, за да се отговори.
Въпреки това две методологии, които могат да осигурят решение с „хлабаво свързване“, са:
Инжектиране на зависимост
Инжектирането на зависимости (особено когато се използва контейнер за инверсия на контрол) осигурява слабо свързване в рамките на приложение или решение - С инжектирането на зависимости вие не кодирате твърдо препратките си към зависими обекти, вместо това кодирате към интерфейси и инжектирате реализации на тези интерфейси.
Ето бърз пример за код на компонент за регистриране на приложение, който имплементира интерфейс на ILogger
public class ConcreteLogger : ILogger
{
public LogMessage(string message)
{
Log.Write(message);
}
}
След това един от вашите класове получава тази конкретна реализация на интерфейса на регистратора.
public class MyClass
{
private ILogger logger;
public myClass(ILogger logger)
{
this.logger = logger;
}
public void DoSomething()
{
// Now if DoSomething needs to call logging it can call what ever ILogger was passed in
this.logger.Log("We did something");
}
}
Ориентация към услугата
Ориентацията на услугата осигурява слабо свързване между различни подсистеми на решение - С ориентацията на услугата всяка част от решението се превръща в собствена самостоятелна услуга, която публикува и интерфейси (често интерфейс, базиран на съобщения).
Това означава, че дадено приложение, когато трябва например да говори с подсистемата за доставка на решение, трябва да знае само за системните интерфейси и своя адрес и не трябва да знае нищо за вътрешното си изпълнение. Това почти може да се разглежда като по-широко приложение на основните OO принципи.
И двете осигуряват два различни типа хлабаво свързване (това е един от проблемите с вашия въпрос, самият термин е свободно дефиниран)
Вашият мозък вероятно?
Програма с интерфейси в ума. Създайте библиотеките си като малки острови от самостоятелен код с минимални и ясни интерфейси. Ограничете обхвата на всички символи, но по-специално на променливите (напр. променливи). Не разкривайте подробности за изпълнението, освен ако не са подходящи.
Други вече са предоставили страхотни отговори, но искам да добавя една мисъл: полиморфизмът, реализиран с помощта на наследяване, не насърчава слабото свързване. Наследяването е много силна връзка между базовите класове и производните класове.
MEF е най-добрият инструмент за хлабаво свързване! Проектирайте приложенията си от самото начало така, че да са много удобни за MEF/плъгини и ще откриете, че приложението ви ще бъде много слабо свързано
Чудесен начин за разхлабване на свързването е Инжектиране на зависимост.
Най-добрият инструмент досега е Microsoft CAB (който включва споменатия по-горе Unity framework)
Включва инструменти за инжектиране на зависимости, обработка на слабо свързани събития и много повече.
