C# Language
ढलाई

टिप्पणियों

एक आधार प्रकार के लिए एक वस्तु कास्ट करें

निम्नलिखित परिभाषाओं को देखते हुए:

public interface IMyInterface1
{
    string GetName();
}

public interface IMyInterface2
{
    string GetName();
}

public class MyClass : IMyInterface1, IMyInterface2
{
    string IMyInterface1.GetName()
    {
        return "IMyInterface1";
    }

    string IMyInterface2.GetName()
    {
        return "IMyInterface2";
    }
}

आधार प्रकार के उदाहरण के लिए एक वस्तु का कास्टिंग:

    MyClass obj = new MyClass();

    IMyInterface1 myClass1 = (IMyInterface1)obj;
    IMyInterface2 myClass2 = (IMyInterface2)obj;

    Console.WriteLine("I am : {0}", myClass1.GetName());
    Console.WriteLine("I am : {0}", myClass2.GetName());

    // Outputs :
    // I am : IMyInterface1
    // I am : IMyInterface2

स्पष्ट कास्टिंग

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

object value = -1;
int number = (int) value;
Console.WriteLine(Math.Abs(number));

अगर हमने सीधे Math.Abs() को value की कोशिश की, तो हमें एक संकलन-समय अपवाद Math.Abs() क्योंकि Math.Abs() में एक अधिभार नहीं है जो एक object को पैरामीटर के रूप में लेता है।

यदि value एक int नहीं डाला जा सकता है, तो इस उदाहरण में दूसरी पंक्ति एक InvalidCastException को फेंक देगी

सुरक्षित स्पष्ट कास्टिंग (`as` संचालक)

यदि आप सुनिश्चित नहीं हैं कि कोई मान उस प्रकार का है जिसे आप सोचते हैं कि आप सुरक्षित रूप से इसे ऑपरेटर के as उपयोग कर सकते हैं। यदि मान उस प्रकार का नहीं है, तो परिणामी मान null होगा।

object value = "-1";
int? number = value as int?;
if(number != null)
{
    Console.WriteLine(Math.Abs(number.Value));
}

ध्यान दें कि null तो मान, कोई प्रकार है as कीवर्ड सुरक्षित रूप से निकलेगा null जब किसी भी कास्टिंग null मूल्य।

अवैध कास्टिंग

एक मान स्वचालित रूप से उपयुक्त प्रकार पर डाला जाएगा यदि कंपाइलर जानता है कि यह हमेशा उस प्रकार में परिवर्तित हो सकता है।

int number = -1;
object value = number;
Console.WriteLine(value);

इस उदाहरण में, हमें विशिष्ट स्पष्ट कास्टिंग सिंटैक्स का उपयोग करने की आवश्यकता नहीं थी क्योंकि कंपाइलर जानता है कि सभी int एस को object एस में डाला जा सकता है। वास्तव में, हम वैरिएबल बनाने से बच सकते हैं और -1 सीधे Console.WriteLine() के तर्क के रूप में पास करते हैं जो किसी object अपेक्षा करता object ।

Console.WriteLine(-1);

कास्टिंग के बिना संगतता की जाँच करना

आप को पता है एक मूल्य के प्रकार और फैली हुई है या औजार हैं कि कोई प्रकार की जरूरत है, लेकिन आप नहीं चाहते हैं वास्तव में उस प्रकार के रूप में यह कास्ट करने के लिए, आप उपयोग कर सकते is ऑपरेटर।

if(value is int)
{
   Console.WriteLine(value + "is an int");
}

स्पष्ट संख्यात्मक रूपांतरण

स्पष्ट कास्टिंग ऑपरेटरों का उपयोग संख्यात्मक प्रकार के रूपांतरण करने के लिए किया जा सकता है, भले ही वे एक दूसरे को विस्तारित या कार्यान्वित न करें।

double value = -1.1;
int number = (int) value;

ध्यान दें कि उन मामलों में जहां गंतव्य प्रकार में मूल प्रकार की तुलना में कम सटीकता है, परिशुद्धता खो जाएगी। उदाहरण के लिए, उपरोक्त उदाहरण में दोहरे मूल्य के रूप में -1.1 पूर्णांक मान के रूप में -1 हो जाता है।

इसके अलावा, संख्यात्मक रूपांतरण संकलन-समय प्रकारों पर निर्भर करते हैं, इसलिए यदि संख्यात्मक प्रकार वस्तुओं में "बॉक्सिंग" किया गया है तो वे काम नहीं करेंगे।

object value = -1.1;
int number = (int) value; // throws InvalidCastException

रूपांतरण संचालक

C # में, प्रकार कस्टम रूपांतरण ऑपरेटरों को परिभाषित कर सकते हैं, जो स्पष्ट या अंतर्निहित जातियों का उपयोग करके मूल्यों को अन्य प्रकारों से परिवर्तित करने की अनुमति देते हैं। उदाहरण के लिए, एक वर्ग पर विचार करें जो एक जावास्क्रिप्ट अभिव्यक्ति का प्रतिनिधित्व करने के लिए है:

public class JsExpression
{
    private readonly string expression;
    public JsExpression(string rawExpression)
    {
        this.expression = rawExpression;
    }
    public override string ToString()
    {
        return this.expression;
    }
    public JsExpression IsEqualTo(JsExpression other)
    {
        return new JsExpression("(" + this + " == " + other + ")");
    }
}

यदि हम दो जावास्क्रिप्ट मूल्यों की तुलना का प्रतिनिधित्व करते हुए एक JsExpression बनाना चाहते हैं, तो हम कुछ इस तरह कर सकते हैं:

JsExpression intExpression = new JsExpression("-1");
JsExpression doubleExpression = new JsExpression("-1.0");
Console.WriteLine(intExpression.IsEqualTo(doubleExpression)); // (-1 == -1.0)

लेकिन हम स्पष्ट कास्टिंग का उपयोग करते समय एक साधारण रूपांतरण की अनुमति देने के लिए, JsExpression कुछ स्पष्ट रूपांतरण ऑपरेटरों को जोड़ सकते हैं।

public static explicit operator JsExpression(int value)
{
    return new JsExpression(value.ToString());
}
public static explicit operator JsExpression(double value)
{
    return new JsExpression(value.ToString());
}

// Usage:
JsExpression intExpression = (JsExpression)(-1);
JsExpression doubleExpression = (JsExpression)(-1.0);
Console.WriteLine(intExpression.IsEqualTo(doubleExpression)); // (-1 == -1.0)

या, हम इन ऑपरेटरों को सिंटैक्स को सरल बनाने के लिए निहितार्थ में बदल सकते हैं।

public static implicit operator JsExpression(int value)
{
    return new JsExpression(value.ToString());
}
public static implicit operator JsExpression(double value)
{
    return new JsExpression(value.ToString());
}

// Usage:
JsExpression intExpression = -1;
Console.WriteLine(intExpression.IsEqualTo(-1.0)); // (-1 == -1.0)

LINQ कास्टिंग संचालन

मान लें कि आपके पास निम्न प्रकार हैं:

interface IThing {  }
class Thing : IThing {  }

LINQ आपको एक प्रक्षेपण बनाने की अनुमति देता है जो Enumerable.Cast<>() और Enumerable.OfType<>() विस्तार विधियों के माध्यम से संकलन-प्रकार के सामान्य प्रकार को IEnumerable<> में बदल देता है।

IEnumerable<IThing> things = new IThing[] {new Thing()};
IEnumerable<Thing> things2 = things.Cast<Thing>();
IEnumerable<Thing> things3 = things.OfType<Thing>();

जब things2 का मूल्यांकन किया जाता है, तो Cast<>() विधि things में सभी मूल्यों को Thing एस में डालने का प्रयास करेगी। यदि यह एक मान का सामना करता है जो डाली नहीं जा सकता है, तो एक InvalidCastException को फेंक दिया जाएगा।

जब things3 का मूल्यांकन किया जाता है, तो OfType<>() विधि भी ऐसा ही करेगी, सिवाय इसके कि यदि यह एक मान का सामना करता है जो डाली नहीं जा सकती है, तो यह अपवाद को छोड़ने के बजाय केवल उस मूल्य को छोड़ देगा।

इन विधियों के सामान्य प्रकार के कारण, वे रूपांतरण ऑपरेटरों को आमंत्रित नहीं कर सकते हैं या संख्यात्मक रूपांतरण कर सकते हैं।

double[] doubles = new[]{1,2,3}.Cast<double>().ToArray(); // Throws InvalidCastException

आप बस एक .Select() अंदर एक कास्ट कर सकते हैं .Select() एक वर्कअराउंड के रूप में:

double[] doubles = new[]{1,2,3}.Select(i => (double)i).ToArray();