Variables in C#

Introduction: Why Variables in C#

ليه أصلاً بنعمل Programs؟ عشان نعالج معلومات أو بيانات. زي مثلاً Program بتاع بنك، لما بيعملوا معاملة، هما بيعالجوا بيانات زي رقم الحساب، اسم صاحب الحساب، الرصيد وهكذا.

أي بيانات أو معلومات بنعالجها، لازم تكون متخزنة في مكان معين. المكان ده بنسميه Memory Location (موقع في الذاكرة). كل جهاز كمبيوتر فيه Memory Locations، وكل Memory Location ليه عنوان (address) بيميزه. ممكن نتخيلها زي كراسي في سينما، كل كرسي ليه رقم.

الـ Memory Locations دي كل واحد ليه عنوان، العناوين دي ممكن نعتبرها أرقام صحيحة موجبة.

What is the relation between variable and memory locations?

افرض عايز أخزن القيمة 10 في الـ Memory. زي ما الطلاب في الفصل ممكن يقعدوا في أي كرسي بشكل عشوائي، القيمة 10 دي كمان هتتخزن في أي Memory Location بشكل عشوائي.

How to Access the Data?

طب دلوقتي لو عايز أوصل للبيانات دي، يعني للقيمة 10، وأطبعها مثلاً؟ هقابل مشكلة. ليه؟ عشان مش هعرف أحدد الـ Memory Location اللي البيانات اتخزنت فيه بالظبط، لأنها اتخزنت بشكل عشوائي. الوصول للـ Memory Location بيبقى صعب جداً بعد تخزين المعلومات. طيب إيه الحل؟ قبل ما أخزن المعلومات، لازم أدي هوية (identity) للـ Memory Location اللي البيانات هتتخزن فيه.

How we can set Identity to Memory Locations?

نقدر ندي هوية للـ Memory Location باستخدام الـ Variables، أو ممكن تقول عليها Identifiers. الـ Syntax عشان تعرف Variable وتدي هوية للـ Memory Location في C# هو كالتالي: الأول بنكتب الـ data_type وبعدين الـ Identifier (اسم الـ Variable).

Syntax: data_type Identifier;

مثال: int a; هنا الـ int هو الـ data type، والـ Identifier هو “a”. لما بنعرف Variable كده، بيتم تخصيص Memory ليه. الـ Memory Location ده بياخد الهوية اللي هي اسم الـ Variable زي ما في الصورة:

الـ “a” هنا هو اسم للـ Memory Location رقم 10344. بعد كده نقدر نخزن قيمة في الـ Memory Location ده اللي متعرف بـ “a” كالتالي:

الـ a = 10; // هنا القيمة هي 10 وبنخزنها في الـ Memory Location اللي متعرف بـ “a” زي الصورة:

مثال تاني: في السينما، كل كرسي ليه رقم مميز، ولما بتيجي بتقعد في الكرسي اللي متخصصلك. بعد كده لو عايز ينادوك أو يوصلولك، يقدروا يوصلولك بسهولة عن طريق رقم الكرسي.

What is a Variable in C# Language?

اسم بنديه لأي Memory Location في الكمبيوتر ده بنسميه Variable. الهدف من الـ Variable هو إنه يدي اسم للـ Memory Location اللي بنخزن فيه بيانات معينة. الـ User بيوصل للبيانات دي عن طريق اسم الـ Variable والـ Compiler بيوصل للبيانات عن طريق الـ memory address. يبقى الـ Variable هو مكان متسمي في Memory الكمبيوتر، البرنامج يقدر يخزن فيه البيانات.

Variables

• الـ Variables دي زي حاويات (containers) بنخزن فيها قيم البيانات (data values).
• الـ Variable ده بيتغير مع الوقت حسب القيمة اللي بنديهاله.
• نقدر نستخدم أي نوع من أنواع الـ data types الموجودة في CSharp Memory Management.

Declaring (Creating) Variables

الـ Variables هي حاويات لتخزين قيم البيانات.

// type variableName = value;
string name = "Corn"; // Define a string variable and assign a value
int myNum = 15; // Define an integer variable and assign a value
 
// Declare without assigning
int myNum; // Declare an integer variable
// Assignment
myNum = 15; // Assign a value later
 
// if you assign a new value to an existing variable, it will overwrite the previous value
int myNum = 15; // Initial assignment
myNum = 20; // Reassigns the value, myNum is now 20
 
int myNum = 5; // Integer variable
double myDoubleNum = 5.99D; // Double variable
char myLetter = 'D'; // Character variable
bool myBool = true; // Boolean variable
string myText = "Hello"; // String variable

الـ Syntax عشان تعرف Variable في C# كالتالي: Syntax: data_type variable_name; Example: int age;

الـ Syntax عشان تدي قيمة مبدئية (initialize) لـ Variable في C# كالتالي: Syntax: data_type variable_name = value; Example: int age = 20;

Multiple Variables

عشان تعرف أكتر من Variable من نفس النوع، ممكن تستخدم لستة مفصولة بـ comma:

int x = 5, y = 6, z = 50; // Declare and initialize multiple int variables
Console.WriteLine(x + y + z); // Print the sum
 
// You can also assign the same value to multiple variables in one line
int x, y, z; // Declare multiple int variables
x = y = z = 50; // Assign the same value to all of them

Rules for variable declaration in C#

1. اسم الـ Variable لازم يبدأ بحرف أو علامة الـ underscore (_).
2. الـ Variables في C# بتفرق بين الحروف الكبيرة والصغيرة (case sensitive). يعني myVar مختلفة عن myvar.
3. ممكن تتكون من أرقام وحروف.
4. مش مسموح بأي رموز خاصة غير الـ underscore.
5. أمثلة على أسماء Variable صحيحة: sum, Height, _value, abc123.

Types of Variables in a Class in C#

فيه أربع أنواع أساسية من الـ Variables ممكن نعرفها جوه الـ Class في C#:

1. Non-Static/Instance Variable
2. Static Variable
3. Constant Variable
4. Readonly Variable

بالإضافة للأنواع دي، فيه أنواع تانية ليها استخدامات خاصة زي var, object, و dynamic. هنتكلم عن كل نوع بالتفصيل.

Static and Non-Static Variables in C#

لو عرفنا Variable صراحةً باستخدام الـ modifier اللي اسمه static، بنسميه static variable. وباقي الـ Variables كلها بتبقا non-static variables (افتراضي). لو عرفنا Variable جوه static block (زي الـ Main method اللي هي static)، يبقى الـ Variable ده static variable. ولو عرفنا Variable جوه non-static block (زي Method عادية مش static)، يبقى ده non-static variable.

عشان نفهم أكتر، بص على الـ Example ده. معرفين فيه تلاتة Variables:

• الـ Variable x هو static variable عشان متعرف بـ static.
• الـ Variable y هو non-static افتراضي.
• الـ Variable z هو static عشان متعرف جوه الـ Main method اللي هي static.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        static int x; // Static Variable (Class level)
        int y; // Non-Static or Instance Variable (Class level)
        static void Main(string[] args)
        {
            int z; // Static Variable (Local to Static method)
        }
    }
}

دلوقتي، تعال نحاول نطبع قيمة x و y جوه الـ Main method. خلينا نديله قيمة مبدئية: x = 100 و y = 200. تقدر تطبع قيمة x مباشرة جوه الـ Main method. لكن مش هتقدر تطبع قيمة y مباشرة.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        static int x = 100; // Static Variable initialized
        int y = 200; // Non-Static or Instance Variable initialized
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}"); // Accessing static variable directly
            Console.Read();
        }
    }
}

Output: x value: 100

لو حاولنا نطبع قيمة y مباشرة، هيجيلنا Compile-time error بيقول an object reference is required for the non-static field, method, or property ‘Program.y’. يعني محتاجين Object عشان نوصل لـ y اللي هي non-static. بص على الـ Example ده اللي بنحاول فيه نطبع x و y مباشرة:

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        static int x = 100; // Static Variable
        int y = 200; // Non-Static or Instance Variable
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}"); // OK
            Console.WriteLine($"x value: {y}"); // Compile-time Error here!
            Console.Read();
        }
    }
}

لما تحاول تشغل الـ Code ده، هيجيلك Compile Time Error.

السبب في كده إن الـ Memory للـ Variable y مش بتتعمل غير لما نعمل instance من الـ Class اللي اسمها Program، ولكل instance بنعمله. لكن الـ x مش محتاج instance من الـ Class. ليه؟ لأن الـ static variable بيتم تهيئته (initialized) أول ما الـ Class تبدأ تتنفذ.

يعني لحد ما نعمل instance من الـ Class Program، الـ Memory مش هتتخصص للـ Variable y، وطول ما الـ Memory مش متخصصة لـ y، مش هنقدر نوصلها. يبقى، أول ما نعمل instance من الـ Class Program، الـ Memory للـ Variable y هتتخصص، وساعتها بس هنقدر نوصل للـ Variable y.

في الـ Example ده، هنعمل instance من الـ Class Program، ونستخدم الـ instance ده عشان نوصل للـ Variable y. لكن الـ x هنوصله مباشرة.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        static int x = 100; // Static Variable
        int y = 200; // Non-Static or Instance Variable
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}"); // Access static directly
            Program obj = new Program(); // Create an instance of the Program class
            Console.WriteLine($"y value: {obj.y}"); // Access non-static using the instance
            Console.Read();
        }
    }
}

دلوقتي لما تشغل الـ Code اللي فوق ده، هتلاقي بيطبع قيمة x و y الاتنين عادي:

Output:

x value: 100
y value: 200

معلومة: أول نقطة محتاج تفتكرها وأنت بتشتغل مع الـ static والـ non-static variables، إن الـ static members (variables, methods, etc.) في الـ Class مش محتاجين instance من الـ Class عشان يتم تهيئتهم وتنفيذهم. في المقابل، الـ non-static members في الـ Class محتاجين instance من الـ Class عشان يتم تهيئتهم وتنفيذهم.

When Static and Non-Static Variables are Initialized in C#?

الـ Static variables في الـ Class بيتم تهيئتها أول ما الـ Class تبدأ تتنفذ. أما الـ non-static variables أو الـ instance variables بيتم تهيئتها فقط بعد عمل instance من الـ Class، وفي كل مرة بنعمل فيها instance جديد من الـ Class.

الفترة من أول ما نبدأ تنفيذ الـ Class لحد ما نخلص تنفيذه بنسميها الـ Life Cycle بتاعة الـ Class. في الـ Life Cycle دي، الـ static variables بيتم تهيئتها مرة واحدة بس. أما الـ non-static أو الـ instance variables بيتم تهيئتها 0 مرة لو ما عملناش أي instance، و N مرة لو عملنا N من الـ instances.

تعال نفهم ده بمثال. بص على الـ Code ده. هنعمل فيه instance من الـ Class Program مرتين.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        static int x = 100; // Static Variable
        int y = 200; // Non-Static or Instance Variable
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}"); // x is 100
            Program obj1 = new Program(); // Create first instance
            Program obj2 = new Program(); // Create second instance
            Console.WriteLine($"obj1 y value: {obj1.y}"); // y for obj1 is 200
            Console.WriteLine($"obj2 y value: {obj2.y}"); // y for obj2 is 200
            Console.Read();
        }
    }
}

في الـ Example ده، أول ما الـ Program execution starts، الـ memory is allocated للـ static variable x. بعد كده عملنا instance من الـ Class Program مرتين، ده معناه إن الـ memory اتخصصت للـ Variable y مرتين. مرة للـ instance obj1 ومرة للـ instance obj2. عشان تفهم أكتر، بص على الـ Diagram ده اللي بيمثل الـ Memory architecture للـ Example اللي فوق.

زي ما أنت شايف في الـ Diagram اللي فوق، الـ static variable x هيتعمل مرة واحدة بس، والـ non-static variable y هيتعمل مرتين عشان عملنا instance من الـ Class Program مرتين.

Initializing Non-Static variables through Class Constructor in C#

لما بنعمل instance من الـ Class، الـ constructor بيتم استدعاؤه (called)، ومن هنا نقدر نهيئ (initialize) الـ instance variables أو الـ non-static variables عن طريق الـ Class constructor.

في الـ Example اللي فات، الاتنين objects كان عندهم نفس قيمة y اللي هي 200. دلوقتي، لو عايز تديله قيم مختلفة، تقدر تعمل ده باستخدام الـ constructor. تعال نفهم ده بمثال. في الـ Example اللي تحت، عملنا constructor بياخد integer parameter واحد، وقيمة الـ parameter ده بنسندها (assign) للـ non-static variable y. واحنا بنعمل الـ instance جوه الـ Main method، بنمرر قيم مختلفة. دلوقتي، أي قيمة هنمررها، هيتم تخزينها جوه الـ non-static variable y.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        static int x = 100; // Static Variable
        int y = 200; // Non-Static or Instance Variable (Initial default)
        // Class Constructor
        public Program(int a) // Constructor takes an int parameter
        {
            y = a; // Initializing non-static variable y with the passed value
        }
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}"); // x is 100
            Program obj1 = new Program(300); // Create obj1, y is 300 for this instance
            Program obj2 = new Program(400); // Create obj2, y is 400 for this instance
            Console.WriteLine($"obj1 y value: {obj1.y}");
            Console.WriteLine($"obj2 y value: {obj2.y}");
            Console.Read();
        }
    }
}

Output:

x value: 100
obj1 y value: 300
obj2 y value: 400

دلوقتي، في الـ Memory، قيمة y للـ obj1 هتبقى 300، وللـ obj2 هتبقى 400. لكن قيمة الـ x هتفضل زي ما هي 100. عشان تفهم أكتر، بص على الـ Diagram ده اللي بتوضح الـ Memory representation.

ممكن يجيلك سؤال دلوقتي، هل نقدر نهيئ الـ static variable عن طريق الـ constructor؟ الإجابة هي أيوة. نقدر نهيئ الـ static variable عن طريق الـ constructor. بس كل مرة الـ constructor يتنفذ فيها، قيمة الـ static variable القديمة هيتم استبدالها بالقيمة الجديدة. عشان تفهم أكتر، بص على الـ Example ده. في الـ Example اللي تحت، بنهيئ الـ static variable عن طريق الـ Class constructor. جزء من شغل الـ constructor إنه بيهيئ الـ Variables x و y بقيمة الـ parameter a.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        static int x = 100; // Static Variable
        int y = 200; // Non-Static or Instance Variable (Initial default)
        // Class Constructor
        public Program(int a) // Constructor takes an int parameter
        {
            y = a; // Initializing non-static variable
            x = a; // Initializing static variable - !!! This will overwrite x for *all* instances !!!
        }
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}"); // x = 100 initially
            Program obj1 = new Program(300); // Constructor sets x to 300
            Console.WriteLine($"obj1 y value: {obj1.y}"); // y = 300 for obj1
            Console.WriteLine($"x value: {x}"); // x is now 300
            Program obj2 = new Program(400); // Constructor sets x to 400
            Console.WriteLine($"obj2 y value: {obj2.y}"); // y = 400 for obj2
            Console.WriteLine($"x value: {x}"); // x is now 400
            Console.Read();
        }
    }
}

Output:

x value: 100
obj1 y value: 300
x value: 300
obj2 y value: 400
x value: 400

عشان تفهم أكتر، بص على الـ Diagram ده:

يبقى النقطة اللي محتاج تفتكرها هي إنك لو بتعمل تهيئة (initializing) للـ static variable عن طريق الـ constructor، فكل مرة الـ constructor يتنفذ فيها، القيمة الموجودة حالياً في الـ static variable هيتم استبدالها بالقيمة الجديدة. لذلك، عموماً مش بنعمل تهيئة للـ static variables عن طريق الـ constructor. لو عايز تهيئ Variable عن طريق الـ constructor، خليه non-static.

Difference Between Static and Non-Static Variables in C#

• في حالة الـ Instance Variable، كل Object هيبقى ليه نسخته الخاصة بيه. أما الـ Static variable، بيبقى ليها نسخة واحدة بس مشتركة بين كل الـ Objects بغض النظر عملت كام Object.
• التغييرات اللي بتعملها في الـ instance variable باستخدام Object معين مش هتظهر في الـ Objects التانية، لأن كل Object ليه نسخته الخاصة من الـ instance variable. أما في حالة الـ static variables، أي تغيير بيحصل في Object معين هيظهر في كل الـ Objects التانية، لأن الـ static variables مشتركة بين كل الـ Objects بتاعت الـ Class.
• الـ instance variables بنقدر نوصلها عن طريق الـ object references (يعني اسم الـ object والنقطة .). أما الـ Static Variables بنقدر نوصلها مباشرة باستخدام اسم الـ Class في C#.
• في الـ Life Cycle بتاعت الـ Class، الـ static variable بيتم تهيئته مرة واحدة بس، أما الـ instance variables بيتم تهيئتها 0 مرة لو ما عملناش أي instance، و n مرة لو عملنا n من الـ instances.

Instance/Non-Static Variables in C# الـ Scope بتاع الـ Instance Variable: بيبقى موجود في كل الـ Class ما عدا في الـ static methods. الـ lifetime بتاع الـ Instance Variable: بيفضل موجود لحد ما الـ Object اللي هو جزء منه يفضل موجود في الـ Memory.

Static Variables in C# الـ Scope بتاع الـ Static Variable: بيبقى موجود في الـ Class كلها. الـ Lifetime بتاع الـ Static Variable: بيفضل موجود لحد ما البرنامج كله يخلص تنفيذه.

Constant Variables in C#

• لو مش عايز حد (أو حتى أنت نفسك) يغير القيمة الموجودة في Variable، ممكن تزود كلمة const قبل نوع الـ Variable.

const int myNum = 15; // Declare a constant integer variable
myNum = 20; // This will cause an error: Cannot assign to 'myNum' because it is a constant

Note: مش ممكن تعرف Variable const من غير ما تدي له قيمة في نفس الوقت. لو عملت كده، هيحصل Error: A const field requires a value to be provided.

في C#، لو عرفنا Variable باستخدام الـ keyword اللي اسمه const، يبقى ده constant variable وقيمة الـ constant variable دي مش ممكن تتعدل بعد ما يتم تعريفها. عشان كده، لازم إجباري تعمل تهيئة (initialize) للـ constant variable وقت التعريف بتاعه. لو عايز تعرف الـ constant PI في برنامجك، ممكن تعرفه كالتالي:

const float PI = 3.14f;

لو ما عملتش تهيئة للـ const variable وقت التعريف بتاعه، هيجيلك Compiler error.

Note: الـ constant variables بيتم عملها مرة واحدة بس. ليه؟ لأن قيمتها مش ممكن تتغير بعد تعريفها، فلو سمحنا نعمل نسخ كتير من الـ constant variable، كل النسخ دي هتخزن نفس القيمة وده يعتبر استهلاك للـ Memory على الفاضي. فلما تكون القيمة مش هتتغير، عمل نسخ كتير هو استهلاك للموارد على الفاضي.

سلوك الـ constant variable شبه سلوك الـ static variables، يعني بيتم تهيئتها مرة واحدة بس في الـ Life Cycle بتاعت الـ Class، ومش بتحتاج instance من الـ Class لا للتهيئة ولا للتنفيذ. عشان تفهم أكتر، بص على الـ Example ده.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        const float PI = 3.14f; // Constant Variable
        static int x = 100; // Static Variable
        //We are going to initialize variable y through constructor
        int y; // Non-Static or Instance Variable
        //Constructor
        public Program(int a)
        {
            //Initializing non-static variable
            y = a;
        }
        static void Main(string[] args)
        {
            //Accessing the static variable without instance
            Console.WriteLine($"x value: {x}"); // x is 100
            //Accessing the constant variable without instance
            Console.WriteLine($"PI value: {PI}"); // PI is 3.14
            Program obj1 = new Program(300); // Create obj1, y=300
            Program obj2 = new Program(400); // Create obj2, y=400
            //Accessing Non-Static variable using instance
            Console.WriteLine($"obj1 y value: {obj1.y}");
            Console.WriteLine($"obj2 y value: {obj2.y}");
            Console.Read();
        }
    }
}

Output:

x value: 100
PI value: 3.14
obj1 y value: 300
obj2 y value: 400

الـ Diagram اللي جاي بيوضح الـ Memory representation للـ Example اللي فوق.

ممكن يجيلك سؤال دلوقتي، لو الاتنين (static و constant) بيتصرفوا بنفس الطريقة، إيه الفرق بينهم؟

Difference Between Static and Constant Variable in C#

الفرق الوحيد بين الـ static والـ constant variable هو إن الـ static variables ممكن تتعدل بعد تهيئتها، أما الـ constant variables في C# مش ممكن تتعدل خالص بعد ما يتم تعريفها (وتهيئتها). تعال نثبت ده. في الـ Example اللي تحت، جوه الـ Main method، بنحاول نعدل قيمة الـ static x والـ constant PI.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        const float PI = 3.14f; // Constant Variable
        static int x = 100; // Static Variable
        int y; // Non-Static or Instance Variable
        //Constructor
        public Program(int a)
        {
            //Initializing non-static variable
            y = a;
        }
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}");
            Console.WriteLine($"PI value: {PI}");
 
            x = 700; // Modifying Static Variable - Allowed
            // PI = 3.15f; // Trying to Modify the Constant Variable - Compile Error!
 
            Console.WriteLine($"x value after modification: {x}"); // x is now 700
 
            Program obj1 = new Program(300);
            Program obj2 = new Program(400);
 
            Console.WriteLine($"obj1 y value: {obj1.y}");
            Console.WriteLine($"obj2 y value: {obj2.y}");
            Console.Read();
        }
    }
}

لما تحاول تشغل الـ Code اللي فوق ده، هيجيلك Compilation Error.

الـ Error ده بيقول صراحةً إن الـ left-hand side بتاع الـ assignment لازم يكون Variable, property أو indexer. لكن هنا هو constant، وبالتالي بيجيلنا compilation error.

Read-Only Variables in C#

لما بنعرف Variable باستخدام الـ keyword اللي اسمه readonly، بيبقى اسمه read-only variable. الـ Variables دي مش ممكن تتعدل زي الـ constants إلا بعد التهيئة. ده معناه إنه مش إجباري تعمل تهيئة (initialize) للـ read-only variable وقت تعريفه، ممكن كمان يتم تهيئته جوه الـ constructor. يعني نقدر نعدل قيمة الـ read-only variable فقط جوه الـ constructor.

سلوك الـ read-only variables بيبقى شبه سلوك الـ non-static variables في C#، يعني بيتم تهيئتها بس بعد ما نعمل instance من الـ Class، ومرة واحدة لكل instance بيتعمل. ده معناه إننا ممكن نعتبرها non-static variable، وعشان نوصل للـ readonly variables محتاجين instance.

Example to Understand Read-Only Variables in C#

في الـ Example اللي تحت، الـ read-only variable z مش متسندلها أي قيمة وقت التعريف، لكن لما نطبع قيمتها، الـ default value بتاعت الـ int اللي هي 0 هيتم عرضها.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        const float PI = 3.14f; // Constant Variable
        static int x = 100; // Static Variable
        //We are going to initialize variable y through constructor
        int y; // Non-Static or Instance Variable
        readonly int z; // Readonly Variable - not initialized here
 
        //Constructor
        public Program(int a)
        {
            y = a;
            // z is not initialized here, will take default value (0 for int)
        }
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}");
            Console.WriteLine($"PI value: {PI}");
 
            Program obj1 = new Program(300); // Create obj1, y=300
            Program obj2 = new Program(400); // Create obj2, y=400
 
            // Accessing Non-Static and Readonly variables using instance
            Console.WriteLine($"obj1 y value: {obj1.y} and Readonly z value: {obj1.z}"); // z will be 0
            Console.WriteLine($"obj2 y value: {obj2.y} and Readonly z value: {obj2.z}"); // z will be 0
            Console.Read();
        }
    }
}

Output:

x value: 100
PI value: 3.14
obj1 y value: 300 and Readonly z value: 0
obj2 y value: 400 and Readonly z value: 0

في الـ Example اللي جاي، بنهيئ الـ readonly variable عن طريق الـ Class constructor. الـ constructor ده هياخد اتنين parameters. الـ parameter الأول هيهيئ الـ non-static variable، والـ parameter التاني هيهيئ الـ readonly variable. يبقى، وقت عمل الـ instance، محتاجين نمرر قيمتين integer للـ constructor function.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        const float PI = 3.14f; // Constant Variable
        static int x = 100; // Static Variable
        //We are going to initialize variable y through constructor
        int y; // Non-Static or Instance Variable
        readonly int z; // Readonly Variable
 
        //Constructor takes two parameters
        public Program(int a, int b)
        {
            //Initializing non-static variable
            y = a;
            //Initializing Readonly variable using constructor
            z = b;
        }
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}");
            Console.WriteLine($"PI value: {PI}");
 
            Program obj1 = new Program(300, 45); // Create obj1, y=300, z=45
            Program obj2 = new Program(400, 55); // Create obj2, y=400, z=55
 
            // Accessing Non-Static and Readonly variables using instance
            Console.WriteLine($"obj1 y value: {obj1.y} and Readonly z value: {obj1.z}");
            Console.WriteLine($"obj2 y value: {obj2.y} and Readonly z value: {obj2.z}");
            Console.Read();
        }
    }
}

Output:

x value: 100
PI value: 3.14
obj1 y value: 300 and Readonly z value: 45
obj2 y value: 400 and Readonly z value: 55

عشان تفهم أكتر الـ Example اللي فوق، بص على الـ Diagram ده اللي بيوضح الـ Memory representation.

graph LR
    A[Program Class] --> B(Static Variable x: 100);
    A --> C(Constant Variable PI: 3.14);
    A --> D[Instance 1: obj1];
    D --> E(Non-Static Variable y: 300);
    D --> F(Readonly Variable z: 45);
    A --> G[Instance 2: obj2];
    G --> H(Non-Static Variable y: 400);
    G --> I(Readonly Variable z: 55);

دلوقتي ممكن يجيلك سؤال تاني، لو الـ non-static والـ readonly الاتنين بيتصرفوا بنفس الطريقة، إيه الفرق بينهم؟

Difference Between Non-Static and Readonly in C#

الفرق الوحيد بين الـ non-static والـ readonly variable هو إنه بعد التهيئة، تقدر تعدل قيمة الـ non-static variable، لكن مش ممكن تعدل قيمة الـ readonly variable. تعال نثبت ده. في الـ Example اللي تحت، بعد ما عملنا الـ instance الأولاني، بنحاول نعدل قيمة الـ non-static y والـ readonly z.

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        const float PI = 3.14f; // Constant Variable
        static int x = 100; // Static Variable
        //We are going to initialize variable y through constructor
        int y; // Non-Static or Instance Variable
        readonly int z; // Readonly Variable
 
        //Constructor takes two parameters
        public Program(int a, int b)
        {
            //Initializing non-static variable
            y = a;
            //Initializing Readonly variable
            z = b;
        }
        static void Main(string[] args)
        {
            Console.WriteLine($"x value: {x}");
            Console.WriteLine($"PI value: {PI}");
 
            Program obj1 = new Program(300, 45); // Create obj1, y=300, z=45
 
            // Accessing Non-Static and Readonly variables using instance
            Console.WriteLine($"obj1 y value: {obj1.y} and Readonly z value: {obj1.z}");
 
            obj1.y = 500; // Modifying Non-Static Variable - Allowed
            // obj1.z = 400; // Trying to Modify Readonly Variable - Compile Error!
 
            Console.WriteLine($"obj1 y value after modification: {obj1.y}"); // y is now 500
 
            Console.Read();
        }
    }
}

لما تحاول تشغل الـ Code اللي فوق ده، هيجيلك Compilation Error.

الـ Error ده بيقول صراحةً إن الـ readonly field مش ممكن يتم إسناد قيمة ليه (ما عدا في الـ constructor أو الـ init-only setter بتاع الـ Type اللي الـ field متعرف فيه أو في الـ variable initializer). ده معناه إنك تقدر تعمل تهيئة للـ readonly variable بس وقت تعريفه أو عن طريق الـ constructor. وهنا، بنحاول نعدل قيمة الـ readonly جوه الـ Main method وده سبب الـ compilation error.

What is the difference between a constant and readonly variable in C#?

الفرق بين الـ constant والـ readonly variable في C# هو إن الـ constant هي قيمة ثابتة لكل الـ Class كلها (مش مرتبطة بـ instance معين)، أما الـ readonly هي قيمة ثابتة خاصة بـ instance معين من الـ Class، ولكل instance بيتم عمله.

Local Variables in C#

الـ Local Variables في C# بتتعرف جوه الـ Method بتاعت الـ Class. الـ Scope بتاع الـ local variable محدود بالـ Method اللي اتعرفت جواه، ده معناه إنك مش ممكن توصلها من بره الـ Method دي. تهيئة (initialization) الـ local variable إجباري.

Scope بتاع الـ Local Variables: بيبقى موجود جوه الـ block (القوسين {}) اللي اتعرف فيه بس. The lifetime بتاع الـ Local Variable: بيفضل موجود لحد ما الـ control بتاع البرنامج يخرج من الـ block اللي اتعرف فيه.

Example to Understand Local Variables in C#

using System;
namespace TypesOfVariables
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // This is a static block (static method)
            int y = 100; // Local Variable 'y'. By default static because in static block.
                         // Scope limited to Main method.
            Console.WriteLine(y); // Can access y here
            Console.Read();
        }
        public void NonStaticBlock()
        {
            // This is a non-static block (non-static method)
            int x = 100; // Local Variable 'x'. By default non-static.
                         // Scope limited to NonStaticBlock method only.
            Console.WriteLine(x); // Can access x here
        }
         // Cannot access x or y here, they are out of scope
    }
}

Special Variable Types

بالإضافة للأنواع الأساسية اللي اتكلمنا عنها (Static, Non-Static, Const, Readonly, Local)، فيه أنواع تانية بتستخدم في C# ليها سلوك مختلف وهي var, object, و dynamic.

var (Implicit Typed Variable)

• إزاي شغاله؟ بتديها قيمة أولية، والـ Compiler هو اللي يحدد نوعها أوتوماتيك من القيمة دي. أنت مش بتحدده. مثال: var x = 10; → الـ Type هنا بقى int. var y = "Hello"; → الـ Type هنا بقى string.

• Rules:

  • مش ممكن تعلنها من غير ما تديلها قيمة أولية. ⚠️ var x; → غلط!
  • مش ممكن تديلها null في البداية. ⚠️ var z = null; → غلط!
  • الـ Type بيتحدد مرة واحدة في (Compile Time) ومتقدرش تغيره بعد كده. مثال:

  var x = 5; // x is implicitly typed as int
  x = "Ahmed"; // Error: Cannot implicitly convert type 'string' to 'int'

• لازم تستخدمها فين؟

  • لو الـ Type اسمه طويل (مثلاً في الـ LINQ أو مع Lambda Expressions in Csharp).
  • لما تكون عايز تكود أسرع من غير ما تكتب نوع المتغير كله.

• ملحوظة:

  • الـ var مش نوع جديد! ده مجرد اختصار بيسهل الكتابة.
  • الـ Variable بيبقا له نوع ثابت (Strongly Typed) من أول ما يتحدد في الـ Compile Time.
  • استخدامه ممكن يبقا بسيط أوي بس برضو ممكن يأثر على قراءة الـ Code لو مش واضح النوع.

---

object

اتكلمنا عنه بالتفصيل في الـ Object

• إزاي شغاله؟ الـ object هو الـ base type أو أبو كل الـ Types في C#. أي حاجة تقدر تحطها فيه (لأن كل الـ Types مبنية عليه أو بتورث منه).

  • ملحوظة مهمة: لو حطيت فيه قيمة من نوع بسيط (value type) زي الـ int أو الـ double، الـ Compiler هيحولها لـ reference type (العملية دي اسمها Boxing). مثال:

  object x = 5; // هنا الـ5 (القيمة) اتحولت لـ object واتخزنت في الـ Heap

• عيوبه:

  • لو عايز تستخدم القيمة اللي جواه، لازم تحولها لـ نوعها الأصلي (العملية دي اسمها Unboxing). مثال:

    int y = (int)x; // Casting back to int (Unboxing)

  • لو عملت Casting لنوع غلط ⇒ هيحصل غلط في الرن تايم (Runtime Error).
  • أبطأ في الأداء بسبب عمليات الـ Boxing والـ Casting.

• مميزاته:

  • مرن جداً. تقدر تخزن أي حاجة فيه.

---

dynamic

• إزاي شغاله؟ الـ dynamic ده نوع الـ Type بتاعه بيتحدد في الرن تايم (Run Time). الـ Compiler مش بيفحصه أثناء كتابة الـ Code. مثال:

  dynamic x = 10; // Type is dynamic, not checked at compile time
  x = "Ahmed"; // Type can change at runtime, no problem

• مميزاته:

  • سهل مع الحاجات الديناميكية (مثل الـ COM Interop أو الـ APIs الخارجية اللي بترجع أنواع مش معروفة مسبقاً).
  • مش محتاج تعمل Casting بنفسك.

• عيوبه:

  • مش آمن (Not Type Safe): أي غلط في الـ Type هتكتشفه فقط لما البرنامج يشتغل.
  • أقل أداءً لإن التحقق من الـ Type بيحصل في الـ Run Time بدل الـ Compile Time.

---

الفروقات الأساسية بينهم (var, object, dynamic)

Feature	var	object	dynamic
وقت تحديد النوع	(Compiler) Compile Time	Compile Time (لكن مع Boxing)	(CLR) Run Time
Type Safety	آمن (الكومبايلر بيشيك)	غير آمن (محتاج Casting)	غير آمن (غلط في الرن تايم)
الأداء	سريع (عادي زي أي نوع)	بطيء (بسبب Boxing/Unboxing)	متوسط (لأنه ديناميكي)
المرونة	محدود (النوع بيتحدد مرة واحدة)	عالي (تقدر تخزن أي حاجة)	عالي جداً (التغيير في الرن تايم)

---

أمثلة عملية على var, object, dynamic

// var
var name = "Mohamed"; // name is implicitly typed as string
var age = 25; // age is implicitly typed as int
 
// object
object obj1 = 10; // Boxing happening here (int 10 is boxed into an object)
object obj2 = "Test"; // string "Test" is treated as an object
int num = (int)obj1; // Unboxing (object is cast back to int)
 
// dynamic
dynamic dyn = 10; // Type is dynamic
dyn = "Text"; // Type can change at runtime, no problem
dyn = dyn.ToUpper(); // If dyn is not a string at this point, this will be a runtime error

---

Conclusion

كده شرحنا الـ Variables في C# بأنواعها المختلفة وإمتى تستخدم كل نوع. من أول الأنواع الأساسية زي الـ Static والـ Non-Static والـ Const والـ Readonly والـ Local Variables، لحد الأنواع الخاصة زي var, object, و dynamic.