कास्टिंग में

कास्टिंग के बारे में

कास्टिंग और टाइप रूपांतरण एक एक्सप्रेशन को एक डेटा टाइप से दूसरे में बदलने के अलग-अलग तरीके हैं।

C# का दस्तावेज़ टाइप रूपांतरण को as ऑपरेटर या is ऑपरेटर के उपयोग के रूप में वर्गीकृत करता है। कास्टिंग को कास्ट ऑपरेटर के उपयोग के रूप में परिभाषित किया गया है।

C# में अक्सर, संख्यात्मक वैल्यू और क्लास पदानुक्रम के दायरे से बाहर, आपको "to" टाइप के किसी मेंबर को कॉल करके रूपांतरण करना पड़ता है, जैसे Int32.Parse(), जो एक स्ट्रिंग को पूर्णांक में बदल देता है, या "from" टाइप के किसी मेंबर को कॉल करके, जैसे object.ToString()। JavaScript और दूसरी डायनैमिक भाषाओं के डेवलपर इस बात का ध्यान रखें।

ध्यान दीजिए कि इम्प्लिसिट और एक्सप्लिसिट कास्ट ऑपरेटर (operator-overloading में चर्चित) उपलब्ध हैं, जिनसे आप अपने ही टाइप पर काफी मनचाही कास्टिंग कर सकते हैं।

प्रिमिटिव टाइप की कास्टिंग - इम्प्लिसिट

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

इम्प्लिसिट कास्ट को दर्शाने के लिए किसी खास सिंटैक्स की ज़रूरत नहीं होती। उदाहरण के लिए:

int myInt = 1729;
long myLong = myInt;

किसी संख्यात्मक (या स्ट्रिंग) एक्सप्रेशन का bool में कोई इम्प्लिसिट रूपांतरण नहीं होता। इस काम के लिए Base Class Library (BCL) Convert.ToBoolean() प्रदान करती है।

char टाइप के एक्सप्रेशन को इम्प्लिसिट रूप से int में कास्ट किया जा सकता है। उलटी दिशा में कास्ट एक्सप्लिसिट होना चाहिए। int की सारी वैल्यू मान्य utf 16 अक्षर नहीं होतीं।

प्रिमिटिव टाइप की कास्टिंग - एक्सप्लिसिट

जहाँ संख्यात्मक टाइप को इम्प्लिसिट रूप से कास्ट नहीं किया जा सकता, वहाँ आम तौर पर आप एक्सप्लिसिट कास्ट ऑपरेटर इस्तेमाल कर सकते हैं।

अगर कास्ट की जा रही वैल्यू को "to" टाइप इसलिए नहीं दर्शा सकता क्योंकि उसकी चौड़ाई काफी नहीं है या चिह्न में टकराव है, तो पूर्णांक के मामले में ओवरफ्लो एक्सेप्शन फेंका जा सकता है। फ्लोट और डबल के मामले में "to" टाइप का वेरिएबल Infinity की वैल्यू ले सकता है।

int टाइप के एक्सप्रेशन को एक्सप्लिसिट रूप से char में कास्ट किया जा सकता है। इससे एक अमान्य char बन सकता है।

प्रिमिटिव टाइप की कास्टिंग - उदाहरण

int largeInt = Int32.MaxValue;
int largeNegInt = Int32.MinValue;
ushort shortUnsignedInt = ushort.MaxValue;
float largeFloat = float.MaxValue;
float smallFloat = 17.29f;

// implicit cast
int from_ushort = shortUnsignedInt;          // 65535
float from_int = largeInt;                   // -21474836E+09
int from_char = 'a';                         // 96

// explicit cast
uint from_largeInt = (uint)largeInt;         // 2147483647
uint from_neg = (uint) largeNegInt;          // 2147483648 or OverflowException is thrown (if checked)
int from_smallFloat = (int) smallFloat;      // 17
int from_largeFloat = (int) largeFloat;      // -2147483648 or OverflowException is thrown (if checked)
char from_intc = (char) 32;                  // ' '
char from_invalid_int = (char) 0xdcbf;       // invalid char - no exception thrown

// no cast available
int fromString = Int32.Parse("42");          // 42
string toString = largeInt.ToString();       // "2147483647"
int fromString_bad = Int32.Parse("forty two");     // FormatException is thrown

checked कीवर्ड के बारे में इस लेख को देखिए।

पदानुक्रम में टाइप का रूपांतरण

किसी भी टाइप को इम्प्लिसिट रूप से उसके बेस क्लास या इंटरफेस में बदला जा सकता है।

IList<int> ll = new List<int>();

बेस क्लास से डिराइव्ड क्लास में बदलने के लिए कास्ट ऑपरेटर इस्तेमाल किया जा सकता है।

IList<int> ll = new List<int>();
List<int> l = (List<int>)ll;

अगर कास्ट इसलिए विफल हो जाता है क्योंकि जिस एक्सप्रेशन को कास्ट किया जा रहा है, उसका टाइप उस टाइप से संबंधित नहीं है जिसमें उसे कास्ट किया जा रहा है, तो InvalidCastException का एक इंस्टेंस फेंका जाता है।

इन टाइप रूपांतरणों के लिए एक अधिक सामान्य तरीका is कीवर्ड का उपयोग करना है:

interface IFoo { int Bar(); }
class Foo : IFoo { public int Bar() { return 42; }}
Object r = new Random();
IFoo ifoo = new Foo();
Object o = new Foo();

int result = 1729;

if (ifoo is Foo foo)
{
    result = foo.Bar();
}
// result == 42

result = 1729;
if (o is Foo foo2)
{
    result = foo2.Bar();
}
// result == 42

result = 1729;
if (r is Foo foo3)
{
    result = foo3.Bar();
}
// result == 1729

as कीवर्ड is जैसा ही काम करता है, जैसे var foo = ifoo as Foo;। इस उदाहरण में अगर ifoo का टाइप Foo नहीं है तो foo की वैल्यू null होगी, वरना ifoo को उसमें असाइन कर दिया जाएगा।

कस्टम कास्ट ऑपरेटर

टाइप अपने खुद के कस्टम एक्सप्लिसिट और इम्प्लिसिट कास्ट ऑपरेटर बना सकते हैं।

BCL में एक्सप्लिसिट और इम्प्लिसिट कास्ट के उदाहरण हैं BigInteger स्ट्रक्ट से दूसरे संख्यात्मक टाइप में और दूसरे टाइप से BigInteger में होने वाले रूपांतरण।

typeof का उपयोग

अगर आपको किसी ऑब्जेक्ट का सटीक टाइप पता करना है, तो is थोड़ा अधिक छूट देने वाला हो सकता है, क्योंकि वह किसी ऑब्जेक्ट को उसकी क्लास या उसकी किसी भी बेस क्लास में बदल देता है। ऐसे मामले में typeof और Object.GetType() ही समाधान हैं।

object o = new List<int>();

o is ICollection<int> // true
o.GetType() == typeof(ICollection<int>) // false
o is List<int> // true
o.GetType() == typeof(List<int>) // true