Es vs como palabra clave del operador en C# – Part 1

La diferencia entre los operadores es y as es la siguiente:

  • El operador is se usa para verificar si el tipo de tiempo de ejecución de un objeto es compatible con el tipo dado o no, mientras que el operador as se usa para realizar la conversión entre tipos de referencia compatibles o tipos anulables.
  • El operador is es de tipo booleano, mientras que el operador as no es de tipo booleano.
  • El operador is devuelve verdadero si el objeto dado es del mismo tipo, mientras que el operador as devuelve el objeto cuando son compatibles con el tipo dado.
  • El operador is devuelve falso si el objeto dado no es del mismo tipo, mientras que el operador devuelve nulo si la conversión no es posible.
  • El operador is se usa solo para conversiones de referencia, boxing y unboxing, mientras que el operador as se usa solo para conversiones anulables, de referencia y boxing.

Ejemplo de operador is :

// C# program to illustrate the
// use of is operator keyword
using System;
  
// taking a class
public class P { }
  
// taking a class
// derived from P
public class P1 : P { }
  
// taking a class
public class P2 { }
  
// Driver Class
public class GFG {
  
    // Main Method
    public static void Main()
    {
  
        // creating an instance
        // of class P
        P o1 = new P();
  
        // creating an instance
        // of class P1
        P1 o2 = new P1();
  
        // checking whether 'o1'
        // is of type 'P'
        Console.WriteLine(o1 is P);
  
        // checking whether 'o1' is
        // of type Object class
        // (Base class for all classes)
        Console.WriteLine(o1 is Object);
  
        // checking whether 'o2'
        // is of type 'P1'
        Console.WriteLine(o2 is P1);
  
        // checking whether 'o2' is
        // of type Object class
        // (Base class for all classes)
        Console.WriteLine(o2 is Object);
  
        // checking whether 'o2'
        // is of type 'P'
        // it will return true as P1
        // is derived from P
        Console.WriteLine(o2 is P1);
  
        // checking whether o1
        // is of type P2
        // it will return false
        Console.WriteLine(o1 is P2);
  
        // checking whether o2
        // is of type P2
        // it will return false
        Console.WriteLine(o2 is P2);
    }
}

Producción:

True
True
True
True
True
False
False

Ejemplo de como operador :

// C# program to illustrate the
// concept of 'as' operator
using System;
  
// Classes
class Y { }
class Z { }
  
class GFG {
  
    // Main method
    static void Main()
    {
  
        // creating and initializing object array
        object[] o = new object[5];
        o[0] = new Y();
        o[1] = new Z();
        o[2] = "Hello";
        o[3] = 4759.0;
        o[4] = null;
  
        for (int q = 0; q < o.Length; ++q) {
  
            // using as operator
            string str1 = o[q] as string;
  
            Console.Write("{0}:", q);
  
            // checking for the result
            if (str1 != null) {
                Console.WriteLine("'" + str1 + "'");
            }
            else {
                Console.WriteLine("Is is not a string");
            }
        }
    }
}

Producción:

0:Is is not a string
1:Is is not a string
2:'Hello'
3:Is is not a string
4:Is is not a string

Publicación traducida automáticamente

Artículo escrito por ankita_saini y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *