Access Modifiers in C#

الـ Access Modifiers هي keywords في C# بتحدد مين يقدر يشوف ويستخدم الـ types (زي الـ class أو struct) والـ members (زي الـ methods أو variables) بتاعتك.

وظيفتها إنها تحدد مستوى الوصول أو الـ accessibility scope، بمعنى تاني، مين يقدر يوصل للكود ده وفين بالظبط، سواء جوه نفس الـ Library أو لو حد استخدم الـ Library دي في مشروع تاني.

جوه الـ Namespace بنقدر نكتب أربع أنواع أساسية:

• الـ Class و Interface (ودول Reference Types)
• الـ Struct و Enum (ودول Value Types)

جوه كل نوع من دول، بيكون فيه عناصر تانية زي الـ functions والـ variables، والـ Access Modifiers هي اللي بتتحكم في كل ده.

Access Modifiers Overview

Comparison Table

الجدول ده بيلخص إمكانية الوصول لكل modifier:

Access Modifier	Inside Class	In Same Namespace	Inherited Class	Another Class
Public	Yes	Yes	Yes	Yes
Private	Yes	No	No	No
Protected	Yes	No	Yes	No
Internal	Yes	Yes	No	No
Protected Internal	Yes	Yes	Yes	No
Private Protected	Yes	No	Yes (in same Library)	No

Valid Modifiers per Scope

الجدول ده بيوضح الـ Access Modifiers المتاحة لكل جزء من الكود والـ default بتاعها.

Scope	Contains	Valid Access Modifiers
Namespace	Class, Struct, Interface, Enum	internal (Default), public
Class	Attributes, Properties, Function, Event	All Access Modifiers (Default → private)
Struct	Attributes, Properties, Function, Event	private (Default), internal, public
Interface	Property Signature, Method Signature, Default Implemented Method	public (Default)
Enum	Labels	N/A for labels

Detailed Explanations

Public

• الـ member بيكون متاح للاستخدام من أي مكان في البرنامج بدون أي قيود.

public class MyClass
{
    // This variable can be accessed from anywhere
    public int myVar = 5;
}
 
class Program
{
    static void Main()
    {
        MyClass obj = new MyClass();
        Console.WriteLine(obj.myVar); // Works perfectly
    }
}

Private

• الوصول بيكون مقتصر على الـ class أو الـ struct اللي اتعرف جواه بس.
• أي member بيكون private بيظهر جنبه علامة قفل في الـ IntelliSense.
• مش بيكون متاح بره الـ scope بتاعه نهائيًا.

public class MyClass
{
    private int myVar = 5;
 
    public void ShowVar()
    {
        // Accessible inside the same class
        Console.WriteLine(myVar); 
    }
}
 
class Program
{
    static void Main()
    {
        MyClass obj = new MyClass();
        obj.ShowVar();
        // obj.myVar = 10; // ERROR: 'MyClass.myVar' is inaccessible due to its protection level
    }
}

Protected

• بيسمح بالوصول جوه نفس الـ class وأي class تاني بيورث منه (derived class).
• بيظهر جنبه علامة نجمة في الـ IntelliSense.
• بنستخدمه بشكل أساسي في الـ Inheritance عشان نسمح للكلاسات اللي بتورث مننا إنها تشوف الـ members دي من غير ما نكرر الكود.
• مينفعش نستخدمه في struct لأن الـ struct مش بتدعم الوراثة.
• بالنسبة للكلاس اللي هو متعرف فيه، هو بيُعتبر private.

public class MyClass
{
    protected int myVar = 5;
}
 
public class DerivedClass : MyClass
{
    public void ShowVar()
    {
        // Accessible because DerivedClass inherits from MyClass
        Console.WriteLine(myVar); 
    }
}

Internal

• الوصول بيكون متاح من أي مكان جوه نفس الـ Assembly (يعني نفس الـ Project، اللي بيتحول لملف DLL أو EXE واحد).
• بيظهر جنبه علامة قلب في الـ IntelliSense.
• لو عملت Library، أي member متعرف كـ internal تقدر تستخدمه جواها براحتك، لكن لو استدعيت الـ Library دي في project تاني، مش هتقدر توصل للـ member ده.

// ---- In ProjectA.dll ----
internal class MyClass
{
    internal int myVar = 5;
}
 
// ---- Also in ProjectA.dll ----
class Program
{
    static void Main()
    {
        MyClass obj = new MyClass();
        // Accessible because it's in the same assembly
        Console.WriteLine(obj.myVar); 
    }
}
 
// ---- In ProjectB.exe (referencing ProjectA.dll) ----
// You cannot create an instance of 'MyClass' or access 'myVar' here.

Protected Internal

• ده مزيج بين protected و internal. الوصول بيكون متاح لو الشرط ده أو ده اتحقق:
  1. الكود اللي بيستدعيه موجود في نفس الـ Assembly (زي internal).
  2. الكود اللي بيستدعيه موجود في derived class (زي protected)، حتى لو كان الـ derived class ده في Assembly مختلف.
• بالنسبة للكلاس اللي هو متعرف فيه، هو بيُعتبر private.

graph TD
    A[Access Scope] --> B{Protected OR Internal};
    B --> C[From Derived Class - Any Assembly];
    B --> D[From Same Assembly - Any Class];

public class MyClass
{
    protected internal int myVar = 5;
}
 
public class DerivedClass : MyClass
{
    public void ShowVar()
    {
        // Accessible because it's a derived class
        Console.WriteLine(myVar);
    }
}

Private Protected

• ده بيشترط تحقق الشرطين مع بعض:
  1. لازم يكون الوصول من derived class.
  2. ولازم يكون الـ derived class ده موجود في نفس الـ Assembly.
• بالنسبة للكلاس اللي هو متعرف فيه، هو بيُعتبر internal.

graph TD
    A[Access Scope] --> B{Private AND Protected};
    B --> C[From Derived Class];
    B --> D[Inside Same Assembly];

public class MyClass
{
    private protected int myVar = 5;
}
 
public class DerivedClass : MyClass
{
    public void ShowVar()
    {
        // Accessible because it's a derived class AND in the same assembly
        Console.WriteLine(myVar);
    }
}

---

Inside a Namespace

جوه الـ Namespace بنقدر نكتب:

• Class
• Struct
• Interface
• Enum

الـ Access Modifiers المتاحة هنا هما اتنين بس:

1. الـ internal (وده الـ Default)
2. الـ public

ملحوظة مهمة: قبل ما تحاول تستخدم أي class أو type من Library تانية، لازم الأول تضيف الـ Library دي كـ dependency في المشروع بتاعك، وبعدين تعملها using في أول الملف.

لو معرّفتش Access Modifier لأي type على مستوى الـ Namespace، الـ C# compiler هيعتبره internal تلقائيًا. ده معناه إنه هيكون متاح للاستخدام جوه نفس الـ Project بس. لو محتاج توصله من project تاني، لازم تعرّفه كـ public.

Inside a Class or Struct

جوه الـ Class أو الـ Struct بنقدر نكتب:

• الـ Attributes (Fields): اللي هي الـ member variables.
• الـ Properties: زي الـ Full Property والـ Automatic Property.
• الـ Functions: زي الـ Constructor والـ Methods.
• الـ Events.

Modifiers in a Struct

متاح 3 أنواع بس:

• private (Default)
• internal
• public

Modifiers in a Class

متاح كل الأنواع الستة:

• private (وده الـ Default)
• private protected
• protected
• internal
• protected internal
• public

الـ Default لأي member جوه class أو struct هو private.

Inside an Interface

جوه الـ Interface بنقدر نكتب:

1. Signature for Property: بنحدد شكل الـ property بس من غير implementation.

   // In an interface, this is a property signature
   public int Salary { get; set; }

2. Signature for Method: بنكتب الـ signature بتاع الـ method بس من غير body.

   public void MyFun();

3. Default Implemented Method: دي feature جديدة من أول C# 8.0، بتسمحلك تكتب method كاملة جوه الـ interface.

   public void Print()
   {
       Console.WriteLine("Hello Default Implemented");
   }

الـ Default لأي member جوه interface هو public، وده منطقي لأن الهدف من الـ interface هو إن الكلاسات اللي بتعملها implement تقدر توصل للـ signatures دي.

Inside an Enum

الـ Enum بنكتب جواه Labels بس. الـ Access Modifiers بتتحط على الـ Enum نفسه، مش على الـ labels اللي جواه.