web-dev-qa-db-fra.com

La chaîne est-elle un type primitif?

Je suis curieux de connaître les types de chaînes et primitifs. Un article comme this dit que la chaîne est de type primitif. Cependant deuxième article sur MSDN ne répertorie pas la chaîne comme type primitif.

Cependant, lorsque j'ai exécuté le code fourni dans le deuxième article, il affiche La chaîne n'est pas de type primitif .

Quelqu'un peut-il me guider à ce sujet?

c#.netvb.netstringprimitive-types
63
Ram

Les deux articles disent que la chaîne n'est [~ # ~] pas [~ # ~] un type primitif. Ce qui n'est pas le cas.

Si vous compilez et exécutez l'exemple de code du deuxième article, il s'imprime:

la chaîne n'est pas un type primitif.

Je pense que la confusion à ce sujet est que la syntaxe de création d'une nouvelle chaîne est similaire à la création de types de valeur.

Lors de la définition d'un type de valeur, tous ces éléments sont égaux (sur un système 32 bits de toute façon)

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

Tout comme ceux-ci lors de la création d'une chaîne de type référence:

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

Nous pouvons également comparer les chaînes par valeur même s'il s'agit de types de référence:

s == "hello";//true

Cela ne fait toujours pas de la chaîne un type primitif.

La réponse acceptée à cette question devrait vous donner des détails à ce sujet.

44
Fedearne

Il n'y a pas de définition "Microsoft" de ce qu'est un type primitif.

Il n'y a que des définitions de types primitifs dans un contexte donné.

  • Le CLR définit les types primitifs comme n'étant rien de plus 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 spécification VB.NET version 10 (dans la section 7.3) définit les "types primitifs" comme étant des types qui ont un alias de mot-clé pour le type (permettant ainsi l'utilisation de ce type sans importer l'espace de noms System), un moyen pour définir des instances de ce type avec un littéral; et permettant l'utilisation de ces types comme constantes; les types primitifs dans VB.NET sont:
    • 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 spécification C # (version 4) définit des alias de mots clés pour certains types, et définit également la manière de spécifier des littéraux pour certaines valeurs; il définit également, séparément, quels types sont disponibles dans les expressions constantes; le concept le plus proche des "types primitifs" que C # a est dans la section 4.1.4: Types simples. (le mot "primitif" n'est utilisé que deux fois dans le document de 600 pages); ces types primitifs sont simplement définis comme des "types de valeur qui ont un alias de mot clé en C #" - string n'est pas mentionné dans cette section:

    • 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)

Vous verrez qu'il n'y a qu'un chevauchement partiel entre toutes ces choses; le CLR considère les deux types de pointeurs comme primitifs, VB.NET et C # voient la décimale comme un type primitif/simple, seul VB.NET considère DateTime comme quelque chose de spécial, VB.NET et C # ont un alias de mot-clé et une syntaxe littérale pour les chaînes mais seul VB.NET spécifie String comme étant un "type primitif", tandis que C # a simplement une section de sa spécification dédiée à System.String...

En conclusion: différents contextes ont des définitions différentes de ce qu'est un "type primitif". Cela n'a pas d'importance - apprenez simplement à utiliser votre langage de programmation, il n'y a aucun sens à se battre et à penser à de tels mots polymorphes. Personnellement, je me demande pourquoi la propriété Type.IsPrimitive existe même.

Pour ce qui est de System.String:

  • CLR: Rien de spécial, c'est juste un type de référence;
  • VB.NET: C'est un type primitif;
  • C #: String est son propre flocon de neige très spécial;
42
Jean Hominal

Mise à jour de changement de position: Non car le code ne ment pas

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

----- fin de mise à jour.
Mais certains documents en ligne semblent traiter String comme une primitive. Je pense Oui - basé sur la définition suivante de "primitif". (Ma définition personnelle serait un type qui ne peut pas être décomposé davantage en types de composants. Mais je suppose que nous sommes simplement "pédants" ici, ce n'est pas un problème pour moi surtout.)

tous les types de données primitifs en C # sont des objets dans l'espace de noms System. Pour chaque type de données, un nom court ou un alias est fourni.

Source: http://msdn.Microsoft.com/en-us/library/ms228360%28VS.80%29.aspx Un autre article en faveur - article MSDN Mag

Résumé: Je suppose que la réponse dépend de votre définition de primitive, qui n'est pas définie sans ambiguïté . Source: Eric Lippert sur un autre SO thread.

10
Gishu

.NET définit (à partir de votre article):

Les types primitifs sont Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Char, Double et Single.

Donc non. Intégré et très important: oui, mais pas primitif.

VB utilise une définition légèrement différente de la CLI et C # semble-t-il.

6
Marc Gravell

Non, la chaîne n'est pas un type primitif.

Cependant, il présente certaines caractéristiques communes aux types primitifs.

Le langage prend en charge les littéraux de chaîne dans le code, de sorte que vous n'avez pas à créer explicitement des instances String à l'aide du mot clé new pour obtenir un objet chaîne.

Il est également possible de concaténer des chaînes à l'aide de +, que le compilateur transforme en appel à String.Concat méthode.

Les chaînes sont immuables, ce qui signifie que dans la plupart des situations, elles ont une sémantique de type valeur, tout comme les types primitifs.

3
Guffa

Selon la définition de Microsoft de "primitive", la chaîne n'est pas considérée comme un type primitif. D'un autre côté, Microsoft a tendance à utiliser la terminologie sans vraiment formuler une définition claire ou cohérente (par exemple "ressource non gérée"), et on pourrait utilement définir "primitive" pour inclure "String", "Array" et "Object", car en leur absence, il n'y aurait aucun moyen de définir des types qui pourraient les émuler efficacement.

3
supercat

La chaîne est un type primitif spécial. Ce n'est pas un type de valeur, mais peut être considéré comme un type primitif car il peut être créé en écrivant des littéraux, par exemple/"bonjour" et il est possible de déclarer une constante de type chaîne. Cela dit, la valeur de IsPrimitive renvoie false

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

EDIT: Je veux reprendre ma réponse ici. Ce n'est techniquement pas un type primitif, mais partage les propriétés que j'ai mentionnées ci-dessus.

1
Tim Carter

En c #, les types sont principalement définis comme deux types: les types de valeur et les types primitifs.

Voir d'abord la définition des types primitifs en C #.

D'un autre côté, tous les types de données primitifs en C # sont des objets dans l'espace de noms System. Pour chaque type de données, un nom court ou un alias est fourni. Par exemple, int est le nom abrégé de System.Int32 et double est la forme abrégée de System.Double.

Maintenant, lisez cet article pour la différence: Types primitifs et types de valeur

System.String correspond à "string", qui est un type primitif dans la CLI. Mais dans la réalité, les types de valeurs sont ceux qui vont dans la pile et non dans l'espace de tas.

Ainsi, la clé est Types de valeur vs types primitifs . Selon la définition de Microsoft de primitive, il s'agit d'un type primitif, mais dans un sens plus général, ce n'est pas le cas.

1
zengr