62 Pregunta: ¿Cuál es la diferencia entre String y string en C #?

pregunta creada en Wed, Jun 27, 2018 12:00 AM

Ejemplo ( note el caso ):

 
string s = "Hello world!";
String s = "Hello world!";

¿Qué son las guías laterales para el uso de cada una? ¿Y cuáles son las differences ?

    
6002
  1. @ ORMapper, pero el hecho es que string es una construcción léxica de la gramática C # mientras que System.String es solo un tipo Independientemente de cualquier diferencia explícita mencionada en cualquier especificación, todavía existe esta diferencia implícita que podría acomodarse con cierta ambigüedad. El lenguaje en sí debe admitir string de manera que la implementación no esté (tan) obligada a considerar para una clase en particular en el BCL.
    2014-12-02 03: 05: 22Z
  2. @ KirkWoll: De acuerdo con la especificación del idioma, el lenguaje en sí mismo debe considerar que string es exactamente igual al tipo BCL System.String, nada más . Eso no es ambiguo en absoluto. Por supuesto, puede implementar su propio compilador, utilizando la gramática de C #, y usar todos los tokens encontrados de esa manera para algo arbitrario, no relacionado con lo que se define en la especificación del lenguaje C #. Sin embargo, el lenguaje resultante solo sería un aspecto de C #, no se podría considerar C #.
    2014-12-02 08: 22: 33Z
  3. Puede usar string sin una directiva de uso para el Sistema. No puedes hacer eso con String.
    2015-11-30 08: 52: 40Z
  4. Para alguien que viene de Algol y Fortran, esta discusión muestra que algo anda mal con el string. Se necesita abreviar System.String, pero, como un alias, parece bastante, pero no exactamente lo mismo. Sin embargo, después de varios años de C #, diría que es seguro usar simplemente string y string.Format() y no preocuparse por System.String.
    2016-12-20 00: 24: 25Z
  5. @ Sangeeta ¿Qué estás diciendo? La clase System.String todavía está allí, y la palabra clave string sigue siendo un alias para ella. Al igual que System.Int32 y int. Son literalmente lo mismo.
    2018-12-08 02: 14: 44Z
30 Respuestas                              30                         

string es un alias en C # para System.String .
Así que técnicamente, no hay diferencia. Es como int vs. System.Int32 .

En cuanto a las pautas, generalmente se recomienda usar string siempre que se refiera a un objeto.

por ejemplo

 
string place = "world";

Del mismo modo, creo que generalmente se recomienda usar String si necesita referirse específicamente a la clase.

por ejemplo

 
string greet = String.Format("Hello {0}!", place);

Este es el estilo que Microsoft tiende a usar en sus ejemplos .

Parece que la orientación en esta área puede haber cambiado, ya que StyleCop ahora impone el uso del C # específico alias.

    
5639
2019-01-22 18: 50: 42Z
  1. Si decide usar StyleCop y lo sigue, eso le indicará que use los tipos específicos del idioma. Así que para C # tendrá cadena (en lugar de Cadena), int (en lugar de Int32), float (en lugar de Single) - stylecop.soyuz5.com/SA1121.html
    2012-05-22 22: 36: 15Z
  2. Siempre uso los alias porque asumí que algún día podría ser útil porque están actuando como una abstracción, por lo tanto, se pueden cambiar sus implementaciones sin que yo tenga para saber.
    2012-10-12 23: 25: 39Z
  3. Visual Studio 2015 dice que String.Format debe cambiarse por string.Format, así que supongo que Microsoft va por ese camino. También siempre he usado String para los métodos estáticos.
    2014-12-22 05: 21: 27Z
  4. Al leer esto, he notado que varios de los comentarios son simplemente incorrectos. @ DRAirey1 Con el tiempo, descubrirá que la forma antigua sigue siendo la mejor, si lo duda, entonces me atrevo a intentar escribir código C # sin usar Visual Studio. Es virtualmente imposible y una situación que surge de vez en cuando en el trabajo de desarrollo web. @Vlad No necesitas importar nada para usar String. @Abhi Su comentario es inútil e igualmente válido para string.Format(). @KlitosG No, eso no es cierto. Todos funcionan exactamente igual.
    2015-05-29 14: 30: 54Z
  5. ¿Podría agregar un comentario de que, de hecho, hay una diferencia? Por ejemplo: nameof(string) no compilará, mientras que nameof(String) lo hará.
    2016-02-05 20: 38: 26Z

Solo por completar, aquí hay un volcado de información relacionada ...

Como han dicho otros, string es un alias para System.String. Se compilan en el mismo código, por lo que en el momento de la ejecución no hay diferencia alguna. Este es solo uno de los alias en C #. La lista completa es:

 
object:  System.Object
string:  System.String
bool:    System.Boolean
byte:    System.Byte
sbyte:   System.SByte
short:   System.Int16
ushort:  System.UInt16
int:     System.Int32
uint:    System.UInt32
long:    System.Int64
ulong:   System.UInt64
float:   System.Single
double:  System.Double
decimal: System.Decimal
char:    System.Char

Aparte de string y object, los alias son todos para tipos de valor. decimal es un tipo de valor, pero no un tipo primitivo en el CLR. El único tipo primitivo que no tiene un alias es System.IntPtr.

En la especificación, los alias de tipo de valor se conocen como "tipos simples". Los literales se pueden usar para valores constantes de cada tipo simple; ningún otro tipo de valor tiene formas literales disponibles. (Compare esto con VB, que permite DateTime literales, y también tiene un alias para ello).

Hay una circunstancia en la que tienes para usar los alias: al especificar explícitamente el tipo subyacente de una enumeración. Por ejemplo:

 
public enum Foo : UInt32 {} // Invalid
public enum Bar : uint   {} // Valid

Eso es solo una cuestión de la forma en que la especificación define las declaraciones de enumeración: la parte posterior a los dos puntos debe ser la producción de tipo integral , que es una ficha de sbyte, byte, short, ushort, int, uint, long, ulong, char ... en lugar de una producción de type como la que utilizan las declaraciones de variables, por ejemplo. No indica ninguna otra diferencia.

Finalmente, cuando se trata de usar: personalmente uso los alias en todas partes para la implementación, pero el tipo CLR para cualquier API. Realmente no importa mucho lo que use en términos de implementación: la coherencia entre su equipo es buena, pero a nadie más le va a importar. Por otro lado, es realmente importante que si se refiere a un tipo en una API, lo haga de manera neutral. Un método llamado ReadInt32 es inequívoco, mientras que un método llamado ReadInt requiere interpretación. La persona que llama podría estar usando un lenguaje que define un alias int para Int16, por ejemplo. Los diseñadores de .NET framework han seguido este patrón, y los buenos ejemplos se encuentran en las clases BitConverter, BinaryReader y Convert.

    
3253
2018-01-20 14: 02: 12Z
  1. La situación de herencia con enum es interesante. ¿Puede señalar la documentación sobre por qué se debe usar el alias para las enumeraciones? ¿O es este un error conocido?
    2008-10-19 02: 00: 57Z
  2. Está en la sección 14.1 de la especificación (no puedo citar aquí fácilmente porque es demasiado largo). No dice explícitamente que tienes que usar el alias, pero los alias son tipo tratados como sus propios tipos. Todo es un poco raro.
    2008-10-19 06: 34: 02Z
  3. @ PiPeep lo que es más sorprendente que la gran cantidad de upvotes es la asombrosa cantidad baja de downvotes (considera que las 5 publicaciones más importantes tienen un total de más de 2000 upvotes, pero solo 1 downvote entre todos ellos). Especialmente cuando consideras la idea de que siempre hay "enemigos" en cualquier comunidad, realmente me parece increíble.
    2011-09-09 21: 27: 44Z
  4. Una diferencia interesante entre string y String es que string' is a keyword in c#, so you can not use it as a variable name.For Ex: string string = "hi"; //compiler error, but String String = "hi"; `es aceptable, ya que String es un identifire no una palabra clave.
    2013-06-05 07: 09: 27Z
  5. @ SanjeevRai: Sí. Puedes usar @string para crear un identificador que termina siendo string. Es una especie de mecanismo de escape.
    2013-06-05 07: 18: 18Z

String significa System.String y es un tipo de .NET Framework. string es un alias en el lenguaje C # para System.String. Ambos están compilados en System.String en IL (lenguaje intermedio), por lo que no hay diferencia. Elige lo que te gusta y usa eso. Si codificas en C #, preferiría string ya que es un alias de tipo C # y es bien conocido por los programadores de C #.

Puedo decir lo mismo sobre (int, System.Int32) etc.

    
662
2011-12-03 19: 53: 11Z
  1. `Si usted codifica en C #, preferiría la cadena porque es un alias de tipo C # y es bien conocida por los programadores de C #. ¿Cuándo una persona de C # no sabría la .NET Framework. +1, ya que creo que en general esta es la mejor respuesta, pero el punto que menciono parece extraño.
    2015-11-16 08: 31: 12Z
  2. Personalmente prefiero usar "Int32", ya que muestra inmediatamente el rango del valor. Imagínese si actualizaran el tipo de "int" en sistemas posteriores de bits superiores. 'int' en c se ve aparentemente como "el tipo de entero que el procesador de destino es más eficiente al trabajar con" , y se define como "al menos 16 bits". Prefiero una consistencia predecible allí, muchas gracias.
    2016-04-28 11: 41: 38Z
  3. @ MyDaftQuestions Estoy de acuerdo. En todo caso, tendría sentido utilizar los tipos .net de forma sistemática porque son ignorantes del lenguaje y el tipo es obvio, independientemente de cualquier idioma (¿conozco todas las idiosincrasias de F # o VB?).
    2017-01-21 17: 39: 59Z
  4. @ Nyerguds Hay dos razones para no preocuparse simplemente por eso. Una de ellas es que int se define en la especificación de lenguaje C # como un entero de 32 bits, independientemente del hardware. C #, a pesar de una herencia compartida en la niebla del tiempo, en realidad no es C. Cambiar int a un entero de 64 bits sería un cambio importante en la especificación y el idioma. También requeriría la redefinición de long, ya que long es actualmente el entero de 64 bits. La otra razón para no preocuparse es irrelevante, ya que los tipos nunca cambiarán, pero .NET es lo suficientemente abstracto como para que el 99% del tiempo no tenga que pensar en ello de todos modos. ;-)
    2018-12-08 02: 47: 06Z
  5. @ Craig Investigo en muchos formatos antiguos de juegos patentados en los que do tengo que pensar en eso todo el tiempo, sin embargo. Y luego, usar Int16, Int32 y Int64 es un lote más transparente en el código que usar el short, int y long
    .
    2018-12-09 02: 29: 47Z

La mejor respuesta que he escuchado sobre el uso dellos alias de tipo proporcionados en C # provienen de Jeffrey Richter en su libro CLR Via C # . Aquí están sus 3 razones:

  
  • He visto a varios desarrolladores confundidos, sin saber si usar cadena o Cadena en su código. Debido a que en C # la cadena (una palabra clave) se asigna exactamente a System.String (un tipo FCL), no hay diferencia y cualquiera puede usarse.
  •   
  • En C #, largo se asigna a System.Int64 , pero en un lenguaje de programación diferente, largo podría asignarse a un Int16 o Int32 . De hecho, C ++ /CLI de hecho se trata como un Int32 . Alguien que esté leyendo el código fuente en un idioma podría malinterpretar fácilmente la intención del código si estuviera acostumbrado a programar en un lenguaje de programación diferente. De hecho, la mayoría de los idiomas ni siquiera tratarán a long como una palabra clave y no compilarán el código que la usa.
  •   
  • La FCL tiene muchos métodos que tienen nombres de tipo como parte de sus nombres de método. Por ejemplo, el tipo BinaryReader ofrece métodos como ReadBoolean , ReadInt32 , ReadSingle , etc., y el El tipo System.Convert ofrece métodos como ToBoolean , ToInt32 , ToSingle , etc. Aunque es legal escribir el siguiente código, la línea con flotador me parece muy poco natural, y no es obvio que la línea sea correcta:
  •   
 
BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

Así que ahí lo tienen. Creo que todos estos son puntos realmente buenos. Sin embargo, no me encuentro usando el consejo de Jeffrey en mi propio código. Tal vez estoy demasiado atascado en mi mundo C # pero termino tratando de hacer que mi código se vea como el código del marco.

    
470
2018-07-04 11: 05: 58Z
  1. El segundo punto suena realmente como una razón no para usar string, int etc.
    2015-06-15 15: 37: 29Z
  2. @ MauganRa Y se supone que sí, el autor del libro enumera esas razones por las que no usa aliases.
    2015-09-15 17: 48: 00Z
  3. "Si alguien está leyendo el código fuente de C #, debe interpretar durante mucho tiempo según la especificación del idioma, no otra especificación de idiomas". Eso pierde el punto por completo. No es que nadie intente interpretar mal el código, simplemente es fácil para el cerebro saltar a la conclusión errónea cuando un tipo tiene un significado diferente al que el programador ve a diario en otro contexto. Todos cometemos errores; el uso de tipos con nombres explícitos hace que esos errores sean menos probables.
    2015-09-21 22: 11: 04Z
  4. + Estas razones resumen mis sentimientos al respecto. Cuando comencé a codificar en C # (proveniente de un fondo Java /C ++ /C) pensé que los alias eran feos. Todavía me siento así, desafortunadamente, la mayor parte del mundo no parece estar de acuerdo conmigo, o no les importa, y por eso usan mayúsculas.
    2017-03-02 10: 41: 21Z
  5. @ jinzai la pregunta es acerca de C #, en la que long se define como un entero de 64 bits con signo, independientemente de la plataforma o el compilador. Entonces, al menos en algunos casos, sí, depende del idioma.
    2018-02-08 14: 30: 36Z

string es una palabra reservada, pero String es solo un nombre de clase. Esto significa que string no se puede usar como nombre de variable por sí mismo.

Si por alguna razón quisieras una variable llamada cadena , solo verías la primera de estas compilaciones:

 
StringBuilder String = new StringBuilder();  // compiles
StringBuilder string = new StringBuilder();  // doesn't compile 

Si realmente desea un nombre de variable llamado cadena , puede usar @ como prefijo:

 
StringBuilder @string = new StringBuilder();

Otra diferencia crítica: el desbordamiento de pila los resalta de manera diferente.

    
424
2017-12-27 17: 33: 19Z
  1. Tenga en cuenta que llamar al @string local no tiene mucho sentido, ya que los nombres de los locales solo están presentes en los PDB. Bien podría llamarlo _string o algo así. Tiene más sentido para las cosas que tienen nombres accesibles a través de la reflexión, donde el nombre de un miembro @string sería "string".
    2013-08-19 10: 30: 07Z
  2. También tenga en cuenta que usar una palabra reservada como nombre de variable es extremadamente poco elegante.
    2015-10-27 15: 16: 54Z
  3. "el desbordamiento de pila los resalta de manera diferente". No se necesitan más razones :)
    2016-04-22 13: 46: 26Z
  4. El OP no quiere usar String o string como nombre de variable. Pidieron una explicación de la diferencia entre estos Tipos . Su respuesta solo sirve para agregar más confusión, OMI
    2016-07-04 15: 14: 19Z
  5. @ Simon_Weaver knots in strings? jaja bueno. :-) Por supuesto, puedes elegir un nombre alternativo, como hilo. Espera un minuto ... ¡D'oh!
    2018-12-09 03: 59: 54Z

Hay una diferencia : no puedes usar String sin using System; de antemano.

    
365
2016-10-03 18: 32: 52Z
  1. por defecto, la mayoría de las personas lo agregan de cualquier manera en la parte superior del archivo. ¡VS lo hace de forma predeterminada en la mayoría de los casos, no en todos!
    2010-04-06 16: 10: 21Z
  2. Por defecto, solo agrego using declaraciones que requiero, y elimino explícitamente todo lo que no. Herramientas de productividad de energía > "[x] Eliminar y dar formato a los usos al guardar"
    2016-05-18 16: 58: 27Z
  3. @ JMD He modificado el archivo de plantilla .cs para que ni siquiera tenga ninguna declaración de uso en la parte superior. También cambié la plantilla de clase a internal sealed.
    2016-12-01 23: 48: 35Z
  4. @ JMD Odio esa función. A veces hace cambios en archivos que no han sido tocados, lo que dificulta ver qué cambios reales contiene un conjunto de cambios. Por supuesto, normalmente elimino "usar spam", pero solo de forma activa, no automática.
    2019-02-19 14: 45: 10Z
  5. Eso puede ser así para C #, pero no para todos los lenguajes .NET. (Powershell importa el espacio de nombres del sistema de forma predeterminada).
    2019-03-19 23: 29: 30Z

Ha sido cubierto arriba; sin embargo, no puedes usar string en la reflexión; debe utilizar String.

    
293
2011-11-19 09: 36: 59Z
  1. No entiendo lo que significa esta respuesta y por qué se ha votado. Puede utilizar typeof(string) en reflexión. Ejemplo uno: if (someMethodInfo.ReturnType == typeof(string)) { ... } Ejemplo dos: var p = typeof(string).GetProperty("FirstChar", BindingFlags.NonPublic | BindingFlags.Instance); ¿Dónde debe usar String, no string? Si intenta cosas como Type.GetType("String") o Type.GetType("string"), ninguno encontrará la clase porque falta el espacio de nombres. Si por alguna razón tonta , compara .Name de un tipo con "string" de una manera que distingue entre mayúsculas y minúsculas, tiene razón.
    2019-05-24 12: 04: 17Z

System.String es la clase de cadena .NET; en C # string es un alias para System.String, por lo que en uso son iguales.

En cuanto a las pautas, no me atascaría demasiado y solo usaría lo que creas: hay cosas más importantes en la vida y el código será el mismo de todos modos.

Si se encuentran construyendo sistemas donde es necesario especificar el tamaño de los enteros que está utilizando y, por lo tanto, tienden a usar Int16, Int32, UInt16, UInt32, etc., entonces puede parecer más natural usar String, y cuando se mueven Alrededor de los diferentes idiomas .NET puede hacer las cosas más comprensibles, de lo contrario, usaría string e int.     

234
2018-02-06 12: 39: 09Z
  1. + 1 por afirmar que hay cosas más importantes en la vida, siento que aquí hay otra pregunta de StackOverflow sobre millones de preguntas sobre un tema trivial está teniendo lugar: es.wikipedia.org/wiki/Parkinson's_law_of_triviality
    2014-04-12 19: 32: 17Z
  2. Simplemente elija uno y sea consistente. Si trabajas en algún lugar con un estilo de casa, úsalo.
    2015-03-16 16: 32: 52Z
  3. desafortunadamente, el estilo es una preferencia personal y puede ser demasiado costoso de implementar en una base de código grande en varios equipos sin un propietario de código dedicado. Siempre hay asuntos más importantes de los que ocuparse en lugar de la cadena frente a la cadena. lo que nos lleva de nuevo a "cosas más importantes en la vida"
    2016-02-24 06: 51: 16Z
  4. Esto es definitivamente una cosa de preferencia; por ejemplo: prefiero usar short, int, ushort, uint en lugar de Int16, etc. Sobre todo porque así es como aprendí. Por supuesto, el Int16 es más fácil de entender de inmediato para aquellos con menos experiencia. +1 de mí!
    2019-01-02 19: 18: 08Z

Prefiero los tipos .NET en mayúsculas (en lugar de los alias) por razones de formato. Los tipos .NET tienen el mismo color que otros tipos de objetos (los tipos de valores son objetos adecuados, después de todo).

Las palabras clave condicionales y de control (como if, switch y return) son minúsculas y de color azul oscuro (de forma predeterminada). Y preferiría no tener el desacuerdo en uso y formato.

Considera:

 
String someString; 
string anotherString; 
    
191
2016-09-28 11: 58: 18Z
  1. ¿También escribes código como: Int32 i = 1; En lugar de int i = 1; ? Parece incoherente no usar el alias de cadena cuando está disponible.
    2013-01-28 10: 49: 37Z
  2. @ nashwan: en realidad, sí, uso Int32 i=1; en lugar de int i = 1;. Creo que el primero es más legible en cuanto a mi intención: es decir, que quiero una firma de 32 bits. entero.
    2013-02-15 17: 30: 42Z
  3. Bueno, supongo que todo depende de si el desarrollador cree que está escribiendo el código C # (cadena) o el código .NET (String). Personalmente, creo que estoy escribiendo C # (y es C # que usa .NET).
    2014-04-15 13: 09: 24Z
  4. @ Alex: mi punto fue simplemente que prefiero ser muy específico en mi codificación para eliminar la ambigüedad.
    2015-04-27 02: 56: 54Z
  5. En el otro extremo absoluto del espectro, casi siempre uso var
    2016-03-18 15: 38: 29Z

string y String son idénticos en todos los aspectos (excepto la "S" mayúscula). No hay implicaciones de rendimiento de ninguna manera.

Se prefiere minúscula string en la mayoría de los proyectos debido al resaltado de sintaxis

    
180
2011-11-19 09: 37: 17Z
  1. Jeffrey Richter recomienda usar el tipo CLR en todos los casos (CLR a través de C #) para evitar exactamente el tipo de confusión que se está produciendo aquí.
    2008-10-18 17: 02: 29Z
  2. Claramente, si usa S o s, habrá causado estas preguntas, así que vote hacia abajo Richter. ;)
    2008-10-18 17: 17: 18Z
  3. Richter quería decir que la cadena no debería haber sido una opción, Microsoft no debería tenerla en el idioma. No puedes desestimar a Richter, ¡es una leyenda! :)
    2008-10-18 19: 23: 07Z
  4. Estoy de acuerdo en que podría haber sido mejor no tener los alias en absoluto. Pero dado que los tenemos, creo que está bien usarlos (pero no en nombres de métodos, etc.)
    2008-10-19 06: 34: 50Z
  5. "string" no es lo mismo que "String". Es significa "System.String". Entonces, si usas "Cadena" tienes que poner "usando Sistema" para incluir el espacio de nombres
    2011-12-03 16: 41: 29Z

C # es un lenguaje que se usa junto con el CLR.

string es un tipo en C #.

System.String es un tipo en el CLR.

Cuando use C # junto con el CLR string se asignará a System.String .

Teóricamente, podría implementar un compilador C # que generó el bytecode de Java. Una implementación sensata de este compilador probablemente asignaría string a java.lang.String para interoperar con la biblioteca de ejecución de Java.

    
171
2015-12-25 12: 55: 26Z
  1. string no es un tipo en C #; es una palabra reservada que se asigna a un tipo en el CLR.
    2011-07-31 17: 58: 52Z
  2. @ CesarGon: De acuerdo con ECMA-334, sección 8.2.1: "C # proporciona un conjunto de tipos predefinidos [...] Los tipos de referencia predefinidos son objeto y cadena . "
    2011-07-31 19: 03: 30Z
  3. Según ECMA-334, sección 9.4.3, "cadena" es una palabra clave. :-) Estoy de acuerdo con usted en que "cadena" es un tipo si se enfoca en la semántica, pero yo diría que es una palabra clave (es decir, una palabra reservada) si se enfoca en la sintaxis. El estándar respalda ambos puntos de vista (¡quizás demasiado ambiguamente!). Para mí, el OP se trata de sintaxis, por lo que tiendo a centrarme en la sintaxis cuando veo las respuestas, pero también veo su punto. Además, su respuesta, tal como está, puede interpretarse como que significa que existen dos tipos diferentes: cadena y Cadena, cuando ese no es el caso. Uno es un mapeo al otro.
    2011-07-31 19: 30: 23Z
  4. Seamos claros al respecto. 'string' es un alias reservado. No es un verdadero tipo de datos. Es algo que apunta a otra cosa. Puede eliminar todos estos alias (o simplemente nunca usarlos) y tener un perfectly buen lenguaje de programación.
    2013-07-08 16: 50: 49Z

Este video de YouTube demuestra prácticamente en qué se diferencian.

Pero ahora para una respuesta textual larga.

Cuando hablamos de .NET hay dos cosas diferentes, uno es .NET framework y el otro hay idiomas (C#, VB.NET, etc.) que usan ese framework.

ingrese la descripción de la imagen aquí

"System.String" a.k.a "String" (mayúscula "S") es un tipo de datos de marco .NET, mientras que "string" es un tipo de datos C#.

ingrese la descripción de la imagen aquí

En resumen, "String" es un alias (lo mismo que se llama con nombres diferentes) de "string". Así que, técnicamente, ambas declaraciones de código a continuación darán el mismo resultado.

 
String s = "I am String";

o

 
string s = "I am String";

De la misma manera, hay alias para otro tipo de datos c # como se muestra a continuación: -

objeto: System.Object, cadena: System.String, bool: System.Boolean, byte: System.Byte, sbyte: System.SByte, breve: System.Int16 y así sucesivamente

Ahora la pregunta del millón desde el punto de vista del programador ¿Cuándo usar "String" y "string"?

Lo primero que debes hacer para evitar confusiones es usar uno de ellos constantemente. Pero desde la perspectiva de las mejores prácticas, cuando se hace una declaración de variables, es bueno usar "cadena" ("s" pequeña) y cuando se usa como nombre de clase, se prefiere "Cadena" (mayúscula "S").

En el código de abajo, el lado izquierdo es una declaración de variable y se declara usando "cadena". En el lado derecho, estamos llamando a un método, por lo que "String" es más sensible.

 
string s = String.ToUpper() ;
    
157
2015-02-28 10: 48: 34Z
  1. "En resumen" String "es un alias (lo mismo que se llama con nombres diferentes) de" string "". Esto no es correcto: el alias es "cadena".
    2014-11-06 12: 04: 10Z
  2. cuando haces una declaración de variables, es bueno usar "string" ("s" pequeña) y cuando lo estés usando como nombre de clase, entonces "String" Se prefiere (mayúscula "S"). Parece que esta convención ya no es válida: si usa Visual Studio 2015 y trata de escribir String, le sugerimos que "simplifique su código", llevándolo a string ...
    2016-11-04 14: 11: 45Z

La minúscula string es un alias para System.String. Son los mismos en C#.

Existe un debate sobre si debe usar los tipos de Tipos de sistema (System.Int32, System.String, etc.) o los tipos C# aliases (int, string, etc.). Personalmente creo que deberías usar el C# aliases, pero esa es mi preferencia personal.

    
148
2017-08-14 04: 33: 23Z
  1. Ese es el problema, no son alias 'C #', son alias 'C'. No hay una 'cadena' o 'int' nativas en el lenguaje C #, solo el azúcar sintáctico.
    2015-05-29 20: 23: 54Z
  2. no está seguro de dónde vino "C", ya que la especificación del lenguaje C # 5 dice "La cadena de palabras clave es simplemente un alias para la clase predefinida System.String". En la página 85, párrafo 4.2.4. Todos los lenguajes de alto nivel son azúcar sintáctico sobre conjuntos de instrucciones y códigos de bytes de CPU.
    2016-02-24 06: 57: 31Z

string es solo un alias para System.String. El compilador los tratará de forma idéntica.

La única diferencia práctica es el resaltado de sintaxis que menciona, y que tiene que escribir using System si usa String.

    
145
2011-12-03 19: 53: 47Z
  1. No es necesario que prefijos System para usar String.
    2008-10-18 19: 24: 16Z
  2. Tiene que incluir un using System cuando usa String, de lo contrario, obtendrá el siguiente error: The type or namespace name 'String' could not be found (are you missing a using directive or an assembly reference?)
    2009-10-16 17: 53: 00Z

Ambos son iguales. Pero desde la perspectiva de las directrices de codificación, es mejor usar string en lugar de String. Esto es lo que generalmente usan los desarrolladores. p.ej. en lugar de usar Int32 usamos int ya que int es un alias de Int32

FYI “La cadena de palabras clave es simplemente un alias para la clase predefinida System.String”. - Especificación de lenguaje C # 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx

    
130
2017-08-14 05: 16: 40Z

Como dicen los demás, son lo mismo. Las reglas de StyleCop, de forma predeterminada, obligarán a utilizar string como una mejor práctica de estilo de código C #, excepto cuando se hace referencia a las funciones estáticas de System.String, como String.Format, String.Join, String.Concat, etc ...

    
110
2011-11-19 09: 35: 51Z
  1. No sabía que StyleCop marcaría el uso de String, excepto los métodos estáticos. Creo que es genial, ya que así es como siempre lo uso: cadena para declaraciones de tipo y cadena cuando accedo a los miembros estáticos.
    2011-05-05 18: 41: 26Z

Nueva respuesta después de 6 años y 5 meses (dilación).

Si bien string es una palabra clave reservada de C # que siempre tiene un significado fijo, String es solo un identificador común que podría referirse a cualquier cosa. Dependiendo de los miembros del tipo actual, el espacio de nombres actual y las directivas using aplicadas y su ubicación, String podría ser un valor o un tipo distinto de global::System.String.

Proporcionaré dos ejemplos donde las directivas using no ayudarán .


Primero, cuando String es un valor del tipo actual (o una variable local):

 
class MySequence<TElement>
{
  public IEnumerable<TElement> String { get; set; }

  void Example()
  {
    var test = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
  }
}

Lo anterior no se compilará porque IEnumerable<> no tiene un miembro no estático llamado Format, y no se aplican métodos de extensión. En el caso anterior, todavía puede ser posible usar String en otros contextos donde un tipo es la única posibilidad sintácticamente. Por ejemplo, String local = "Hi mum!"; podría estar bien (dependiendo del espacio de nombres y las directivas using).

Peor: Decir String.Concat(someSequence) probablemente (dependiendo de using s) irá al método de extensión Linq Enumerable.Concat. No irá al método estático string.Concat.


En segundo lugar, cuando String es otro tipo , anidado dentro del tipo actual:

 
class MyPiano
{
  protected class String
  {
  }

  void Example()
  {
    var test1 = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
    String test2 = "Goodbye";
  }
}

Ninguna declaración en el método Example se compila. Aquí, String siempre es un piano cadena , MyPiano.String. Ningún miembro (static o no) Format existe en él (o se hereda de su clase base). Y el valor "Goodbye" no se puede convertir en él.

    
92
2015-01-15 14: 21: 22Z
  1. Supongo que sería diabólico y podría: using String = System.Int32; using Int32 = System.String; y luego contar los errores.
    2015-05-08 00: 40: 28Z
  2. esta es la respuesta correcta. string es System.String. String podría ser cualquier cosag.
    2018-10-09 20: 26: 00Z
  3. De acuerdo @DaveCousineau: ese es el punto del alias. Puede crear otro tipo de String que no se establecería en el objeto System.String. Echa un vistazo a: blog.paranoidcoding .com /2019/04/08 /…
    2019-04-11 16: 37: 15Z
  4. "La palabra clave string tiene un significado concreto en C #. Es el tipo System.String que existe en el ensamblaje del tiempo de ejecución del núcleo. El tiempo de ejecución entiende este tipo de manera intrínseca y proporciona las capacidades que esperan los desarrolladores para strings en .NET. Su presencia es tan importante para C # que si ese tipo no existe, el compilador saldrá antes de intentar analizar incluso una línea de código. Por lo tanto, string tiene un significado preciso e inequívoco en el código C #. El identificador String aunque no tiene un significado concreto en C #. Es un identificador que pasa por todas las reglas de búsqueda de nombres como Widget, Student, etc ... "
    2019-04-11 16: 40: 28Z
  5. 2019-05-23 05: 46: 50Z

El uso de los tipos de sistema hace que sea más fácil portar entre C # y VB.Net, si te gusta ese tipo de cosas.

    
91
2008-09-22 19: 40: 08Z
  1. Convertir entre C # y VB.NET es bastante sencillo. developerfusion.com/tools/convert/vb-to-csharp
    2011-07-01 20: 35: 22Z

Contra lo que parece ser una práctica común entre otros programadores, prefiero String sobre string, solo para resaltar el hecho de que String es un tipo de referencia, como mencionó Jon Skeet.

    
83
2011-11-19 09: 35: 06Z

string es un alias (o taquigrafía) de System.String. Eso significa que al escribir string nos referimos a System.String. Puede leer más en el enlace de reflexión: 'cadena' es un alias /taquigrafía de System.String.

    
78
2016-10-08 18: 50: 20Z

String (System.String) es una clase en la biblioteca de clases base. string (en minúscula) es un trabajo reservado en C # que es un alias para System.String. Int32 vs int es una situación similar a la de Boolean vs. bool. Estas palabras clave específicas del lenguaje C # le permiten declarar primitivos en un estilo similar a C.

    
70
2013-12-24 04: 50: 19Z

Me gustaría agregar esto a la respuesta de lfousts, del libro de Ritchers:

  

La especificación del lenguaje C # dice: "Como cuestión de estilo, el uso de la palabra clave se favorece sobre   uso del nombre completo del tipo de sistema ”. No estoy de acuerdo con la especificación del idioma; yo prefiero   to utilice los nombres de tipo FCL y evite por completo los nombres de tipo primitivos. De hecho, deseo que   los compiladores ni siquiera ofrecieron los nombres tipográficos primitivos y forzaron a los desarrolladores a usar el FCL   escriba nombres en su lugar. Aquí están mis razones:

     
  • He visto a varios desarrolladores confundidos, sin saber si usar cadena   o Cadena en su código. Porque en C # cadena (una palabra clave) se asigna exactamente a    System.String (un tipo FCL), no hay diferencia y se puede usar cualquiera de los dos. Similar,   He oído a algunos desarrolladores decir que int representa un entero de 32 bits cuando la aplicación   se ejecuta en un sistema operativo de 32 bits y representa un entero de 64 bits cuando la aplicación   se está ejecutando en un sistema operativo de 64 bits. Esta declaración es absolutamente falsa: en C #, un int siempre se asigna   a System.Int32 , y por lo tanto representa un entero de 32 bits independientemente del sistema operativo el   el código se está ejecutando en. Si los programadores usarían Int32 en su código, entonces este potencial   También se elimina la confusión.

  •   
  • En C #, largo se asigna a System.Int64 , pero en un lenguaje de programación diferente, largo   podría asignarse a un Int16 o Int32 . De hecho, C ++ /CLI trata a long como Int32 .   Alguien que lea el código fuente en un idioma podría malinterpretar fácilmente el código   intención si él o ella estaban acostumbrados a programar en un lenguaje de programación diferente.   De hecho, la mayoría de los idiomas ni siquiera tratan a largo como una palabra clave y no compilan código   que lo usa.

  •   
  • La FCL tiene muchos métodos que tienen nombres de tipo como parte de sus nombres de método. por   por ejemplo, el tipo BinaryReader ofrece métodos como ReadBoolean , ReadInt32 ,    ReadSingle , y así sucesivamente, y el tipo System.Convert ofrece métodos como    ToBoolean , ToInt32 , ToSingle , etc. Aunque es legal escribir lo siguiente   código, la línea con flotador me parece muy poco natural, y no es obvio que la línea sea   correcto:

     
    BinaryReader br = new BinaryReader(...);
    float val = br.ReadSingle(); // OK, but feels unnatural
    Single val = br.ReadSingle(); // OK and feels good
    
  •   
  • Muchos programadores que usan C # exclusivamente tienden a olvidar que otras programaciones   se pueden usar idiomas contra el CLR, y debido a esto, C # -isms se arrastran en el   código de la biblioteca de clase. Por ejemplo, la FCL de Microsoft está casi exclusivamente escrita en C # y   los desarrolladores del equipo de FCL ahora han introducido métodos en la biblioteca como    Array 's GetLongLength , que devuelve un valor Int64 que es un largo en C # pero no   en otros idiomas (como C ++ /CLI). Otro ejemplo es System.Linq.Enumerable ’s   Método LongCount .

  •   

No obtuve su opinión antes de leer el párrafo completo.

    
70
2018-12-05 09: 34: 21Z

String no es una palabra clave y se puede usar como identificador, mientras que string es una palabra clave y no se puede usar como identificador. Y en el punto de vista de la función, ambos son iguales.

    
64
2011-11-19 09: 35: 19Z

Llegando tarde a la fiesta: uso los tipos CLR el 100% del tiempo (bueno, excepto si forzó para usar el tipo C #, pero no recuerdo cuándo fue la última vez que ).

Originalmente comencé a hacer esto hace años, según los libros de CLR de Ritchie. Para mí tenía sentido que todos los idiomas de CLR tuvieran que ser capaces de admitir el conjunto de tipos de CLR, por lo que el uso de los tipos de CLR era más claro y, posiblemente, un código más "reutilizable".

Ahora que lo he estado haciendo durante años, es un hábito y me gusta la coloración que muestra VS para los tipos CLR.

La única desventaja real es que el autocompletado usa el tipo C #, por lo que termino volviendo a escribir tipos generados automáticamente para especificar el tipo CLR en su lugar.

También, ahora, cuando veo "int" o "cadena", me parece muy mal, como si estuviera viendo el código C de 1970.

    
64
2012-08-24 15:22:47Z

Es una cuestión de convención, de verdad. string se parece más al estilo C /C ++. La convención general es utilizar todos los accesos directos que haya proporcionado el idioma elegido (int /Int para Int32). Esto se aplica a "objeto" y decimal también.

Teóricamente, esto podría ayudar a incluir el código de puerto en un futuro estándar de 64 bits en el que "int" podría significar Int64, pero ese no es el punto, y esperaría que cualquier asistente de actualización cambie cualquier referencia int a Int32 de todos modos. seguro.

    
59
2018-10-03 04: 24: 47Z

No hay diferencia.

La palabra clave C # string se asigna al tipo .NET System.String, es un alias que se ajusta a las convenciones de nomenclatura del lenguaje.

Del mismo modo, int se asigna a System.Int32.

    
47
2012-01-15 00: 30: 34Z
  1. En una compilación de 64 bits, int se asigna a System.Int64 (8 bytes), en una compilación de 32 bits se asigna a System.Int32 (4 bytes)
    2012-07-25 15: 26: 08Z
  2. 2013-04-17 07: 18: 49Z
  3. IntPtr y UIntPtr son los únicos tipos que cambian de tamaño según la plataforma (sin tener en cuenta los punteros actual como int* y los tipos compuestos por [U] IntPtrs o punteros reales).
    2013-04-23 21: 20: 46Z
  4. 2013-05-23 22: 37: 50Z

Hay una cita sobre este tema en libro de Daniel Solis .

  

Todos los tipos predefinidos se asignan directamente a   Tipos de .NET subyacentes. Los nombres de tipo C # (cadena) son simplemente alias para el   Tipos .NET (String o System.String), por lo que el uso de los nombres .NET funciona bien de manera sintáctica, aunque   Esto es desalentado. Dentro de un programa de C #, debe usar los nombres de C #   en lugar de los nombres .NET.

    
42
2016-12-11 05: 27: 45Z

cadena es una palabra clave, y no puede utilizar cadena como identificador.

Cadena no es una palabra clave, y puedes usarla como identificador:

Ejemplo

 
string String = "I am a string";

La palabra clave string es un alias para   System.String aparte de la cuestión de palabras clave, los dos son exactamente  equivalente.

 
 typeof(string) == typeof(String) == typeof(System.String)
    
39
2016-03-16 19: 35: 32Z
  1. La única pequeña diferencia es que si usa la clase String, debe importar el espacio de nombres del sistema sobre su archivo, mientras que no tiene que hacer esto cuando se utiliza la palabra clave de cadena.
    2018-03-04 09: 29: 34Z
  2. Hay casos de uso simples en los que la declaración de igualdad fallaría ... Por ejemplo, definir una Cadena de llamada de tipo en el espacio de nombres blah e importar que namespace en el archivo en el que se ejecuta la declaración de igualdad.
    2019-06-04 13: 36: 55Z

Sí, eso no es una diferencia entre ellos, al igual que el bool y el Boolean.

    
38
2015-12-25 12: 55: 50Z

No hay diferencia entre los dos: string, sin embargo, parece ser la opción preferida cuando se considera el código fuente de otros desarrolladores.

    
33
2011-11-19 09: 34: 52Z
fuente colocada aquí