C# vérifier le type d'objet

C# est un langage de programmation qui considère l'objet comme classe de base pour toutes les classes dérivées d'un programme. Tous les types sont hérités d'objets qui sont ensuite utilisés pour exécuter certaines fonctionnalités en étendant les propriétés des classes dérivées. L'objet C# dérivé possède certaines méthodes et capacités pour référencer et déréférencer n'importe quel objet du type de base. Le référencement d'un objet dans le cas des classes dérivées et de base joue un rôle important pour vérifier le type d'objet en cours de création. Le casting avec l'objet de classe de base est obligatoire pour le rendre compatible pour vérifier le type d'objet.

Syntaxe :

Le flux syntaxique pour vérifier le type d'objet en C# consiste à obtenir le type d'objet et sa nature d'objet associée.

public Type GetType ();

Et si les types d'objet sont déjà identifiés, alors typeof() est utilisé pour identifier l'objet C#

typeof()

Comment vérifier le type d'objet en C# ?

La vérification du type d'objet en C# joue un rôle central dans la détermination du type et des détails de l'objet liés à l'implémentation. Ces détails sont très importants pour les programmeurs en termes de mise en œuvre et de satisfaction des exigences. Ainsi, il existe certaines manières de vérifier l'objet en C# qui sont les suivantes :

• GetType() est une méthode assez fréquemment utilisée pour vérifier le type d'objet en C#. Cette méthode est utilisée pour fonctionner au moment de l'exécution et est principalement utilisée pour appeler un seul objet en tant qu'entité au moment de l'exécution.
• La méthode Get type() est une méthode de la classe d'objet utilisée pour faire un référencement pour une instance de la classe.
• Le type de est utilisé pour compiler le type d'objet en un seul et est ensuite utilisé pour créer l'ensemble afin d'obtenir le type d'objet et sa description au moment de la compilation, ce qui fait connaître l'opérande de son type, s'il est donné par l'utilisateur ou s'il est fourni par le système.
• Que nous utilisions la méthode Get type() ou le type 0f dans le cas d'un type connu d'arguments ou de paramètres, tout dépend du système et de son type de retour et de la manière dont nous allons renvoyer la valeur qu'il contient pour vérification et modification.
• Enfin, après avoir utilisé les deux méthodes, il crée des métadonnées d'informations ou, par exemple, des métadonnées de la classe entière qui sont utilisées pour stocker le résultat d'une manière ou d'une autre au moment de la création d'un objet dans le programme C#.
• De plus, il y a un point très important à garder à l'esprit, comme dire que le type d'objet en C# est déclaré avant l'exécution, dans ce cas, la méthode get type() aidera à récupérer et si, dans le cas où l'objet le type à créer en C# n'est pas déclaré et dépend du type déjà présent en tant que métadonnées alors dans ce cas le type de peut être utilisé au moment de l'exécution.
• L'opérateur est-il également utilisé pour obtenir la valeur qui est principalement utilisée lorsqu'une instance renvoie une valeur vraie ou fausse, ce qui signifie que l'instance se présente sous la forme d'un arbre d'héritage ?

Exemples

Discutons d'exemples de type d'objet de vérification C#.

Exemple n°1

Ce programme démontre l'utilisation de l'objet en C# avec l'objet déjà intégré dans le système, comme indiqué dans le résultat.

Code :

using System;
using System.Text;
class Demo_Prog
{
static void Main()
{
object vl_1 = new StringBuilder();
Console.WriteLine(vl_1.GetType());
}
}

Sortie :

Exemple n°2

Ce programme démontre l'utilisation de la méthode GetType() qui est utilisée très fréquemment pour vérifier le type d'objet de C# également avec l'utilisation lorsqu'elle est nécessaire au moment de l'exécution de l'exécution, comme indiqué dans le résultat.

Code :

using System;
namespace Consl_App1
{
class Fruit { }
class Kiwi : Fruit { }
class Pro_g
{
static Fruit newFruit()
{
return new Kiwi();
}
static void Main(string[] args)
{
Fruit f = newFruit();
Console.WriteLine(typeof(Fruit));
Console.WriteLine(f.GetType());
Console.ReadKey();
}
}
}

Sortie :

Exemple #3

Ce programme démontre l'objet dérivé dans la classe à partir de l'objet de base comme indiqué dans la sortie pour identifier le type d'objet dans la classe en C#.

Code :

using System;
public class M_Bs_Cl {
}
public class M_Drvd_Cl: M_Bs_Cl {
}
public class Test
{
public static void Main()
{
M_Bs_Cl m_bs = new M_Bs_Cl();
M_Drvd_Cl m_Drvd = new M_Drvd_Cl();
object obj = m_Drvd;
M_Bs_Cl bsc = m_Drvd;
Console.WriteLine("m_bs: Type is obj{0}", m_bs.GetType());
Console.WriteLine("m_Drvd: Type is obj{0}", m_Drvd.GetType());
Console.WriteLine("object obj = m_Drvd: obj_Type is {0}", obj.GetType());
Console.WriteLine("M_Bs_Cl b = myDerived: Type is {0}", bsc.GetType());
}
}

Sortie :

Exemple n°4

Ce programme démontre l'utilisation d'un objet avec tous les différents types d'arguments comme objet, comme indiqué dans le résultat. Ces différents types d'arguments sont utilisés pour obtenir la valeur et le type d'objet est identifié avec la nature qu'il possède selon les exigences.

Code :

using System;
class Demo_Prog
{
static void Main()
{
string vl_1 = "Java Pearl Ruby";
Verify(vl_1);
Verify((object)vl_1);
int num = 150;
Verify(num);
Verify((object)num);
Verify(null);
}
static void Verify(object vl_1)
{
Console.WriteLine(vl_1 != null);
if (vl_1 is string)
{
Console.WriteLine("Value_Of_String: {0}", vl_1);
}
else if (vl_1 is int)
{
Console.WriteLine("Value_Of_int: {0}", vl_1);
}
}
}

Sortie :

Exemple #5

Ce programme démontre qu'il s'agit d'un opérateur par rapport à l'objet lorsqu'il doit renvoyer une valeur vraie pour toute instance où la référence montre l'héritage dans l'arborescence comme indiqué dans la sortie.

Code :

using System;
public class C1
{
}
public class C2: C1
{
}
public class C3 {
}
public class sck_br {
public static void Main()
{
C1 ob_1 = new C1();
C2 ob_2 = new C2();
Console.WriteLine(ob_1 is C1);
Console.WriteLine(ob_1 is Object);
Console.WriteLine(ob_2 is C2);
Console.WriteLine(ob_2 is Object);
Console.WriteLine(ob_2 is C2);
Console.WriteLine(ob_2 is C3);
Console.WriteLine(ob_2 is C3);
}
}

Sortie :

Conclusion

Le type d'objet C# est principalement utilisé par les programmeurs afin de récupérer les informations détaillées sur l'objet au moment de la compilation ou parfois au moment de l'exécution du programme. Le type de valeur renvoyé dépend du type de variable ou d'objet requis au moment de l'exécution ou de la compilation. Ainsi, la création d'un type d'objet C# joue un rôle très important en termes de métadonnées d'information.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!