c# - usar - para que se utiliza int en programacion

¿Cuándo se debe utilizar la palabra clave as en C#?

Question

Cuando desea cambiar los tipos de la mayoría del tiempo, solo desea utilizar el modelo tradicional.

var value = (string)dictionary[key];

Es bueno porque

• Es rápido
• Se quejará si algo está mal (en lugar de dar el objeto son nulas excepciones)

Entonces, ¿cuál es un buen ejemplo de uso que realmente no pude encontrar o pensar en algo que se adapte perfectamente?

Nota: en realidad creo que a veces hay casos en que el complaciente impide el uso de un reparto en el as funciona (¿están relacionados los genéricos?).

Answer 1

Aquí hay un fragmento de http://blog.nerdbank.net/2008/06/when-not-to-use-c-keyword.html

class SomeType {
    int someField;
    // The numeric suffixes on these methods are only added for reference later
    public override bool Equals1(object obj) {
        SomeType other = obj as SomeType;
        if (other == null) return false;
        return someField == other.SomeField;
    }
    public override bool Equals2(object obj) {
        if (obj == null) return false;
        // protect against an InvalidCastException
        if (!(obj is SomeType)) return false;
        SomeType other = (SomeType)obj;
        return someField == other.SomeField;
    }
}

El método Equals1 anterior es más eficiente (y más fácil de leer) que Equals2, aunque hacen el mismo trabajo. Mientras Equals1 compila a IL que realiza la comprobación de tipo y la conversión exactamente una vez, Equals2 compila para hacer una comparación de tipo primero para el operador "es", y luego hace una comparación de tipo y se convierte junto como parte del operador (). Así que usar "as" en este caso es en realidad más eficiente. El hecho de que sea más fácil de leer es una ventaja.

En conclusión, solo use la palabra clave C # "como" en la que espera que la conversión falle en un caso no excepcional. Si cuenta con una conversión para que tenga éxito y no está preparado para recibir ningún objeto que falle, debe usar el operador de conversión () para que se genere una excepción apropiada y útil.

Answer 2

Cada vez que necesite un objeto de conversión segura sin excepción, utilice as :

MyType a = (MyType)myObj; // throws an exception if type wrong

MyType a = myObj as MyType; // return null if type wrong

Answer 3

Como se usa para evitar la lógica de doble casting como en:

if (x is MyClass)
{
  MyClass y = (MyClass)x;
}

Utilizando

MyClass y = x as MyClass;
if (y == null)
{
}

FYI, IL generado para el caso # 1:

  // if (x is MyClass)
  IL_0008:  isinst     MyClass
  IL_000d:  ldnull
  IL_000e:  cgt.un
  IL_0010:  ldc.i4.0
  IL_0011:  ceq
  IL_0013:  stloc.2
  IL_0014:  ldloc.2
  IL_0015:  brtrue.s   IL_0020
  IL_0017:  nop
  // MyClass y = (MyClass)x;
  IL_0018:  ldloc.0
  IL_0019:  castclass  MyClass
  IL_001e:  stloc.1

y para el caso # 2:

  // MyClass y = x as MyClass;
  IL_0008:  isinst     MyClass
  IL_000d:  stloc.1
  // if (y == null)
  IL_000e:  ldloc.1
  IL_000f:  ldnull
  IL_0010:  ceq
  IL_0012:  stloc.2
  IL_0013:  ldloc.2
  IL_0014:  brtrue.s   IL_0018

Answer 4

La implementación de .Count () en Enumerable lo usa para hacer que Count () se recopile más rápido

La implementación es como:

        ICollection<TSource> collection = source as ICollection<TSource>;
        if (collection != null)
        {
            return collection.Count;
        }
        ICollection collection2 = source as ICollection;
        if (collection2 != null)
        {
            return collection2.Count;
        }

Eso intenta convertir la fuente a ICollection o ICollection, ambos tienen una propiedad Count. Si eso falla, Count () itera toda la fuente. Por lo tanto, si no está seguro del tipo y necesita el objeto del tipo más adelante (como en el ejemplo anterior), debe usar as .

Si solo desea probar si el objeto es de un tipo determinado, y si está seguro de que el objeto es de un tipo determinado (o deriva de / implementa ese tipo), entonces puede emitir

Answer 5

Ok Nice responde a todos, pero vamos a poner un poco práctico. En su propio código, es decir, en el código de no proveedor, el poder REAL de la palabra clave AS no se destaca.

Pero cuando se trata de objetos de proveedor como en WPF / silverlight, la palabra clave AS es una ventaja real. por ejemplo, si tengo una serie de controles en un Canvas y quiero rastrear el último control seleccionado, pero borro el seguimiento varaible cuando hago clic en el Canvas, haría esto:

private void layoutroot_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
               //clear the auto selected control
        if (this.SelectedControl != null 
            && sender is Canvas && e.OriginalSource is Canvas)
        {
            if ((sender as Canvas).Equals(( e.OriginalSource as Canvas)))
            {
                this.SelectedControl = null;
            }
        }
    }

Otra razón por la que usa AS keyoword es cuando su Clase implementa 1 o más Interfaces y desea usar explícitamente solo una interfaz:

IMySecond obj = new MyClass as IMySecond

Aunque no es realmente necesario aquí, asignará nulo a la variable obj si MyClass no implementa IMySecond

Answer 6

Usar as no arrojará una excepción de conversión, sino que simplemente devolverá el null si la conversión falla.

Answer 7

Utilícelo cuando sea válido para que un objeto no sea del tipo que desea, y desea actuar de manera diferente si lo es. Por ejemplo, en algo de pseudo-código:

foreach (Control control in foo)
{
    // Do something with every control...

    ContainerControl container = control as ContainerControl;
    if (container != null)
    {
        ApplyToChildren(container);
    }
}

O la optimización en LINQ to Objects (muchos ejemplos como este):

public static int Count<T>(this IEnumerable<T> source)
{
    IList list = source as IList;
    if (list != null)
    {
        return list.Count;
    }
    IList<T> genericList = source as IList<T>;
    if (genericList != null)
    {
        return genericList.Count;
    }

    // Okay, we''ll do things the slow way...
    int result = 0;
    using (var iterator = source.GetEnumerator())
    {
        while (iterator.MoveNext())
        {
            result++;
        }
    }
    return result;
}

Así que usar as es como un is + un reparto. Casi siempre se usa con un control de nulidad después, según los ejemplos anteriores.