📘 شرح شامل لمفاهيم C# الأساسية

1. Generics (الأدوية / الأنواع العامة)

المفهوم: تسمح Generics بكتابة كلاسات، دوال، أو واجهات تعمل مع نوع بيانات غير محدد مسبقًا، مما يعزز إعادة استخدام الكود مع الحفاظ على أمان الأنواع (Type Safety).

المزايا:

• تجنب ازدواجية الكود.
• أداء أفضل مقارنة باستخدام object (تجنب عمليات الـ Boxing/Unboxing).
• اكتشاف الأخطاء في وقت الترجمة.

مثال:

// كلاس عام (Generic Class)
public class Stack<T>
{
    private List<T> _items = new List<T>();
    
    public void Push(T item) => _items.Add(item);
    public T Pop()
    {
        if (_items.Count == 0)
            throw new InvalidOperationException();
        T item = _items[_items.Count - 1];
        _items.RemoveAt(_items.Count - 1);
        return item;
    }
}

// الاستخدام
Stack<int> intStack = new Stack<int>();
intStack.Push(5);
int num = intStack.Pop();

Stack<string> stringStack = new Stack<string>();
stringStack.Push("مرحباً");

2. Delegates (المفوضات)

المفهوم: المفوض هو نوع بيانات يشير إلى دالة (أو أكثر) بمواصفات محددة (المعاملات ونوع الإرجاع). يستخدم لتمرير الدوال كمعاملات، ولتنفيذ أحداث وعمليات رد الاتصال (Callbacks).

مثال:

// تعريف مفوض
public delegate int MathOperation(int x, int y);

// دوال تتوافق مع التوقيع
public int Add(int a, int b) => a + b;
public int Multiply(int a, int b) => a * b;

// الاستخدام
MathOperation op = Add;
int result = op(3, 4);        // 7
op = Multiply;
result = op(3, 4);            // 12

المفوضات المتعددة (Multicast Delegates):

public delegate void Notify(string message);

Notify del = msg => Console.WriteLine("Log: " + msg);
del += msg => Console.WriteLine("Send email: " + msg);
del("تم التحديث");  // سيتم استدعاء كلا الدالتين

أنواع المفوضات الجاهزة:

• Action (لا ترجع قيمة)
• Func<TResult> (ترجع قيمة)
• Predicate<T> (ترجع bool)

Action<string> print = s => Console.WriteLine(s);
Func<int, int, int> sum = (a, b) => a + b;
Predicate<int> isEven = n => n % 2 == 0;

3. Lambda Expressions (تعبيرات لامدا)

المفهوم: طريقة مختصرة لكتابة دوال مجهولة (بدون اسم) تستخدم غالبًا مع المفوضات و LINQ. تتكون من معاملات (يسار =>) وجسم التعبير (يمين).

الصيغة العامة: (المعاملات) => التعبير

أمثلة:

// بدون معاملات
Action greet = () => Console.WriteLine("Hello");

// معامل واحد دون أقواس
Func<int, int> square = x => x * x;

// عدة معاملات
Func<int, int, int> add = (a, b) => a + b;

// جسم معقد (أكثر من عبارة)
Func<int, int> factorial = n =>
{
    int result = 1;
    for (int i = 1; i <= n; i++) result *= i;
    return result;
};

// استخدام مع LINQ
var numbers = new List<int> { 1, 2, 3, 4, 5 };
var evens = numbers.Where(n => n % 2 == 0).ToList();

4. Extension Methods (دوال الامتداد)

المفهوم: تتيح إضافة دوال جديدة لأنواع موجودة دون تعديل تعريفها الأصلي أو استخدام الوراثة. تُعرف داخل كلاس ثابت (static) والدالة نفسها ثابتة، ويسبق المعامل الأول الكلمة this.

مثال:

public static class StringExtensions
{
    public static string Reverse(this string input)
    {
        if (string.IsNullOrEmpty(input)) return input;
        char[] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
    
    public static bool IsNumeric(this string str)
    {
        return double.TryParse(str, out _);
    }
}

// الاستخدام
string name = "C#";
string reversed = name.Reverse();  // "#C"
Console.WriteLine("123".IsNumeric()); // True

توسيع واجهات:

public static class LinqExtensions
{
    public static IEnumerable<T> ForEach<T>(this IEnumerable<T> source, Action<T> action)
    {
        foreach (var item in source) action(item);
        return source;
    }
}

// الاستخدام
new[] {1,2,3}.ForEach(x => Console.Write(x)); // 123

5. Immutability (الثبات / عدم القابلية للتغيير)

المفهوم: الكائن الثابت هو الذي لا تتغير حالته (قيم خصائصه) بعد إنشائه. بدلًا من تعديل الكائن، يتم إنشاء كائن جديد بقيم معدلة. هذا يبسط البرمجة متعددة الخيوط ويمنع الآثار الجانبية.

كيفية تحقيق الثبات في C#:

// نوع ثابت (Immutable)
public class Person
{
    public string Name { get; }
    public int Age { get; }
    
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
    
    // إنشاء كائن جديد بدلاً من تغيير الحالي
    public Person WithAge(int newAge) => new Person(this.Name, newAge);
}

// استخدام السجلات (C# 9+)
public record Point(int X, int Y); // أنواع ثابتة بشكل تلقائي

var p1 = new Point(3, 4);
var p2 = p1 with { X = 5 }; // نسخة جديدة بتعديل X

الفوائد:

• سلامة في البيئات المتعددة الخيوط (Thread-Safe).
• إمكانية مشاركة الكائنات بدون مخاوف.
• تسهيل كتابة دوال خالية من الآثار الجانبية.

أنواع ثابتة جاهزة: string، DateTime، ImmutableArray<T>، ImmutableList<T> من namespace System.Collections.Immutable.

6. LINQ (Language Integrated Query)

المفهوم: مجموعة من دوال الامتداد (على IEnumerable<T> و IQueryable<T>) تسمح بتنفيذ استعلامات شبيهة بقاعدة البيانات مباشرة في لغة C#. تدعم عدة مصادر بيانات: مصفوفات، قوائم، XML، وقواعد البيانات (عبر Entity Framework).

أسلوبان للكتابة:

Query Syntax (شبيه SQL):

var numbers = new[] { 1, 2, 3, 4, 5, 6 };
var evenNumbers = from n in numbers
                  where n % 2 == 0
                  orderby n descending
                  select n;
// النتيجة: 6, 4, 2

Method Syntax (باستخدام دوال الامتداد ولامدا):

var evenNumbers = numbers
    .Where(n => n % 2 == 0)
    .OrderByDescending(n => n);

أهم دوال LINQ:

الدالة	الوظيفة
Where	تصفية العناصر حسب شرط
Select	تحويل كل عنصر إلى شكل آخر (Projection)
OrderBy / OrderByDescending	ترتيب تصاعدي / تنازلي
GroupBy	تجميع العناصر حسب مفتاح
Join	ربط مصدرين وفق شرط
First / FirstOrDefault	استرجاع العنصر الأول
Any / All	التحقق من وجود عنصر يلبي شرطًا
Aggregate / Sum / Average / Count	عمليات تجميعية
Skip / Take	تقسيم النتائج (للصفحات)

أمثلة متقدمة:

// تصفية وتحويل
var names = new[] { "Ahmed", "Sara", "Mohamed" };
var upperNames = names.Where(n => n.Length > 4)
                       .Select(n => n.ToUpper());

// تجميع
var people = new[]
{
    new { Name = "Ali", Age = 25 },
    new { Name = "Sara", Age = 25 },
    new { Name = "Mohamed", Age = 30 }
};
var grouped = people.GroupBy(p => p.Age)
                    .Select(g => new { Age = g.Key, Count = g.Count() });

// انضمام (Join)
var customers = new[] { new { Id = 1, Name = "Ahmed" }, new { Id = 2, Name = "Sara" } };
var orders = new[] { new { CustId = 1, Product = "Book" }, new { CustId = 1, Product = "Pen" } };

var query = from c in customers
            join o in orders on c.Id equals o.CustId
            select new { c.Name, o.Product };

ملاحظة: معظم دوال LINQ (مثل Where, Select) لا تنفذ فورًا، بل عند البدء بالتكرار (مثل foreach أو استدعاء .ToList()). استخدم .ToList() أو .ToArray() لتنفيذ فوري.

---

📌 خلاصة

• Generics → كتابة كود مرن وآمن الأنواع.
• Delegates → تمرير الدوال ككائنات.
• Lambda → دوال مجهولة قصيرة.
• Extension Methods → إضافة دوال لأنواع قائمة.
• Immutability → إنشاء كائنات ثابتة لا تتغير.
• LINQ → استعلامات قوية ومتكاملة مع اللغة.

هذه المفاهيم تمثل ركائز أساسية للبرمجة الحديثة في C#، وتساعدك على كتابة كود أنظف وأكثر كفاءة وقابلية للصيانة.