Access Modifiers in CSharp

الـ Access Modifiers، أو زي ما بيتسموا برضه Access Specifiers، هما عبارة عن C# Keywords بتساعدنا نحدد نطاق الوصول أو الرؤية (accessibility scope). ببساطة، هما اللي بيحددوا مين يقدر يستخدم أو يشوف type معين (زي class أو struct) أو عضو معين (زي method أو variable) ومين لأ.

في لغة C#، إحنا بنكتب الكود بتاعنا جوه Namespace، وجوه الـ namespace ده بنعرف types مختلفة زي:

• Class
• Interface
• Struct
• Enum

وجوه الـ Types دي، بنكتب أعضاء (members) زي الـ functions والمتغيرات وغيرها. الـ Access Modifiers هي اللي بتجاوب على سؤال: “الحاجات دي هتبقى متاحة للوصول لحد فين بالظبط؟ هل جوه الـ Library (المشروع) بس، ولا لو حد استخدم الـ Library دي في مشروع تاني هيقدر يوصلها برضه؟“.

Types of Access Modifiers

لغة C# بتدعم 6 أنواع من الـ Access Modifiers:

1. Public
2. Private
3. Protected
4. Internal
5. Protected Internal
6. Private Protected
7. file new access modifier

الـ Members اللي متعرفة جوه type معين بتكون دايمًا متاحة للوصول من جوه نفس الـ type ده، بغض النظر عن الـ Access Modifier بتاعها. القيود بتظهر بس لما بنحاول نوصل للعضو ده من بره الـ type.

Detailed Breakdown of Each Access Modifier

خلينا نفصص كل واحد فيهم بالتفصيل.

1. Public

• الشرح: نقدر نوصله من أي مكان في البرنامج بدون أي قيود، سواء جوه نفس الـ Assembly (المشروع) أو من أي Assembly تاني.
• مثال:

public class MyClass
{
	public int myVar = 5;
}
 
class Program
{
	static void Main()
	{
		MyClass obj = new MyClass();
		// Accessible from anywhere
		Console.WriteLine(obj.myVar);
	}
}

2. Private

• الشرح: نقدر نوصله فقط جوا نفس الكلاس أو الـ Struct اللي هو متعرف جواه. ده أكتر نوع مقيد فيهم.
• العلامة في الـ IDE: الـ Member بيبقى عليه شكل قفل.
• مثال:

public class MyClass
{
	private int myVar = 5;
 
	public void ShowVar()
	{
		// Accessible only inside this class
		Console.WriteLine(myVar); 
	}
}
 
class Program
{
	static void Main()
	{
		MyClass obj = new MyClass();
		obj.ShowVar(); // This works
		// obj.myVar = 10; // This would cause a compile-time ERROR
	}
}

3. Protected

• الشرح: نقدر نوصله جوا نفس الكلاس، وفي أي Inherited Classes (كلاسات بتورث منه)، حتى لو الكلاس اللي بيورث ده موجود في Assembly مختلف.
• العلامة في الـ IDE: بيبقى عليه شكل نجمة.
• الاستخدام: بنستخدمه بشكل أساسي مع الـ Inheritance عشان نسمح للكلاسات الأبناء إنها توصل لأعضاء معينة في الكلاس الأب من غير ما نخليها public للكل.
• ملاحظات:
  • مينفعش نستخدمه في Struct لأنه مش بيدعم الوراثة.
  • بالنسبة للكلاس اللي هو فيه، هو بيتعامل معاملة الـ private.
• مثال:

public class MyClass
{
	protected int myVar = 5;
}
 
// DerivedClass can access myVar because it inherits from MyClass
public class DerivedClass : MyClass
{
	public void ShowVar()
	{
		Console.WriteLine(myVar);
	}
}
 
public class AnotherClass
{
	public void TryAccess()
	{
		MyClass obj = new MyClass();
		// obj.myVar = 10; // ERROR: Not accessible from a non-derived class
	}
}

4. Internal

• الشرح: نقدر نوصله جوا نفس الـ project/assembly. الـ Assembly هو المنتج النهائي لعملية الـ build (زي ملف DLL أو EXE). أي كلاس جوه نفس المشروع يقدر يشوفه، لكن لو حاولت تستخدمه من مشروع تاني، مش هتقدر.
• العلامة في الـ IDE: بيبقى عليه علامة قلب.
• مثال:

// This class is in ProjectA.dll
internal class MyClass
{
	internal int myVar = 5;
}
 
// This class is also in ProjectA.dll
class ProgramInSameAssembly
{
	static void Main()
	{
		MyClass obj = new MyClass();
		// Works because it's in the same assembly
		Console.WriteLine(obj.myVar); 
	}
}
// If you try to access MyClass from ProjectB.exe, it will fail.

5. Protected Internal

• الشرح: ده مزيج بيجمع بين Protected و Internal. الوصول بيكون مسموح به في حالتين (OR):
  • من أي كلاس داخل نفس الـ Assembly.
  • أو من أي Inherited Class، حتى لو كان في assembly مختلف.
• بالنسبة للكلاس اللي هو فيه: بيتعامل معاملة الـ private.
• مثال:

public class MyClass
{
	protected internal int myVar = 5;
}
 
// Derived class in another assembly
public class DerivedClass : MyClass
{
	public void ShowVar()
	{
		// Accessible: it's a derived class
		Console.WriteLine(myVar); 
	}
}
 
// Non-derived class in the same assembly
public class AnotherClassInSameAssembly
{
	public void AccessVar()
	{
		MyClass obj = new MyClass();
		// Accessible: it's in the same assembly
		obj.myVar = 10;
	}
}

6. Private Protected

• الشرح: ده مزيج مقيد أكتر، بيجمع بين Private و Protected. الوصول مسموح به بس لو الشرطين دول اتحققوا مع بعض (AND):
  • من Inherited Class.
  • و لازم الكلاس ده يكون في نفس الـ Assembly.
• بالنسبة للكلاس اللي هو فيه: بيتعامل معاملة الـ internal.
• مثال:

// In ProjectA.dll
public class MyClass
{
	private protected int myVar = 5;
}
 
// In ProjectA.dll
public class DerivedClass : MyClass
{
	public void ShowVar()
	{
		// Accessible: derived class AND in the same assembly
		Console.WriteLine(myVar); 
	}
}
 
// In ProjectB.exe
public class DerivedInAnotherAssembly : MyClass
{
	public void TryShowVar()
	{
		// Console.WriteLine(myVar); // ERROR: Not in the same assembly
	}
}

7. New in Modern .NET: The file Modifier

ابتداءً من C# 11 (واللي مكمل معانا في .NET 8, 9, و 10)، ظهر Access Modifier جديد ومهم جدًا اسمه file.

• الـ file modifier: بيخلي الكلاس متشاف فقط جوه ملف الكود (الـ .cs file) اللي هو مكتوب فيه.
• ده مفيد جدًا في حالات الـ Source Generators عشان يمنع تعارض الأسماء بين الملفات المختلفة.

// File-scoped type (C# 11+)
file class HiddenHelpers
{
    // This class is ONLY visible within this specific .cs file
}

مش مهم.

Summary of Access Levels

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

Access Modifier	Inside Class	In Same Namespace	Inherited Classes	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

Access Modifiers in Different Scopes

القواعد بتختلف على حسب المكان اللي بتكتب فيه الكود.

Inside a Namespace

جوه الـ Namespace، الـ types اللي بنعرفها (Class, Struct, Interface, Enum) معندهاش غير اتنين Access Modifiers متاحين:

1. الـ Internal (Default): لو مكتبتش أي حاجة، الـ type بتاعك هيكون internal. ده معناه إنه هيكون متشاف جوه الـ Library (المشروع) اللي هو فيه بس. لو حاولت تستخدمه من مشروع تاني، مش هتشوفه وهيطلعلك error.
2. الـ Public: لو عايز الـ type بتاعك يكون متاح للاستخدام في أي مشروع تاني، لازم تعمله public.

قبل ما تحاول تستخدم أي class أو حاجة موجودة في Library تانية، لازم الأول تضيف reference للـ Library دي في المشروع بتاعك (Right click at project → Build dependencies → Project dependencies → Add project reference)، وبعدين تعمل using للـ namespace بتاعها فوق في ملف الكود.

Inside a Class or a Struct

جوه الـ Class أو الـ Struct، بنقدر نكتب members زي الـ Fields, Properties, Methods, و Events.

• جوه الـ Class: متاح كل الستة Access Modifiers.
• جوه الـ Struct: متاح تلاتة بس: Private، Internal، و Public.

الافتراضي (Default) في الاتنين هو Private.

Inside an Interface

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

• الـ Signature for a Property: بنحدد شكل الـ property بس، زي: public int Salary {get; set;}.
• الـ Signature for a Method: بنكتب توقيع الـ method من غير body، زي: public void MyFun();.
• الـ Default Implemented Method: function كاملة بالـ body بتاعها (ميزة اتضافت في C# 8.0).

الافتراضي (Default) في الـ Interface هو Public. والسبب هو إن الـ Interface عبارة عن contract، فلازم كل حاجة فيه تكون متاحة للكلاس اللي هيعمله implement.

Inside an Enum

جوه الـ Enum، بنكتب Labels (أسماء القيم)، ودي بتكون public بشكل افتراضي.

Summary Table for Scopes & Defaults

Scope	What’s Inside?	Valid Access Modifiers	Default
Namespace	Class, Struct, Interface, Enum	Internal, Public	Internal
Class	Fields, Properties, Methods, Events	All 6 Modifiers	Private
Struct	Fields, Properties, Methods, Events	Private, Internal, Public	Private
Interface	Property/Method Signatures, Default Methods	-	Public

Practical Example Breakdown

المثال ده بيوضح الفرق الدقيق بين private protected و protected internal في سيناريوهات مختلفة:

// Library: Common
public class TypeA
{
	private protected int X;
	protected int Y; 
	protected internal int Z;
}
 
// === Scenario 1: Derived Class in the SAME Library ===
// Class: TypeB
internal class TypeB : TypeA
{
    public TypeB()
    {
        // X is accessible: derived AND in same assembly.
        this.X = 1;
 
        // Y is accessible: derived.
        this.Y = 2;
 
        // Z is accessible: in same assembly.
        this.Z = 3;
    }
}
 
// === Scenario 2: Derived Class in ANOTHER Library ===
// Class: TypeC (in a different project/assembly)
internal class TypeC : TypeA
{
	public TypeC()
	{
		// X is NOT accessible: it's a derived class, BUT NOT in the same assembly.
		// this.X = 1; // ERROR
 
		// Y is accessible: it's a derived class.
		this.Y = 2;
 
		// Z is accessible: it's a derived class.
		this.Z = 3;
	}
}