همانطور که قول داده بودم، به اصول GRASP می‌پردازیم.
اصول GRASP-General Responsibility Assignment
Software Principles
این اصول به بررسی نحوه تقسیم
وظایف بین کلاس‌ها و مشارکت اشیاء برای به انجام رساندن یک مسئولیت می‌پردازند.
اینکه هر کلاس در ساختار نرم افزار چه وظیفه‌ای دارد و چگونه با کلاس‌های دیگر
مشارکت میکند تا یک عملکرد به سیستم اضافه گردد. این اصول به چند بخش تقسیم میشوند:
- کنترلر ( Controller )
- ایجاد کننده ( Creator )
- انسجام قوی ( High Cohesion )
- واسطه گری ( Indirection )
- دانای اطلاعات ( Information Expert )
- اتصال ضعیف ( Low Coupling )
- چند ریختی ( Polymorphism )
- حفاظت از تاثیر تغییرات ( Protected Variations )
- مصنوع خالص ( Pure Fabrication )
Controller
این الگو بیان میکند که مسئولیت
پاسخ به رویداد‌های (Events ) یک سناریوی محدود مانند یک مورد
کاربردی ( Use Case ) باید به عهده یک کلاس غیر UI باشد. کنترلر باید کارهایی را که نیاز است در پاسخ رویداد انجام
شود، به دیگران بسپرد و نتایج را طبق درخواست رویداد بازگرداند. در اصل، کنترلر دریافت
کننده رویداد، راهنمای مسیر پردازش برای پاسخ به رویداد و در نهایت برگرداننده پاسخ
به سمت مبداء رویداد است. در زیر مثالی را می‌بینیم که رویداد اتفاق افتاده توسط واسط
گرافیکی به سمت یک handler (که متدی است با ورودیِ
فرستنده و آرگمانهای مورد نیاز) در کنترلر فرستاده میشود. این روش event handling، در نمونه‌های وب فرم و ویندوز فرم دیده میشود. به صورتی خود کلاس‌های .Net وظیفه Event Raising از سمت UI
با کلیک روی دکمه را انجام میدهد:
public class UserController
{
protected void OnClickCreate(object sender, EventArgs e)
{
// call validation services
// call create user services
}
}
در مثال بعد عملیات مربوط به User در یک WebApiController پاسخ داده میشود. در اینجا به جای استفاده از Event Raising برای کنترل کردن رویداد، از فراخوانی یک متد در کنترلر توسط درخواست HttpPost انجام میگیرد. در اینجا نیاز
است که در سمت کلاینت درخواستی را ارسال کنیم:
public class UserWebApiController
{
[HttpPost]
public HttpResponseMessage Create(UserViewModel user)
{
// call validation services
// call create user services
}
}
Creator :
این اصل میگوید شیء ای میتواند یک شیء
دیگر را بسازد ( instantiate ) که: (اگر کلاس B بخواهد کلاس A را instantiate کند)
- کلاس B شیء از کلاس A را در خود داشته باشد؛
- یا اطلاعات کافی برای instantiate کردن از A را داشته باشد؛
- یا به صورت نزدیک با A در ارتباط باشد؛
- یا بخواهد شیء A را ذخیره کند.
از آنجایی که این اصل بدیهی به نظر میرسد، با مثال نقض، درک بهتری را نسبت به آن میتوان پیدا کرد:
// سازنده
public class B
{
public static A CreateA(string name, string lastName, string job)
{
return new A() {
Name =name,
LastName = lastName,
Job = job
};
}
}
// ایجاد شونده
public class A
{
public string Name { get; set; }
public string LastName { get; set; }
public string Job { get; set; }
}
public class Context
{
public void Main()
{
var name = "Rasoul";
var lastName = "Abbasi";
var job = "Developer";
var obj = B.CreateA(name, lastName, job);
}
}
و اما چرا این مثال، اصل Creator را نقض میکند. در مثال میبینید که کلاس B،
یک شیء از نوع A را در متد Main کلاس Context ایجاد میکند. کلاس B فقط یک متد برای تولید A دارد و
در عملیات تولید A هیچ منطق خاصی را پیاده سازی نمیکند.کلاس
B شیء ای را از کلاس A ، در خود ندارد، با آن ارتباط
نزدیک ندارد و آنرا ذخیره نمیکند. با اینکه کلاس B
اطلاعات کافی را برای تولید A از ورودی میگیرد، ولی این
کلاس Context است که اطلاعات کافی را ارسال
مینماید. اگر در کلاس B منطقی اضافه بر instance گیریِ ساده وجود داشت (مانند بررسی صحت و اعتبار
سنجی)، میتوانستیم بگوییم کلاس B از یک مجموعه عملیات instance گیری با خبر است که کلاس Context نباید از آن
خبر داشته باشد. لذا اکنون هیچ دلیلی وجود ندارد که وظیفه تولید A را در Context انجام ندهیم و این مسئولیت را به
کلاس B منتقل کنیم. این مورد ممکن است در ذهن شما با الگوی Factory تناقض داشته باشد. ولی نکته اصلی در الگو Factory انجام عملیات instance گیری با
توجه به منطق برنامه است؛ یعنی وظیفه‌ای که کلاس Context
نباید از آن خبر داشته باشد را به کلاس Factory منتقل
میکنیم. در غیر اینصورت ایجاد کلاس Factory بی معنا
خواهد بود (مگر به عنوان افزایش انعطاف پذیری معماری که بتوان به راحتی نوع پیاده سازی یک
واسط را تغییر داد).
High Cohesion :
این اصل اشاره به یکی از اصول
اساسی طراحی نرم افزار دارد. انسجام واحد‌های نرم افزاری باعث افزایش خوانایی، سهولت
اشکال زدایی، قابلیت نگهداری و کاهش تاثیر زنجیره‌ای تغییرات میشود. طبق این اصل، مسئولیتهای
هر واحد باید مرتبط باشد. لذا اجزایی کوچک با مسئولیتهای منسجم و متمرکز بهتر از
اجزایی بزرگ با مسئولیتهای پراکنده است. اگر واحد‌های سازنده نرم افزار انسجام
ضعیفی داشته باشند، درک همکاری‌ها، استفاده مجدد آنها، نگه داری نرم افزار و پاسخ
به تغییرات سخت‌تر خواهد شد.
در مثال زیر نقض این اصل را
مشاهده میکنیم:
class Controller
{
public void CreateProduct(string name, int categoryId) { }
public void EditProduct(int id, string name) { }
public void DeleteProduct(int id) { }
public void CreateCategory(string name) { }
public void EditCategory(int id, string name) { }
public void DeleteCategory(int id) { }
} همانطور که میبینید، کلاس
کنترلر ما، مسئولیت مدیریت Product و Category را بر عهده دارد. بزرگ شدن این کلاس، باعث سخت‌تر شدن
خواندن کد و رفع اشکال میگردد. با جداسازی کنترلر مربوط به Product از Category میتوان انسجام را بالا برد.
Indirection :
این اصل بیان میکند که با تعریف
یک واسط بین دو مولفه نرم افزاری میتوان میزان اتصال نرم افزار را کاهش داد. بدین
ترتیب وظیفه هماهنگی ارتباط دو مؤلفه، به عهده این واسط خواهد بود و نیازی نیست داده‌های ورودی و خروجی دو مؤلفه، هماهنگ باشند. در اینجا واسط، از وابستگی بین دو مؤلفه
با پنهان کردن ضوابط هر مؤلفه از دیگری و ایجاد وابستگی ضعیف خود با دو مؤلفه، باعث
کاهش اتصال کلی طراحی میگردد.
الگوهای Adapter
و Delegate و همچنین نقش کنترلر در الگوی معماری MVC از این اصل پیروی میکنند.
class SenderA
{
public Mediator mediator { get; }
public SenderA() { mediator = new Mediator(); }
public void Send(string message, string reciever) { mediator.Send(message, reciever); }
}
class SenderB
{
public Mediator mediator { get; }
public SenderB() { mediator = new Mediator(); }
public void Send(string message) { }
}
public class RecieverA
{
public void DoAction(string message)
{
// انجام عملیات بر اساس پیغام دریافت شده
switch (message)
{
case "create":
break;
case "delete":
break;
default:
break;
}
}
}
public class RecieverB
{
public void DoAction(string message)
{
// انجام عملیات بر اساس پیغام دریافت شده
switch (message)
{
case "edit":
break;
case "rollback":
break;
default:
break;
}
}
}
class Mediator
{
internal void Send(string message, string reciever)
{
switch (reciever)
{
case "A":
var recieverObjA = new RecieverA();
recieverObjA.DoAction(message);
break;
case "B":
var recieverObjB = new RecieverB();
recieverObjB.DoAction(message);
break;
default:
break;
}
}
}
class IndirectionContext
{
public void Main()
{
var senderA = new SenderA();
senderA.Send("rollback", "B");
var senderB = new SenderA();
senderB.Send("create", "A");
}
} در این مثال کلاس Mediator به عنوان واسط ارتباطی بین کلاس‌های Sender و Receiver قرار گرفته و نقش تحویل پیغام را دارد.
در مقاله بعدی، به بررسی سایر اصول GRASP خواهم پرداخت.
