¿Cuál es la diferencia entre cadena y cadena en C#?

Solo por el bien de la integridad, aquí hay un volcado cerebral de información relacionada...

Como otros han señalado, string es un alias para System.String. Se compilan con 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 is 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 todos los tipos simples; ningún otro tipo de valor tiene formas literales disponibles. (Compare esto con VB, que permite DateTime literales, y tiene un alias para él también.)

Hay una circunstancia en la que tiene para usar los alias: cuando se especifica 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 el spec define declaraciones enum - la parte después de los dos puntos tiene que ser la producción de tipo integral , que es un token de sbyte, byte, short, ushort, int, uint, long, ulong, char... a diferencia de una producción de tipo utilizada por declaraciones de variables, por ejemplo. No indica ninguna otra diferencia.

Finalmente, cuando se trata de qué usar: personalmente uso los alias en todas partes para la implementación, pero el tipo CLR para cualquier API. Realmente no importa demasiado lo que uses en términos de implementación: la consistencia entre tu equipo es agradable, pero a nadie más le importará. Por otro lado, es realmente importante que si se refiere a un tipo en una API, lo haga de una manera neutral en el idioma. Un método llamado ReadInt32 es inequívoco, mientras que un método llamado ReadInt requiere interpretación. El llamante podría estar usando un lenguaje que defina un alias int para Int16, por ejemplo. Los diseñadores de. NET framework han seguido esto patrón, buenos ejemplos de estar en el BitConverter, BinaryReader y Convert clases.

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

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

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

• He visto a varios desarrolladores confundidos, sin saber si usar string o String en su código. Porque en C# la cadena (una palabra clave) se asigna exactamente al Sistema.String (un tipo FCL), no hay diferencia y cualquiera puede ser utilizado.
• En C#, long se asigna a Sistema.Int64, pero en un lenguaje de programación diferente, larga podría mapa a un Int16 o Int32. De hecho, C++ / CLI de hecho trata como un Int32 . Alguien que lee el código fuente en un lenguaje podría fácilmente malinterpretar la intención del código si él o ella estaban acostumbrados a programar en un lenguaje de programación diferente. De hecho, la mayoría de los lenguajes ni siquiera tratan long como una palabra clave y no compilan código que lo use.
• La FCL tiene muchos métodos que tienen nombres de tipo como parte de sus nombres de método. Por ejemplo, el BinaryReader ofertas de tipo de métodos tales como ReadBoolean, ReadInt32, ReadSingle, y así sucesivamente, y el Sistema.Convertir ofertas de tipo de métodos tales como ToBoolean, ToInt32, ToSingle, y así sucesivamente. Aunque es legal escribir el siguiente código, la línea con flotador me parece muy antinatural, 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 muy buenos puntos. Sin embargo, no me encuentro usando el consejo de Jeffrey en mi propio código. Tal vez estoy demasiado atascado en mi mundo de C#, pero termino tratando de hacer que mi código se vea como el código del marco.

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 string , solo verías la primera de estas compilaciones:

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

Si realmente quieres un nombre de variable llamado string puedes usar @ como prefijo:

StringBuilder @string = new StringBuilder();

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

Hay una diferencia - no se puede usar String sin using System; de antemano.

Se ha cubierto anteriormente; sin embargo, no puede usar string en la reflexión; debe usar String.

System.String es la clase. NET string-en C# string es un alias para System.String - por lo que en uso son los mismos.

En cuanto a las pautas, no me empantanaría demasiado y solo usaría lo que quiera: 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án utilizando y así tienden a usar Int16, Int32, UInt16, UInt32 etc. entonces podría parecer más natural use String - y cuando se mueve entre diferentes lenguajes.net podría hacer las cosas más comprensibles - de lo contrario usaría string e int.

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

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

Considere:

String someString; 
string anotherString; 

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

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

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 se utiliza C#, junto con el CLR string se asignará a System.String.

Teóricamente, se podría implementar un compilador C#que generara bytecode Java. Una sensata aplicación de este compilador probablemente mapa string a java.lang.String para interoperar con el tiempo de ejecución de Java biblioteca.

Este video de YouTube demuestra prácticamente cómo difieren.

Pero ahora para una larga respuesta textual.

Cuando hablamos de .NET hay dos cosas diferentes una es .NET framework y la otra hay lenguajes ( C# , VB.NET etc)que utilizan ese marco.

"System.String" también conocido como" String "("S "mayúscula) es un tipo de datos de marco .NET mientras que" string " es un tipo de datos C#.

En cadena corta "" es un alias (lo mismo llamado con diferentes nombres) de "string". Así que técnicamente ambas sentencias de código a continuación darán la misma salida.

String s = "I am String";

O

string s = "I am String";

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

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

Ahora la pregunta del millón de dólares desde el punto de vista del programador, así que cuándo usar "String" y ¿"string"?

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

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

string s = String.ToUpper() ;

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

La única diferencia práctica es el resaltado de sintaxis como mencionas, y que tienes que escribir using System si usas String.

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

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

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. por ejemplo, en lugar de usar Int32 usamos int como int es 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

Como dicen los otros, son lo mismo. Las reglas de StyleCop, de forma predeterminada, le obligarán a usar string como una práctica recomendada de estilo de código C#, excepto cuando haga referencia a funciones estáticas System.String, como String.Format, String.Join, String.Concat, etc...

El uso de tipos de sistema facilita el porteo entre C# y VB.Net, si te gustan esas cosas.

En contra de 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.

string es un alias (o abreviatura) de System.String. Eso significa que al escribir string nos referimos a System.String. Puedes leer más en think link: 'string' es un alias/abreviatura de System.Cadena.

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

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

Llegar tarde a la fiesta: Uso los tipos CLR el 100% de las veces (bueno, excepto si forzado a usar el tipo C#, pero no recuerdo cuándo fue la última vez).

Originalmente comencé a hacer esto hace años, según los libros de CLR de Ritchie. Tenía sentido para mí que todos los lenguajes CLR en última instancia tienen que ser capaces de soportar el conjunto de tipos CLR, por lo que el uso de los tipos CLR usted mismo proporcionó código más claro y posiblemente más "reutilizable".

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

Lo único realmente deprimente es que auto-complete usa el tipo C#, por lo que termino reescribiendo los tipos generados automáticamente para especificar el tipo CLR en su lugar.

También, ahora, cuando veo "int" o "string", simplemente se ve muy mal para mí, como si estuviera mirando el código C de 1970.

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

La especificación del lenguaje C# indica, "Como cuestión de estilo, el uso de la palabra clave se favorece sobre el uso de la nombre completo del tipo de sistema."No estoy de acuerdo con la especificación de idioma; I prefiera usar los nombres de tipo FCL y evitar completamente el tipo primitivo nombre. De hecho, deseo que los compiladores ni siquiera ofrecen el tipo primitivo nombres y obligaron a los desarrolladores a utilizar Nombres de tipo FCL en su lugar. Aquí están mis razones:

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

Es una cuestión de convención, realmente. string se parece más al estilo C/C++. La convención general es usar cualquier atajo que haya proporcionado el idioma elegido (int / Int para Int32). Esto va para "object" y decimal también.

Teóricamente esto podría ayudar a portar el código en algún 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 cambiara cualquier int referencias a Int32 de todos modos solo para estar seguro.

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.

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

Mientras que string es una palabra clave reservada de C# que siempre tiene un significado fijo, String es solo un identificador ordinario 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.

Daré dos ejemplos en los que using las directivas no help .

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 using directriz).

Peor: Decir String.Concat(someSequence) probablemente (dependiendo de usings) vaya 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 instrucción en el método Example compila. Aquí String es siempre una cuerda de piano , MyPiano.String. Ningún miembro (static o no) Format existe en él (o se hereda de su clase base). Y el el valor "Goodbye" no se puede convertir en él.

Hay una cita sobre este tema de El libro de Daniel Solís.

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

String es una palabra clave, y no se puede usar string como identificador.

String 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 la palabra clave, los dos son exactamente equivalente.

 typeof(string) == typeof(String) == typeof(System.String)

Sí, no hay diferencia entre ellos, al igual que el bool y Boolean.

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.