சி ஷார்ப் ரிஃப்ளெக்சன்(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()

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

நன்றி

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

 

 

ENUMS சி ஷார்ப்

 

இனம்ஸ் ஏன் பயன்படுத்த வேண்டும்?

சிஷார்ப்பில் இனம்ஸ் என்பது ஸ்ட்ராங்க்லி டைப்டு கான்ஸ்டன்ஸ் ஆகும்.

இப்பொழுது நம்மிடம் customer என்றொரு கிளாஸ் உள்ளது. அதில் name, gender என்று இரு பிராப்பர்ட்டிகள் உள்ளன.

இதில் gender ஒரு இன்டிஜெர் ஆகும். இதன் மதிப்பு முறையே

0-Unknown,

1-Male

2-female

கீழே ஒரு சான்று நிரல் உள்ளது.

using System;
public class Enums
{
    public static void Main()
    {
        Customer[] customers = new Customer[3];
        customers[0] = new Customer()
        {
            Name = "Mark",
            Gender = 1
        };
        customers[1] = new Customer()
        {
            Name = "Mary",
            Gender = 2
        };
        customers[2] = new Customer()
        {
            Name = "Sam",
            Gender = 0
        };
        foreach (Customer customer in customers)
        {
            Console.WriteLine("Name = {0} && Gender = {1}", customer.Name, GetGender(customer.Gender));
        }
    }


    public static string GetGender(int gender)
    {
        // The swicth here is less readable because of these integral numbers
        switch (gender)
        {
            case 0:
                return "Unknown";
            case 1:
                return "Male";
            case 2:
                return "Female";
            default:
                return "Invalid Data for Gender";
        }
    }
}


// 0 - Unknown
// 1 - Male
// 2 - Female


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

 

,மேலே உள்ள நிரலில் Customer என்றொரு கிளாஸ் உள்ளது..இந்த கிளாஸின் ஆப்ஜெக்டுகள் அர்ரேயாக அறிவிக்கப்பட்டு தொடக்க மதிப்பிருத்தப் பட்டுள்ளன,.

 

இதில் GetGender என்றொரு மெத்தட் உள்ளது. இதற்கு gender -ன் இன்டிஜெர் மதிப்பை அனுப்பினால் அதன் gender ஸ்ட்ரிங்க் மதிப்பை ரிடர்ன் செய்யும்.

மேலே உள்ள நிரல் வரிகள் வாசிக்க்அ தகுந்ததாக இல்லை. மேலும் நிர்வாகிக்கவும் எளிது அல்ல.

இப்பொழுது கீழே உள்ள சான்று நிரலை கவனிக்கவும்.

using System;
public class Enums
{
    public static void Main()
    {
        Customer[] customers = new Customer[3];
        customers[0] = new Customer()
        {
            Name = "Mark",
            Gender = Gender.Male
        };
        customers[1] = new Customer()
        {
            Name = "Mary",
            Gender = Gender.Female
        };
        customers[2] = new Customer()
        {
            Name = "Sam",
            Gender = Gender.Unknown
        };
        foreach (Customer customer in customers)
        {
            Console.WriteLine("Name = {0} && Gender = {1}", customer.Name, GetGender(customer.Gender));
        }
    }


    public static string GetGender(Gender gender)
    {
        // The swicth here is now more readable and maintainable because 
        // of replacing the integral numbers with Gender enum
        switch (gender)
        {
            case Gender.Unknown:
                return "Unknown";
            case Gender.Male:
                return "Male";
            case Gender.Female:
                return "Female";
            default:
                return "Invalid Data for Gender";
        }
    }
}


public enum Gender
{
    Unknown = 0,
    Male = 1,
    Female = 2
}


public class Customer
{
    public string Name { get; set; }
    public Gender Gender { get; set; }
}

மேலே உள்ள நிரலில் enum அறிமுகப்படுத்தப் பட்டுள்ளது. இதில் மூன்று மெம்பர்கள் உள்ளன. ஒவ்வொன்றின் இன்டிஜெர் மதிப்பும் முறையே கொடுக்கப்பட்டுள்ளது. இப்பொழுது GetGender மெத்தடில் நாம் இப்பொழுது எழுதியுள்ள நிரலை கவனிக்கவும். முன்பு எழுதியதற்கும் இப்பொழுது எழுதியதற்கும் உள்ள வேறுபாட்டை கவனிக்கவும்.

இப்பொழுது நிரல் வரிகள் வாசிக்க தகுந்ததாகவும் நிர்வாகிக்க எளிதாகவும் உள்ளது.

மேலும் Enum பற்றிய குறிப்புகள்.

1. இனம்ஸ் எனப்படுவது எனுமுரேசன் ஆகும்.

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

அது போல் ஒரு இனம் டைப்பின் இன்டிஜெர் மதிப்பை மற்றொரு இனம் டைப்பிற்கு மதிப்பிருத்த முடியாது.

ஒரு இனம்மின் டிஃபால்ட் டைப் இன்டிஜெர் ஆகும்.

இதில் முதல் எளிமெண்டின் மதிப்பு 0 ஆகும். அதற்கடுத்த ,மதிப்புகள் டிஃபால்ட் ஆக ஒவ்வொன்றாய் அதிகரிக்கும்.

இதன் மதிப்புகளை நா,ம் விரும்பினால் மாற்றியமைக்கலாம்.

இனம்கள் வேல்யூ டைப் ஆகும்.

Enum என்ற கீவேர்டு இதை அறிவிக்க உதவுகின்றது. இது இதன் கீ மெம்பர்களையும் அதன் மதிப்பையும் அறிய  Getvalues, GetNames என்ற ஸ்டேட்டிக் மெத்தட்கள் பயன்படுகின்றன.

-நன்றி

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