C # जेनरिक और टाइप चेकिंग

Question 1

मेरे पास एक विधि है जो IList<T>एक पैरामीटर के रूप में उपयोग करती है । मुझे यह जांचने की आवश्यकता है कि उस Tवस्तु का प्रकार क्या है और इसके आधार पर कुछ करना है। मैं Tमूल्य का उपयोग करने की कोशिश कर रहा था , लेकिन संकलक इसे अनुमति नहीं देता है। मेरा समाधान निम्नलिखित है:

private static string BuildClause<T>(IList<T> clause)
{
    if (clause.Count > 0)
    {
        if (clause[0] is int || clause[0] is decimal)
        {
           //do something
        }
        else if (clause[0] is String)
        {
           //do something else
        }
        else if (...) //etc for all the types
        else
        {
           throw new ApplicationException("Invalid type");
        }
    } 
}

ऐसा करने के लिए एक बेहतर तरीका होना चाहिए। क्या कोई तरीका है जिससे मैं जांच कर सकता हूं Tकि किस प्रकार का मामला पारित हुआ है और फिर एक switchबयान का उपयोग करें ?

Question 2

आप ओवरलोड का उपयोग कर सकते हैं:

public static string BuildClause(List<string> l){...}

public static string BuildClause(List<int> l){...}

public static string BuildClause<T>(List<T> l){...}

या आप सामान्य पैरामीटर के प्रकार का निरीक्षण कर सकते हैं:

Type listType = typeof(T);
if(listType == typeof(int)){...}

Question 3

आप उपयोग कर सकते हैं typeof(T)।

private static string BuildClause<T>(IList<T> clause)
{
     Type itemType = typeof(T);
     if(itemType == typeof(int) || itemType == typeof(decimal))
    ...
}

Question 4

डिफ़ॉल्ट रूप से पता है कि एक शानदार तरीका नहीं है। इसके बाद मैं इससे निराश हो गया और थोड़ा उपयोगिता वर्ग लिखा जिसने थोड़ी मदद की और वाक्य रचना को थोड़ा साफ कर दिया। अनिवार्य रूप से यह कोड में बदल जाता है

TypeSwitcher.Do(clause[0],
  TypeSwitch.Case<int>(x => ...),  // x is an int
  TypeSwitch.Case<decimal>(d => ...), // d is a decimal 
  TypeSwitch.Case<string>(s => ...)); // s is a string

पूर्ण ब्लॉग पोस्ट और कार्यान्वयन पर विवरण यहाँ उपलब्ध हैं

http://blogs.msdn.com/jaredpar/archive/2008/05/16/switching-on-types.aspx

Question 5

और, क्योंकि C # विकसित हो गया है, आप पैटर्न मिलान का उपयोग (अब) कर सकते हैं ।

private static string BuildClause<T>(IList<T> clause)
{
    if (clause.Count > 0)
    {
        switch (clause[0])
        {
            case int x: // do something with x, which is an int here...
            case decimal x: // do something with x, which is a decimal here...
            case string x: // do something with x, which is a string here...
            ...
            default: throw new ApplicationException("Invalid type");
        }
    }
}

और फिर से C # 8.0 में स्विच एक्सप्रेशंस के साथ, सिंटैक्स और भी अधिक रसीला हो जाता है।

private static string BuildClause<T>(IList<T> clause)
{
    if (clause.Count > 0)
    {
        return clause[0] switch
        {
            int x => "some string related to this int",
            decimal x => "some string related to this decimal",
            string x => x,
            ...,
            _ => throw new ApplicationException("Invalid type")
        }
    }
}

Question 6

टाइपो ऑपरेटर ...

typeof(T)

... सी # स्विच स्टेटमेंट के साथ काम नहीं करेगा। लेकिन यह कैसे? निम्नलिखित पोस्ट में एक स्थिर वर्ग है ...

क्या इससे बेहतर विकल्प 'स्विच ऑन टाइप' है?

... जो आपको इस तरह कोड लिखने देगा:

TypeSwitch.Do(
    sender,
    TypeSwitch.Case<Button>(() => textBox1.Text = "Hit a Button"),
    TypeSwitch.Case<CheckBox>(x => textBox1.Text = "Checkbox is " + x.Checked),
    TypeSwitch.Default(() => textBox1.Text = "Not sure what is hovered over"));

Question 7

हर किसी के लिए जो कहता है कि प्रकारों की जाँच करना और प्रकार के आधार पर कुछ करना जेनेरिक के लिए एक महान विचार नहीं है मैं सहमत हूँ लेकिन मुझे लगता है कि कुछ परिस्थितियाँ हो सकती हैं जहाँ यह पूरी तरह से समझ में आता है।

उदाहरण के लिए यदि आपके पास एक ऐसा वर्ग है जो कहता है कि इसे लागू किया गया है (नोट: मुझे वह सब कुछ नहीं दिखाई दे रहा है जो यह कोड सरलता के लिए करता है और बस इसमें काट दिया जाता है और यहाँ चिपका दिया जाता है, इसलिए यह संपूर्ण कोड की तरह निर्माण या कार्य नहीं कर सकता है लेकिन यह बिंदु भर में हो जाता है। इसके अलावा, यूनिट एक एनम है):

public class FoodCount<TValue> : BaseFoodCount
{
    public TValue Value { get; set; }

    public override string ToString()
    {
        if (Value is decimal)
        {
            // Code not cleaned up yet
            // Some code and values defined in base class

            mstrValue = Value.ToString();
            decimal mdecValue;
            decimal.TryParse(mstrValue, out mdecValue);

            mstrValue = decimal.Round(mdecValue).ToString();

            mstrValue = mstrValue + mstrUnitOfMeasurement;
            return mstrValue;
        }
        else
        {
            // Simply return a string
            string str = Value.ToString() + mstrUnitOfMeasurement;
            return str;
        }
    }
}

...

public class SaturatedFat : FoodCountWithDailyValue<decimal>
{
    public SaturatedFat()
    {
        mUnit = Unit.g;
    }

}

public class Fiber : FoodCount<int>
{
    public Fiber()
    {
        mUnit = Unit.g;
    }
}

public void DoSomething()
{
       nutritionFields.SaturatedFat oSatFat = new nutritionFields.SaturatedFat();

       string mstrValueToDisplayPreFormatted= oSatFat.ToString();
}

इसलिए संक्षेप में, मुझे लगता है कि कुछ विशेष करने के लिए, यह देखने के लिए मान्य कारण हैं कि आप यह देखना चाहते हैं कि जेनेरिक किस प्रकार का है।

Question 8

आप क्या करना चाहते हैं, इसके लिए स्विच स्टेटमेंट का उपयोग करने का कोई तरीका नहीं है। स्विच स्टेटमेंट को अभिन्न प्रकारों के साथ आपूर्ति की जानी चाहिए, जिसमें जटिल प्रकार जैसे "टाइप" ऑब्जेक्ट या उस मामले के लिए कोई अन्य ऑब्जेक्ट प्रकार शामिल नहीं है।

Question 9

आपका निर्माण पूरी तरह से एक सामान्य विधि के उद्देश्य को पराजित करता है। यह उद्देश्य से बदसूरत है क्योंकि आप जो हासिल करने की कोशिश कर रहे हैं उसे प्राप्त करने का एक बेहतर तरीका होना चाहिए, हालांकि आपने हमें यह पता लगाने के लिए पर्याप्त जानकारी नहीं दी है कि यह क्या है।

Question 10

आप कर सकते हैं typeOf(T), लेकिन मैं आपकी विधि को दोगुना कर दूंगा और सुनिश्चित करूंगा कि आपकी एकल जिम्मेदारी का उल्लंघन न हो। यह एक कोड गंध होगा, और यह कहना नहीं है कि ऐसा नहीं किया जाना चाहिए लेकिन आपको सतर्क रहना चाहिए।

जेनरिक की बात यह है कि टाइप-अज्ञेयवादी अल्गोरिथम का निर्माण करने में सक्षम है क्या आप परवाह नहीं करते हैं कि प्रकार क्या है या जब तक यह मानदंड के एक निश्चित सेट के भीतर फिट बैठता है। आपका कार्यान्वयन बहुत सामान्य नहीं है।

Question 11

मुझे उम्मीद है कि आप इस मददगार को खोज लेंगे:

typeof(IList<T>).IsGenericType == true
typeof(IList<T>).GetGenericTypeDefinition() == typeof(IList<>)
typeof(IList<int>).GetGenericArguments()[0] == typeof(int)

https://dotnetfiddle.net/5qUZnt

Question 12

इस बारे में कैसा है :

            // Checks to see if the value passed is valid. 
            if (!TypeDescriptor.GetConverter(typeof(T)).IsValid(value))
            {
                throw new ArgumentException();
            }