Tạo một phương thức chung trong C #

Tôi đang cố gắng kết hợp một loạt các phương pháp tương tự thành một phương pháp chung. Tôi có một số phương thức trả về giá trị của một chuỗi truy vấn hoặc null nếu chuỗi truy vấn đó không tồn tại hoặc không có định dạng chính xác. Điều này sẽ đủ dễ dàng nếu tất cả các kiểu đều có thể null nguyên bản, nhưng tôi phải sử dụng kiểu chung có thể null cho số nguyên và ngày tháng.

Đây là những gì tôi có bây giờ. Tuy nhiên, nó sẽ trả về giá trị 0 nếu giá trị số không hợp lệ và rất tiếc đó là giá trị hợp lệ trong các trường hợp của tôi. có ai giúp tôi ra ngoài không? Cảm ơn!

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;
}

Điều gì sẽ xảy ra nếu bạn chỉ định giá trị mặc định để trả về, thay vì sử dụng mặc định (T)?

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

Nó cũng giúp việc gọi nó dễ dàng hơn:

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

Nhược điểm là bạn cần các giá trị ma thuật để biểu thị các giá trị chuỗi truy vấn không hợp lệ / bị thiếu.

Tôi biết, tôi biết, nhưng ...

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

Cái này thì sao? Thay đổi loại trả lại từ TthànhNullable<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;
        }

Bạn có thể sử dụng loại Có thể đơn nguyên (mặc dù tôi thích câu trả lời của Jay hơn)

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;
    }
}

Phương pháp của bạn sẽ giống như sau:

    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>();
    }

Convert.ChangeType()không xử lý chính xác các kiểu hoặc kiểu liệt kê nullable trong .NET 2.0 BCL (tôi nghĩ rằng nó đã được sửa cho BCL 4.0 mặc dù). Thay vì làm cho việc triển khai bên ngoài phức tạp hơn, hãy làm cho bộ chuyển đổi làm được nhiều việc hơn cho bạn. Đây là cách triển khai tôi sử dụng:

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);
  }
}

Sau đó, việc triển khai GetQueryString <T> của bạn có thể là:

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;
}

Tôi muốn bắt đầu với một lớp như thế này cài đặt lớp {public int X {get; set;} public string Y {get; bộ; } // lặp lại nếu cần

 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

 }

Điều này đã hoạt động tốt trên 100 dự án. Bạn có thể sử dụng một trong nhiều giải pháp phân tích cú pháp khác để phân tích cú pháp các giá trị.