C # में एक सामान्य विधि बनाना

Question 1

मैं समान विधियों के एक समूह को एक सामान्य विधि में संयोजित करने का प्रयास कर रहा हूं। मेरे पास कई विधियाँ हैं जो एक querystring, या null का मान लौटाती हैं यदि वह querystring मौजूद नहीं है या सही प्रारूप में नहीं है। यह काफी आसान होगा यदि सभी प्रकार मूल रूप से अशक्त थे, लेकिन मुझे पूर्णांक और दिनांक के लिए अशक्त सामान्य प्रकार का उपयोग करना होगा।

यहाँ अब मेरे पास क्या है। हालाँकि, यदि कोई संख्यात्मक मान अमान्य है, और यह दुर्भाग्य से मेरे परिदृश्य में एक मान्य मान है, तो यह 0 को वापस कर देगा। क्या कोई मेरी मदद कर सकता है? धन्यवाद!

public static T GetQueryString<T>(string key) where T : IConvertible
{
    T result = default(T);

    if (String.IsNullOrEmpty(HttpContext.Current.Request.QueryString[key]) == false)
    {
        string value = HttpContext.Current.Request.QueryString[key];

        try
        {
            result = (T)Convert.ChangeType(value, typeof(T));  
        }
        catch
        {
            //Could not convert.  Pass back default value...
            result = default(T);
        }
    }

    return result;
}

Question 2

यदि आपने डिफ़ॉल्ट (T) का उपयोग करने के बजाय डिफ़ॉल्ट मान निर्दिष्ट किया है तो क्या होगा?

public static T GetQueryString<T>(string key, T defaultValue) {...}

यह कॉल करना भी आसान बनाता है:

var intValue = GetQueryString("intParm", Int32.MinValue);
var strValue = GetQueryString("strParm", "");
var dtmValue = GetQueryString("dtmPatm", DateTime.Now); // eg use today's date if not specified

नकारात्मक होने के कारण आपको अमान्य / अनुपस्थित क्वेरी मूल्यों को दर्शाने के लिए जादू के मूल्यों की आवश्यकता होती है।

Question 3

मुझे पता है, मुझे पता है, लेकिन ...

public static bool TryGetQueryString<T>(string key, out T queryString)

Question 4

इस बारे में क्या? से वापसी प्रकार परिवर्तित Tकरने के लिएNullable<T>

public static Nullable<T> GetQueryString<T>(string key) where T : struct, IConvertible
        {
            T result = default(T);

            if (String.IsNullOrEmpty(HttpContext.Current.Request.QueryString[key]) == false)
            {
                string value = HttpContext.Current.Request.QueryString[key];

                try
                {
                    result = (T)Convert.ChangeType(value, typeof(T));  
                }
                catch
                {
                    //Could not convert.  Pass back default value...
                    result = default(T);
                }
            }

            return result;
        }

Question 5

आप शायद मोनड के प्रकार का उपयोग कर सकते हैं (हालांकि मैं जे के उत्तर को पसंद करूंगा)

public class Maybe<T>
{
    private readonly T _value;

    public Maybe(T value)
    {
        _value = value;
        IsNothing = false;
    }

    public Maybe()
    {
        IsNothing = true;
    }

    public bool IsNothing { get; private set; }

    public T Value
    {
        get
        {
            if (IsNothing)
            {
                throw new InvalidOperationException("Value doesn't exist");
            }
            return _value;
        }
    }

    public override bool Equals(object other)
    {
        if (IsNothing)
        {
            return (other == null);
        }
        if (other == null)
        {
            return false;
        }
        return _value.Equals(other);
    }

    public override int GetHashCode()
    {
        if (IsNothing)
        {
            return 0;
        }
        return _value.GetHashCode();
    }

    public override string ToString()
    {
        if (IsNothing)
        {
            return "";
        }
        return _value.ToString();
    }

    public static implicit operator Maybe<T>(T value)
    {
        return new Maybe<T>(value);
    }

    public static explicit operator T(Maybe<T> value)
    {
        return value.Value;
    }
}

आपकी विधि इस तरह दिखाई देगी:

    public static Maybe<T> GetQueryString<T>(string key) where T : IConvertible
    {
        if (String.IsNullOrEmpty(HttpContext.Current.Request.QueryString[key]) == false)
        {
            string value = HttpContext.Current.Request.QueryString[key];

            try
            {
                return (T)Convert.ChangeType(value, typeof(T));
            }
            catch
            {
                //Could not convert.  Pass back default value...
                return new Maybe<T>();
            }
        }

        return new Maybe<T>();
    }

Question 6

Convert.ChangeType().NET 2.0 BCL में nullable type या enumerations को सही ढंग से हैंडल नहीं करता है (मुझे लगता है कि यह BCL 4.0 के लिए निश्चित है)। बाहरी कार्यान्वयन को अधिक जटिल बनाने के बजाय, कनवर्टर को आपके लिए अधिक काम करने दें। यहां एक कार्यान्वयन है जिसका मैं उपयोग करता हूं:

public static class Converter
{
  public static T ConvertTo<T>(object value)
  {
    return ConvertTo(value, default(T));
  }

  public static T ConvertTo<T>(object value, T defaultValue)
  {
    if (value == DBNull.Value)
    {
      return defaultValue;
    }
    return (T) ChangeType(value, typeof(T));
  }

  public static object ChangeType(object value, Type conversionType)
  {
    if (conversionType == null)
    {
      throw new ArgumentNullException("conversionType");
    }

    // if it's not a nullable type, just pass through the parameters to Convert.ChangeType
    if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
    {
      // null input returns null output regardless of base type
      if (value == null)
      {
        return null;
      }

      // it's a nullable type, and not null, which means it can be converted to its underlying type,
      // so overwrite the passed-in conversion type with this underlying type
      conversionType = Nullable.GetUnderlyingType(conversionType);
    }
    else if (conversionType.IsEnum)
    {
      // strings require Parse method
      if (value is string)
      {
        return Enum.Parse(conversionType, (string) value);          
      }
      // primitive types can be instantiated using ToObject
      else if (value is int || value is uint || value is short || value is ushort || 
           value is byte || value is sbyte || value is long || value is ulong)
      {
        return Enum.ToObject(conversionType, value);
      }
      else
      {
        throw new ArgumentException(String.Format("Value cannot be converted to {0} - current type is " +
                              "not supported for enum conversions.", conversionType.FullName));
      }
    }

    return Convert.ChangeType(value, conversionType);
  }
}

तब गेटिइस्ट्रिंग <T> का आपका कार्यान्वयन हो सकता है:

public static T GetQueryString<T>(string key)
{
    T result = default(T);
    string value = HttpContext.Current.Request.QueryString[key];

    if (!String.IsNullOrEmpty(value))
    {
        try
        {
            result = Converter.ConvertTo<T>(value);  
        }
        catch
        {
            //Could not convert.  Pass back default value...
            result = default(T);
        }
    }

    return result;
}

Question 7

मैं इस वर्ग की तरह एक वर्ग के साथ शुरू करना पसंद करता हूं {public int X {get; set;} public string Y {get; सेट; } // आवश्यकतानुसार दोहराएं

 public settings()
 {
    this.X = defaultForX;
    this.Y = defaultForY;
    // repeat ...
 }
 public void Parse(Uri uri)
 {
    // parse values from query string.
    // if you need to distinguish from default vs. specified, add an appropriate property

 }

इसने 100 परियोजनाओं पर अच्छा काम किया है। आप मानों को पार्स करने के लिए कई अन्य पार्सिंग समाधानों में से एक का उपयोग कर सकते हैं।