C# Propiedad iSprimitive

A veces, creamos e incluimos variables en nuestra aplicación C#. Entonces, podemos crear variables especificando los tipos de datos. Los tipos de datos se clasifican en múltiples categorías. En este tutorial, veamos cómo verificar si el tipo especificado es un tipo primitivo o no.

Propiedad iSprimitiva

La propiedad ISPrimitiva se utiliza para verificar si el tipo de datos dado es primitivo. Si el tipo es primitivo, devuelve verdadero; De lo contrario, falso.

Sintaxis:

typeof (type).Esprimitivo

Tipo de retorno:

Devuelve el valor booleano (verdadero/falso).

Supongamos que si desea devolver el tipo, use la propiedad de nombre.

Sintaxis:

Tipo.Nombre

Lista de tipos primitivos:

1. Booleano - Se utiliza para almacenar valores booleanos
2. Byte - Almacena valores de bytes
3. Sbyte - Almacena valores de byte firmados
4. Int16 - Almacena valores enteros en 16 bits
5. Uint16 - Almacena valores enteros sin firmar en 16 bits
6. Int32 - Almacena valores enteros en 32 bits
7. Uint32 - Almacena valores enteros sin firmar en 16 bits
8. Int64 - Almacena valores enteros en 64 bits
9. Uint64 - Almacena valores enteros sin firmar en 64 bits
10. Intptr - Almacena valores de puntero entero
11. Uintptr - Almacena valores enteros sin firmar en 16 bits
12. Carbonizarse - Almacena personajes
13. Doble - Almacena de tipo doble
14. Soltero - Almacena valores en un solo tipo de estenosis/flotación

Ejemplo 1:

Verifiquemos si los tipos son tipos primitivos o no.

usando el sistema;
clase Linuxhint

static public void main ()
// Verifique el tipo - Sbyte
Consola.WriteLine ("Tipo:"+TypeOf (SByte).Nombre + "y es primitivo ?: "+typeof (sbyte).IsPrimitivo);
// Verifique el tipo - booleano
Consola.WriteLine ("Tipo:"+typeof (booleano).Nombre + "y es primitivo ?: "+typeof (booleano).IsPrimitivo);
// Verifique el tipo - byte
Consola.WriteLine ("Tipo:"+typeof (byte).Nombre + "y es primitivo ?: "+typeof (byte).IsPrimitivo);
// Verifique el tipo - INT16
Consola.WriteLine ("Tipo:"+TypeOf (int16).Nombre + "y es primitivo ?: "+typeof (int16).IsPrimitivo);
// Verifique el tipo - uint16
Consola.WriteLine ("Tipo:"+typeof (uint16).Nombre + "y es primitivo ?: "+typeof (uint16).IsPrimitivo);
// Verifique el tipo - INT32
Consola.WriteLine ("Tipo:"+TypeOf (int32).Nombre + "y es primitivo ?: "+typeof (int32).IsPrimitivo);
// verifique el tipo - uint32
Consola.WriteLine ("Tipo:"+typeof (uint32).Nombre + "y es primitivo ?: "+typeof (uint32).IsPrimitivo);
// verifique el tipo - int64
Consola.WriteLine ("Tipo:"+TypeOf (int64).Nombre + "y es primitivo ?: "+typeof (int64).IsPrimitivo);
// verifique el tipo - uint64
Consola.WriteLine ("Tipo:"+typeof (uint64).Nombre + "y es primitivo ?: "+typeof (uint64).IsPrimitivo);
// Verifique el tipo - IntPTR
Consola.WriteLine ("Tipo:"+TypeOf (IntPTR).Nombre + "y es primitivo ?: "+typeof (intptr).IsPrimitivo);
// marque el tipo - uintptr
Consola.WriteLine ("Tipo:"+TypeOf (Uintptr).Nombre + "y es primitivo ?: "+typeof (uintptr).IsPrimitivo);
// Verifique el tipo - Char
Consola.WriteLine ("Tipo:"+TypeOf (char).Nombre + "y es primitivo ?: "+typeof (char).IsPrimitivo);
// Verifique el tipo - Double
Consola.WriteLine ("Tipo:"+TypeOf (doble).Nombre + "y es primitivo ?: "+typeof (doble).IsPrimitivo);
// Verifique el tipo - Single
Consola.WriteLine ("Tipo:"+typeof (single).Nombre + "y es primitivo ?: "+typeof (single).IsPrimitivo);

Producción:

Explicación:

Método principal interno -

Línea 7 - Línea 46: Estamos comprobando si los 14 tipos son primitivos o no. Todos están bajo tipos primitivos. Entonces, la salida es verdadera para los 14 tipos.

Ejemplo 2:

Verificar los tipos de matriz y enum son primitivos o no.

usando el sistema;
clase Linuxhint

static public void main ()
// verificar el tipo - matriz
Consola.WriteLine ("Tipo:"+typeof (matriz).Nombre + "y es primitivo ?: "+typeof (matriz).IsPrimitivo);
// Verifique el tipo - enum
Consola.WriteLine ("Tipo:"+TypeOf (enum).Nombre + "y es primitivo ?: "+typeof (enum).IsPrimitivo);

Producción:

No son primitivos ya que la salida es falsa.

Resumen

En este tutorial de C#, vimos cómo verificar si el tipo es primitivo o no utilizar propiedades iSprimitive. Esta propiedad nos dice devolviendo un valor booleano. Si es cierto, podemos decir que el tipo es primitivo y si es falso, podemos decir que el tipo no es primitivo. Hay 14 tipos de 14 primitivos en C#.