C # के सूक्ष्म क्षण

यह कोई रहस्य नहीं है कि सी # आज एक लोकप्रिय और गतिशील रूप से विकसित भाषा है, इसके प्रत्यक्ष प्रतियोगी, जावा भाषा के विपरीत, जो कार्यक्षमता के मामले में ठहराव की अवधि का अनुभव कर रहा है। जावा का मुख्य निर्विवाद लाभ सही क्रॉस-प्लेटफ़ॉर्म है, बजाय सुस्त और सीमित, सी # की तरह।



सी # एक सरल भाषा है, इसकी सादगी के लिए धन्यवाद PHP भी रहता है। लेकिन एक ही समय में, यह बहुत कार्यात्मक है, और एक "हाइब्रिड" भाषा की स्थिति है, जो विभिन्न प्रतिमानों को जोड़ती है, प्रोग्रामिंग की अनिवार्य शैली और कार्यात्मक दोनों के लिए अंतर्निहित समर्थन है।



किसी भी भाषा की तरह, शार्प की अपनी सूक्ष्मताएं, विशेषताएं, "नुकसान" और अल्पज्ञात विशेषताएं हैं। मेरा क्या मतलब है? कटौती के तहत पढ़ें ...

पैकेजिंग और अनपैकिंग - हर कोई जानता है, लेकिन हर कोई नहीं

संदर्भ प्रकार (ऑब्जेक्ट, डायनेमिक, स्ट्रिंग, क्लास, इंटरफ़ेस, डेलीगेट) प्रबंधित हीप में संग्रहीत किए जाते हैं, मान प्रकार (स्ट्रक्चरल, एनम, बूल, बाइट, चार, इंट, फ्लोट, डबल) एप्लीकेशन स्टैक में संग्रहीत किए जाते हैं (जब मूल्य प्रकार को छोड़कर) एक वर्ग क्षेत्र है)। एक मान प्रकार को संदर्भ प्रकार में परिवर्तित करना एक निहित बॉक्सिंग ऑपरेशन के साथ होता है - एक रैपर वर्ग में मूल्य प्रकार की एक प्रति डालते हुए, जिसका एक उदाहरण ढेर पर संग्रहीत होता है। पैकेजिंग प्रकार सीएलआर द्वारा उत्पन्न होता है और संग्रहीत मूल्य प्रकार के इंटरफेस को लागू करता है। एक संदर्भ प्रकार को एक मान प्रकार में बदलने से एक अनबॉक्सिंग ऑपरेशन का कारण बनता है - पैकेज से मूल्य प्रकार की एक प्रति निकालता है और इसे स्टैक पर डालता है।

using System;



class Program

{

static void Main()

{

int val = 5;

object obj = val; //

int valUnboxed = ( int )obj; //

}

}



अनुरूप आईएल कोड:



.locals init ([0] int32 val, [1] object obj, [2] int32 valUnboxed)

IL_0000: nop

IL_0001: ldc.i4.5

IL_0002: stloc.0

IL_0003: ldloc.0

IL_0004: box [mscorlib]System.Int32

IL_0009: stloc.1

IL_000a: ldloc.1

IL_000b: unbox.any [mscorlib]System.Int32

IL_0010: stloc.2

IL_0011: ret







पैकेजिंग और अनपैकिंग अपेक्षाकृत धीमे संचालन (नकल करना) है, इसलिए जब भी संभव हो, उनसे बचें। निम्नलिखित कोड पैकेजिंग के लिए गैर-स्पष्ट मामलों को प्रदर्शित करता है:

using System;



class Program

{

static void Main()

{

// 1.

IComparable< int > iComp = 1;

// 2. enum System.Enum

Enum format = UriFormat.Unescaped;

// 3. dynamic

dynamic d = 1;

}

}



Msdn में, उन मामलों में मूल्य प्रकारों से बचने की सिफारिश की जाती है जब उन्हें कई बार पैक किया जाना चाहिए, उदाहरण के लिए, गैर-सार्वभौमिक संग्रह कक्षाओं (ArrayList) में। जेनेरिक कलेक्शन (System.Collections.Generic namespace) का उपयोग करके वैल्यू टाइप रैपिंग से बचा जा सकता है। यह भी याद रखना चाहिए कि आईएल-कोड स्तर पर गतिशील एक ही वस्तु है, केवल (हमेशा नहीं) विशेषताओं के साथ टैग किया गया है।

मेमने में पुनरावृत्ति - दुर्भावनापूर्ण बंद के बारे में

हम लंबोदर भावों का उपयोग करते हुए पुनरावर्ती तथ्यात्मक गणना के शास्त्रीय कार्यान्वयन की ओर मुड़ते हैं:

using System;

using System.Numerics;



class Program

{

static void Main()

{

Func< int , BigInteger> fact = null ;

fact = x => x > 1 ? x * fact(x - 1) : 1;

}

}



हम जानते हैं कि एक लैम्बडा पर्यावरण चर (बंद) पर कब्जा करने की क्षमता के कारण खुद को संदर्भित करने में सक्षम है। हम जानते हैं कि कैद की गई वस्तुओं को एक लंबोदर अभिव्यक्ति के संदर्भ के बाहर संशोधित किया जा सकता है, और भाषा में इस व्यवहार को ओवरराइड करने की कोई अंतर्निहित क्षमता नहीं है। यह स्पष्ट है कि ज्यादातर मामलों में यह दृष्टिकोण स्वीकार्य नहीं होगा, और हम किसी तरह लैंबडा के संदर्भ के बाहर कैप्चर किए गए चर को बदलने की क्षमता को सीमित करना चाहेंगे।



सामान्य स्थिति में, एक निश्चित बिंदु कॉम्बिनेटर को लागू करने से प्रस्तुत समस्या हल हो जाती है:

using System;

using System.Numerics;



class Program

{

static void Main()

{

var fact = YPointCombinator.Create< int , BigInteger>(f => (n) => n > 1 ? n * f(n - 1) : 1);

var power = YPointCombinator.Create< int , int , BigInteger>(f => (x, y) => y > 0 ? x * f(x, y - 1) : 1);

}

}

public static class YPointCombinator

{

public static Func<T1, T2> Create<T1, T2>(Func<Func<T1, T2>, Func<T1, T2>> f)

{

return f(r => Create( f )( r ));

}

public static Func<T1, T2, T3> Create<T1, T2, T3>(Func<Func<T1, T2, T3>, Func<T1, T2, T3>> f)

{

return f((r1, r2) => Create(f)(r1, r2));

}

}



निजी और प्रतिबिंब क्षेत्र, या हम आपके OOP पर थूकते हैं

प्रतिबिंब तंत्र का उपयोग करके, आप किसी वर्ग के निजी क्षेत्र का मान भी बदल सकते हैं।

यह स्पष्ट है कि इस निर्माण को केवल आपातकाल के मामले में लागू करने के लिए, एनकैप्सुलेशन के सिद्धांत का पालन करना।

using System;

using System.Reflection;



class Sample

{

private string _x = "No change me!" ;

public override string ToString()

{

return _x;

}

}

class Program

{

static void Main()

{

var sample = new Sample();

typeof (Sample).GetField( "_x" , BindingFlags.NonPublic | BindingFlags.Instance)

.SetValue(sample, "I change you..." );

Console .Write(sample);

Console .ReadKey();

}

}



UPD: जैसा कि सही ढंग से उल्लेख किया गया है, निजी क्षेत्र को बदलने में केवल तभी सफलता मिलेगी जब असेंबली एक कोड समूह से संबंधित हो, जिसमें आवश्यक अनुमति हो। आप वर्ग (विधि) को कुछ इस तरह से चिह्नित करके इस अधिकार को घोषित कर सकते हैं:

[System.Security.Permissions.ReflectionPermission(System.Security.Permissions.SecurityAction.Assert)]



.NET सुरक्षा प्रणाली के साथ सब कुछ सरल नहीं है, और .NET 4 में इसमें बड़े बदलाव हुए हैं ।

बतख टाइपिंग और फॉरेस्ट लूप

फ़ॉर्च का उपयोग करते हुए एक वर्ग के उदाहरण के तत्वों पर पुनरावृति करने में सक्षम होने के लिए, इसमें GetEnumerator () विधि को लागू करने के लिए पर्याप्त है।

using System;

using System.Collections.Generic;



class Sample

{

public IEnumerator< int > GetEnumerator()

{

for ( var i = 0; i < 10; ++i)

yield return i;

}

}

class Program

{

static void Main()

{

foreach ( var t in new Sample())

Console .WriteLine(t);

Console .ReadKey();

}

}



तथाकथित "डक" टाइपिंग की यह छोटी सी अभिव्यक्ति, आमतौर पर गतिशील भाषाओं में उपयोग की जाती है, सी # में भी होती है।

अनाम प्रकार - अधिक संभव है

अनाम प्रकार के चर संग्रह में संग्रहीत किए जा सकते हैं। अपने लिए देखें:

using System;

using System.Linq;



class Program

{

static void Main()

{

var list = new [] {

new { Name = "Alex" , Age = 18 },

new { Name = "Petr" , Age = 30 } }.ToList();



Console .Write(list.Find(x => x.Name == "Petr" ));

Console .ReadKey();

}

}



अनाम प्रकार के वेरिएबल्स को दूसरे दायरे में पास किया जा सकता है:

using System;



class Program

{

static dynamic User

{

get { return new { Name = "Alex" , Age = 18 }; }

}



static void Main()

{

Console .Write(User.Name);

Console .ReadKey();

}

}



रेफ कभी-कभी छोड़ा जा सकता है

C # 4.0 के साथ शुरू, रेफरी कीवर्ड को COM इंटरॉप के माध्यम से कॉल करते समय छोड़ा जा सकता है। नामित तर्कों के संयोजन में, यह बहुत प्रभावशाली दिखता है:

using System;

using Word = Microsoft.Office.Interop.Word;



class Program

{

static void Main()

{

var app = new Word.Application();

Word.Document doc = null ;



// C# 2.0 - 3.5

object

filename = "test.doc" ,

visible = true ,

missing = Type.Missing;



doc = app.Documents.Open(

ref filename, ref missing, ref missing, ref missing, ref missing, ref missing,

ref missing, ref missing, ref missing, ref missing, ref missing, ref visible,

ref missing, ref missing, ref missing, ref missing);



// C# 4.0

doc = app.Documents.Open(FileName: "test.doc" , Visible: true );

}

}



नोट: नामित पैरामीटर और रेफरी को छोड़ने की क्षमता भाषा उपकरण हैं, इसलिए, .NET फ्रेमवर्क 4.0 और .NET फ्रेमवर्क 2.0, 3.0, 3.5 दोनों को मूल एप्लिकेशन ढांचे के रूप में चुना जा सकता है।

पर्दे के पीछे क्या रहता है

भाषा के अन्य सभी "सूक्ष्मताओं" के बीच, मैं ऑब्जेक्ट्स के नियतात्मक विनाश की समस्या को बाहर कर दूंगा, थ्रेडएबोर्टएक्स अपवाद जैसे अतुल्यकालिक अपवादों को संभालने की जटिलता। ब्याज के शक्तिशाली सूत्र सिंक्रनाइज़ेशन उपकरण हैं और भाषा में अतुल्यकालिक संचालन के लिए एम्बेडिंग समर्थन से संबंधित सी # 5.0 में आगामी परिवर्तन हैं।