Différence entre is et as mot-clé

Veuillez dire quelle est la différence entre iset asmot - clé en C #

est

L' isopérateur vérifie si un objet peut être converti en un type spécifique.

Exemple:

if (someObject is StringBuilder) ...

comme

L' asopérateur tente de convertir un objet en un type spécifique et renvoie null en cas d'échec.

Exemple:

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

Aussi lié:

Fonderie

L' opérateur de conversion tente de convertir un objet en un type spécifique et lève une exception en cas d'échec.

Exemple:

StringBuilder b = (StringBuilder)someObject.

La différence entre IS et As est que ...

IS - Is Operator est utilisé pour vérifier la compatibilité d'un objet avec un type donné et il renvoie le résultat sous la forme d'un booléen (vrai ou faux).

AS - As Operator est utilisé pour convertir un objet en un type ou une classe donné.

Ex.

Student s = obj as Student;

est équivalent à:

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

Les mots clés iset assont utilisés pour la conversion de type en C #.

Lorsque vous regardez le code IL des utilisations des deux mots-clés, vous obtiendrez facilement la différence.

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

Code IL (pour le code C # ci-dessus est dans l'image jointe):

Le code IL pour l' isutilisation des mots clés contient des instructions IL à la fois isinstaet castclass.
Mais le code IL pour l' asutilisation des mots clés n'a que isinsta.

Dans l'utilisation mentionnée ci-dessus, deux transtypages se produiront là où le ismot-clé est utilisé et un seul transtypage où le asmot-clé est utilisé.

Remarque: Si vous utilisez un ismot-clé pour vérifier une condition et que vous ne vous intéressez pas au résultat du transtypage, il n'y aura qu'un seul transtypage, c'est-à-dire

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

iset les asmots - clés seront utilisés en fonction de la nécessité.

Le mot clé is vérifie si la valeur sur son côté gauche est une instance du type sur le côté droit. Par exemple:

if(obj is string)
{
     ...
}

Notez que dans ce cas, vous devrez utiliser un cast explicite supplémentaire pour obtenir obj sous forme de chaîne.

Le mot clé as est utilisé pour convertir les types Nullable. Si la valeur spécifiée n'est pas une instance du type spécifié, null est renvoyé. Par exemple:

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

Je dirais: lisez MSDN en ligne, mais le voici:

L'opérateur is vérifie si un objet est compatible avec un type donné et le résultat de l'évaluation est un booléen: vrai ou faux.

L'opérateur as ne lèvera jamais d'exception.

L'opérateur Is, un cast, renvoie true s'il réussit. Il renvoie false si la distribution échoue. Avec lui, vous ne pouvez pas capturer la variable convertie. Cet opérateur est le plus utile lors de la vérification des types dans les instructions if et les expressions.

Tout comme un casting. Avec lui, nous gagnons en performance et évitons les exceptions lorsqu'une distribution est invalide. Null est renvoyé lorsque la distribution est impossible. Pour les types de référence, le format tel que cast est recommandé. C'est à la fois rapide et sûr.Nous pouvons tester la variable résultante par rapport à null, puis l'utiliser. Cela élimine les lancers supplémentaires

1. L'opérateur is vérifie si l'objet est compatible avec le type donné le résultat basé sur vrai ou faux.
2. comme est utilisé pour convertir un type en un autre type et en cas d'échec de la conversion, les résultats sont null, sauf lors de la levée de l'exception. bien voir le lien pour une meilleure compréhension avec des exemples https://blogs.msdn.microsoft.com/prakasht/2013/04/23/difference-between-direct-casting-is-and-as-operator-in-c/

is OPERATOR L'opérateur is en C # est utilisé pour vérifier le type d'objet et il renvoie une valeur booléenne: true si l'objet est du même type et false dans le cas contraire. ou aussi L'opérateur «est» permet de vérifier si le type d'exécution d'un objet est compatible ou non avec un type donné. Pour les objets nuls, il renvoie false par exemple

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

comme OPERATOR

L'opérateur as fait le même travail que l'opérateur is mais la différence est au lieu de booléen, il renvoie l'objet s'il est compatible avec ce type, sinon il retourne null. En d'autres termes, l'opérateur 'as' est utilisé pour effectuer des conversions entre compatibles les types.

par exemple

Type obj = Object as Type;

Avantages de as over is Dans le cas de l'opérateur is, pour taper cast, nous devons faire deux étapes:

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

En fait, cela affecte les performances puisque chaque fois que le CLR passera par la hiérarchie d'héritage, en vérifiant chaque type de base par rapport au type spécifié.

Pour éviter cela, utilisez as, il le fera en une seule étape. Nous ne devons utiliser l'opérateur is que pour vérifier le type.

L'opérateur As est similaire à un cast, mais renvoie null au lieu d'une exception en cas d'échec.

Et l'opérateur Is est utilisé pour vérifier si un objet est compatible avec un certain type. Il est généralement utilisé dans les instructions If.

is: L'opérateur is permet de vérifier si le type d'exécution d'un objet est compatible avec un type donné

as: L'opérateur as est utilisé pour effectuer des conversions entre les types compatibles.

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

Jetez un œil à la vidéo youtube ci-dessous qui explique la différence d'une manière plus démonstrative et visuelle: -

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

Ci-dessous, la réponse longue avec l'explication du code.

Le mot clé «IS» est utile pour vérifier si les objets sont compatibles avec un type. Par exemple, dans le code ci-dessous, nous vérifions si l'objet «ocust» est un type de classe «Client».

object ocust = new Customer();

if (ocust is Customer)
{ 

Le mot-clé "AS" permet d'effectuer la conversion d'un type à un autre type. Par exemple, dans le code ci-dessous, nous convertissons un objet en un type de données chaîne. Si le mot-clé «AS» ne peut pas taper cast, il renvoie NULL.

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

MyClass myObject = (MyClass) obj;

contre

MyClass myObject = obj as MyClass;

Le second retournera null si obj n'est pas une MyClass, plutôt que de lancer une exception de conversion de classe.

est retournera seulement vrai ou faux

IS et AS sont utilisés pour le moulage de type sécurisé

IS Keyword -> vérifie si le type d'un objet donné est compatible avec le nouveau type d'objet. Il ne lève jamais d'exception. Il s'agit d'un type booléen .. renvoie soit vrai soit faux

`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: vérifie si le type d'un objet donné est compatible avec le nouveau type d'objet. Il retourne non nul si l'objet donné est compatible avec le nouveau, sinon nul. Cela lève une exception.

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

Les deux opérateurs sont utilisés pour le moulage de type sûr.

Opérateur AS:

L'opérateur AS vérifie également si le type d'un objet donné est compatible avec le nouveau type d'objet. Ce mot clé vérifie si le type d'un objet donné est compatible avec le nouveau type d'objet. S'il n'est pas compatible avec le nouveau, il retournera NULL.

Opérateur SI:

Cet opérateur vérifie si le type d'un objet est compatible avec le nouvel objet. S'il est compatible, il renvoie vrai sinon faux.