Différence entre is et as keyword
Veuillez indiquer la différence entre les mots-clés is et as en C #.
est
L'opérateur is vérifie si un objet peut être converti en un type spécifique.
Exemple:
if (someObject is StringBuilder) ...
comme
L'opérateur as tente de convertir un objet en un type spécifique et renvoie la valeur null s'il échoue.
Exemple:
StringBuilder b = someObject as StringBuilder;
if (b != null) ...
Aussi lié:
Moulage
opérateur de conversion tente de convertir un objet en un type spécifique et lève une exception s'il échoue.
Exemple:
StringBuilder b = (StringBuilder)someObject.
La différence entre EST et As est-ce que ..
EST - Est un opérateur utilisé pour vérifier la compatibilité d'un objet avec un type donné et renvoie le résultat sous forme de valeur booléenne (vraie ou fausse).
EN TANT QUE - As Operator est utilisé pour la conversion d'un objet en un type ou une classe donnés.
Ex.
Student s = obj as Student;
est équivalent à:
Student s = obj is Student ? (Student)obj : (Student)null;
Le mot-clé is vérifie si la valeur à gauche est une instance du type à droite. Par exemple:
if(obj is string)
{
...
}
Notez que dans ce cas, vous devrez utiliser une conversion explicite supplémentaire pour obtenir obj en tant que 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é, la valeur NULL est renvoyée. Par exemple:
string str = obj as string;
if(str != null)
{
...
}
Les mots clés "is" et "as" sont utilisés pour la conversion de types en C #.
Lorsque vous consultez le code d’utilisation IL des deux mots-clés, vous constaterez 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
}
Le code IL pour le code C # ci-dessus est dans l'image ci-jointe entrez la description de l'image ici
Le code IL pour son utilisation par mot-clé contient des instructions IL à la fois isinsta et castclass. mais le code IL utilisé comme mot clé n'a que isinsta.
Dans l'utilisation mentionnée ci-dessus, une conversion de type à deux reprises se produira où mot-clé est utilisé et une seule fois où mot-clé est utilisé.
Remarque: Si vous utilisez le mot clé 'is' pour vérifier une condition, ne vous intéressez pas au résultat du type caste, alors une fois seulement le type caste se produira. c'est à dire.
if (baseclassInstance is DerivedClass)
{
// do something based on the condition check.
}
Les mots-clés 'is' et 'as' seront utilisés en fonction de la nécessité.
Je dirais: lisez MSDN en ligne, mais la 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ève jamais une exception.
- cet opérateur vérifie si l'objet est compatible avec le type donné. Le résultat est basé sur true ou false.
- as est utilisé pour convertir un type en un autre type et en cas d'échec de la conversion, la valeur est null, à l'exception d'une 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 -opérateur-en-c/
Est opérateur, un casting, retourne vrai s'il réussit. Il retourne faux si le casting échoue. Avec elle, vous ne pouvez pas capturer la variable convertie. Cet opérateur est particulièrement utile lors de la vérification de types dans des instructions if et des expressions. L'opération is-cast n'est idéale que si la variable résultante n'est pas nécessaire pour une utilisation ultérieure.
Comme est un casting. Avec lui, nous gagnons en performance et évitons les exceptions lorsqu'un casting est invalide. Null est retourné quand le casting est impossible. Pour les types de référence, le type tel que moulé est recommandé. Il est à la fois rapide et sûr. Nous pouvons tester la variable résultante avec la valeur null et l’utiliser ensuite. Cela élimine les lancers supplémentaires
is OPERATOR L'opérateur is en C # permet de vérifier le type d'objet et renvoie une valeur booléenne: true si l'objet est du même type et false sinon. ou encore L'opérateur "est" est utilisé pour vérifier si le type d'exécution d'un objet est compatible avec un type donné ou non. Pour les objets null, il retourne false, par exemple
if(obj is AnimalObject)
{
//Then Work
}
en tant qu'OPERATEUR
L'opérateur as fait le même travail que l'opérateur is mais la différence est au lieu de bool, il renvoie l'objet s'il est compatible avec ce type, sinon il renvoie null. En d'autres termes, l'opérateur 'en tant que' est utilisé pour effectuer des conversions entre les types.
par exemple
Type obj = Object as Type;
Avantages de la fin de l'opération Dans le cas de son opérateur, pour taper le transtypage, nous devons procéder en deux étapes:
Check the Type using is
If it’s true then Type cast
En réalité, cela affecte les performances puisque chaque fois que le CLR passe par la hiérarchie d'héritage, chaque type de base est comparé au type spécifié.
Pour éviter cela, utilisez comme, il le fera en une étape. Nous ne devrions utiliser l'opérateur is que pour vérifier le type.
Regardez la vidéo youtube ci-dessous qui explique la différence de manière plus démonstrative et visuelle: -
https://www.youtube.com/watch?v=IKmRtJcRX_I
Ci-dessous, la réponse longue avec une explication de 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 de convertir un type en 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" n'est pas en mesure de transtyper, il renvoie NULL.
object o = "somestring";
string str = o as string;
MyClass myObject = (MyClass) obj;
contre
MyClass myObject = obj as MyClass;
La seconde retournera null si obj n'est pas une MyClass, plutôt que de lever une exception de conversion de classe.
est retournera seulement vrai ou faux
L'opérateur As est similaire à une distribution, 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 déclarations If.
Les deux opérateurs sont utilisés pour la coulée de type en toute sécurité.
AS Operator:
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érifiera si le type d'un objet donné est compatible avec le nouveau type d'objet. Si ce n'est pas compatible avec le nouveau, il retournera NULL.
Opérateur IS:
Cet opérateur vérifie si le type d'un objet est compatible avec le nouvel objet. Si c'est compatible, il retourne vrai sinon faux.
Les deux IS et AS sont utilisés pour le cast 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 jette jamais une exception. C'est un type booléen..rend vrai ou 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.`
Mot clé AS: vérifie si le type d'un objet donné est compatible avec le nouveau type d'objet. Il retourne non-null si l'objet donné est compatible avec new, sinon null .. Ceci 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`