محصور سازی در C#چیست؟

Encapsulation در C#: یه جعبه سیاه مفید!

سلام دوستان عزیز. امروز می‌خواهیم درباره‌ی یک مفهوم خیلی مهم توی برنامه‌نویسی شیءگرا (Object-Oriented Programming) صحبت کنیم به اسم Encapsulation. شاید اسمش یکم ترسناک به نظر برسه، ولی در واقع خیلی ساده و کاربردیه. فرض کنید یه جعبه دارید که داخلش یه سری چیزهای پیچیده قرار داره، ولی شما فقط یه دکمه روی جعبه می‌بینید. وقتی دکمه رو فشار می‌دید، جعبه کارش رو انجام می‌ده. Encapsulation هم یه چیزی شبیه به همینه!

Encapsulation یعنی چی؟ یعنی اینکه داده‌ها (Data) و رفتارهای (Behavior) مربوط به یه چیز رو توی یه واحد (مثل یک کلاس) جمع کنیم و اون‌ها رو از دنیای بیرون پنهان کنیم. به عبارت دیگه، فقط یه رابط (Interface) مشخص برای استفاده از اون واحد ارائه بدیم.

چرا Encapsulation مهمه؟ به چند دلیل:

• امنیت (Security): با پنهان کردن داده‌ها، می‌تونیم از دسترسی‌های غیرمجاز جلوگیری کنیم. مثلا اگه یه کلاس برای حساب بانکی داشته باشیم، نمی‌خوایم هر کسی بتونه مستقیم موجودی حساب رو تغییر بده.
• سادگی (Simplicity): وقتی جزئیات پیاده‌سازی پنهان هستن، کار با کد خیلی راحت‌تر می‌شه. لازم نیست نگران پیچیدگی‌های داخلی یه کلاس باشیم.
• تغییرپذیری (Flexibility): می‌تونیم پیاده‌سازی داخلی یه کلاس رو تغییر بدیم بدون اینکه کد دیگه‌ای که از اون کلاس استفاده می‌کنه، خراب بشه. فقط باید رابط کاربری (Interface) کلاس رو همون‌طوری نگه داریم.
• سازماندهی (Organization): Encapsulation به ما کمک می‌کنه کدمون رو بهتر سازماندهی کنیم و از آشفتگی جلوگیری کنیم. هر کلاس مسئول یه بخش مشخص از برنامه است.

چطوری Encapsulation رو توی C# پیاده‌سازی کنیم؟

توی C#، ما از کلاس‌ها (Classes) و دسترسی‌دهنده‌ها (Access Modifiers) برای پیاده‌سازی Encapsulation استفاده می‌کنیم. دسترسی‌دهنده‌ها مشخص می‌کنن که کدوم قسمت‌های یه کلاس از بیرون قابل دسترسی هستن و کدوم قسمت‌ها پنهان می‌مونن.

معمول‌ترین دسترسی‌دهنده‌ها توی C# عبارتند از:

مثلا، اگه یه فیلد رو private تعریف کنیم، فقط کد داخل خود کلاس می‌تونه به اون فیلد دسترسی داشته باشه. برای اینکه از بیرون به اون فیلد دسترسی داشته باشیم، معمولا از پراپرتی‌ها (Properties) استفاده می‌کنیم.

یه مثال ساده

فرض کنید می‌خوایم یه کلاس برای یه ماشین تعریف کنیم. این ماشین یه رنگ (Color) و یه سرعت (Speed) داره. ما نمی‌خوایم هر کسی بتونه مستقیم سرعت ماشین رو تغییر بده. فقط می‌خوایم یه متد داشته باشیم به اسم Accelerate که سرعت ماشین رو افزایش بده.

public class Car
{
    private string color;
    private int speed;

    public Car(string color)
    {
        this.color = color;
        this.speed = 0;
    }

    public string Color
    {
        get { return color; }
        set { color = value; }
    }

    public int Speed
    {
        get { return speed; }
        private set { speed = value; } // Only the class can set the speed
    }

    public void Accelerate(int increment)
    {
        speed += increment;
        if (speed > 200)
        {
            speed = 200; // Limit the maximum speed
        }
    }

    public void Brkae(int decrement) //Misspelled Break
    {
        speed -= decrement;
        if (speed < 0)
        {
            speed = 0; // Ensure speed doesn't go below zero
        }
    }
}

// How to use it:
// Car myCar = new Car("Red");
// Console.WriteLine(myCar.Color); // Output: Red
// myCar.Accelerate(50);
// Console.WriteLine(myCar.Speed); // Output: 50
// myCar.Speed = 300; // Error: Speed is read-only outside the class

توی این مثال، فیلد speed به صورت private تعریف شده. یعنی فقط کد داخل کلاس Car می‌تونه بهش دسترسی داشته باشه. برای اینکه بتونیم از بیرون سرعت ماشین رو بخونیم، یه پراپرتی به اسم Speed تعریف کردیم. این پراپرتی یه get داره که مقدار سرعت رو برمی‌گردونه، و یه private set داره که فقط کد داخل کلاس می‌تونه مقدار سرعت رو تغییر بده. همچنین متد Accelerate به ما اجازه می‌ده سرعت ماشین رو با یه روش کنترل‌شده افزایش بدیم.

به این ترتیب، ما با استفاده از Encapsulation، داده‌ها و رفتارهای مربوط به ماشین رو توی یه واحد جمع کردیم و اون‌ها رو از دسترسی‌های غیرمجاز محافظت کردیم. به این هم توجه کنید که ما ماکزیمم سرعت رو هم مشخص کردیم و اگه بیشتر از اون باشه به مقدار ماکزیمم ریست می‌شه.

این یه مثال ساده بود. توی پروژه‌های بزرگتر، Encapsulation نقش خیلی مهم‌تری ایفا می‌کنه و به ما کمک می‌کنه کدمون رو بهتر سازماندهی کنیم و از پیچیدگی‌ها جلوگیری کنیم.

یه مثال از وراثت (Inheritance) و Encapsulation

فرض کنید می‌خواهیم یه کلاس به اسم ElectricCar بسازیم که از کلاس Car ارث ببره. ElectricCar یه باتری (Battery) هم داره که باید ازش محافظت کنیم:

public class ElectricCar : Car
{
    private int batteryLevel;

    public ElectricCar(string color) : base(color)
    {
        this.batteryLevel = 100;
    }

    public int BatteryLevel
    {
        get { return batteryLevel; }
        private set { batteryLevel = value; } // Only the class can set the battery level
    }

    public void Charge(int amount)
    {
        batteryLevel += amount;
        if (batteryLevel > 100)
        {
            batteryLevel = 100;
        }
    }

    public void Drive(int distance)
    {
       int  powerUsed = distance / 10; // Assuming 10 km per % of battery
       if (batteryLevel >= powerUsed)
        {
            Accelerate(distance / 5); // Increase speed based on distance
            batteryLevel -= powerUsed;
            Console.WriteLine($"Driving {distance} km. Battery level: {batteryLevel}");
        }
        else
        {
            Console.WriteLine("Not enough battery to drive this distance.");
        }
    }

}

// Usage example:
// ElectricCar myElectricCar = new ElectricCar("Blue");
// myElectricCar.Drive(50); // Outputs: Driving 50 km. Battery level: 95

در این مثال، batteryLevel خصوصی است و فقط از طریق متد Charge و Drive می‌توان آن را تغییر داد. این یک نوعی Encapsulation است که از دسترسی مستقیم و نادرست به سطح باتری جلوگیری می‌کند.

خلاصه

Encapsulation یه مفهوم خیلی مهم توی برنامه‌نویسی شیءگراست که به ما کمک می‌کنه کدمون رو امن‌تر، ساده‌تر، قابل تغییرتر و بهتر سازماندهی کنیم. با استفاده از کلاس‌ها و دسترسی‌دهنده‌ها توی C#، می‌تونیم Encapsulation رو به راحتی پیاده‌سازی کنیم.

امیدوارم این مقاله براتون مفید بوده باشه. اگه سوالی داشتید، حتما بپرسید!

Encapsulation دقیقا چه مشکلی رو حل می‌کنه؟

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

آیا همیشه باید از Encapsulation استفاده کنیم؟

به طور کلی، بله. استفاده از Encapsulation یه روش خوب برای نوشتن کد حرفه‌ای و قابل نگهداریه. البته در پروژه‌های خیلی کوچیک، شاید استفاده از Encapsulation خیلی ضروری نباشه، ولی در پروژه‌های بزرگتر، حتما توصیه می‌شه.

فرق بین Encapsulation و Abstraction چیه؟

Abstraction یعنی پنهان کردن جزئیات غیرضروری و ارائه یه دید کلی از یه چیز. Encapsulation یعنی جمع کردن داده‌ها و رفتارها توی یه واحد و محافظت از اون‌ها. Abstraction بیشتر مربوط به طراحی سطح بالا (High-Level Design) هست، در حالی که Encapsulation بیشتر مربوط به پیاده‌سازی (Implementation) هست. این دو مفهوم معمولا با هم استفاده می‌شن و مکمل همدیگه هستن. Abstraction به ما نشون می‌ده که چی کار باید بکنیم، و Encapsulation به ما کمک می‌کنه اون کار رو چطوری انجام بدیم.

چرا توی مثال ماشین، پراپرتی Speed رو به صورت read-only تعریف کردیم؟

برای اینکه کنترل کنیم چطوری سرعت ماشین تغییر می‌کنه. ما نمی‌خوایم هر کسی بتونه مستقیم مقدار سرعت رو تغییر بده. فقط می‌خوایم از طریق متد Accelerate سرعت رو افزایش بدیم و از طریق Brkae (تایپی) سرعت رو کاهش بدیم. این کار باعث می‌شه که مطمئن بشیم سرعت ماشین همیشه توی یه محدوده مشخص باقی می‌مونه.

اگه یه فیلد رو به صورت public تعریف کنیم، چه اتفاقی می‌افته؟

اگه یه فیلد رو به صورت public تعریف کنیم، هر کدی می‌تونه به اون فیلد دسترسی داشته باشه و مقدارش رو تغییر بده. این کار می‌تونه باعث بروز مشکلاتی بشه، چون ما هیچ کنترلی روی نحوه استفاده از اون فیلد نداریم. به همین دلیل، معمولا توصیه می‌شه فیلدها رو به صورت private تعریف کنیم و از پراپرتی‌ها برای دسترسی به اون‌ها استفاده کنیم.