C# 7.0 புதிய அம்சங்கள்.

C# 7.0  புதிய அம்சங்கள்

புதிதாக வெளியாகியுள்ள விசுவல் ஸ்டுடியோ 2017 –ன் உள்ள c# 7.0-ன் புதிய அம்சங்கள்.

இதில் நிறைய புதிய அம்சங்கள் அறிமுகபடுத்தப்பட்டுள்ளன. முக்கியயமாக டேட்டா நுகர்வு,நிரலை எளிமைப்படுத்துதல்,செயல் திறன் ஆகியவற்றில் கவனம் செலுத்தப்பட்டுள்ளது.tuples-ல் புதிய விசயங்களில் கவனம் செலுத்தப் பட்டுள்ளது.மேலும் pattern matching-லும் கவனம் செலுத்தப்பட்டுள்ளது.சிறிய மற்றும் பெரிய அம்சங்கள் நிறைய சேர்க்கப் பட்டு உ.ள்ளன.

Out வேரியபிள்கள்:

இதற்கு முன் ஒரு மெத்தடை out பாராமீட்ட்டருடன் அழைக்கும் பொழுது முன் கூடியே டேட்டா டைப்பை அறிவித்து விட்டு பிறகு அழைக்க வேண்டும்.

உதாரணாமாக.

public void PrintCoordinates(Point p)

{

int x, y; // have to "predeclare"

p.GetCoordinates(out x, out y);

WriteLine($"({x}, {y})");

}

இப்பொழுது மெத்தடை அழைக்கும் பொழுதே டேட்டா டைப்பை அறிவிக்கலாம்.

உதாரணமாக.

public void PrintCoordinates(Point p)

{

p.GetCoordinates(out int x, out int y);

WriteLine($"({x}, {y})");

}

மேலும் செயல் திறனை அதிகப்படுத்த வேரியபிளின் டைப்பாக var என்று அறிவிக்கலாம்.

உதாரணமாக

p.GetCoordinates(out var x, out var y);

மற்றொரு பொதுவான உபயோகமான out parameter-ன் try patteren –ல் பூலியன் மதிப்பானது சரி என்பதை உறுதிப்படுத்த அதை out வேரியபிள்கள் வெளியீடு செய்கின்றன.

உதாரணமாக

public void PrintStars(string s)

{

if (int.TryParse(s, out var i)) { WriteLine(new string('*', i)); }

else { WriteLine("Cloudy - no stars tonight!"); }

}

C# 7.0 ஆனது pattern களில் புதிய கருத்துகளை அறிமுகப்படுத்தியுள்ளது.

C# 7.0 புதிய pattern –கள்

Constant pattern of the form c-இதில் c என்பது கான்ஸ்டண்ட் ஆகும். இதில் உள்ளீடு ஆனது c –ன் மதிப்புடன் சரியாக உள்ளதா என சரி பார்க்கப்படுகின்றது.

T-ன் type pattern –(Type T)-இதில் உள்ளீடானது T-ன் டேட்டா டைப்புடன் சரிபார்க்கப்படுகின்றது.

Var pattern var x-இதில் உள்ளீடானது x –ல் (அதே டேட்டடைப்புடன் உள்ள)மதிப்பிருத்தப்படுகின்றது.

C# 7.0 ஆனது ஏற்கனவே உள்ள pattern களில் புதிய கட்டமைப்புகளை அறிமுகப்படுத்தியுள்ளது.

1.is expression ஆனது இப்பொழுது pattern ஆனதை வலது பக்கத்தில் இருத்திக் கொள்ளலாம்.

2.case classusஇப்பொழுது switch construct-ல் கான்ஸ்டன்ட் மதிப்புடன் சரி பார்ப்பதோடு இல்லாமல் பேட்டெர்ன்களுடன் சரிபார்த்துக் கொள்ளலாம்.

பேட்டர்ன்களுடன் -is expression.

public void PrintStars(object o)

{

if (o is null) return; // constant pattern "null"

if (!(o is int i)) return; // type pattern "int i"

WriteLine(new string('*', i));

}

பேட்டர்ன்(patterns) உடன் ஆன switch-expession.

1.   Switch மதிப்புகளை வேல்யூ மதிப்புடன் இல்லாமல் எல்லா டைப்புடனும் சரி பார்க்கலாம்.

2.   Case classus-ல் pattern உடன் சரி பாக்கலாம்.

3.   கூடுதல் விதிமுறைகளையும் சரி பார்க்கலாம்.

உதாரணம்.

switch(shape)

{

case Circle c:

WriteLine($"circle with radius {c.Radius}");

break;

case Rectangle s when (s.Length == s.Height):

WriteLine($"{s.Length} x {s.Height} square");

break;

case Rectangle r:

WriteLine($"{r.Length} x {r.Height} rectangle");

break;

default:

WriteLine("<unknown shape>");

break;

case null:

throw new ArgumentNullException(nameof(shape));

}

இது வரை இருந்தது போல் இல்லாமல் case classus-ந் ஒழுங்குபடுத்துதல் (அதாவது வரிசை))முக்கியமானதாகும்.

மேற்கண்ட நிரல் வரிகளில் square ஆனது rectangle ஐ காட்டுலும் முன் வரவேண்டும் என்பதை இதற்கு உதாரணமாக சொல்லலாம்.

எந்த வரிசையில் எழுதப்பட்டாலும் default classus ஆனது கடைசியிலேயே சரி பார்க்கப்படும்.

கடைசியாக உள்ள null classus ஆனது not reachable கிடையாது.

Tuples

ஒரு மெத்தடை அழைக்கப்படும் பொழுது அது எத்தனை மதிப்புகளை திருப்பி அனுப்பும் என்பதாகும். இப்பொழுது c# 7.0-வில் புதிய வசதிகள் ஏற்படுத்தப்பட்டுள்ளன.

உதாரணம்.

(string, string, string) LookupName(long id) // tuple return type

{

... // retrieve first, middle and last from data storage

return (first, middle, last); // tuple literal

}

இப்பொழுது மெத்தட் ஆனது ஒன்றுக்கும் மேற்பட்ட உறுப்பிகளைக் கொண்ட tuple ஆக திருப்பி அனுப்புகின்றது.

மெத்தடை அழைக்கும் பொழுது அது பெறப்படும் tuple ஆனது தனித்தனியே பிரிக்கப்படலாம்.

உதாரணமாக

var names = LookupName(id);

WriteLine($"found {names.Item1} {names.Item3}.");

Item1 போன்றவை அதன் default ஆகும் நாம் விரும்பினாம் அதற்கு குறிப்பிடப்பட்ட பெயர் வைத்துக்கொள்ளலாம்.

(string first, string middle, string last) LookupName(long id) // tuple elements have names

இப்பொழுது மெத்தட் அழைக்கப்படும் நிரல் வரிகள் உதாரனமாக

var names = LookupName(id);

WriteLine($"found {names.first} {names.last}.");

மேலும் tuple litteral களில் உறுப்புகளின் பெயரை குறிப்பிட்டு திருப்பி அனுப்பலாம்.

return (first: first, middle: middle, last: last); // named tuple elements in a literal

tuple-களின் பெயரை பொருட்படுத்தாமல் அதன் மதிப்புகளை ஒன்றுக்கொன்று மதிப்பிருத்திக் கொள்ளலாம்.மேலும் ஒரு tuple ஆனதின் ஒரு டைப்பை மற்றொரு டைப்புக்கு பதிப்பிருத்திக் கொள்ளலாம்.

Tuples என்பது value type ஆகும்.இது public மற்றும் mutable ஆகும்.

இரண்டு tuples ஒரே மதிப்புகள் என்றால் அவை ஒரே மாதிரியான hash code ஆனதையும் கொண்டிருக்க வேண்டும்.

இது டூபில்களை மெத்தடின் திருப்பி அனுப்ப படுவதற்கு மற்றுமட்டும் அல்லாமல் மேலும் பல விதமாக உபயோகப்படுகின்றது. உதாரணமாக multiple value கொண்ட dictionary க்கு ஒரு டூபிலை (tuple) key ஆகக் கொள்ளலாம். அதே போல் multiple value கொண்ட லிஸ்டிற்கும் டூபிலை

பயன்படுத்திக் கொள்ளலாம்.

Deconstruction.

Tuple ஆனதை மெத்தடில் இருந்து திருப்பி அனுப்பும் பொழுது தனித்தனியே பெயரிட்டு பிரித்துக் கொள்ளலாம்.

உதாரணமாக.

(string first, string middle, string last) = LookupName(id1); // deconstructing declaration

WriteLine($"found {first} {last}.");

 மேலும் டூபிலின் டேட்டா டைப்பாக var என்றும் அறிவித்துக் கொள்ளலாம்.

உதாரணமாக

(var first, var middle, var last) = LookupName(id1); // var inside

அல்லது

var (first, middle, last) = LookupName(id1); // var outside

இவ்வாரும் உபயோகப் படுத்தலாம்.

பின் வகும் deconstruct method வடிவத்தைக் கொண்டிருந்தால் deconstruct என்ற கருத்தை tuple மற்றும் அல்லாமல் எந்த விதமான டைப்பிற்கும் ப்யன்படுத்த்க் கொள்ளலாம்.

public void Deconstruct(out T1 x1, ..., out Tn xn) { ... }

மேலே உள்ள நிரல் வரிகளில் out வேரியபிள்கள் deconstruct செய்யப்ப்படுகின்றன.

இதில் tuple உபயோகப்படுத்தாமல் out உபயோகப்படுத்தப் பட்டிருப்பதற்கு காரணம் இது மெத்தட் ஓவர் லோடிங்கிற்கு பயன் படுத்தப்பட்டிருக்கின்றது.

class Point

{

public int X { get; }

public int Y { get; }

public Point(int x, int y) { X = x; Y = y; }

public void Deconstruct(out int x, out int y) { x = X; y = Y; }

}

(var myX, var myY) = GetPoint(); // calls Deconstruct(out myX, out myY);

Local methods

 Local methods  மற்றும் functions நடப்பு c#-வெர்சனில் உள்ளது என்றாலும் பின் வருவன அதில் இல்லை.

• Generic
• out parameters
• Ref
• params

இப்பொழுது c# 7.0-வில் பின் வருமாறு நிரலை எழுதலாம்.

private static void Main(string[] args)

{

    int local_var = 100;

    int LocalFunction(int arg1)

    {

        return local_var * arg1;

    }

    Console.WriteLine(LocalFunction(100));

}

லிட்டரல்சின் ரீடபிலிட்டியை(literals readablity)அதிகப்படுத்துதல்.

லிட்டரசல்களை பிரிப்பதற்கு(அதாவது ரீடபிலிட்டியை அதிகரிக்க) அனடர்ஸ்கோரை பயன்படுத்தலாம். (_). இதனால் அதன் மதிப்பு மாறாது.

var lit1 = 478_1254_3698_44;

 var lit2 = ab0Xab_bc47at_XY;

ரெஃப்(ref) ஆக மெத்தட் திருப்பி அனுப்பும் மதிப்பை  உபயோகித்தல்

.c# 7.0 வில் ஒரு ref டைப்பை பராமீட்டராக அனுப்பி ref டைப்பை திருப்பி அனுப்பி அதை ref டைப் வேரியபிளில் பெற்றுக் கொள்ளலாம். உதாரணமாக

ref string getFromList(string strVal, string[] Values)

{

 foreach (string val1 in Values)

 {

     if (strVal == val1)

        return ref val1; //return location as ref not actual value

 }

}

string[] values = { "a", "b", "c", "d" };

ref string strSubstitute = ref getFromList("b", values);

strSubstitute = "K"; // replaces 7 with 9 in the array

System.Write(values[1]); // it prints "K"

எக்ஸ்பிரசனில் பிழை எரிதல்.

இப்பொழுது exception ஆனதை ஒரு expression –ல் இருந்தே throw செய்யலாம்.

உதாரணம்.

public string getEmpInfo( string EmpName)

    {

        string[] empArr = EmpName.Split(",");

        return (empArr.Length > 0) ? empArr[0] : throw new Exception("Emp Info Not exist");

    }

                            -நன்றி

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