Si hay una diferencia, ¿cuál es la diferencia entre las dos formas de hacer el siguiente elenco?¿Cuál es la diferencia entre el casting y el uso de "como" en C#?
En este caso e es un objeto GridViewRowEventArgs.
GridView gv = (GridView)e.Row.FindControl("gv"); //first way
GridView gv2 = e.Row.FindControl("gv") as GridView; //second way
Las diferencias son:
InvalidCastException.as falla, simplemente devuelve una referencia nula.as con tipos de valores que no admiten valores (por ejemplo, no puede hacer "o as int").as se puede usar para desagrupar un tipo de valor que admite valores de nulo.)EDIT: Tengo written elsewhere cuando considero que es apropiado usar qué operador. Puede valer la pena leerlo ...
Sin embargo, si utilizó un tipo de referencia, digamos Tabla, el primero generaría InvalidCastException en caso de que o no se pueda asignar a la Tabla y el segundo simplemente devolverá nulo.
En general, la diferencia entre un elenco estático y "como", es que el elenco emitirá una excepción si falla, mientras que "como" simplemente establecerá la variable a nulo.
La instrucción "como" básicamente intenta lanzar la variable, y devuelve nulo si falla en lugar de arrojar una excepción. Como tal, el valor al que está lanzando debe ser anulable: un tipo de referencia o una primitiva que admite nulos. En su ejemplo, tendría que hacer:
int? i2 = o as int;
o no se compilará.
El reparto segura como
variable as type
hace lo mismo que
(variable is type) ? (type)variable : (type)null
y no funcionará para los tipos de valor.
Aparte del problema que Jon señaló, la palabra clave as efectivamente arroja o como SomeClass. Si o no se deriva de SomeClass, devuelve null. Mientras que un elenco simple lanzaría una excepción.
SomeClass i2 = o as SomeClass;
convierte
SomeClass i2;
if (o is SomeClass)
i2 = (SomeClass)o;
else
i2 = null;
Lo que no se menciona en las respuestas anteriores es intención - ¿por qué realizar la conversión, y (lo más importante) lo que sucede en las líneas después de la conversión ?
Por ejemplo, he visto un código similar al siguiente varias veces:
if ((foo as SomeType).SomeMethod()) { /* ... */ }
Esto podría ser comparado con la versión fundido usando:
if (((SomeType) foo).SomeMethod()) { /* ... */ }
Entonces, ¿cuál de estos es mejor?
El elenco es.
El uso de as dará como resultado un NullReferenceException si la conversión falla.
El uso de un yeso dará como resultado un InvalidCastException si la conversión falla.
Ahora dime, ¿cuál es una excepción más útil para la depuración? A NullReferenceException, que podría ser producido por casi cualquier cosa, o un InvalidCastException, que le permite saber qué salió mal en realidad.
Por lo tanto, solamente uso as si la conversión es realidad opcional (lo que significa que hay debe ser un cheque null antes de usar la variable). De lo contrario, use un molde, lo que hace que sus intenciones sean más explícitas.
Podría estar diciendo lo obvio aquí, pero una cosa que se obtiene con el 'como' es que se garantiza que terminará con un objeto del tipo que solicitó. Esto es útil en ciertas situaciones.
Déjenme actualizar mi código Jon con un tipo de referencia. – Xaisoft
No hay mucha necesidad - He explicado más en mi respuesta ahora :) –
Muchas gracias, de hecho lo actualicé con un GridView, pero tu respuesta es lo suficientemente buena. – Xaisoft