¿Es String un tipo primitivo?

Tengo curiosidad sobre la cuerda y los tipos primitivos. Un artículo como este dice que la cuerda es de tipo primitivo. Sin embargo, el segundo artículo en MSDN no muestra la cadena como tipo primitivo.

Sin embargo, cuando ejecuté el código proporcionado en el segundo artículo, muestra String is not Primitive type .

¿Alguien puede guiarme en esto?

Ambos artículos dicen que la cadena NO es un tipo primitivo. Lo cual no es

Si comstack y ejecuta el código de ejemplo del segundo artículo, se imprimiría:

cadena no es un tipo primitivo.

Creo que la confusión sobre esto es que la syntax de crear una nueva cadena es similar a la creación de tipos de valores.

Al definir un tipo de valor, todos estos son iguales (en un sistema de 32 bits de todos modos)

System.Int32 a = new System.Int32(5); System.Int32 a = 5; int a = 5; 

Al igual que estos al crear una cadena de tipo de referencia:

 System.String s = new System.String(new char[]{'h', 'e', 'l', 'l', 'o'}); System.String s = "hello"; string s = "hello"; 

También podemos comparar cadenas por valor aunque sean tipos de referencia:

 s == "hello";//true 

Esto todavía no hace que la cadena sea un tipo primitivo.

La respuesta aceptada a esta pregunta debería darle detalles al respecto.

No existe una definición de “Microsoft” sobre qué tipo de primitivo es.

Solo hay definiciones de tipos primitivos en un contexto dado.

  • El CLR define tipos primitivos como nada más que:
    • System.Boolean
    • System.Byte
    • System.SByte
    • System.Int16
    • System.UInt16
    • System.Int32
    • System.UInt32
    • System.Int64
    • System.UInt64
    • System.IntPtr
    • System.UIntPtr
    • System.Char
    • System.Double
    • System.Single
  • La especificación VB.NET versión 10 (en la sección 7.3) define “tipos primitivos” como tipos que tienen un alias de palabra clave para el tipo (permitiendo así el uso de ese tipo sin importar el espacio de nombres del System ), una forma de definir instancias de ese tipo escribe con un literal; y permitiendo el uso de estos tipos como constantes; los tipos primitivos en VB.NET son:
    • System.Byte
    • System.SByte
    • System.UInt16 ( UShort )
    • System.Int16 ( Short )
    • System.UInt32 ( UInteger )
    • System.Int32 ( Integer )
    • System.UInt64 ( ULong )
    • System.Int64 ( Long )
    • System.Single
    • System.Double
    • System.Decimal
    • System.Boolean
    • System.DateTime ( Date )
    • System.Char
    • System.String
  • La especificación C # (versión 4) define alias de palabras clave para algunos tipos, y también define la forma de especificar literales para algunos valores; también define, por separado, qué tipos están disponibles en expresiones constantes; el concepto más cercano a “tipos primitivos” que tiene C # es en la sección 4.1.4: Tipos simples. (la palabra “primitivo” solo se usa dos veces en el documento de 600 páginas); estos tipos primitivos simplemente se definen como “tipos de valores que tienen un alias de palabra clave en C #” – la string no se menciona en esa sección:

    • System.SByte ( sbyte )
    • System.Byte ( byte )
    • System.Int16 ( short )
    • System.UInt16 ( ushort )
    • System.Int32 ( int )
    • System.UInt32 ( uint )
    • System.Int64 ( long )
    • System.UInt64 ( ulong )
    • System.Char ( char )
    • System.Single ( float )
    • System.Double ( double )
    • System.Boolean ( bool )
    • System.Decimal ( decimal )

Verás que solo hay una superposición parcial entre todas estas cosas; el CLR ve ambos tipos de punteros como primitivos, tanto VB.NET como C # ven el decimal como un tipo primitivo / simple, solo VB.NET ve a DateTime como algo especial, tanto VB.NET como C # tienen un alias de palabra clave y una syntax literal para las cadenas pero solo VB.NET especifica que String es un “tipo primitivo”, mientras que C # simplemente tiene una sección de su especificación dedicada a System.String

En conclusión: diferentes contextos tienen diferentes definiciones para lo que es un “tipo primitivo”. No importa, solo aprende cómo usar tu lenguaje de progtwigción, no tiene sentido pelear y pensar sobre tales palabras polimórficas. Personalmente, me pregunto por qué existe la propiedad Type.IsPrimitive .

En cuanto a System.String :

  • CLR: nada especial, es solo un tipo de referencia;
  • VB.NET: es un tipo primitivo;
  • C #: La String es su propio copo de nieve muy especial;

Actualización de cambio de postura: No, ya que el código no miente

 Console.WriteLine(typeof(string).IsPrimitive); => False Console.WriteLine(typeof(int).IsPrimitive); => True 

—– fin de la actualización.
Pero cierta documentación en línea parece tratar a String como un primitivo. Creo que , según la siguiente definición de “primitivo”. (Mi definición personal sería un tipo que no se puede dividir más en tipos de componentes. Pero supongo que estamos siendo ‘pedantes’ aquí, no es un problema para mí en su mayoría).

todos los tipos de datos primitivos en C # son objetos en el espacio de nombres del sistema. Para cada tipo de datos, se proporciona un nombre corto o alias.

Fuente: http://msdn.microsoft.com/en-us/library/ms228360%28VS.80%29.aspx Otro artículo a favor: artículo de MSDN Mag

Resumen: supongo que la respuesta depende de tu definición de primitiva, que no está inequívocamente definida . Fuente: Eric Lippert en otro hilo SO.

.NET define (desde su artículo):

Los tipos primitivos son Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Char, Double y Single.

Entonces no Incrustado y muy importante: sí, pero no es un primitivo.

VB usa una definición ligeramente diferente a la CLI y C #, parece.

Según la definición de Microsoft de “primitivo”, la cadena no se considera un tipo primitivo. Por otro lado, Microsoft tiende a usar terminología sin formular realmente una definición clara o consistente (por ejemplo, “recurso no gestionado”), y podría ser útil definir “primitiva” para incluir “Cadena”, “Matriz” y “Objeto”, ya que en su ausencia no habría forma de definir tipos que pudieran emularlos de manera eficiente.

No, la cadena no es un tipo primitivo.

Sin embargo, tiene algunas características comunes con los tipos primitivos.

El lenguaje admite literales de cadena en el código, por lo que no tiene que crear explícitamente instancias String utilizando la new palabra clave para obtener un objeto de cadena.

También hay soporte para concatenar cadenas utilizando el operador + , que el comstackdor convierte en una llamada al método String.Concat .

Las cadenas son inmutables, lo que significa que en la mayoría de las situaciones tiene una semántica de tipo de valor, al igual que los tipos primitivos.

String es un tipo primitivo especial. No es un tipo de valor, pero se puede considerar como un tipo primitivo porque puede crearse escribiendo literales, por ejemplo / “hola” y es posible declarar una constante de tipo cadena. Habiendo dicho eso, el valor de IsPrimitive devuelve falso

 Console.WriteLine("hello".GetType().IsPrimitive) // output = False 

EDITAR: Quiero recuperar mi respuesta aquí. Técnicamente no es un tipo primitivo, pero comparte las propiedades que mencioné anteriormente.

En c #, los tipos se definen principalmente como dos tipos: tipos de valores y tipos primitivos.

Primero vea la definición de tipos primitivos en C #.

Por otro lado, todos los tipos de datos primitivos en C # son objetos en el espacio de nombres del sistema. Para cada tipo de datos, se proporciona un nombre corto o alias. Por ejemplo, int es el nombre abreviado de System.Int32 y double es la forma abreviada de System.Double.

Ahora, lea este artículo para la diferencia: tipos primitivos y tipos de valores

System.String asigna a ” string “, que es un tipo primitivo en la CLI. Pero en la realidad, los tipos de valores son los que van en la stack y no en el espacio del montón.

Entonces, la clave son los tipos de valor frente a los tipos primitivos . Según la definición de primitiva de Microsoft, es un tipo primitivo, pero en un sentido más general, no lo es.

no lo son, porque son una secuencia de caracteres