சி ஷார்ப் ரிஃப்ளெக்சன்(Reflection)

ரிஃப்ளெக்சன் என்பது இயக்க நேரத்தில் சி ஷார்ப்பின் அசெம்ப்ளியின் மெடா டேட்டாவை ஆராய்தல் ஆகும். இது அசெம்ப்ளீயில் உள்ள எல்லா டைப்களை கண்டறிவதற்கும் அசெம்ப்ளியில் உள்ள மெதட்களை அழைப்பதற்கும் பயன்படுகின்றன. இது டைப், பிராப்பர்ட்டிகள்,மெதட் மற்றும் ஆப்ஜெக்டின் ஈவண்ட் போன்றவற்றை கண்டறிவதற்கு பயன்படுகின்றன.

ரிஃப்ளெக்சன் உதவியுடன் இயக்க நேரத்தில் ஒரு டைப்பிற்கு இன்ஸ்டன்ஸ் உருவாக்கவோ அல்லது டைப்பை ஏற்கனவே உள்ள ஆப்ஜெக்டிற்கு காஸ்ட் செய்ய்வோ பயன்படுகின்றது.

ரிஃப்ளெக்சனால் சில பயன்கள் இருக்கின்றன.

அவையாவன:

1.நீங்கள் ஒரு டூலை டிராக் செய்து ஒரு விண்டோஸ் அப்ளிகேசன் அல்லது ASP.NET அப்ளிகேசனில் உள்ள் ஃபார்மில் டிராப் செய்தால் சி ஷார்ப் ஆனது ரிஃப்ளெக்சன் உதவியுடன் அதன் பிராப்பர்ட்டி மற்றும் ஈவ்சண்ட்களை கண்டறிந்து பிராப்பர்ட்டி பாக்சில் வெளியிடுகின்றது.

2. ரிஃப்ளெக்சன் உதவியுடன் லேட் பைண்டிங்கை அடையலாம்.இதனால் இயக்க நேரத்தில் ஒரு டைப்பிற்கு ஆப்ஜெக்ட் உருவாக்கலாம். அது பற்றிய தகவல்கள் கம்பைல் நேரத்தில் இருந்திருக்காது.

3. இப்பொழுது சான்றாக ஒரு இன்டெஃபேஸிற்கு இரண்டு இம்ப்ளிமென்டேசன்கள் இருப்பதாக எடுத்துக் கொள்வோம். நீங்கள் config ஃபைல் உதவியுடன் இரண்டில் ஒன்றை தேர்ந்தெடுக்கலாம். ரிஃப்ளெக்சன் உதவியுடன் ஒரு கிளாசின் பெயரை ரீட் செய்து கான்ஃபிக் ஃபைலில் அந்த கிளாசை தேர்ந்த்டுத்து அதற்கு ஆப்ஜெக்ட் உருவாக்கலாம். இது லேட் பைண்டிங்கிற்கு மற்றொரு சான்றாகும்.

ஆகையால் ரிஃப்ளெக்சன் உதவியுடன் ஒரு டைப் பற்றிய(பிராப்பர்ட்டி, மெத்தட், ஈவண்ட், ஃபியல்ட்ஸ்) தகவல் அறியலாம். மேலும் லேட் பைண்டிங்கும் செய்யலாம்.

இந்த கட்டுரையில் ரிஃப்ளெக்சன் உதவியுடன் ஒரு கிளாசின் பிராப்பர்ட்டி, மெத்தட்கள், கன்ஸ்ட்ரக்டர்கள் பற்றிய தகவல்களை எவ்வாறு அறியலாம் என்று பார்க்கலாம்.

System.Reflection என்ற நேம் பேசை பயன்படுத்த வேண்டும்.

இதில் டைப் கிளாஸ் மிக முக்கியமான ஒன்றாகும்.

ஒரு கஸ்டமர் கிளாசை எடுத்துக் கொள்வோம்.

இதற்கு இரண்டு கன்ஸ்ட்ரக்டர்கள் உள்ளன.

இரண்டு  ஆட்டோ இம்ப்ளிமெண்டடு பிராப்பர்ட்டிகள் மற்றும்

இரண்டு மெத்தட்கள் உள்ளன.

using System;
using System.Reflection;
namespace Pragim
{
    public class MainClass
    {
        private static void Main()
        {
            // Get the Type Using GetType() static method
            Type T = Type.GetType("Pragim.Customer");
            // Print the Type details
            Console.WriteLine("Full Name = {0}",T.FullName);
            Console.WriteLine("Just the Class Name = {0}",T.Name);
            Console.WriteLine("Just the Namespace = {0}", T.Namespace);
            Console.WriteLine();
            // Print the list of Methods
            Console.WriteLine("Methods in Customer Class");
            MethodInfo[] methods = T.GetMethods();
            foreach (MethodInfo method in methods)
            {
                // Print the Return type and the name of the method
                Console.WriteLine(method.ReturnType.Name + " " + method.Name);
            }
            Console.WriteLine();
            //  Print the Properties
            Console.WriteLine("Properties in Customer Class");
            PropertyInfo[] properties = T.GetProperties();
            foreach (PropertyInfo property in properties)
            {
                // Print the property type and the name of the property
                Console.WriteLine(property.PropertyType.Name + " " + property.Name);
            }
            Console.WriteLine();

  //  Print the Constructors
            Console.WriteLine("Constructors in Customer Class");
            ConstructorInfo[] constructors = T.GetConstructors();

foreach (ConstructorInfo constructor in constructors)
            {
                Console.WriteLine(constructor.ToString());
            }
        }
    }

public class Customer
    {
        public int Id { get; set; }
        public string Name { get; set; }


        public Customer(int ID, string Name)
        {
            this.Id = ID;
            this.Name = Name;
        }


        public Customer()
        {
            this.Id = -1;
            this.Name = string.Empty;
        }


        public void PrintID()
        {
            Console.WriteLine("ID = {0}", this.Id);
        }
        public void PrintName()
        {
            Console.WriteLine("Name = {0}", this.Name);
        }
    }
}

இந்த சான்று நிரலில் கஸ்டமர் கிளாசின் டைப்பை கண்டறிவதற்கு GetType() என்ற ஸ்டேட்டிக் மெத்தடை பயன்படுத்தியுள்ளோம். இந்த மெத்தடை பயன்படுத்துவதற்கு கிளாசின் முழுப்பெயர்(நேம் ஸ்பேஸ் பெயர் சேர்த்து)குறிப்பிட்டுள்ளோம்.

Type T = Type.GetType("Pragim.Customer");

இதே பயனை typeof என்ற கீ வேர்டு உதவிய்டன் அடையலாம்.

Type T = typeof(Customer);

GetType() என்றக் மெத்தடை அந்த கிளாசின் ஆப்ஜெக்டின் மூலமாகவும் அறியலாம்.

Customer C1 = new Customer();
Type T = C1.GetType();

மேலே உள்ள சான்று நிரலில்

மெத்தட் பற்றிய தகவல்கள் Type.GetMethods()

என்ற மெத்தட் மூலமும்

கன்ஸ்ட்ரக்டர் பற்றிய தகவல்கள் Type.GetConstructors()

என்ற மெத்தட் மூலமும்

பிராப்பர்ட்டி போன்ற தகவல்கள் Type.GetProperties()

என்ற மெத்தட் மூலமும் கண்டறியப்படுகின்றது.

நன்றி

முத்து கார்த்திகேயன் ,மதுரை