Usando "como bool?" en lugar de "objetar algo ViewState = [" Hola "]"

Así que estoy pasando código antiguo (2.0) y me encontré con esto:Usando "como bool?" en lugar de "objetar algo ViewState = [" Hola "]"

object isReviewingValue = ViewState["IsReviewing"]; 

if (isReviewingValue is bool) 
{ 
    return (bool)isReviewingValue; 
}

Mi primer pensamiento fue para nosotros el "como" palabra clave para evitar lo innecesario

(bool)isReviewingValue;

Pero "como" solo funciona con tipos sin valor. No hay problema, sólo siguió adelante e hizo esto:

bool? isReviewingValue= ViewState["IsReviewing"] as bool?; 
if (isReviewingValue.HasValue) 
{ 
    return isReviewingValue.Value; 
}

pregunta es: Además de mirar un poco más legible, es esta de hecho mejor?

EDIT:

public Stopwatch AsRun() 
{ 
    Stopwatch watch = new Stopwatch(); 

    watch.Start(); 
    for (Int32 loopCounter = 0; loopCounter < 10000; loopCounter++) 
    { 
    Object value = true; 
    Boolean? test = value as Boolean?; 
    if (test.HasValue) 
    { 
     Boolean something = test.Value; 
    } 
    } 
    watch.Stop(); 

    return watch; 
} 

public Stopwatch ObjectIsRun() 
{ 
    Stopwatch watch = new Stopwatch(); 

    watch.Start(); 
    for (Int32 loopCounter = 0; loopCounter < 10000; loopCounter++) 
    { 
    Object test = true; 
    if (test is Boolean) 
    { 
     Boolean something = (Boolean)test; 
    } 
    } 
    watch.Stop(); 

    return watch; 
}

Respuesta: Resulta que con los métodos anteriores se ejecutan de manera de prueba, el código original es aproximadamente 10 veces más rápido.

Fuente

2010-04-20 Programmin Tool

no lo hago Comprende por qué estás haciendo esto. No hay ninguna mejora Contienen la misma cantidad de líneas de código. El segundo NO es más claro que el primero; de hecho, hay más 'ruido' en el segundo. Yo digo que dejen al primero solo. –

Principalmente porque parece realmente tonto escribir como objeto, usar es, luego escribir de nuevo a booleano cuando bool? me ocuparé de eso y me da una manera fácil de verificar si el valor era booleano en primer lugar (HasValue). Saber que al convertir valores bool a null no parece ser una elección más sensata, entonces toda la ronda sobre la cadena se opone a bool. –

Sin embargo, dicho esto, tenía curiosidad también desde el punto de vista del rendimiento. –

creo que el primero es más fácil de leer, y es más rápido, así [unos 10 nanosegundos frente a 100 nanosegundos, de acuerdo con una prueba que acaba de ejecutar;) (es decir, no va a ralentizar su programa de ninguna manera)]

Fuente

2010-04-20 13:49:32 Jimmy

Interesante. Eso es algo de lo que estaba buscando. –

Resulta que es aproximadamente 10 veces más lento hacer la segunda, como dijiste. (Lo probé un poco demasiado solo para comprobarlo dos veces) –

En realidad es un poco peor. Si el valor en "IsReviewing" no es un bool o nulo, su código generará una excepción. La versión original simplemente lo ignorará.

Fuente

2010-04-20 13:45:27

Solo necesita agregar un cheque nulo en su declaración if y está listo para ir a – juharr

-1. isReviewingValue.HasValue * es * una comprobación nula. – Jimmy

** ¿Qué ** excepción? – ANeves

En segundo lugar es mejor, porque si ViewState ["IsReviewing"] no es un bool, como palabra clave establece automáticamente esto a nulo. En la primera opción, impleméntalo, no puedes hacer eso. Y el resultado tiene en buen recipiente.

Fuente

2010-04-20 13:46:57 Svisstack

Si en el primer ejemplo se devuelve un valor nulo de otro modo, ¿por qué no utilizar este:

bool? MyMethod() 
{ 
    return ViewState["IsReviewing"] as bool?; 
}

Fuente

2010-04-20 13:48:24 n535

Esto no se compilará. El operador 'as' solo se puede usar con tipos que aceptan nulos. – ChaosPandion

¿Se perdió el '?' por supuesto. – n535

Abajo-voto eliminado :) – ChaosPandion

El operador de coalescencia eliminará algunos códigos para usted. Para responder a su pregunta, como lo dejó bien claro Jimmy, las diferencias técnicas entre ambos son minúsculas, así que use lo que crea que es mejor. Personalmente, me inclino a usar este método. que podría considerarse sesgado aunque ...

private bool GetIsReviewing() 
{ 
    return (ViewState["IsReviewing"] as bool?) ?? false; 
}

Fuente

2010-04-20 14:16:55 ChaosPandion

El único problema es que el valor podría ser falso. ¿No pasaría eso, bool? en lugar de bool también? –

@Programmin Tool - ¿Eso aclara un poco las cosas? – ChaosPandion

Se puede usar un enfoque de método de extensión genérica para añadir el azúcar sintáctica:

public static class TypecastExtensions { 
    public static T CastOrDefault<T>(this object o) where T : struct { 
     return o as Nullable<T> ?? default(T); 
    } 

    public static T CastOrDefault<T>(this object o, T defaultValue) where T : struct { 
     return o as Nullable<T> ?? defaultValue; 
    } 
}

Uso:

bool isReviewingValue = ViewState["IsReviewing"].CastOrDefault<bool>();

Fuente

2010-04-20 14:59:09 spoulson

Usando "como bool?" en lugar de "objetar algo ViewState = [" Hola "]"

Respuesta

Cuestiones relacionadas