Diferencia entre es y como palabra clave

Indique cuál es la diferencia entre una palabra clave isy asen C #

es

El isoperador comprueba si un objeto se puede convertir a un tipo específico.

Ejemplo:

if (someObject is StringBuilder) ...

como

El asoperador intenta convertir un objeto a un tipo específico y devuelve nulo si falla.

Ejemplo:

StringBuilder b = someObject as StringBuilder;
if (b != null) ...

También relacionado:

Fundición

El operador de conversión intenta convertir un objeto en un tipo específico y lanza una excepción si falla.

Ejemplo:

StringBuilder b = (StringBuilder)someObject.

La diferencia entre IS y As es que ...

IS : el operador Is se utiliza para verificar la compatibilidad de un objeto con un tipo determinado y devuelve el resultado como un booleano (verdadero o falso).

AS : como operador se utiliza para convertir un objeto en un tipo o clase determinados.

Ex.

Student s = obj as Student;

es equivalente a:

Student s = obj is Student ? (Student)obj : (Student)null;

Tanto isy aspalabras clave se utilizan para la conversión de tipos en C #.

Cuando eche un vistazo al código IL de usos de ambas palabras clave, obtendrá la diferencia fácilmente.

Código C #:

BaseClass baseclassInstance = new DerivedClass();
DerivedClass derivedclassInstance;

if (baseclassInstance is DerivedClass)
{
   derivedclassInstance = (DerivedClass)baseclassInstance;
   // do something on derivedclassInstance
}


derivedclassInstance = baseclassInstance as DerivedClass;

if (derivedclassInstance != null)
{
   // do something on derivedclassInstance
}

Código IL (para el código C # anterior está en la imagen adjunta):

El código IL para el isuso de palabras clave contiene instrucciones IL isinstay castclass.
Pero el código IL para el asuso de palabras clave solo tiene isinsta.

En el uso mencionado anteriormente, ocurrirán dos encasillamientos donde isse use la palabra clave y solo un encasillado dondeas se use la palabra clave.

Nota: Si está usando una ispalabra clave para verificar alguna condición y no tiene ningún interés en el resultado del encasillado, entonces solo habrá un encasillado, es decir

if (baseclassInstance is DerivedClass)
{
   // do something based on the condition check.
}

isy las aspalabras clave se utilizarán según la necesidad.

La palabra clave is comprueba si el valor de su lado izquierdo es una instancia del tipo del lado derecho. Por ejemplo:

if(obj is string)
{
     ...
}

Tenga en cuenta que, en este caso, tendrá que usar una conversión explícita adicional para obtener obj como cadena.

La palabra clave as se utiliza para convertir tipos que aceptan valores NULL. Si el valor especificado no es una instancia del tipo especificado, se devuelve un valor nulo. Por ejemplo:

string str = obj as string;
if(str != null)
{
     ...
}

Yo diría: lea MSDN en línea, pero aquí está:

El operador is comprueba si un objeto es compatible con un tipo determinado y el resultado de la evaluación es un booleano: verdadero o falso.

El operador as nunca lanzará una excepción.

Es operador, un elenco, devuelve verdadero si tiene éxito. Devuelve falso si el elenco falla. Con él, no puede capturar la variable convertida. Este operador es más útil cuando se verifican tipos en sentencias if y expresiones. Is-cast solo es ideal si la variable resultante no será necesaria para un uso posterior

Como es un yeso. Con él, ganamos rendimiento y evitamos excepciones cuando un elenco no es válido. Se devuelve nulo cuando el reparto es imposible. Para los tipos de referencia, se recomienda el modelo as-cast. Es rápido y seguro. Podemos probar la variable resultante contra nula y luego usarla. Esto elimina yesos adicionales

1. Este operador comprueba si el objeto es compatible con el tipo dado y el resultado se basa en verdadero o falso.
2. as se usa para convertir un tipo a otro tipo y en el error de conversión resulta nulo, excepto que se genera una excepción. Bueno, vea el enlace para una mejor comprensión con ejemplos https://blogs.msdn.microsoft.com/prakasht/2013/04/23/difference-between-direct-casting-is-and-as-operator-in-c/

es OPERADOR El operador is en C # se usa para verificar el tipo de objeto y devuelve un valor bool: verdadero si el objeto es del mismo tipo y falso si no. o también El operador "es" se utiliza para comprobar si el tipo de tiempo de ejecución de un objeto es compatible con un tipo determinado o no. Para objetos nulos, devuelve falso, por ejemplo

if(obj is AnimalObject)
{
 //Then Work
}

como OPERADOR

El operador as hace el mismo trabajo que el operador is, pero la diferencia es que en lugar de bool, devuelve el objeto si son compatibles con ese tipo, de lo contrario devuelve nulo En otras palabras, el operador 'as' se usa para realizar conversiones entre compatibles tipos.

p.ej

Type obj = Object as Type;

Ventajas de as over is En el caso del operador is, para escribir cast, debemos seguir dos pasos:

Check the Type using is
If it’s true then Type cast

En realidad, esto afecta el rendimiento ya que todas y cada una de las veces que CLR pasará por la jerarquía de herencia, verificando cada tipo base con el tipo especificado.

Para evitar esto, use como, lo hará en un solo paso. Solo para verificar el tipo debemos usar el operador is.

El operador As es similar a una conversión, pero devuelve un valor nulo en lugar de una excepción si falla.

Y el operador Is se utiliza para comprobar si un objeto es compatible con un tipo determinado. Por lo general, se usa en declaraciones If.

is: El operador is se usa para verificar si el tipo de tiempo de ejecución de un objeto es compatible con un tipo dado

as: El operador as se utiliza para realizar conversiones entre tipos compatibles.

object s = "this is a test";
string str=string.Empty;
if( s is string)
    str = s as string;

Eche un vistazo al video de YouTube a continuación que explica la diferencia de una manera más demostrativa y visual:

https://www.youtube.com/watch?v=IKmRtJcRX_I

A continuación se muestra la respuesta larga con la explicación del código.

La palabra clave "IS" es útil para comprobar si los objetos son compatibles con un tipo. Por ejemplo, en el siguiente código, estamos comprobando si el objeto "ocust" es un tipo de clase "Cliente".

object ocust = new Customer();

if (ocust is Customer)
{ 

La palabra clave "AS" ayuda a realizar conversiones de un tipo a otro. Por ejemplo, en el siguiente código, estamos convirtiendo el objeto a un tipo de datos de cadena. Si la palabra clave "AS" no puede escribir cast, devuelve NULL.

object o = "somestring";
string str = o as string;

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

El segundo devolverá nulo si obj no es MyClass, en lugar de lanzar una excepción de conversión de clase.

solo devolverá verdadero o falso

Tanto IS como AS se utilizan para la fundición de tipo seguro

IS Keyword -> comprueba si el tipo de un objeto dado es compatible con el nuevo tipo de objeto. Nunca lanza una excepción. Este es un tipo booleano ... devuelve verdadero o falso

`student stud = new student(){}
if(stud is student){} // It returns true // let say boys as derived class
if(stud is boys){}// It returns false since stud is not boys type
 //this returns true when,
student stud = new boys() // this return true for both if conditions.`

AS Keyword: comprueba si el tipo de un objeto dado es compatible con el nuevo tipo de objeto. Devuelve un valor no nulo si el objeto dado es compatible con uno nuevo, de lo contrario es nulo. Esto genera una excepción.

`student stud = new student(){}
 // let say boys as derived class
boys boy = stud as boys;//this returns null since we cant convert stud type from base class to derived class
student stud = new boys()
boys boy = stud as boys;// this returns not null since the obj is pointing to derived class`

Ambos operadores se utilizan para la fundición de tipo seguro.

Como operador:

El operador AS también comprueba si el tipo de un objeto dado es compatible con el nuevo tipo de objeto. Esta palabra clave comprobará si el tipo de un objeto dado es compatible con el nuevo tipo de objeto. Si no es compatible con el nuevo, devolverá NULL.

Operador IS:

Este operador comprueba si el tipo de objeto es compatible con el nuevo objeto. Si es compatible, devuelve verdadero; de lo contrario, falso.