மெத்தட்
என்பது தொடர்ச்சியாக எழுதப்பட்ட கட்டளை
வரிகளின் தொகுப்பாகும்.
இவை
குறிப்பிட்ட செயலைப் புரிகின்றன.
சி
ஷார்ப்பில் மெத்தட் வகைகள்.
1. பாராமீட்டர் இல்லா
மெத்தட்
2. பாராமீட்டருடன்
கூடிய மெத்தட்
3. பாராமீட்டர்
மற்றும் ரிடர்ன் டைப் கூடிய மெத்தட்
4. கால் பை
வேல்யூ(call by value) மெத்தட்
5. கால் பை
ரெஃபெரென்ஸ் கொண்ட மெத்தட்
6. Out பாராமீட்டர்
மெத்தட்
7. மெத்த்ட் ஓவர்
ரைடிங்க்
8. மெத்தட் ஓவர்
லோடிங்க்
9. மெத்தட் ஹைடிங்க்
10. அப்ஸ்ட்ராக்ட்
மெத்தட்கள்
11. விர்ச்சுவல்
மெத்தட்கள்.
12. ஸ்டேட்டிக்
மெத்தட்கள்
பாராமீட்டர் இல்லாதமெத்தட்கள்.
ஒரு மெத்தட் ஆனது
எந்த வித பாரா மீட்டரையும் ஏற்காத முறையில் எழுதப்பட்ட மெத்தட் பாராமீட்டர் இல்லாத
மெத்தட் ஆகும்.
சான்று நிரல்.
using System;
namespace MethodExamples
{
class ParameterLessMethod
{
protected void Message()
{
Console.WriteLine("Hello World!");
}
static void Main()
{
var p = new ParameterLessMethod();
p.Message();
Console.ReadLine();
}
}
}
பாராமீட்டருடன் கூடிய மெத்தட் என்பது என்ன?
ஒன்று அல்லது ஒன்றுக்கு மேற்பட்ட பாராமீட்டரை ஏற்கும்
மெத்தட் பாராமீட்டருடன் கூடிய மெத்தட்
ஆகும்.
using System;
namespace MethodExamples
{
class ParameterMethod
{
public void PrintMessage(string message)
{
Console.WriteLine("Hello " + message);
}
static void Main()
{
var p = new ParameterMethod();
p.PrintMessage("Farhan Ahmed");
Console.ReadLine();
}
}
}
பாரா
மீட்டர் மற்றும் ரிடர்ன் டைப்
எந்த
மதிப்பையும் ரிடர்ன் செய்யாத மெத்தட் void டைப்பாக குறிப்பிடப்படுகின்றது.
using System;
namespace MethodExamples
{
class ParameterAndReturnMethod
{
protected int MethodValue(int value)
{
Console.WriteLine("Entered value is:"+value);
return value;
}
static void Main()
{
var p = new ParameterAndReturnMethod();
p.MethodValue(15);
Console.ReadLine();
}
}
1.
}
Call
by value மெத்தட் என்பது என்ன?
பாராமீட்டர்
ஆனது ஒரு மெத்தடிற்க்கு பாஸ் செய்யும் பொழுது அதன் ம்திப்பு காப்பி
செய்யப்படுகின்றது. அந்த மெத்தட் ஆனது அதன் ஒரிஜினல் மதிப்பை மாற்றம் செய்ய
இயலாது. அந்த மெத்தடுக்குள் அந்த மதிப்பானது மாற்றம் செய்யப்பட்டாலும் ஒரிஜினல்
மதிப்பு மாறாது.
using System;
namespace MethodExamples
{
class CallByValueMethod
{
public void ShowValue(int value)
{
value *= value;
Console.WriteLine("Value of method:" + value);
}
static void Main(string[] args)
{
int value = 20;
var p = new CallByValueMethod();
Console.WriteLine("Value before method called:"+value);
p.ShowValue(value);
Console.WriteLine("Value after method called:" + value);
Console.ReadLine();
}
}
}
ரெஃப்ரென்ஸ்
மெத்தட் என்பது என்ன?
பாரா
மீட்டர் ஆனது சென்ட் ஆகும் பொழுது ref என்ற கீவேர்டுடன் பாஸ் செய்யப்ட்டால் அது
கால் பை ரெஃபெரென்ஸ் ஆகும். இந்த முறையில் மெத்தடிற்குள் நடக்கும் மாற்றமானது
ஒரிஜினல் மதிப்பை மாற்றி அமைக்கும்.
using System;
namespace MethodExamples
{
class CallByReferenceMethod
{
protected void PrintNumber(ref int number)
{
number *= number;
Console.WriteLine("Value of reference method: " + number);
}
static void Main()
{
int number = 100;
var p = new CallByReferenceMethod();
Console.WriteLine("Value before reference method called: " + number);
p.PrintNumber(ref number);
Console.WriteLine("Reflected value afrter method called: " + number);
Console.ReadLine();
}
}
}
Out பாராமீட்டர்
Out
கீவேர்டுடன் கூடிய பாராமீட்டர் அவுட் பாராமீட்டர் ஆகும்.இது மெத்தடில் இருந்து ரிடர்ன்
செய்யப்பட வேண்டிய மதிப்பைக் குறிக்கின்றது. இந்த வித பாராமீட்டரை பயன்படுத்தி
ஒன்றுக்கு மேற்பட்ட மதிப்பை ஒரு மெத்தடில் இருந்து ரிடர்ன் செய்யலாம்.
using System;
namespace MethodExamples
{
class OutParameterMethod
{
protected void PrintNumber(out int number)
{
int squre=0;
number = squre;
number *= number;
Console.WriteLine("Please enter number");
squre = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Value when method called out parameter: " + number);
}
static void Main()
{
int number = 50;
var p = new OutParameterMethod();
Console.WriteLine("Value before out parameter method called: " + number);
p.PrintNumber(out number);
Console.WriteLine("Value after out parameter method called: " + number);
Console.ReadLine();
}
}
}
எக்ஸ்டன்சன்
மெத்தட் என்பது என்ன?
இந்த
வித மெத்தட் ஆனது ஒரிஜினல் டைப்பை மாற்றி
அமைக்காமல் ஏற்கனவே உள்ள டைப்பிற்க்கு மெத்தட்களை ஆட் செய்கின்றது
using System;
namespace MethodExamples
{
class ExtentionMethod
{
static void Main()
{
int number;
Console.WriteLine("Enter numer");
number = Convert.ToInt32(Console.ReadLine());
bool result = number.IsEven();
Console.WriteLine(result);
Console.ReadLine();
}
}
public static class Helper
{
public static bool IsEven(this int number)
{
return (number%2==0);
}
}
}
அனானிமஸ்
மெத்தட் என்பது என்ன?
பெயர்
குறிப்பிடப்படாத மெத்தட் அனானிமஸ் மெத்தட் எனப்படுகின்றது. இது delegate
கீவேர்டுடன் குறிப்பிடப்படுகின்றது. இதற்கு பெயரும் ரிடர்ன் டைப்பும் தேவையில்லை
using System;
namespace MethodExamples
{
class AnonymousMethod
{
public delegate void Print(int value);
static void Main()
{
Print print = delegate (int val)
{
Console.WriteLine("Inside Anonymous method. Value: {0}", val);
};
print(100);
Console.ReadLine();
}
}
}
மெத்தட்
ஓவர் லோடிங்க் எனப்படுவது என்ன?
ஒன்றுக்கு
மேற்பட்ட மெத்தட்கள் ஒரே பெயரில் இருக்கும்
. ஆனால் பாராமீட்டர்களின் என்னிகையோ, டைப்போ அல்லது ஆர்டரோ மாறி இருக்கும்.
using System;
namespace MethodExamples
{
class MethodOverloading
{
static void Main()
{
var demo = new Demo();
int firstTotal= demo.Add(10, 20);
int secondTotal = demo.Add(10, 20, 30);
double thirdTotal= demo.Add(10.5, 20.5);
Console.WriteLine("Total:{0}",firstTotal);
Console.WriteLine("Second Total:{0}",secondTotal);
Console.WriteLine("Third Total:{0}", thirdTotal);
Console.ReadLine();
}
}
public class Demo
{
public int Add(int valueOne, int valueTwo)
{
return valueOne + valueTwo;
}
public int Add(int valueOne, int valueTwo, int valueThree)
{
return valueOne + valueTwo + valueThree;
}
public double Add(double valueOne, double valueTwo)
{
return valueOne + valueTwo;
}
}
மெத்தட்
ஓவர் ரைடிங்க் என்பது என்ன?
இம்முறையில்
மெத்த்டின் பெயர் மற்றும் பாராமீட்டர்களின் டைப்பும் ஒரே மாதிரி இருக்கும். ஆனால்
மெத்தட்கள் ஒரே கிளாசிற்க்குள் இல்லாமல் பேரண்ட் கிளாஸ் மற்றும் சைல்ட்
கிளாஸிற்க்குள் இருக்கும்.
using System;
namespace MethodExamples
{
class MethodOverriding
{
static void Main()
{
var employee = new Employee();
employee.PrintFullName();
Console.WriteLine("------------");
var contactEmployee = new ContactEmployee();
contactEmployee.PrintFullName();
Console.ReadLine();
}
}
public class Employee
{
public string firstName { get; set;}
public string lastName { get; set; }
public virtual void PrintFullName()
{
Console.WriteLine("Please enter first name:");
firstName = Convert.ToString(Console.ReadLine());
Console.WriteLine("Please enter last name:");
lastName = Convert.ToString(Console.ReadLine());
Console.WriteLine("FullName:"+ firstName +" "+ lastName);
}
}
public class ContactEmployee:Employee
{
public override void PrintFullName()
{
base.PrintFullName();
}
}
}
மெத்தட்
ஹைடிங்க் என்பது என்ன?
ஒரே
பெயர் மற்றும் பாராமீட்டர் டைப் கொண்ட மெத்த்ட்கள் அதன் பேஸ் கிளாசில் உள்ள மெதடை
new கீவேர்டு உதவியுடன் ஹைட் செய்வதை மெத்தட் ஹைட் என்கின்றோம்.
using System;
namespace MethodExamples
{
class MethodHiding
{
static void Main()
{
var customer = new Customer();
customer.FullName();
Console.WriteLine("----------");
var premiumCustomer = new PremiumCustomer();
premiumCustomer.FullName();
Console.ReadLine();
}
}
public class Customer
{
public string firstName { get; set; }
public string lastName { get; set; }
public void FullName()
{
Console.WriteLine("Enter first name");
firstName = Convert.ToString(Console.ReadLine());
Console.WriteLine("Enter last name");
lastName = Convert.ToString(Console.ReadLine());
Console.WriteLine("Full Name:" + firstName + " " + lastName);
}
}
public class PremiumCustomer:Customer
{
public string middleName { get; set; }
public new void FullName()
{
Console.WriteLine("Enter first name");
firstName = Convert.ToString(Console.ReadLine());
Console.WriteLine("Enter middle name");
middleName = Convert.ToString(Console.ReadLine());
Console.WriteLine("Enter last name");
lastName = Convert.ToString(Console.ReadLine());
Console.WriteLine("Full Name:" + firstName + " " +middleName +" " + lastName);
}
}
}
அப்ஸ்ட்ராக்ட்
மெத்தட் என்பது என்ன?
அப்ஸ்ட்ராக்ட்
கீவேர்டுடன் இந்த மெத்தட் இருக்கும்.இதில் இம்ப்ளிமென்டேசன் இல்லாமல் மெத்தட்
அறிவிப்பு மட்டும் இருக்கும். இந்த மெத்தட் உள்ள கிளாசை இன் ஹெரிட் செய்யும்
கிளாஸில் இந்த மெத்தடிற்கான இம்ப்ளிமென்டேசன் இருக்கும்.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace MethodExamples
{
public abstract class AbstractMethod
{
public abstract void MyAbstractMethod();
}
}
அப்ஸ்ட்ராக்ட் மெத்தட் அம்சங்கள்.
1.
ஒரு
அப்ஸ்ட்ராக்ட் கிளாஸிற்குள் தான் அப்ஸ்ட்ராக்ட் மெத்தட் இருக்கும்.இதில் அறிவிப்பு
மட்டும் இருக்கும். மெத்தட் பாடி(body) இருக்காது.
2.
இந்த மெத்தடின்
இம்ப்ளிமெண்டேசன் மெத்தட் ஓவர் ரரைடிங்க் செய்து சைல்ட் கிளாஸில் இருக்கும்.சைல்ட்
கிளாஸ் நான் அப்ஸ்ட்ராக்ட் கிளாசாக இருக்கும்.
விர்ச்சுவல்
மெத்தட்கள்
விர்ச்சுவல்
மெத்தட் ஆனது அது இருக்கும் கிளாஸின் சைல்ட் கிளஸில் இந்த மெத்தட் ஆனது ஓவர்ட்
ரைட் செய்ய அனுமதிக்கின்றது அது virtual என்ற கீ வர்டு மூலம் சாத்தியமாகின்றது.
இது override கீவேர்டு மூலம் ஓவர்ரைட் செய்யப்படுகின்றது
using System;
namespace MethodExamples
{
public class VirtualMethod
{
public virtual string Message(string msg)
{
return "Hello" + msg;
}
}
public class myClass : VirtualMethod
{
public override string Message(string msg)
{
return base.Message(msg);
}
}
public class program
{
static void Main()
{
var p = new VirtualMethod();
string name= p.Message("Farhan Ahmed");
var p1 = new myClass();
string name1= p1.Message("Rahul Sharma");
Console.WriteLine(name);
Console.WriteLine(name1);
Console.ReadLine();
}
}
}
விர்ச்சுவல்
மெத்தட் அப்ஸ்ட்ராக்ட் மெத்தட் வித்தியாசங்கள்.
இது virtual என்ற கீவேர்டை கொண்டுள்ளது.இதற்கு டிஃபால்ட் இம்ப்ளிமென்டேசன் இருக்கும். எனினும் இதை டெரிவெட் கிளாஸில் ஓவர் ரைட் செய்யலாம். இதற்கு
override கீவேர்டு பயன்படுகின்றது.
அப்ஸ்ட்ராக்ட் மெத்தட் ஆனதில் அறிவிப்பு மட்டும் இருக்கும்.
இம்ப்ளிமெண்டேசன் இருக்கது. இது abstract கீவேர்டை பயன்படுத்துகின்றது. இதன் இம்பளிமெண்டேசன்
கட்டாயம் டெரிவெட் கிளாஸில் இருக்க வேண்டும். இதற்கு override கீவேர்டு பயன்படுத்தலாம்
அல்லது பயன்படுத்தாமலும் இருக்கலாம்.
ஸ்டேடிக்
மெத்தட் என்பது என்ன?
ஸ்டேடிக்
மெத்தடை கிளாஸிற்கு ஆப்ஜெக்ட் உருவாக்கமேலேயே அழைக்கலாம்.இதை அழைப்பதற்கு கிளாஸின்
பெயர் பயன்படுகின்றது.இது static என்ற கீவேர்டை பயன்படுத்துகின்றது.
using System;
namespace MethodExamples
{
static class StaticMethod
{
public static void PrintValue(int value)
{
Console.WriteLine("The Value is: " + value);
}
}
public class StaticExample
{
static void Main()
{
StaticMethod.PrintValue(100);
Console.ReadLine();
}
}
}
நன்றி
முத்து கார்த்திகேயன்,மதுரை.
