.net ejemplos - ¿Cuál es la diferencia entre String y string en C#?




java antes (25)

Ejemplo ( note el caso ):

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

¿Cuáles son las pautas para el uso de cada una? ¿Y cuáles son las diferencias ?


Answers

Como dicen los demás, son lo mismo. Las reglas de StyleCop, de forma predeterminada, le obligarán a utilizar la 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.


No hay diferencia.

La palabra clave C # se stringasigna al tipo .NET System.String: es un alias que se ajusta a las convenciones de nomenclatura del idioma.

Del mismo modo, los intmapas a System.Int32.


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 debe escribir using System si usa String .


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

Como otros han señalado, la 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 la string y el object , los alias son todos para valorar los tipos. 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 los literales de DateTime , y también tiene un alias para él).

Hay una circunstancia en la que tiene que 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 declaraciones de enumeración: la parte posterior a los dos puntos tiene que ser la producción de tipo integral , que es una muestra de sbyte , byte , short , ushort , int , uint , long , ulong , char . .. en contraposición a una producción de tipo tal como lo usan 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 agradable, 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 BitConverter buenos ejemplos en las BitConverter , BinaryReader y Convert .


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

Pero ahora para una respuesta textual larga.

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

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

En resumen, "Cadena" es un alias (lo mismo que se llama con nombres diferentes) de "cadena". Así que, técnicamente, ambas declaraciones 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 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 , abreviación: 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 evitar es confundirte con uno de ellos de manera consistente. 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 siguiente código, el lado izquierdo es una declaración de variable y se declara usando "cadena". En el lado derecho, estamos llamando a un método para que "Cadena" sea más sensible.

string s = String.ToUpper() ;

System.String es la clase de cadena .NET. En C #, la 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 uso 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 utilizar String , y cuando se mueven entre diferentes Los lenguajes .net podrían hacer las cosas más comprensibles, de lo contrario, usaría string e int.


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

string es un tipo en C #.

System.String es un tipo en el CLR.

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

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


La string minúscula 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 C# aliases ( int , string , etc.). Personalmente creo que deberías usar los C# aliases , pero esa es solo mi preferencia personal.


Ambos son lo mismo. Pero desde la perspectiva de las directrices de codificación, es mejor utilizar una string lugar de una String . Esto es lo que generalmente usan los desarrolladores. por ejemplo, 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 ". - C # Language Specification 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx


Sí, eso no es una diferencia entre ellos, al igual que el booly 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.


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.


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.


string es una palabra clave, y no puedes usar string como identificador.

La cadena no es una palabra clave, y puede usarla como un identificador:

Ejemplo

string String = "I am a string";

La palabra clave stringes un alias para System.Stringel problema de la palabra clave, los dos son exactamente equivalentes.

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

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 utilizar la string cada vez que se refiera a un objeto.

p.ej

string place = "world";

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

p.ej

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 de los alias específicos de C #.


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


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

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


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 para System.String en IL (Intermediate Language), por lo que no hay diferencia. Elige lo que te gusta y usa eso. Si codificas en C #, preferiría una string ya que es un alias de tipo C # y es bien conocido por los programadores de C #.

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


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.


Llegando tarde a la fiesta: uso los tipos CLR el 100% del tiempo (bueno, excepto si me veo obligado 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. 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 proporcionaba un código más claro y posiblemente 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 decepción real es que la función de autocompletar usa el tipo C #, por lo que termino volviendo a escribir tipos generados automáticamente para especificar el tipo CLR.

Además, ahora, cuando veo "int" o "cadena", me parece muy mal, como si estuviera mirando el código C de 1970.


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


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

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.


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

Si bien stringes una palabra clave reservada de C # que siempre tiene un significado fijo, Stringes 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 usingdirectivas aplicadas y su ubicación, Stringpodría ser un valor o un tipo distinto de global::System.String.

Daré dos ejemplos donde las usingdirectivas no ayudarán .

Primero, cuando Stringes 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 se ha llamado un miembro no estático Formaty no se aplican métodos de extensión. En el caso anterior, todavía puede ser posible utilizar Stringen 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 usingdirectivas).

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

En segundo lugar, cuando Stringhay 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 de las dos afirmaciones en el Examplemétodo compila. Aquí Stringes siempre un piano string , MyPiano.String. Ningún miembro ( statico no) Formatexiste en él (o se hereda de su clase base). Y el valor "Goodbye"no se puede convertir en él.


Prefiero los tipos de .NET 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.

Considerar:

String someString; 
string anotherString; 

JavaScript

 var str = "My big string contain apples and oranges";
 var n = str.indexOf("apples"); 
 alert(n); //will alert 22, -1 if not found

jQuery

  <p>My big string contain apples and oranges</p>
  alert($("p:contains(apples)")[0] != undefined); //will alert true if found




c# .net string types alias