String è un tipo primitivo?

Sono curioso della stringa e dei tipi primitivi. L’articolo come questo dice che la stringa è di tipo primitivo. Tuttavia, il secondo articolo su MSDN non elenca la stringa come tipo primitivo.

Tuttavia, quando eseguo il codice fornito nel secondo articolo, viene visualizzato String non è di tipo Primitive .

Qualcuno può guidarmi su questo?

Entrambi gli articoli dicono che la stringa NON è un tipo primitivo. Quale non è.

Se compili ed esegui il codice di esempio dal secondo articolo, verrebbe stampato:

la stringa non è un tipo primitivo.

Penso che la confusione su questo è che la syntax di creare una nuova stringa è simile alla creazione di tipi di valore.

Quando si definisce un tipo di valore, tutti questi sono uguali (su un sistema a 32 bit comunque)

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

Proprio come questi quando si crea una stringa di tipo di riferimento:

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

Inoltre possiamo confrontare stringhe per valore anche se sono tipi di riferimento:

 s == "hello";//true 

Questo ancora non rende la stringa un tipo primitivo.

La risposta accettata a questa domanda dovrebbe darti dettagli in merito.

Non esiste una definizione “Microsoft” di cosa sia un tipo primitivo.

Esistono solo definizioni di tipi primitivi in ​​un dato contesto.

  • Il CLR definisce i tipi primitivi come nient’altro che:
    • 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 specifica VB.NET versione 10 (nella sezione 7.3) definisce “tipi primitivi” come tipi che hanno un alias di parole chiave per il tipo (permettendo così l’uso di quel tipo senza importare lo spazio System nomi di System ), un modo per definire le istanze di quel digita con un letterale; e permettendo l’uso di questi tipi come costanti; i tipi primitivi in ​​VB.NET sono:
    • 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 specifica C # (versione 4) definisce gli alias di parole chiave per alcuni tipi e definisce anche il modo di specificare i valori letterali per alcuni valori; definisce inoltre, separatamente, quali tipi sono disponibili in espressioni costanti; il concetto più vicino ai “tipi primitivi” che C # ha nella sezione 4.1.4: Tipi semplici. (la parola “primitivo” è usata solo due volte nel documento di 600 pagine); questi tipi primitivi sono semplicemente definiti come “tipi di valore che hanno un alias di parole chiave in C #” – la string non è menzionata in quella sezione:

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

Vedrai che c’è solo una parziale sovrapposizione tra tutte queste cose; il CLR vede entrambi i tipi di puntatore come primitivi, sia VB.NET che C # vedono i decimali come un tipo primitivo / semplice, solo VB.NET vede DateTime come qualcosa di speciale, sia VB.NET che C # hanno un alias parola chiave e una syntax letterale per le stringhe ma solo VB.NET specifica String come un “tipo primitivo”, mentre C # ha semplicemente una sezione della sua specifica dedicata a System.String

In conclusione: diversi contesti hanno definizioni diverse per ciò che è un “tipo primitivo”. Non importa – impara come usare il tuo linguaggio di programmazione, non ha senso combattere e pensare a parole così polimorfiche. Personalmente, mi chiedo perché esiste anche la proprietà Type.IsPrimitive .

Come per System.String :

  • CLR: Niente di speciale, è solo un tipo di riferimento;
  • VB.NET: è un tipo primitivo;
  • C #: String è il suo fiocco di neve molto speciale;

Aggiornamento del cambio di posizione: no poiché il codice non giace

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

—– fine dell’aggiornamento.
Ma alcuni documenti online sembrano trattare String come un primitivo. Penso – basato sulla seguente definizione di “primitivo”. (La mia definizione personale sarebbe un tipo che non può essere ulteriormente suddiviso in tipi di componenti, ma suppongo che siamo semplicemente “pedanti” qui, è un problema per me per lo più.)

tutti i tipi di dati primitivi in ​​C # sono oggetti nel namespace System. Per ogni tipo di dati, viene fornito un nome breve o un alias.

Fonte: http://msdn.microsoft.com/en-us/library/ms228360%28VS.80%29.aspx Un altro articolo a favore – Articolo MSDN Mag

Riepilogo: Credo che la risposta dipenda dalla tua definizione di primitiva, che non è definita in modo univoco . Fonte: Eric Lippert su un altro thread SO.

.NET definisce (dal tuo articolo):

I tipi primitivi sono Booleano, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Char, Double e Single.

Quindi no. Insito e molto importante: sì, ma non primitivo.

VB utilizza una definizione leggermente diversa per la CLI e C # sembra.

Sotto la definizione Microsoft di “primitiva”, la stringa non è considerata un tipo primitivo. D’altra parte, Microsoft tende ad usare la terminologia senza realmente formulare una definizione chiara o coerente (ad esempio “risorsa non gestita”), e si potrebbe definire utile “primitiva” per includere “String”, “Array” e “Object”, poiché in loro assenza non ci sarebbe modo di definire i tipi che potrebbero emularli in modo efficiente.

No, la stringa non è un tipo primitivo.

Tuttavia, ha alcune caratteristiche comuni con i tipi primitivi.

La lingua supporta i valori letterali stringa nel codice, in modo che non sia necessario creare in modo esplicito istanze String utilizzando la new parola chiave per ottenere un object stringa.

C’è anche il supporto per concatenare le stringhe usando l’operatore + , che il compilatore trasforma in una chiamata al metodo String.Concat .

Le stringhe sono immutabili, il che significa che nella maggior parte delle situazioni ha semantica del tipo value, proprio come i tipi primitivi.

La stringa è un tipo primitivo speciale. Non è un tipo di valore, ma può essere considerato un tipo primitivo perché può essere creato scrivendo letterali, ad esempio / “ciao” ed è ansible dichiarare una costante di tipo stringa. Detto questo, il valore di IsPrimitive restituisce false

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

EDIT: Voglio riprendere la mia risposta qui. Non è tecnicamente un tipo primitivo, ma condivide le proprietà che ho dichiarato sopra.

In c # i tipi sono principalmente definiti come due tipi: tipi di valore e tipi primitivi.

Per prima cosa vedi la definizione dei tipi primitivi in ​​C #.

D’altra parte, tutti i tipi di dati primitivi in ​​C # sono oggetti nello spazio dei nomi System. Per ogni tipo di dati, viene fornito un nome breve o un alias. Ad esempio, int è il nome breve per System.Int32 e double è la forma abbreviata di System.Double.

Ora, leggi questo articolo per la differenza: tipi primitivi e tipi di valore

System.String esegue il mapping su ” string “, che è un tipo primitivo nella CLI. Ma nella realtà, i tipi di valore sono quelli che vanno nello stack e non nello spazio heap.

Quindi, la chiave è Tipi di valore vs Tipi primitivi . Con la definizione di primitivo di Microsoft, è un tipo primitivo, ma in un senso più generale, non è così.

non lo sono, perché sono una sequenza di caratteri