ارث‌بری و چندریختی در C#: پیشرفته‌تر شوید

در دنیای توسعه نرم‌افزار، به‌ویژه در اکوسیستم قدرتمند .NET و زبان برنامه‌نویسی C#، مفاهیم شی‌گرایی (Object-Oriented Programming – OOP) ستون فقرات هر طراحی موفق و پایدار را تشکیل می‌دهند. در میان اصول بنیادین OOP، ارث‌بری (Inheritance) و چندریختی (Polymorphism) نه تنها ابزارهایی برای سازماندهی کد هستند، بلکه قدرتی بی‌نظیر برای ایجاد سیستم‌هایی با قابلیت توسعه‌پذیری بالا، انعطاف‌پذیری و نگهداری آسان فراهم می‌آورند. این مفاهیم، در نگاه اول شاید ساده به نظر برسند، اما تسلط واقعی بر آن‌ها، نیازمند درکی عمیق از جزئیات، کاربردهای پیشرفته و چالش‌های نهفته آن‌هاست.

این مقاله با هدف ارتقاء درک شما از ارث‌بری و چندریختی در C# به سطحی فراتر از مبانی، تدوین شده است. ما نه تنها به بازنگری تعاریف بنیادین می‌پردازیم، بلکه وارد قلمروهای پیچیده‌تر، مانند کاربرد آن‌ها در الگوهای طراحی (Design Patterns)، مواجهه با چالش‌های رایج، و بررسی نقش آن‌ها در معماری‌های نوین نرم‌افزاری می‌شویم. اگر آماده‌اید که مهارت‌های خود را در C# به سطح جدیدی ببرید و نرم‌افزارهایی بسازید که هم قدرتمند و هم قابل نگهداری باشند، تا انتهای این سفر عمیق با ما همراه باشید.

بازنگری اجمالی: ارث‌بری و چندریختی در سطح بنیادین

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

ارث‌بری (Inheritance): رابطه “یک-است-از” (is-a)

ارث‌بری مکانیزمی است که به یک کلاس (کلاس فرزند یا مشتق شده – Derived Class) اجازه می‌دهد تا ویژگی‌ها (Properties) و رفتارها (Methods) را از یک کلاس دیگر (کلاس والد یا پایه – Base Class) به ارث ببرد. این قابلیت، اصلی‌ترین راه برای تحقق مفهوم “یک-است-از” در طراحی شی‌گراست. برای مثال، یک “ماشین” یک-است-از یک “وسیله نقلیه”، یا یک “گربه” یک-است-از یک “حیوان”.

هدف اصلی ارث‌بری، قابلیت استفاده مجدد از کد (Code Reusability) و ایجاد سلسله‌مراتب منطقی بین اشیاء است. در C#، یک کلاس تنها می‌تواند از یک کلاس پایه به ارث ببرد (ارث‌بری تکی – Single Inheritance)، اما می‌تواند چندین اینترفیس را پیاده‌سازی کند (که نوعی از ارث‌بری قرارداد محسوب می‌شود).

public class Vehicle
{
    public string Brand { get; set; }
    public void StartEngine()
    {
        Console.WriteLine("Engine started.");
    }
}

public class Car : Vehicle // Car inherits from Vehicle
{
    public int NumberOfDoors { get; set; }
    public void Drive()
    {
        Console.WriteLine("Car is driving.");
    }
}

// Usage
Car myCar = new Car();
myCar.Brand = "Toyota";
myCar.StartEngine(); // Method inherited from Vehicle
myCar.Drive();       // Method defined in Car

چندریختی (Polymorphism): “اشکال بسیار”

کلمه چندریختی از ریشه یونانی “poly” (به معنای زیاد) و “morph” (به معنای شکل) گرفته شده است، که به معنای “اشکال بسیار” یا “توانایی گرفتن اشکال مختلف” است. در برنامه‌نویسی شی‌گرا، چندریختی به این معنی است که اشیاء از کلاس‌های مختلف می‌توانند به یکدیگر به عنوان اشیاء از یک کلاس پایه یا یک اینترفیس مشترک نگاه شوند و به همان روش با آن‌ها تعامل شود، اما رفتار متفاوتی از خود نشان دهند.

C# از چندریختی عمدتاً از طریق دو مکانیزم پشتیبانی می‌کند:

1. چندریختی زمان کامپایل (Compile-time Polymorphism): که به آن بارگذاری بیش از حد متد (Method Overloading) نیز گفته می‌شود. این قابلیت به شما اجازه می‌دهد تا چندین متد با یک نام یکسان در یک کلاس داشته باشید، به شرطی که امضای آن‌ها (تعداد، نوع یا ترتیب پارامترها) متفاوت باشد. کامپایلر بر اساس آرگومان‌های ارسالی، متد مناسب را در زمان کامپایل انتخاب می‌کند.

   
           public class Calculator
           {
               public int Add(int a, int b) { return a + b; }
               public double Add(double a, double b) { return a + b; }
               public int Add(int a, int b, int c) { return a + b + c; }
           }
           

2. چندریختی زمان اجرا (Runtime Polymorphism): که اغلب منظور از چندریختی، همین نوع است. این قابلیت از طریق متدهای `virtual`، `override` و `abstract`، و همچنین اینترفیس‌ها پیاده‌سازی می‌شود. این امکان را فراهم می‌آورد که یک متد در کلاس پایه تعریف شود و سپس در کلاس‌های مشتق شده، پیاده‌سازی متفاوتی داشته باشد. در زمان اجرا، بر اساس نوع واقعی شیء، متد مناسب فراخوانی می‌شود.

   
           public class Animal
           {
               public virtual void MakeSound() // virtual method
               {
                   Console.WriteLine("Animal makes a sound.");
               }
           }
   
           public class Dog : Animal
           {
               public override void MakeSound() // override base method
               {
                   Console.WriteLine("Dog barks.");
               }
           }
   
           public class Cat : Animal
           {
               public override void MakeSound() // override base method
               {
                   Console.WriteLine("Cat meows.");
               }
           }
   
           // Usage for runtime polymorphism
           Animal myAnimal1 = new Dog();
           Animal myAnimal2 = new Cat();
           Animal myAnimal3 = new Animal();
   
           myAnimal1.MakeSound(); // Output: Dog barks.
           myAnimal2.MakeSound(); // Output: Cat meows.
           myAnimal3.MakeSound(); // Output: Animal makes a sound.
           

چندریختی به ما امکان می‌دهد تا کدی بنویسیم که با یک اینترفیس (یا کلاس پایه) تعامل می‌کند، بدون اینکه نگران جزئیات پیاده‌سازی انواع مختلف باشیم. این یکی از قوی‌ترین اصول برای ایجاد کدهای انعطاف‌پذیر، قابل توسعه و قابل نگهداری است.

انواع ارث‌بری و کاربردهای پیشرفته آن

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

ارث‌بری پیاده‌سازی (Implementation Inheritance) در مقابل ارث‌بری اینترفیس (Interface Inheritance)

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

در مقابل، ارث‌بری اینترفیس به معنای پیاده‌سازی یک اینترفیس توسط یک کلاس است. در این حالت، کلاس تنها “قرارداد” (Contract) یا “رفتار” را به ارث می‌برد، نه پیاده‌سازی آن را. اینترفیس‌ها تنها امضای متدها، ویژگی‌ها، رویدادها و ایندکسرها را تعریف می‌کنند و هیچ پیاده‌سازی‌ای ندارند (تا C# 8.0، که Default Interface Methods معرفی شدند، اما حتی با آن هم، هدف اصلی ارائه قرارداد است).

چه زمانی از کدام استفاده کنیم؟

• ارث‌بری پیاده‌سازی (کلاس‌های پایه): زمانی مناسب است که بین کلاس‌ها رابطه “یک-است-از” قوی وجود دارد و کلاس‌های مشتق شده نیاز به استفاده مجدد از بخش قابل توجهی از منطق یا داده‌های کلاس پایه دارند. این رویکرد، اشتراک‌گذاری کد را تسهیل می‌کند. با این حال، استفاده بیش از حد یا نادرست از آن می‌تواند منجر به مشکلاتی مانند “مشکل کلاس پایه شکننده” (Fragile Base Class Problem) شود، که در آن تغییرات در کلاس پایه به طور ناخواسته کلاس‌های مشتق شده را تحت تأثیر قرار می‌دهند.
• ارث‌بری اینترفیس: زمانی که می‌خواهید یک قرارداد رفتاری را بدون تحمیل جزئیات پیاده‌سازی تعریف کنید، اینترفیس‌ها انتخاب عالی هستند. آن‌ها انعطاف‌پذیری بالایی را فراهم می‌کنند و پایه و اساس برای Dependency Injection و تست‌پذیری هستند. اینترفیس‌ها به شما اجازه می‌دهند تا چندریختی را در سطحی انتزاعی‌تر اعمال کنید و “یک نوع-عمل” (is-a-kind-of) را بیان می‌کنند، نه لزوماً “یک-است-از”. مثلاً یک `Car` می‌تواند رانده شود (IDrivable)، اما Car لزوماً یک IDrivable نیست، بلکه Car نوعی از یک وسیله نقلیه است.

کلاس‌های `sealed`

کلمه کلیدی `sealed` در C# برای جلوگیری از ارث‌بری از یک کلاس به کار می‌رود. وقتی یک کلاس را `sealed` اعلام می‌کنید، هیچ کلاس دیگری نمی‌تواند از آن به ارث ببرد. این قابلیت می‌تواند به دلایل مختلفی مفید باشد:

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

public sealed class FinalConfiguration
{
    public string ConnectionString { get; set; }
    // No class can inherit from FinalConfiguration
}

کلاس‌های `abstract` و اینترفیس‌ها: تمایز دقیق‌تر

هم کلاس‌های `abstract` و هم اینترفیس‌ها برای تعریف قراردادها و انتزاعیات در C# استفاده می‌شوند، اما تفاوت‌های کلیدی بین آن‌ها وجود دارد که درک آن‌ها برای طراحی پیشرفته ضروری است:

• پیاده‌سازی:
  • کلاس `abstract`: می‌تواند هم اعضای `abstract` (که باید توسط کلاس‌های مشتق شده پیاده‌سازی شوند) و هم اعضای غیر `abstract` (با پیاده‌سازی پیش‌فرض) داشته باشد. همچنین می‌تواند فیلدها (fields)، سازنده‌ها (constructors) و اعضای استاتیک (static members) داشته باشد.
  • اینترفیس: تا C# 8.0 تنها شامل امضای اعضا بود و هیچ پیاده‌سازی‌ای نداشت. از C# 8.0 به بعد، می‌توانند متدهای پیش‌فرض (Default Interface Methods) را داشته باشند، اما همچنان نمی‌توانند فیلدهای نمونه (instance fields) یا سازنده‌ها داشته باشند.
• ارث‌بری/پیاده‌سازی:
  • کلاس `abstract`: یک کلاس تنها می‌تواند از یک کلاس پایه (abstract یا غیر abstract) به ارث ببرد.
  • اینترفیس: یک کلاس می‌تواند چندین اینترفیس را پیاده‌سازی کند. این به C# اجازه می‌دهد تا به نوعی “چند ارث‌بری” رفتار را از طریق اینترفیس‌ها شبیه‌سازی کند.
• رابطه:
  • کلاس `abstract`: بهترین گزینه برای تعریف یک نوع پایه (Base Type) است که دارای رفتار مشترک و ویژگی‌های مشترک برای انواع مختلفی است که رابطه “یک-است-از” قوی دارند (مثلاً `Shape` به عنوان کلاس پایه برای `Circle` و `Rectangle`).
  • اینترفیس: بهترین گزینه برای تعریف قابلیت‌ها یا قراردادهایی است که کلاس‌ها می‌توانند بدون توجه به سلسله‌مراتب ارث‌بری خود، آن‌ها را پیاده‌سازی کنند (مثلاً `ILogger`، `ISerializable`).

انتخاب بین `abstract` class و Interface:

معمولاً از کلاس `abstract` زمانی استفاده می‌کنیم که:

• می‌خواهیم کد مشترکی بین چندین کلاس مشتق شده به اشتراک بگذاریم.
• می‌خواهیم رفتار پیش‌فرض را ارائه دهیم که کلاس‌های مشتق شده می‌توانند آن را بازنویسی کنند.
• اعضای protected یا private مورد نیاز هستند.
• می‌خواهیم یک سلسله‌مراتب نوع قوی (strong type hierarchy) ایجاد کنیم.

و از اینترفیس زمانی استفاده می‌کنیم که:

• می‌خواهیم رفتار خاصی را تعریف کنیم که ممکن است توسط کلاس‌های مختلف با سلسله‌مراتب‌های ارث‌بری متفاوت پیاده‌سازی شود.
• می‌خواهیم قابلیت چند پیاده‌سازی (multiple implementations) از یک قرارداد را داشته باشیم.
• نیاز به قابلیت تست‌پذیری و انعطاف‌پذیری بالا (مانند Dependency Injection) داریم.

Composition over Inheritance: اصل طلایی طراحی

یکی از مهم‌ترین اصول طراحی شی‌گرا، “Composition over Inheritance” (ترکیب بر ارث‌بری) است. این اصل بیان می‌کند که به جای ارث بردن از یک کلاس برای استفاده مجدد از قابلیت‌های آن، بهتر است که یک شیء از آن کلاس را به عنوان یک کامپوننت (component) در کلاس خود گنجانده (compose) و از طریق آن با قابلیت‌هایش تعامل کنید.

چرا ترکیب بهتر است؟

• کاهش وابستگی: ارث‌بری یک وابستگی محکم (tight coupling) بین کلاس والد و فرزند ایجاد می‌کند. تغییرات در والد می‌تواند به طور ناخواسته فرزند را تحت تأثیر قرار دهد. ترکیب، وابستگی ضعیف‌تری (loose coupling) ایجاد می‌کند، زیرا کلاس‌ها به جای اینکه “یک-است-از” یکدیگر باشند، “یک-دارد-از” (has-a) یکدیگر هستند.
• انعطاف‌پذیری بیشتر: با ترکیب، می‌توانید رفتار یک کلاس را در زمان اجرا تغییر دهید، به سادگی با جایگزینی کامپوننت داخلی. با ارث‌بری، ساختار کلاس ثابت است.
• اجتناب از مشکلات سلسله‌مراتب: سلسله‌مراتب ارث‌بری عمیق می‌تواند پیچیده و دشوار برای نگهداری شود. ترکیب به شما امکان می‌دهد تا سیستم‌های خود را از قطعات کوچک‌تر و قابل مدیریت‌تر بسازید.
• عدم نیاز به ارث‌بری غیرضروری: گاهی اوقات یک کلاس فقط برای استفاده از یک یا دو متد از کلاس پایه به ارث می‌برد که این کار می‌تواند ساختار را بی جهت پیچیده کند. ترکیب این مشکل را حل می‌کند.

مثال: سیستم پرواز در بازی

// Bad example: Inheritance for behavior
public class Bird : Animal
{
    public void Fly() { Console.WriteLine("Bird is flying."); }
}

public class Penguin : Bird // Problem: Penguin cannot fly
{
    // Need to override Fly() to do nothing or throw error
    public override void Fly() { Console.WriteLine("Penguins can't fly!"); }
}

// Good example: Composition for behavior
public interface IFlyBehavior
{
    void Fly();
}

public class CanFly : IFlyBehavior
{
    public void Fly() { Console.WriteLine("Flapping wings!"); }
}

public class CannotFly : IFlyBehavior
{
    public void Fly() { Console.WriteLine("Cannot fly."); }
}

public class NewBird
{
    private IFlyBehavior _flyBehavior;

    public NewBird(IFlyBehavior flyBehavior)
    {
        _flyBehavior = flyBehavior;
    }

    public void PerformFly()
    {
        _flyBehavior.Fly();
    }

    public void SetFlyBehavior(IFlyBehavior flyBehavior)
    {
        _flyBehavior = flyBehavior;
    }
}

// Usage
NewBird duck = new NewBird(new CanFly());
duck.PerformFly(); // Output: Flapping wings!

NewBird penguin = new NewBird(new CannotFly());
penguin.PerformFly(); // Output: Cannot fly.

// Change behavior at runtime
duck.SetFlyBehavior(new CannotFly());
duck.PerformFly(); // Output: Cannot fly.

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

چندریختی در عمل: فراتر از `virtual` و `override`

در حالی که `virtual` و `override` سنگ بنای چندریختی زمان اجرا هستند، جنبه‌های دیگری نیز وجود دارد که به چندریختی قدرت و انعطاف‌پذیری بیشتری می‌بخشد.

چندریختی با اینترفیس‌ها: نهایت انعطاف‌پذیری

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

مزیت اصلی این رویکرد، دکوپلینگ (decoupling) شدید است. کدی که با یک اینترفیس کار می‌کند، نیازی به دانستن جزئیات کلاس‌های پیاده‌ساز ندارد. این امر تست‌پذیری، نگهداری و قابلیت توسعه را به شدت بهبود می‌بخشد.

public interface IShape
{
    double GetArea();
    double GetPerimeter();
}

public class Circle : IShape
{
    public double Radius { get; set; }
    public Circle(double radius) { Radius = radius; }
    public double GetArea() { return Math.PI * Radius * Radius; }
    public double GetPerimeter() { return 2 * Math.PI * Radius; }
}

public class Rectangle : IShape
{
    public double Width { get; set; }
    public double Height { get; set; }
    public Rectangle(double width, double height) { Width = width; Height = height; }
    public double GetArea() { return Width * Height; }
    public double GetPerimeter() { return 2 * (Width + Height); }
}

// Usage demonstrating interface polymorphism
public static class ShapeCalculator
{
    public static void PrintShapeDetails(IShape shape)
    {
        Console.WriteLine($"Area: {shape.GetArea()}, Perimeter: {shape.GetPerimeter()}");
    }
}

// In Main method or another class:
IShape myCircle = new Circle(5);
IShape myRectangle = new Rectangle(4, 6);

ShapeCalculator.PrintShapeDetails(myCircle);    // Output: Area: 78.53..., Perimeter: 31.41...
ShapeCalculator.PrintShapeDetails(myRectangle); // Output: Area: 24, Perimeter: 20

در این مثال، متد `PrintShapeDetails` نیازی به دانستن اینکه آیا شیء `Circle` است یا `Rectangle` ندارد؛ تنها با اینترفیس `IShape` کار می‌کند. این قابلیت، بنیاد بسیاری از الگوهای طراحی پیشرفته و فریم‌ورک‌های مدرن است.

چندریختی عمومی (Generic Polymorphism): کار با انواع ناشناخته

Generics (ژنریک‌ها) در C# به شما اجازه می‌دهند تا کلاس‌ها، متدها و اینترفیس‌ها را با یک یا چند پارامتر نوع تعریف کنید. این قابلیت، نوعی از چندریختی است که به شما اجازه می‌دهد تا کدی بنویسید که روی انواع مختلف داده کار کند، بدون اینکه نیاز به کپی‌پیست کردن کد یا استفاده از `object` و تبدیل نوع (casting) باشد.

ژنریک‌ها چندریختی را در سطح نوع (Type-level polymorphism) ارائه می‌دهند. به عنوان مثال، `List<T>` می‌تواند یک لیست از `int`، `string` یا هر نوع دلخواه دیگری باشد، و متدهای آن به طور یکسان برای همه این انواع کار می‌کنند.

public class GenericProcessor<T>
{
    public void Process(T item)
    {
        Console.WriteLine($"Processing item of type {typeof(T).Name}: {item}");
    }
}

// Usage
GenericProcessor<int> intProcessor = new GenericProcessor<int>();
intProcessor.Process(100); // Output: Processing item of type Int32: 100

GenericProcessor<string> stringProcessor = new GenericProcessor<string>();
stringProcessor.Process("Hello Generics"); // Output: Processing item of type String: Hello Generics

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

کوواریانس (Covariance) و کنتراواریانس (Contravariance): انعطاف‌پذیری در وراثت نوع

کوواریانس و کنتراواریانس، مفاهیم پیشرفته‌تری هستند که انعطاف‌پذیری بیشتری را در تخصیص نوع در سیستم‌های چندریختی C# فراهم می‌کنند. این مفاهیم بیشتر در مورد اینترفیس‌ها و Delegateهای عمومی (Generic Delegates) کاربرد دارند.

• کوواریانس (`out` keyword): به شما اجازه می‌دهد تا یک نوع عمومی را با نوع مشتق شده‌تری نسبت به آنچه که در اصل مشخص شده است، استفاده کنید. این قابلیت برای پارامترهای نوع خروجی (return types) در اینترفیس‌ها و Delegateها کاربرد دارد. یعنی اگر `TDerived` از `TBase` مشتق شده باشد، `IEnumerable` را می‌توان به عنوان `IEnumerable` در نظر گرفت. (مثال: `IEnumerable` به `IEnumerable