استفاده از اصول DRY، KISS و YAGNI در C#

اگر خودتان را تکرار نکنید، آن را ساده نگه دارید و فقط عملکردی را که واقعاً به آن نیاز دارید اجرا کنید، کد سی شارپ شما تمیزتر، ساده‌تر و نگهداری آسان‌تر خواهد بود.

تلاش بی پایان برای افزایش کیفیت کد ما و بهبود خوانایی، قابلیت نگهداری و عملکرد آن، چندین اصل معماری و طراحی را در طول سالها ایجاد کرده است. اصول DRY (“تکرار نکنید”)، YAGNI (“شما به آن نیاز نخواهید داشت”) و KISS (“ساده نگه دارید، احمقانه”) سه اصل هستند که همه باید هنگام کدنویسی به خاطر داشته باشیم.< /p>

این سه مخفف مفاهیمی را نشان می‌دهند که می‌توانند به ساده‌تر کردن فرآیند توسعه شما و همچنین ساده‌تر، پاک‌تر و قابل نگهداری‌تر کردن کد شما کمک کنند. ما این سه اصل را در اینجا بررسی خواهیم کرد و همچنین یاد خواهیم گرفت که چگونه می توان آنها را در کد برنامه های NET شما اعمال کرد.

برای کار با نمونه کدهای ارائه شده در این مقاله، باید Visual Studio 2022 را در سیستم خود نصب کنید. اگر قبلاً نسخه‌ای ندارید، می‌توانید Visual Studio 2022 را از اینجا بارگیری کنید.

یک پروژه برنامه کاربردی کنسول در ویژوال استودیو ایجاد کنید

ابتدا، اجازه دهید یک پروژه برنامه کاربردی کنسول NET Core در ویژوال استودیو ایجاد کنیم. با فرض اینکه Visual Studio 2022 در سیستم شما نصب شده است، مراحل ذکر شده در زیر را برای ایجاد یک پروژه برنامه کاربردی کنسول NET Core جدید دنبال کنید.

1. Visual Studio IDE را راه اندازی کنید.
2. روی “ایجاد پروژه جدید” کلیک کنید.
3. در پنجره “ایجاد پروژه جدید”، “Console App (.NET Core)” را از لیست الگوهای نمایش داده شده انتخاب کنید.
4. بعدی را کلیک کنید.
5. در پنجره “پیکربندی پروژه جدید خود” که در ادامه نشان داده شده است، نام و مکان پروژه جدید را مشخص کنید.
6. بعدی را کلیک کنید.
7. در پنجره “اطلاعات اضافی”، “NET 7.0 (Standard Term Support)” را به عنوان نسخه چارچوبی که می خواهید استفاده کنید انتخاب کنید.
8. روی ایجاد کلیک کنید.

ما از این پروژه برنامه کاربردی کنسول NET 7 برای کار با نمونه‌های کد از اصول DRY، YAGNI، و KISS در بخش‌های بعدی این مقاله استفاده خواهیم کرد.

اصل DRY

در توسعه نرم افزار، اصل “خودت را تکرار نکن” به این معنی است که باید از تکرار کد در برنامه خود اجتناب کنید. DRY بر تسهیل قابلیت نگهداری کد منبع برنامه شما در تمام مراحل چرخه عمر برنامه تأکید دارد. رعایت این اصل تضمین می کند که تغییر کد در یک مکان به طور خودکار هر اتفاقی از آن کد را در برنامه به روز می کند.

اصل DRY توسعه دهندگان را تشویق می کند تا کدی را بنویسند که تمیز، ماژولار و قابل استفاده مجدد باشد. ماژولار بودن می تواند به ایجاد تغییرات و اضافات در برنامه کارآمدتر و بدون درز کمک کند، با خطر کمتری برای ورود خطا به سیستم.

DRY را می توان در تمام جنبه های فرآیند توسعه نرم افزار شما از جمله کد، فایل های پیکربندی، اسناد و رابط کاربری اعمال کرد. می‌تواند به توسعه‌دهندگان کمک کند تا میزان کد مورد نیاز برای نوشتن، نگهداری و حذف کدهای اضافی را کاهش دهند، که منجر به نقص‌های کمتر و استفاده مؤثرتر از منابع می‌شود.

اصل DRY ممکن است برای تقویت همکاری بین توسعه‌دهندگان و آموزش توسعه‌دهندگان جدید نحوه مشارکت موفقیت‌آمیزتر در پایگاه کد موجود، علاوه بر افزایش کیفیت و قابلیت نگهداری کد استفاده شود.

اجرای اصل DRY در سی شارپ

شما می توانید اصل DRY را در سی شارپ به روش های زیر پیاده سازی کنید:

• استفاده از روش‌ها: روش‌ها اصل DRY را اجرا می‌کنند و به شما امکان می‌دهند کدهایی را متمرکز کنید که در بخش‌های مختلف برنامه شما استفاده می‌شود. اغلب آسان تر است که کدی را که در چندین مکان تکرار می شود به یک متد منتقل کنید و آن را از همه جا فراخوانی کنید. هر گونه تغییر مورد نیاز را می توان در یک مکان واحد در پایگاه کد شما انجام داد.
• استفاده از کلاس‌ها و وراثت: وقتی خطوط کد در بسیاری از کلاس‌ها و متدها پخش می‌شوند، می‌توان آن‌ها را به یک کلاس والد منتقل کرد که تمام کلاس‌های مشتق شده می‌توانند آن را به ارث ببرند. این رویکرد تضمین می‌کند که تغییرات در کد را می‌توان در یک مکان واحد به جای هر کلاس جداگانه‌ای که کلاس پایه را گسترش می‌دهد، انجام داد.
• استفاده از رابط ها: کدهای به اشتراک گذاشته شده در بین کلاس ها بدون کلاس پایه مشترک ممکن است به یک رابط منتقل شده و توسط کلاس های مربوطه پیاده سازی شوند. به این ترتیب، کد در همه انواع به اشتراک گذاشته می شود، به طوری که اگر زمانی نیاز به تغییر کد داشتید، فقط باید رابط را به روز کنید.

قطعه کد زیر نحوه اجرای اصل DRY را با استفاده از روش ها نشان می دهد. به نحوه استفاده مجدد از متد AddIntegers توجه کنید.

class Program
{
        static void Main(string[] args)
        {
            int a = 5;
            int b = 10;
            int x = 10;
            int y = 20;
            // Calling the AddIntegers method twice
            int s1 = AddIntegers(a, b);
            int s2 = AddIntegers(x, y);
            Console.WriteLine($"Sum of a and b is: {s1}, " +
                $"Sum of x and y is: {s2}");
            Console.ReadKey();
        }
     static int AddIntegers(int num1, int num2)
     {
            return num1 + num2;
     }
}

این نمونه خوبی از اصل DRY است زیرا ما از تکرار کد برای اضافه کردن دو عدد اجتناب کردیم و در عوض یک روش قابل استفاده مجدد ایجاد کردیم که می تواند چندین بار با پارامترهای مختلف فراخوانی شود.

اصل KISS

در زمینه معماری و طراحی نرم‌افزار، اصل «ساده، احمقانه نگه دارید» از راه‌حل‌های ساده‌تر نسبت به راه‌حل‌های پیچیده حمایت می‌کند، زیرا درک، استفاده و نگهداری آنها در طول زمان آسان‌تر است. هدف این اصل تشویق سادگی در طراحی و عملکرد برنامه‌ها، محصولات و خدمات است.

شما می توانید اصل KISS را در تمام جنبه های توسعه نرم افزار از معماری برنامه تا طراحی رابط کاربری اعمال کنید. ایده اصلی آن شامل دوری از پیچیدگی های غیرضروری و در عوض اولویت دادن به سادگی و ایجاد ساده ترین راه حل ممکن است که به طور موثر نیازهای کاربر یا کار را برآورده می کند.

KISS به طور کلی یک اصل مهم در مهندسی است. کلی جانسون در ابتدا از اصل KISS برای تأکید بر اهمیت طراحی‌های ساده هواپیما استفاده کرد. با گذشت زمان، این اصل به محبوبیت بی‌نظیری دست یافت و به عنوان یک اصل راهنما برای مشکلات مختلف از طراحی تا حل مسئله در برنامه‌های نرم‌افزاری شناخته شد.

اجرای اصل KISS در سی شارپ

دو روش زیر را در نظر بگیرید. روش اول نام ماه را به عنوان یک رشته متن با استفاده از ساختار Switch-Case برمی گرداند. روش دوم با استفاده از ساختار If-Else به همین نتیجه می رسد. آیا می توانید بگویید که روش KISS کدام است؟

public static string GetMonthNameUsingSwitchCase(int number)
{
     switch (number)
     {
         case 1:
             return "January";
         case 2:
             return "February";
         case 3:
             return "March";
         case 4:
             return "April";
         case 5:
             return "May";
         case 6:
             return "June";
         case 7:
             return "July";
         case 8:
             return "August";
         case 9:
             return "September";
         case 10:
             return "October";
         case 11:
             return "November";
         case 12:
             return "December";
         default:
             throw new InvalidOperationException();
     }
}

public static string GetMonthNameUsingIfElse(int number)
{
     if ((number < 1) || (number > 12)) throw new InvalidOperationException();
         string[] months = {
             "January",
             "February",
             "March",
             "April",
             "May",
             "June",
             "July",
             "August",
             "September",
             "October",
             "November",
             "December"
     };
         return months[number - 1];
}

همانطور که در اینجا می بینید، روشی که از ساختار Switch-Case استفاده می کند بسیار ساده تر و قابل درک است.

اصل YAGNI

اصل YAGNI یا “شما به آن نیاز نخواهید داشت” به این معنی است که شما باید عملکرد را فقط پس از نیاز به آن اجرا کنید. اصل YAGNI می‌گوید کدهای غیرضروری پیچیدگی می‌افزاید و درک، آزمایش و نگهداری سیستم را سخت‌تر می‌کند. مدیریت یک برنامه کارآمد و کارآمد آسان تر است، بنابراین فقط ویژگی هایی را که نیاز دارید اجرا کنید.

اصل YAGNI ارتباط نزدیکی با روش توسعه نرم افزار چابک دارد که بر ارائه سریع و منظم نرم افزار کار تأکید دارد. تمرکز بر حیاتی‌ترین ویژگی‌ها و ارائه زود هنگام به توسعه‌دهندگان این امکان را می‌دهد که بازخورد مکرر از ذینفعان دریافت کنند، برنامه‌های خود را تنظیم کنند و به طور مداوم برنامه را بهبود بخشند.

اصل YAGNI برنامه‌ریزی یا پیش‌اندیشی را ناامید نمی‌کند، اما توسعه‌دهندگان را تشویق می‌کند تا روی موارد ضروری تمرکز کنند و از افزودن ویژگی‌هایی که استفاده نمی‌کنند اجتناب کنند. توسعه دهندگان همچنین باید از “طلاکاری” کد خود اجتناب کنند و به خاطر کمال، پیچیدگی های غیرضروری را اضافه کنند.

اجرای اصل YAGNI در سی شارپ

قطعه کد زیر نمونه ای از اصل YAGNI را ارائه می دهد. می بینید چرا؟

class Author
    {
        private string _firstName;
        private string _lastName;
        public Author(string firstName, string lastName)
        {
            _firstName = firstName;
            _lastName = lastName;
        }
        public string GetAuthorName()
        {
            return $"{_firstName} {_lastName}";
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Author author = new Author("Joydip", "Kanjilal");
            Console.WriteLine($"Full name: {author.GetAuthorName()}");
        }
    }

در این مثال، کلاس Author از اصل YAGNI برای اجرای حداقل عملکرد پیروی می کند. برای این مثال ساده، ما فقط دو ویژگی از موجودیت Author را در نظر گرفته ایم، یعنی نام و نام خانوادگی.

ما ویژگی‌های غیرضروری مانند سن، آدرس یا شماره تلفن را اعمال نکرده‌ایم. ممکن است بعداً این ویژگی ها را پیاده سازی کنیم، اگر متوجه شویم که از آنها استفاده می کنیم. در عین حال، با پیاده‌سازی نکردن ویژگی‌های غیرضروری و اجتناب از نفوذ کد – ویژگی‌های اضافی که ممکن است درک، استفاده و نگهداری کد را سخت‌تر کند، به اصل YAGNI پایبند هستیم.

با اعمال اصول DRY، KISS، و YAGNI، می‌توانیم برنامه‌های بهتری بسازیم و توسعه‌دهندگان را بهره‌ورتر کنیم. اگر تلاش‌های تکراری را به حداقل برسانیم، کد خود را تا حد امکان ساده نگه داریم و ویژگی‌های اضافی را حذف کنیم، می‌توانیم نرم‌افزار بهتری ایجاد کنیم که درک و نگهداری آن در طول زمان ساده‌تر باشد.