Reflection in CSharp

Introduction to Reflection

موضوع النهاردة شيق وممتع جدًا، هو متقدم شوية بس هنبسطه مع بعض. لما تفهمه كويس، هتتحمس جدًا وهتحاول تلاقي أفكار تستعمله فيها، لإن الموضوع ده powerful جدًا وبيديلك إمكانيات رهيبة وانت بتكتب كود في الـ .NET.

لو انت شغال حاليًا على مشاريع حقيقية، فانت سواء تعرف أو متعرفش، فانت بتستخدمه بشكل أو بآخر، أو بتستخدم library هي اللي بتستخدمه، لإنه بقى داخل تقريبًا في كل حاجة.

موضوعنا النهاردة اسمه Reflection.

What is Reflection?

كلمة reflection معناها “انعكاس”. لما بتقف قدام المراية بتشوف انعكاس ليك، بتشوف وشك ومناخيرك وكل تفاصيلك.

نفس الكلام بالنسبة للكود، الانعكاس بيمكنك إنك تشوف وتطلع على التفاصيل الداخلية للـ Assembly من غير ما يكون معاك الـ source code بتاعه، أو حتى لو معاك الـ source code بس عايز تعمل الكلام ده في الـ run-time.

هتفهم أكتر واحنا ماشيين، بس خلينا الأول نعرف إيه هو الـ Assembly لإنه هو ده المدخل الرئيسي للـ Reflection.

What is an Assembly?

كلمة assembly في لغات البرمجة عمومًا، وفي الـ .NET تحديدًا، بنتكلم عن الـ binary files اللي بتطلع من عملية الـ build للكود بتاعك.

لما بنعمل build لبروجكت جديد، بنلاقي في الـ output folder ملفات الامتداد بتاعها .dll و .exe. كل ملف من دول بنقول عليه Assembly. بما إننا شغالين .NET Core، خلينا نركز أكتر على الـ DLL.

فالـ Assembly في .NET هو ملف الـ DLL اللي بيخرج لما تعمل build للبروجكت بتاعك.

الـ Assembly ده بيكون شايل حاجات كتير، منها:

• الـ Metadata: دي معلومات عن الـ Assembly نفسه ومحتوياته، زي اسم الـ Assembly، الـ version بتاعه، الـ location، وتفاصيل تانية كتير.
• الـ Intermediate Language (IL): اتكلمنا عن الـ IL قبل كده. ده اللغة الوسيطة اللي الكود بتاعك بيترجم ليها وقت الـ compilation. الكود مش بيتحول لـ machine language مباشرة، لأ، بيتحول الأول لـ IL، وبعد كده في الـ run-time الـ IL بيتحول لـ machine code.
• الـ Embedded Resources: دي ملفات انت بتدمجها مع الـ Assembly بتاعك لو حبيت.

تعالوا نشوف الكلام ده بيتم إزاي بالتفصيل.

Getting Started with Reflection

عشان نبدأ نتعامل مع الـ Reflection، أول حاجة بنعملها هي import للـ namespace اللي اسمه System.Reflection.

using System.Reflection;

ده اللي فيه كل الأدوات اللي هنحتاجها. بعد كده، أنا عايز أوصل أو آخد reference للـ Assembly.

احنا اتفقنا إن الـ Assembly هو ملف الـ DLL. لما بعمل run للبروجكت بتاعي، عملية الـ run بتعمل build الأول، والـ compiler بيطلع الـ Assembly، وبعدين الـ debugger بياخد الـ Assembly ده ويعمله attach عشان تقدر تعمل debug.

فالبروجكت بتاعي اللي هو CsharpAdvancedReflection لما أعمله run وقت تشغيله بقى اسمه Assembly.

عشان أوصل له، فيه class اسمه Assembly جواه شوية methods زي:

• GetEntryAssembly()
• GetExecutingAssembly()
• GetCallingAssembly()

خلينا دلوقتي في GetExecutingAssembly(). الـ method دي بترجعلك reference للـ Assembly اللي فيه الكود اللي بيتنفذ حاليًا. يعني السطر اللي بتنادي فيه الـ method دي، هيرجعلك الـ Assembly بتاع البروجكت اللي السطر ده مكتوب فيه.

// Get a reference to the currently executing assembly
Assembly assembly = Assembly.GetExecutingAssembly();

تعالوا نشوف إيه التفاصيل اللي ممكن نعرفها عن الـ Assembly.

// Print the full name of the assembly
Console.WriteLine($"Assembly Name: {assembly.FullName}");
 
// Print the location (path) of the assembly file
Console.WriteLine($"Assembly Location: {assembly.Location}");

لما نشغل الكود ده هنشوف النتيجة:

Assembly Name: CsharpAdvancedReflection, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
Assembly Location: C:\...\CsharpAdvancedReflection.dll

الـ FullName بيحتوي على كذا معلومة: الاسم، الـ Version، الـ Culture، والـ PublicKeyToken.

طب لو عايز تفصل المعلومات دي وتاخد كل حاجة لوحدها؟ فيه method اسمها GetName().

// Get an AssemblyName object with detailed information
AssemblyName assemblyName = assembly.GetName();
 
Console.WriteLine($"Name: {assemblyName.Name}");
Console.WriteLine($"Version: {assemblyName.Version}");

الـ method دي بترجع object من نوع AssemblyName جواه التفاصيل دي متفصلة. ولو عملت assemblyName.ToString() هيرجعلك نفس الـ FullName اللي شفناه فوق.

Entry vs. Calling vs. Executing Assembly

عشان نفهم الفرق بين الـ methods المختلفة، هنعمل setup بسيط:

1. هنضيف class library بروجكت جديد ونسميه MyFirstExtension.
2. هنضيف class library تاني ونسميه MySecondExtension.

الهدف منهم إننا نوضح الفرق بين GetEntryAssembly, GetCallingAssembly, و GetExecutingAssembly.

هنعمل reference كالتالي:

• البروجكت الرئيسي (CsharpAdvancedReflection) هياخد reference من MyFirstExtension.
• البروجكت MyFirstExtension هياخد reference من MySecondExtension.

graph LR
    MainProject(CsharpAdvancedReflection) --> FirstExt(MyFirstExtension);
    FirstExt --> SecondExt(MySecondExtension);

في MyFirstExtension، هنعمل class اسمه ReflectionDemo وفيه method اسمها PrintAssemblyDetails.

في MySecondExtension، هنعمل class اسمه ReflectionDemo2 وفيه نفس الـ method.

الـ method اللي في ReflectionDemo هتنادي على الـ method اللي في ReflectionDemo2.

// In MyFirstExtension -> ReflectionDemo.cs
public static class ReflectionDemo
{
    public static void PrintAssemblyDetails()
    {
        // Call the method in the second extension
        MySecondExtension.ReflectionDemo2.PrintAssemblyDetails();
    }
}

وفي البروجكت الرئيسي، هننادي على الـ method اللي في MyFirstExtension.

// In Main Project -> Program.cs
MyFirstExtension.ReflectionDemo.PrintAssemblyDetails();

الـ call stack ماشي إزاي؟ الـ CsharpAdvancedReflection بينادي MyFirstExtension اللي بدوره بينادي MySecondExtension.

دلوقتي، جوه الـ method النهائية في ReflectionDemo2 هنطبع بيانات الـ Assemblies التلاتة.

// In MySecondExtension -> ReflectionDemo2.cs
public static void PrintAssemblyDetails()
{
    var entryAssembly = Assembly.GetEntryAssembly();
    var callingAssembly = Assembly.GetCallingAssembly();
    var executingAssembly = Assembly.GetExecutingAssembly();
 
    Console.WriteLine($"Entry Assembly: {entryAssembly.GetName().Name}");
    Console.WriteLine($"Calling Assembly: {callingAssembly.GetName().Name}");
    Console.WriteLine($"Executing Assembly: {executingAssembly.GetName().Name}");
}

لما نشغل الكود، الناتج هيكون:

Entry Assembly: CsharpAdvancedReflection
Calling Assembly: MyFirstExtension
Executing Assembly: MySecondExtension

كده فهمنا الفرق:

• الـ Entry Assembly: هو الـ Assembly اللي بدأ تنفيذ الأبلكيشن (ملف الـ EXE عادةً).
• الـ Calling Assembly: هو الـ Assembly اللي نادى على الـ method اللي بتتنفذ حاليًا. في حالتنا، MyFirstExtension هو اللي نادى على PrintAssemblyDetails اللي في MySecondExtension.
• الـ Executing Assembly: هو الـ Assembly اللي فيه الكود اللي بيتنفذ حاليًا.

Resources

Embedded Resources

هنقفل كلامنا عن الـ Assembly بموضوع الـ Resources. افترض إن البروجكت بتاعك محتاج يدعم الترجمة. ده معناه إنك محتاج dictionary لكل لغة. الملفات دي المفروض تكون موجودة مع الأبلكيشن بتاعك عشان تقراها في الـ run-time.

بس فيه مشكلة: لو الملف موجود جنب الأبلكيشن، اليوزر يقدر يفتحه ويعدل فيه، وانت مش عايز كده. عايز تحمي ملفات الترجمة دي.

أحد الحلول هي الـ Embedded Resources. إزاي؟

هنضيف فولدر جديد في البروجكت الرئيسي ونسميه Resources، وجواه هنضيف ملف تكست ar.txt.

لما تختار الملف ده، هتلاقي في الـ Properties بتاعته خاصيتين مهمين:

1. الـ Copy to Output Directory: دي بتحدد هل الملف هيتنسخ للفولدر بتاع الـ build ولا لأ. القيمة الافتراضية Do not copy. لو خليتها Copy always، الملف هيتنسخ جنب الـ DLL بتاعك. بس ده مش اللي احنا عايزينه، لإن اليوزر هيقدر يشوفه.
2. الـ Build Action: دي بتحدد إيه الإجراء اللي هيتاخد مع الملف ده وقت الـ build. القيمة الافتراضية None.

اللي يهمنا هنا هو قيمة Embedded Resource. لو اخترتها وعملت build، الملف مش هيظهر في الـ output folder، لكنه هيكون اتدمج جوه ملف الـ DLL نفسه.

لو استخدمنا أداة زي JetBrains dotPeek عشان نفتح الـ DLL، هنلاقي فولدر اسمه Resources ظهر جوه الـ Assembly، وجواه الملف بتاعنا.

الاسم بتاع الـ resource ده مهم جدًا، لإنك هتستخدمه عشان توصل للملف في الـ run-time. الاسم بيكون بالصيغة دي: ProjectName.FolderName.FileName

ففي حالتنا هيكون: CsharpAdvancedReflection.Resources.ar.txt. ملحوظة: الاسم ده case-sensitive، يعني الحروف الكابيتال والسمول بتفرق.

Reading Embedded Resources

دلوقتي أنا عايز أقرأ محتويات الملف ده وأطبعها في الـ Console.

لازم نقرأ الـ resource من نفس الـ Assembly اللي هو جواه.

// Get the current assembly
Assembly assembly = Assembly.GetExecutingAssembly();
 
// Define the resource name
string resourceName = "CsharpAdvancedReflection.Resources.ar.txt";
 
// Get the resource as a stream
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
{
    if (stream == null)
    {
        Console.WriteLine("Resource not found!");
        return;
    }
 
    Console.WriteLine("Resource found!");
 
    // Use a StreamReader to read the content
    using (StreamReader reader = new StreamReader(stream))
    {
        string content = reader.ReadToEnd();
        Console.WriteLine(content);
    }
}

ايه هو الـ Stream؟ باختصار شديد، هو آلية بتمكنك من قراءة وكتابة البيانات في أي مكان (ملف، ميموري، داتابيز، إلخ). الـ method اللي اسمها GetManifestResourceStream بترجعلك stream object للملف اللي حددته.

الـ stream ده بيديلك access على الـ Bytes بتاعة الملف. كل ملف في الآخر هو عبارة عن شوية bytes جنب بعض. بنقدر نقرأ الـ bytes دي ونحولها لـ characters.

في الكود اللي فوق، استخدمنا StreamReader عشان يسهل علينا عملية القراءة وتحويل الـ bytes لنص.

لو غيرنا حرف واحد في اسم الـ resource (مثلاً خليناه كابيتال وهو سمول)، الـ stream هيرجع null وهتظهر رسالة “Resource not found!“.

ده كده الجزء الأول من الفيديو. شوفنا إيه هو الـ Assembly، والفرق بين طرق الحصول عليه، وإزاي نعمل embedded resource ونقرأه. في الجزء الجاي، هندخل في عمق الـ Reflection ونشوف القوة الحقيقية اللي بيديها لينا.

Inspecting Types and Dynamic Invocation

قولنا إن الـ Assembly هو بوابة القصر الكبيرة. الـ Assembly ده هو البروجكت بتاعك بعد ما يتعمله build.

جوه البروجكت ده فيه إيه؟ فيه types زي classes, interfaces, structs. وجوه كل type فيه methods, properties, fields, و events.

فبعد ما دخلنا من البوابة الكبيرة (Assembly)، قدامنا دلوقتي أبواب الغرف اللي جوه القصر، واللي هي الـ Types. عشان أقدر أدخل أي غرفة، محتاج أوصل للـ Type بتاعها الأول.

Getting a Type Object

اتكلمنا قبل كده إن كل الأنواع في الـ .NET بتورث من parent واحد رئيسي هو Object. وفي الـ Object class ده، فيه method اسمها GetType().

object obj = new object();
Type objectType = obj.GetType();

الـ method دي بترجع object من نوع اسمه Type. الـ Type ده هو باب الغرفة اللي لما تفتحه هتقدر تشوف كل الكنوز اللي جواها.

لازم تحط في دماغك إننا كل ده بنتعامل مع assembly وكود في الـ run-time، مش في الـ compile-time. يعني إيه؟ يعني تخيل إنك مش معاك reference للـ assembly ده أصلًا، ومع ذلك بتقدر تتعامل معاه. هو ده دور الـ Reflection.

طيب، إزاي نوصل للـ Type ده؟ الـ Assembly نفسه جواه method اسمها GetTypes()، ودي بترجعلك كل الـ types اللي متعرفة جواه.

public class Employee { }
public class Product { }
 
// ... in Main method
Assembly assembly = Assembly.GetExecutingAssembly();
Type[] types = assembly.GetTypes();
 
foreach (var type in types)
{
    Console.WriteLine($"Type Name: {type.FullName}");
}

هنا عملنا loop على كل الـ types اللي في الـ Assembly الحالي.

من الـ Type object ده، تقدر تعرف كل تفاصيله:

foreach (var type in types)
{
    Console.WriteLine($"Name: {type.Name}");
    Console.WriteLine($"Is Public: {type.IsPublic}");
    // Use ?. to avoid null error if it has no base
    Console.WriteLine($"Base Type: {type.BaseType?.Name}"); 
    Console.WriteLine("----------------");
}

بالطريقة دي، بتقدر تعرف اسم الـ Type، هو public ولا لأ، وبيورث من مين (BaseType)، وهل هو sealed أو generic، وكل حاجة تانية. دي اللي بنسميها الـ Metadata بتاعة الـ Type.

فيه method تانية اسمها GetExportedTypes() ودي بترجع الـ public types بس، على عكس GetTypes() اللي بترجع كله.

فيه طرق تانية عشان تجيب الـ Type:

• لو معاك variable، ممكن تستخدم variable.GetType().
• لو عايز Type معين باسمه، ممكن تستخدم typeof() keyword.

Type stringType = typeof(string);
Type intType = typeof(int);

Inspecting Type Members

دلوقتي بعد ما فتحنا باب الغرفة (Type)، عايزين نشوف الكنوز اللي جواها. الـ Type class فيه method اسمها GetMembers()، ودي بترجع كل الـ code members اللي جوه الـ Type ده (سواء method, property, field, event, constructor, أي حاجة).

Type dateTimeType = typeof(DateTime);
MemberInfo[] members = dateTimeType.GetMembers();
 
foreach (var member in members)
{
    Console.WriteLine($"Name: {member.Name}, Member Type: {member.MemberType}");
}

هتلاحظ إن methods زي Parse بتتكرر كذا مرة. ده بسبب الـ Method Overloading؛ كل overload بيعتبر member منفصل.

الـ GetMembers() بترجع كل الـ members بغض النظر هي static ولا instance.

Filtering Members with BindingFlags

لو عايز تفلتر النتايج، فيه overload تاني للـ method دي بياخد enum اسمه BindingFlags. دي عبارة عن flags بتحدد بيها إيه اللي انت عايزه بالظبط.

// Get only PUBLIC INSTANCE members
var instanceMembers = dateTimeType.GetMembers(BindingFlags.Public | BindingFlags.Instance);
 
// Get only PUBLIC STATIC members
var staticMembers = dateTimeType.GetMembers(BindingFlags.Public | BindingFlags.Static);
 
// Get NON-PUBLIC STATIC members (private, internal, etc.)
var nonPublicStaticMembers = dateTimeType.GetMembers(BindingFlags.NonPublic | BindingFlags.Static);

لاحظ إننا بنستخدم | (single pipe)، وده الـ bitwise OR operator اللي بنستخدمه عشان ندمج الـ flags مع بعض.

بالطريقة دي، تقدر تشوف حتى الـ private members اللي في العادي مش بتقدر توصلها. وشوية وهنعرف إزاي ننفذ private method كمان!

لو عايز تجيب نوع معين من الـ members، فيه methods مخصصة بتسهل عليك الموضوع:

• GetMethods()
• GetProperties()
• GetFields()
• GetConstructors()

مثلاً، عشان نعرف هل الـ property دي read-only ولا لأ، ممكن نشوف هل ليها set method ولا لأ.

var properties = dateTimeType.GetProperties();
foreach (var prop in properties)
{
    bool isReadOnly = !prop.CanWrite;
    Console.WriteLine($"Property: {prop.Name}, Is Read-Only: {isReadOnly}");
}

Getting Method Parameters

بعد ما جبنا الـ methods، ممكن كمان نعرف إيه الـ parameters اللي كل method بتاخدها.

// Get a specific method by name
MethodInfo addDaysMethod = dateTimeType.GetMethod("AddDays");
 
if (addDaysMethod != null)
{
    // Get its parameters
    ParameterInfo[] parameters = addDaysMethod.GetParameters();
    foreach (var param in parameters)
    {
        Console.WriteLine($"Parameter Name: {param.Name}, Type: {param.ParameterType.Name}");
    }
}

بالطريقة دي، بتقدر تشرح الـ DLL وتعرف كل تفاصيله من غير ما يكون معاك السورس كود.

Invoking Methods Dynamically

لحد هنا إحنا بنقرأ معلومات بس. الاستفادة الأكبر من الـ Reflection هي إننا نقدر نتفاعل مع الـ Type ده، يعني ننفذ الـ methods بتاعته بشكل ديناميكي باستخدام method اسمها Invoke().

Invoking a Static Method

الـ static method مش محتاجة instance من الـ class عشان تتنفذ.

Type mathType = typeof(Math);
MethodInfo minMethod = mathType.GetMethod("Min", new Type[] { typeof(int), typeof(int) });
 
// Parameters for the method
object[] parameters = { 5, 10 };
 
// Invoke the static method. First argument is null because it's static.
object result = minMethod.Invoke(null, parameters);
 
Console.WriteLine($"The minimum is: {result}"); // Output: 5

الـ Invoke method بتاخد 2 parameters:

1. الـ instance اللي هتنفذ عليه الـ method. في حالة الـ static method، بنبعت null.
2. الـ Array of objects بيمثل الـ parameters اللي الـ method محتاجاها.

Invoking an Instance Method

الـ instance method لازم تتنفذ على object معين.

DateTime today = DateTime.Now;
Type dateTimeType = typeof(DateTime);
MethodInfo addDaysMethod = dateTimeType.GetMethod("AddDays");
 
// Parameters for the AddDays method
object[] parameters = { 10.0 }; // Add 10 days
 
// Invoke the method on the 'today' instance
// Note: DateTime is immutable, so AddDays returns a new instance
object newDate = addDaysMethod.Invoke(today, parameters);
 
Console.WriteLine($"Original Date: {today}");
Console.WriteLine($"New Date: {newDate}");

هنا بعتنا الـ today object كأول parameter للـ Invoke عشان يعرف ينفذ الـ method دي على مين.

Practical Use Cases for Reflection

دلوقتي الصورة هتبدأ توضح أكتر لما نشوف أمثلة عملية.

Use Case 1: Building a Plugin System

برامج زي Visual Studio و VS Code بتستخدم extensions عشان تزود features. الـ extensions دي بتشتغل إزاي؟ بالـ Reflection.

الفكرة إن الأبلكيشن الأساسي بيعمل scan لفولدر معين، يلاقي فيه ملفات DLL (الـ plugins)، ويستخدم الـ Reflection عشان يحمل الـ assemblies دي في الـ run-time، وبعدين يبدأ يشوف إيه الـ classes والـ methods اللي جواها وينفذها.

sequenceDiagram
    participant App as Main App
    participant FS as File System
    participant Reflector as Reflection
    participant Plugin as Plugin.dll

    App->>FS: Scan "Plugins" folder for DLLs
    FS-->>App: Found Plugin.dll
    App->>Reflector: Assembly.LoadFrom("Plugin.dll")
    Reflector-->>App: Loaded Assembly
    App->>Reflector: assembly.GetType("Plugin.EntryPoint")
    Reflector-->>App: Found Type
    App->>Reflector: type.GetMethod("Initialize")
    Reflector-->>App: Found Method
    App->>Plugin: method.Invoke()
    Plugin-->>App: Plugin Initialized!

بالكود، الموضوع ممكن يبقى كده:

string pluginsPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Extensions");
string[] pluginFiles = Directory.GetFiles(pluginsPath, "*.dll");
 
foreach (var file in pluginFiles)
{
    // 1. Load the assembly
    Assembly pluginAssembly = Assembly.LoadFrom(file);
    
    // 2. Find the entry point type (assuming a convention)
    // The full name is needed: Namespace.TypeName
    string typeName = $"{pluginAssembly.GetName().Name}.EntryPoint";
    Type entryPointType = pluginAssembly.GetType(typeName);
 
    if (entryPointType != null)
    {
        // 3. Find the initialization method
        MethodInfo initializeMethod = entryPointType.GetMethod("Initialize");
 
        if (initializeMethod != null)
        {
            // 4. Invoke the method
            initializeMethod.Invoke(null, null); // Assuming it's a static method with no parameters
        }
    }
}

بكده، أنت عملت سيستم بيقرأ extensions ويشغلها في الـ run-time من غير ما تكون عارف عنها أي حاجة وقت الـ compile-time.

Use Case 2: Dynamic Object Mapping

عملية نسخ الداتا من object لـ object تاني (خصوصًا من أنواع مختلفة) اسمها mapping. المكتبات المشهورة زي AutoMapper بتستخدم الـ Reflection بكثافة.

نقدر نعمل mapper بسيط جدًا بالـ Reflection:

public static void MapProperties(object source, object destination)
{
    Type sourceType = source.GetType();
    Type destType = destination.GetType();
 
    PropertyInfo[] sourceProps = sourceType.GetProperties();
 
    foreach (var sourceProp in sourceProps)
    {
        // Find a property with the same name in the destination object
        PropertyInfo destProp = destType.GetProperty(sourceProp.Name);
 
        // Check if the destination property exists and is writable
        if (destProp != null && destProp.CanWrite)
        {
            // Get value from source and set it on destination
            object value = sourceProp.GetValue(source);
            destProp.SetValue(destination, value);
        }
    }
}

الـ method دي، في 3 سطور logic، بتقدر تنسخ القيم بين أي اتنين objects طالما أسماء الـ properties متشابهة، حتى لو كانوا من أنواع مختلفة تمامًا. ده مثال واضح جدًا على قوة ومرونة الـ Reflection.

Conclusion

الـ Reflection مستخدم في حاجات كتير جدًا في عالم الـ .NET:

• الـ Dependency Injection (DI) Containers: بتستخدمه عشان تكتشف الـ services وتعملها instantiate.
• الـ Object-Relational Mappers (ORMs): زي Entity Framework، بيستخدمه عشان يعمل map للداتا اللي جاية من الداتابيز للـ C# objects.
• الـ Serialization Libraries: زي Newtonsoft.Json، بتستخدمه عشان تقرأ الـ properties وتحول الـ object لـ JSON والعكس.
• الـ Unit Testing Frameworks: بتستخدمه عشان تكتشف الـ Test methods وتشغلها.

A Note on Attributes

آخر حاجة الـ Attributes. هي عبارة عن “علامة” أو metadata إضافية بتحطها على الكود بتاعك (زي class أو method).

[Serializable]
public class MyData
{
    [Required]
    public string Name { get; set; }
}

الـ attributes دي في حد ذاتها مش بتعمل حاجة. هي مجرد معلومات. الـ Reflection هو الأداة اللي بتخليك تقرأ الـ metadata دي في الـ run-time وتاخد action بناءً عليها.

// Check if a type has a specific attribute
bool isSerializable = typeof(MyData).IsDefined(typeof(SerializableAttribute), false);

الـ Reflection موضوع قوي جدًا، وفهمه بيفتحلك أبواب كتير وبيخليك تفهم إزاي الأدوات والمكتبات اللي بتستخدمها كل يوم شغالة من جوه.