Differenza tra is e as keyword

Indica qual è la differenza tra ise asparola chiave in C #

è

L' isoperatore verifica se è possibile eseguire il cast di un oggetto su un tipo specifico.

Esempio:

if (someObject is StringBuilder) ...

come

L' asoperatore tenta di eseguire il cast di un oggetto su un tipo specifico e restituisce null se non riesce.

Esempio:

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

Anche correlato:

getto

L' operatore cast tenta di eseguire il cast di un oggetto su un tipo specifico e genera un'eccezione se non riesce.

Esempio:

StringBuilder b = (StringBuilder)someObject.

La differenza tra IS e As è che ..

IS - Is Operator viene utilizzato per verificare la compatibilità di un oggetto con un determinato tipo e restituisce il risultato come booleano (vero o falso).

AS - L'operatore As viene utilizzato per il cast di oggetti in un determinato tipo o classe.

Ex.

Student s = obj as Student;

è equivalente a:

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

Sia ise asparole chiave vengono utilizzate per il tipo di getto in C #.

Quando dai un'occhiata al codice IL di utilizzo di entrambe le parole chiave, otterrai facilmente la differenza.

Codice 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
}

Codice IL (per il codice C # sopra è nell'immagine allegata):

Il codice IL per l' isutilizzo delle parole chiave contiene istruzioni IL sia isinstae castclass.
Ma il codice IL per l' asutilizzo delle parole chiave ha solo isinsta.

Nell'uso sopra menzionato, si verificheranno due typecast in cui isviene utilizzata la parola chiave e solo un typecast in cui asviene utilizzata la parola chiave.

Nota: se stai utilizzando la isparola chiave per verificare alcune condizioni e non sei interessato al risultato di typecast, ci sarà solo un typecast, ad es.

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

ise le asparole chiave verranno utilizzate in base alla necessità.

La parola chiave is controlla se il valore sul lato sinistro è un'istanza del tipo sul lato destro. Per esempio:

if(obj is string)
{
     ...
}

Nota che in questo caso dovrai usare un cast esplicito extra per ottenere obj come stringa.

La parola chiave as viene utilizzata per eseguire il cast di tipi nullable. Se il valore specificato non è un'istanza del tipo specificato, viene restituito null. Per esempio:

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

Direi: leggi MSDN online, ma eccolo qui:

L'operatore is controlla se un oggetto è compatibile con un determinato tipo e il risultato della valutazione è un booleano: true o false.

L'operatore as non genererà mai un'eccezione.

È l'operatore, un cast, restituisce true se riesce. Restituisce false se il cast fallisce. Con esso, non è possibile acquisire la variabile convertita. Questo operatore è molto utile quando si controllano i tipi nelle istruzioni if ​​ed espressioni L'is-cast è l'ideale solo se la variabile risultante non sarà necessaria per un ulteriore utilizzo

Come è un cast. Con esso, otteniamo prestazioni ed evitiamo eccezioni quando un cast non è valido. Null viene restituito quando il cast è impossibile. Per i tipi di riferimento, si consiglia l'as-cast. È sia veloce che sicuro. Possiamo testare la variabile risultante contro null e quindi usarla. Questo elimina lanci extra

1. Questo operatore controlla se l'oggetto è compatibile con il tipo dato il risultato in base a vero o falso.
2. as viene utilizzato per eseguire il cast di un tipo su un altro tipo e in caso di errore di conversione risulta nullo tranne che per la generazione di un'eccezione. bene vedere il collegamento per una migliore comprensione con esempi https://blogs.msdn.microsoft.com/prakasht/2013/04/23/difference-between-direct-casting-is-and-as-operator-in-c/

is OPERATOR L'operatore is in C # viene utilizzato per controllare il tipo di oggetto e restituisce un valore bool: true se l'oggetto è dello stesso tipo e false in caso contrario. o anche L'operatore "is" viene utilizzato per verificare se il tipo di runtime di un oggetto è compatibile con un determinato tipo o meno. Per gli oggetti nulli, restituisce false ad es

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

come OPERATORE

L'operatore as fa lo stesso lavoro dell'operatore is ma la differenza è invece di bool, restituisce l'oggetto se sono compatibili con quel tipo, altrimenti restituisce null. In altre parole, l'operatore 'as' viene utilizzato per eseguire conversioni tra compatibili tipi.

per esempio

Type obj = Object as Type;

Vantaggi di as over is In caso di operatore is, per digitare cast, dobbiamo fare due passaggi:

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

In realtà questo influisce sulle prestazioni poiché ogni volta che il CLR passerà attraverso la gerarchia di ereditarietà, controllando ogni tipo di base rispetto al tipo specificato.

Per evitare ciò, usa come, lo farà in un solo passaggio. Solo per verificare il tipo dovremmo usare l'operatore is.

L'operatore As è simile a un cast, ma restituisce null invece di un'eccezione se fallisce.

E l'operatore Is viene utilizzato per verificare se un oggetto è compatibile con un certo tipo. Di solito viene utilizzato nelle istruzioni If.

is: L'operatore is viene utilizzato per verificare se il tipo di runtime di un oggetto è compatibile con un determinato tipo

as: L'operatore as viene utilizzato per eseguire conversioni tra tipi compatibili.

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

Dai un'occhiata al video di YouTube qui sotto che spiega la differenza in modo più dimostrativo e visivo: -

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

Di seguito la risposta lunga con la spiegazione del codice.

La parola chiave "IS" è utile per verificare se gli oggetti sono compatibili con un tipo. Ad esempio, nel codice seguente stiamo controllando se l'oggetto "ocust" è un tipo di classe "Customer".

object ocust = new Customer();

if (ocust is Customer)
{ 

La parola chiave "AS" aiuta a fare la conversione da un tipo a un altro tipo. Ad esempio, nel codice seguente stiamo convertendo un oggetto in un tipo di dati stringa. Se la parola chiave "AS" non è in grado di digitare cast, restituisce NULL.

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

MyClass myObject = (MyClass) obj;

vs

MyClass myObject = obj as MyClass;

Il secondo restituirà null se obj non è una MyClass, anziché generare un'eccezione di cast di classe.

è restituirà solo vero o falso

Sia IS che AS vengono utilizzati per il casting di tipo sicuro

Parola chiave IS -> controlla se il tipo di un dato oggetto è compatibile con il nuovo tipo di oggetto. Non genera mai un'eccezione. Questo è un tipo booleano .. restituisce vero 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.`

Parola chiave AS: controlla se il tipo di un dato oggetto è compatibile con il nuovo tipo di oggetto. Restituisce non nullo se l'oggetto dato è compatibile con quello nuovo, altrimenti nullo .. Questo genera un'eccezione.

`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`

Entrambi gli operatori vengono utilizzati per la fusione di tipo sicuro.

Operatore AS:

L'operatore AS controlla anche se il tipo di un dato oggetto è compatibile con il nuovo tipo di oggetto. Questa parola chiave verificherà se il tipo di un dato oggetto è compatibile con il nuovo tipo di oggetto. Se non è compatibile con il nuovo, restituirà NULL.

Operatore IS:

Questo operatore controlla se il tipo di un oggetto è compatibile con il nuovo oggetto. Se è compatibile restituisce true altrimenti false.