c# - por - request querystring javascript

¿Cómo se evalúan las variables Request.QueryString[]?

Question

Frecuentemente hago uso de las variables Request.QueryString[] .

En mi Page_load , a menudo hago cosas como:

       int id = -1;

        if (Request.QueryString["id"] != null) {
            try
            {
                id = int.Parse(Request.QueryString["id"]);
            }
            catch
            {
                // deal with it
            }
        }

        DoSomethingSpectacularNow(id);

Todo parece un poco torpe y basura. ¿Cómo Request.QueryString[] su Request.QueryString[] s?

Answer 1

Bueno, para empezar, use int.TryParse ...

int id;
if (!int.TryParse(Request.QueryString["id"], out id))
{
    id = -1;
}

Eso supone que "no presente" debería tener el mismo resultado que "no es un número entero", por supuesto.

EDITAR: en otros casos, cuando va a usar los parámetros de solicitud como cadenas de todos modos, creo que definitivamente es una buena idea validar que están presentes.

Answer 2

De hecho, tengo una clase de utilidad que usa Generics para "ajustar" la sesión, lo que hace todo el "trabajo pesado" para mí, también tengo algo casi idéntico para trabajar con los valores de QueryString.

Esto ayuda a eliminar el código duplicado para los controles (a menudo numerosos).

Por ejemplo:

public class QueryString
{
    static NameValueCollection QS
    {
        get
        {
            if (HttpContext.Current == null)
                throw new ApplicationException("No HttpContext!");

            return HttpContext.Current.Request.QueryString;
        }
    }

    public static int Int(string key)
    {
        int i; 
        if (!int.TryParse(QS[key], out i))
            i = -1; // Obviously Change as you see fit.
        return i;
    }

    // ... Other types omitted.
}

// And to Use..
void Test()
{
    int i = QueryString.Int("test");
}

NOTA:

Obviamente, esto hace uso de estática, que a algunas personas no les gusta debido a la forma en que puede afectar el código de prueba. Puedes refactorizar fácilmente en algo que funcione en función de las instancias y las interfaces que necesites ... Solo creo que el ejemplo estático es el más ligero.

Espero que esto ayude / da algo para pensar.

Answer 3

Eeee esto es un riesgo de karma ...

Tengo una abstracción que se puede probar por unidad DRY porque, bueno, porque había demasiadas variables de cadena de consulta para continuar en una conversión heredada.

El código siguiente es de una clase de utilidad cuyo constructor requiere una entrada NameValueCollection (this.source) y las "keys" de la matriz de cadenas se debe a que la aplicación heredada era bastante orgánica y había desarrollado la posibilidad de que varias cadenas diferentes fueran una clave de entrada potencial. Sin embargo, me gusta la extensibilidad. Este método inspecciona la colección de la clave y la devuelve en el tipo de datos requerido.

private T GetValue<T>(string[] keys)
{
    return GetValue<T>(keys, default(T));
}

private T GetValue<T>(string[] keys, T vDefault)
{
    T x = vDefault;

    string v = null;

    for (int i = 0; i < keys.Length && String.IsNullOrEmpty(v); i++)
    {
        v = this.source[keys[i]];
    }

    if (!String.IsNullOrEmpty(v))
    {
        try
        {
            x = (typeof(T).IsSubclassOf(typeof(Enum))) ? (T)Enum.Parse(typeof(T), v) : (T)Convert.ChangeType(v, typeof(T));
        }
        catch(Exception e)
        {
            //do whatever you want here
        }
    }

    return x;
}

Answer 4

Estoy usando un pequeño método de ayuda:

public static int QueryString(string paramName, int defaultValue)
{
    int value;
    if (!int.TryParse(Request.QueryString[paramName], out value))
        return defaultValue;
    return value;
}

Este método me permite leer valores de la cadena de consulta de la siguiente manera:

int id = QueryString("id", 0);

Answer 5

Puede usar los métodos de extensión a continuación también y hacer esto

int? id = Request["id"].ToInt();
if(id.HasValue)
{

}

// Métodos de extensión

public static int? ToInt(this string input) 
{
    int val;
    if (int.TryParse(input, out val))
        return val;
    return null;
}

public static DateTime? ToDate(this string input)
{
    DateTime val;
    if (DateTime.TryParse(input, out val))
        return val;
    return null;
}

public static decimal? ToDecimal(this string input)
{
    decimal val;
    if (decimal.TryParse(input, out val))
        return val;
    return null;
}

Answer 6

Use int.TryParse en su lugar para deshacerse del bloque try-catch:

if (!int.TryParse(Request.QueryString["id"], out id))
{
  // error case
}

Answer 7

Prueba este tipo ...

List<string> keys = new List<string>(Request.QueryString.AllKeys);

Entonces podrás buscar al hombre por una cuerda muy fácil a través de ...

keys.Contains("someKey")

Answer 8

Tengo funciones para cada uno (en realidad es una clase pequeña, con muchas estáticas):

• GetIntegerFromQuerystring(val)
• GetIntegerFromPost(val)
• ....

Devuelve -1 si falla ( que casi siempre está bien para mí, tengo algunas otras funciones para números negativos también ).

Dim X as Integer = GetIntegerFromQuerystring("id")
If x = -1 Then Exit Sub

Answer 9

Debajo hay un método de extensión que te permitirá escribir código como este:

int id = request.QueryString.GetValue<int>("id");
DateTime date = request.QueryString.GetValue<DateTime>("date");

Hace uso de TypeDescriptor para realizar la conversión. Según sus necesidades, puede agregar una sobrecarga que toma un valor predeterminado en lugar de lanzar una excepción:

public static T GetValue<T>(this NameValueCollection collection, string key)
{
    if(collection == null)
    {
        throw new ArgumentNullException("collection");
    }

    var value = collection[key];

    if(value == null)
    {
        throw new ArgumentOutOfRangeException("key");
    }

    var converter = TypeDescriptor.GetConverter(typeof(T));

    if(!converter.CanConvertFrom(typeof(string)))
    {
        throw new ArgumentException(String.Format("Cannot convert ''{0}'' to {1}", value, typeof(T)));
    }

    return (T) converter.ConvertFrom(value);
}

Answer 10

Modifiqué la respuesta de Bryan Watts, de modo que si el param tu pregunta no existe y has especificado un tipo que admite nulos, devolverá nulo:

public static T GetValue<T>(this NameValueCollection collection, string key)
    {
        if (collection == null)
        {
            return default(T);
        }

        var value = collection[key];

        if (value == null)
        {
           return default(T);
        }

        var type = typeof(T);

        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
        {
            type = Nullable.GetUnderlyingType(type);
        }

        var converter = TypeDescriptor.GetConverter(type);

        if (!converter.CanConvertTo(value.GetType()))
        {
            return default(T);
        }

        return (T)converter.ConvertTo(value, type);
    }

Ahora puede hacer esto:

Request.QueryString.GetValue<int?>(paramName) ?? 10;

Answer 11

if(!string.IsNullOrEmpty(Request.QueryString["id"]))
{
//querystring contains id
}