entre - string c# ejemplos
¿Cuál es la diferencia entre String y string en C#? (30)
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 ?
Contra lo que parece ser una práctica común entre otros programadores, prefiero
String
más que
string
solo para resaltar el hecho de que
String
es un tipo de referencia, como mencionó Jon Skeet.
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.
Es una cuestión de convención, de verdad.
string
Simplemente se parece más al estilo C / C ++.
La convención general es utilizar los accesos directos que haya proporcionado su idioma elegido (int / Int para
Int32
).
Esto va para "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
int
referencia a
Int32
cualquier modo solo para estar seguro.
Hay una cita sobre este tema del libro de Daniel Solis .
Todos los tipos predefinidos se asignan directamente a los tipos .NET subyacentes. Los nombres de tipo C # (cadena) son simplemente alias para los tipos .NET (String o System.String), por lo que el uso de los nombres .NET funciona bien sintácticamente, aunque no se recomienda. Dentro de un programa de C #, debe usar los nombres de C # en lugar de los nombres de .NET.
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.
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.
No hay diferencia.
La palabra clave C # se
string
asigna al tipo .NET
System.String
: es un alias que se ajusta a las convenciones de nomenclatura del idioma.
Del mismo modo, los
int
mapas a
System.Int32
.
Sí, eso no es una diferencia entre ellos, al igual que el
bool
y
Boolean
.
Solo 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 el uso del nombre completo del tipo de sistema". No estoy de acuerdo con la especificación del lenguaje; Prefiero usar los nombres de tipo FCL y evitar completamente los nombres de tipo primitivos. De hecho, me gustaría que los compiladores ni siquiera ofrecieran los nombres de tipo primitivos y forzaran a los desarrolladores a usar los nombres de tipo FCL en su lugar. Aquí están mis razones:
He visto a varios desarrolladores confundidos, sin saber si usar una cadena o una cadena en su código. Debido a que en C # la cadena (una palabra clave) se asigna exactamente a System.String (un tipo de FCL), no hay diferencia y cualquiera puede usarse. De forma similar, he escuchado a algunos desarrolladores decir que int representa un número entero de 32 bits cuando la aplicación se ejecuta en un sistema operativo de 32 bits y que representa un número entero de 64 bits cuando la aplicación se ejecuta 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 número entero de 32 bits independientemente del sistema operativo en el que se ejecuta el código. Si los programadores usaran Int32 en su código, entonces esta confusión potencial también se elimina.
En C #, largos mapas a System.Int64 , pero en un lenguaje de programación diferente, siempre podría asignar a un Int16 o Int32 . De hecho, C ++ / CLI trata durante mucho tiempo 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 larga como palabra clave y no compilar código que lo utiliza.
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 tipo System.Convert ofrece métodos como ToBoolean , ToInt32 , ToSingle , etc. Aunque es legal escribir el siguiente código, la línea con float 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
Muchos programadores que usan C # exclusivamente tienden a olvidar que otros lenguajes de programación pueden usarse contra el CLR, y debido a esto, C # -ism se introduce en el código de la biblioteca de clases. Por ejemplo, FCL de Microsoft está casi escrito exclusivamente en C # y desarrolladores en el equipo FCL ahora han introducido métodos en la biblioteca como matriz ''s GetLongLength , que devuelve un Int64 valor que es un tiempo en C #, pero no en otros idiomas (como C ++ / CLI). Otro ejemplo es el método LongCount de System.Linq.Enumerable .
No obtuve su opinión antes de leer el párrafo completo.
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 como es
Boolean vs. bool
.
Estas palabras clave específicas del lenguaje C # le permiten declarar primitivos en un estilo similar a C.
Ambos son lo mismo.
Pero desde la perspectiva de las directrices de codificación, es mejor usar 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
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 C # que generó 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.
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
System.String
, como
String.Format
,
String.Join
,
String.Concat
, etc.
Ha sido cubierto arriba;
sin embargo, no puedes usar la
string
en la reflexión;
Debes usar
String
.
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 eso es solo mi preferencia personal.
La mejor respuesta que he escuchado sobre el uso de los alias de tipo proporcionados en C # proviene 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 una cadena o una 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 #, los mapas largos a System.Int64 , pero en un lenguaje de programación diferente, podrían asignarse a un Int16 o Int32 . De hecho, C ++ / CLI de hecho trata durante mucho tiempo 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 lo tratan como una palabra clave y no compilan el 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 ejemplo, el tipo BinaryReader ofrece métodos como ReadBoolean , ReadInt32 , ReadSingle , etc., y el tipo System.Convert ofrece métodos como ToBoolean , ToInt32 , ToSingle , etc. Aunque es legal escribir el siguiente código, la línea con float 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.
Nueva respuesta después de 6 años y 5 meses (dilación).
Mientras que la
string
es una palabra clave reservada de C # que siempre tiene un significado fijo, la
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 aplicadas
using
y su ubicación,
String
podría ser un valor o un tipo distinto de
global::System.String
.
Proporcionaré dos ejemplos donde el
using
directivas no ayudará
.
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 el
using
directivas).
Peor aún: si se dice
String.Concat(someSequence)
(dependiendo del
using
s), se
using
el 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 de las dos afirmaciones del método
Example
se compila.
Aquí
String
es siempre una
string
piano,
MyPiano.String
.
No existe ningún
Format
miembro (
static
o no) 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;
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: cuando 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 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 muestra de
sbyte
,
byte
,
short
,
ushort
,
int
,
uint
,
long
,
ulong
,
char
. .. a diferencia de una producción de
tipo
como la que 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 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 idioma que define un alias
int
para
Int16
, por ejemplo.
Los diseñadores del marco .NET 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
, abreviado:
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() ;
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
cualquier momento en 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 #.
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 funcional ambos son iguales.
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 #, prefiero la
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.
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 en los que es necesario especificar el tamaño de los enteros que está utilizando y, por lo tanto, tienden a usar
Int16
,
Int32
,
UInt16
,
UInt32
, etc., puede que parezca más natural utilizar
String
, y al moverse entre diferentes Los lenguajes .net podrían hacer las cosas más comprensibles, de lo contrario, usaría string e int.
string
es un alias (o taquigrafía) de
System.String
.
Eso significa, al escribir
string
nos referimos
System.String
.
Puedes leer más en think link:
''string'' es un alias / taquigrafía de System.String.
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
.
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.
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úscula en la mayoría de los proyectos debido al resaltado de sintaxis
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
string
es un alias para
System.String
aparte del tema de la palabra clave, los dos son exactamente equivalentes.
typeof(string) == typeof(String) == typeof(System.String)
Hay una diferencia
: no puedes usar
String
sin
using System;
antemano.