C#中字符串和字符串有什么区别?

时间:2008-08-10 07:18:02

标签: c# .net string types alias

示例(注意案例):

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

每种用途的 指南 是什么?什么是 差异

68 个答案:

答案 0 :(得分:5604)

string是C#中System.String的别名 从技术上讲,没有区别。这就像int vs. System.Int32

就指南而言,通常建议您在引用某个对象时使用string

e.g。

string place = "world";

同样,我认为如果您需要专门参考该课程,通常建议使用String

e.g。

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

这是Microsoft倾向于在their examples中使用的样式。

似乎此区域的指南可能已更改,因为StyleCop现在强制使用C#特定别名。

答案 1 :(得分:3237)

仅仅为了完整起见,这里是相关信息的大脑转储...

正如其他人所说,stringSystem.String的别名。它们编译为相同的代码,因此在执行时没有任何区别。这只是C#中的别名之一。完整清单是:

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

除了stringobject之外,别名都是值类型。 decimal是值类型,但不是CLR中的基本类型。唯一没有别名的原始类型是System.IntPtr

在规范中,值类型别名称为“简单类型”。文字可用于每种简单类型的常量值;没有其他值类型具有可用的文字形式。 (与VB比较,它允许DateTime文字,并且也有别名。)

有一种情况是 使用别名:明确指定枚举的基础类型时。例如:

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

这只是规范定义枚举声明的方式问题 - 冒号之后的部分必须是整数类型生成,这是sbyte的一个标记,{{ 1}},byteshortushortintuintlongulong ...相反例如,变量声明所使用的类型生产。它没有表明任何其他差异。

最后,当谈到使用它时:我个人在各处使用别名来实现,但是任何API都使用CLR类型。你在实施方面使用它并不重要 - 团队之间的一致性很好,但没有人会关心。另一方面,如果您在API中引用类型,则以语言中立的方式执行此操作,这一点非常重要。名为char的方法是明确的,而名为ReadInt32的方法需要解释。例如,调用者可能正在使用为ReadInt定义int别名的语言。 .NET框架设计人员遵循了这种模式,Int16BitConverterBinaryReader类中有很好的例子。

答案 2 :(得分:655)

String代表System.String,它是.NET Framework类型。 stringSystem.String的C#语言中的别名。它们都在IL (中间语言)中编译为 System.String,因此没有区别。选择你喜欢的并使用它。如果您使用C#编写代码,我更喜欢string,因为它是C#类型的别名,并且是C#程序员所熟知的。

我可以对intSystem.Int32等说同样的话。

答案 3 :(得分:465)

我曾听说过在C#中使用提供的类型别名的最佳答案来自Jeffrey Richter在他的书CLR Via C#中。以下是他的3个理由:

  
      
  • 我看到许多开发人员感到困惑,不知道是否在他们的代码中使用字符串字符串。因为在C#中,字符串(一个关键字)完全映射到System.String(一种FCL类型),所以没有区别,可以使用它们。
  •   
  • 在C#中,映射到 System.Int64 ,但在其他编程语言中,可映射到 Int16 Int32 。实际上,C ++ / CLI确实将long视为 Int32 。如果某人使用一种语言阅读源代码,如果他或她习惯于使用不同的编程语言进行编程,则很容易误解代码的意图。事实上,大多数语言甚至不会将 long 视为关键字,也不会编译使用它的代码。
  •   
  • FCL有许多方法,它们将类型名称作为其方法名称的一部分。例如, BinaryReader 类型提供了诸如 ReadBoolean ReadInt32 ReadSingle 等方法,以及 System.Convert 类型提供的方法包括 ToBoolean ToInt32 ToSingle 等。虽然编写下面的代码是合法的,但浮点线对我来说感觉非常不自然,并且线条不正确并不明显:
  •   
BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

所以你有它。我认为这些都是非常好的观点。但是,我发现自己在自己的代码中没有使用Jeffrey的建议。也许我太过陷入C#世界,但我最终试图让我的代码看起来像框架代码。

答案 4 :(得分:420)

string是保留字,但String只是一个类名。 这意味着string本身不能用作变量名。

如果由于某种原因你想要一个名为 string 的变量,你只能看到第一个这样的编译:

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

如果您确实需要名为 string 的变量名称,可以使用@作为前缀:

StringBuilder @string = new StringBuilder();

另一个重要区别:Stack Overflow以不同方式突出显示它们。

答案 5 :(得分:362)

存在一个差异 - 您事先没有String就无法使用using System;

答案 6 :(得分:292)

上面已经介绍过;但是,你不能在反射中使用string;你必须使用String

答案 7 :(得分:233)

System.String是.NET字符串类 - 在C#中stringSystem.String的别名 - 所以在使用它们时是相同的。

至于指导方针,我不会太陷入困境,只是使用你想要的任何东西 - 生活中有更重要的事情,代码也会是相同的。

如果您发现自己构建系统,需要指定您正在使用的整数的大小,那么倾向于使用Int16Int32UInt16,{{1}然后使用UInt32看起来更自然 - 当在不同的.net语言之间移动时,它可能会使事情变得更容易理解 - 否则我会使用string和int。

答案 8 :(得分:191)

出于格式化原因,我更喜欢大写的.NET类型(而不是别名)。 .NET类型的颜色与其他对象类型相同(毕竟值类型是正确的对象)。

条件和控件关键字(例如ifswitchreturn)是小写的,并且颜色为深蓝色(默认情况下)。而且我宁愿在使用和格式方面没有分歧。

考虑:

String someString; 
string anotherString; 

答案 9 :(得分:179)

stringString在所有方面都相同(大写“S”除外)。无论如何都没有性能影响。

由于语法高亮显示

,大多数项目都首选小写string

答案 10 :(得分:170)

C#是一种与CLR一起使用的语言。

string 是C#中的一种类型。

System.String 是CLR中的一种类型。

当您将CL#与CLR一起使用时 string 将映射到 System.String

理论上,您可以实现生成Java字节码的C#编译器。这个编译器的合理实现可能会将 string 映射到 java.lang.String ,以便与Java运行时库进行互操作。

答案 11 :(得分:156)

This YouTube视频实际上展示了它们的不同之处。

但是现在需要很长的文字答案。

当我们谈论.NET时,有两个不同的东西,一个是.NET框架,另一个是使用该框架的语言(C#VB.NET等)

enter image description here

System.String”a.k.a“字符串”(大写字母“S”)是.NET框架数据类型,而“字符串”是C#数据类型。

enter image description here

简而言之,“String”是“string”的别名(使用不同的名称调用相同的东西)。因此从技术上讲,下面的代码语句都会给出相同的输出。

String s = "I am String";

string s = "I am String";

以同样的方式存在其他c#数据类型的别名,如下所示: -

对象:System.Object,字符串:System.String,bool:System.Boolean,字节:System.Byte,sbyte:System.SByte,简称:System.Int16等等

现在从程序员的角度来看百万美元的问题那么何时使用“String”和“string”?

避免混淆的第一件事是始终如一地使用其中一个。但是从最佳实践角度来看,当你进行变量声明时,最好使用“string”(小“s”),当你使用它作为类名时,首选“String”(大写“S”)。

在下面的代码中,左侧是变量声明,它使用“string”声明。在右侧,我们称之为方法,因此“字符串”更明智。

string s = String.ToUpper() ;

答案 12 :(得分:147)

小写stringSystem.String的别名。 它们在C#中是相同的。

关于您是否应该使用系统类型(System.Int32System.String等)类型或C# aliasesintstring存在争议等)。我个人认为你应该使用C# aliases,但这只是我个人的偏好。

答案 13 :(得分:144)

string只是System.String的别名。编译器会以相同的方式处理它们。

唯一的实际区别是你提到的语法高亮,如果你使用using System,你必须写String

答案 14 :(得分:130)

两者都是一样的。但从编码指南的角度来看,最好使用string代替String。这是开发人员通常使用的。例如我们使用Int32代替使用int,而intInt32的别名

FYI “关键字字符串只是预定义类System.String的别名。” - C#语言规范4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx

答案 15 :(得分:110)

正如其他人所说,他们是一样的。默认情况下,StyleCop规则会强制您使用string作为C#代码样式的最佳做法,除非引用System.String静态函数,例如String.FormatString.Join,{ {1}}等等......

答案 16 :(得分:91)

6年零5个月后的新答案(拖延)。

虽然string是保留的C#关键字,但始终具有固定含义,String只是一个普通的标识符,可以引用任何内容。根据当前类型的成员,当前命名空间和应用的using指令及其位置,String可以是与global::System.String不同的值或类型。

我将提供两个 using指令无法帮助的示例


首先,当String是当前类型(或本地变量)的 时:

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

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

以上内容无法编译,因为IEnumerable<>没有名为Format的非静态成员,并且不适用任何扩展方法。在上述情况下,仍然可以在其他上下文中使用String,其中 type 是语法上唯一的可能性。例如String local = "Hi mum!";可能没问题(取决于命名空间和using指令)。

更糟糕:说String.Concat(someSequence)可能(取决于using)转到Linq扩展方法Enumerable.Concat。它不会转到静态方法string.Concat


其次,当String是另一个 类型 时,嵌套在当前类型中:

class MyPiano
{
  protected class String
  {
  }

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

Example方法中的任何一个语句都没有编译。此处String始终是钢琴stringMyPiano.String。没有成员(static或不)Format存在于其上(或从其基类继承)。并且值"Goodbye"无法转换为它。

答案 17 :(得分:90)

使用系统类型可以更容易地在C#和VB.Net之间进行移植,如果您遇到这种情况。

答案 18 :(得分:83)

对于其他程序员的常见做法,我更喜欢String而非string,只是为了强调String是一种参考类型,正如Jon Skeet所提到的那样。 / p>

答案 19 :(得分:78)

stringSystem.String的别名(或简写)。这意味着,通过输入string,我们的意思是System.String。您可以在思考链接中阅读更多内容:'string' is an alias/shorthand of System.String.

答案 20 :(得分:70)

我只想将此添加到来自Ritchers书中的lfousts答案:

  

C#语言规范指出,“作为一种风格,关键字的使用受到青睐   使用完整的系统类型名称。“我不同意语言规范;我更喜欢   使用FCL类型名称并完全避免基本类型名称。事实上,我希望如此   编译器甚至没有提供原始类型名称,并迫使开发人员使用FCL   改为输入名称。以下是我的理由:

     
      
  • 我看到很多开发人员感到困惑,不知道是否使用字符串   或者代码中的字符串。因为在C#字符串(一个关键字)中完全映射到    System.String (一种FCL类型),没有区别,任何一种都可以使用。同样的,   我听说有些开发人员说应用程序时 int 表示32位整数   在32位操作系统上运行,并且它在应用程序时表示64位整数   正在64位操作系统上运行。这句话绝对是错误的:在C#中, int 总是映射   到 System.Int32 ,因此无论操作系统如何,它都代表一个32位整数   代码正在运行。如果程序员在他们的代码中使用 Int32 ,那么这个潜力   混乱也被消除了。

  •   
  • 在C#中,映射到 System.Int64 ,但使用其他编程语言   可以映射到 Int16 Int32 。实际上,C ++ / CLI确实将 long 视为 Int32 。   有人用一种语言阅读源代码很容易误解代码   如果他或她习惯于使用不同的编程语言进行编程。   事实上,大多数语言甚至不会将 long 视为关键字,也不会编译代码   使用它。

  •   
  • FCL有许多方法,它们将类型名称作为其方法名称的一部分。对于   例如, BinaryReader 类型提供了诸如 ReadBoolean ReadInt32 等方法,    ReadSingle 等等, System.Convert 类型提供了诸如    ToBoolean ToInt32 ToSingle ,依此类推。尽管编写以下内容是合法的   代码, float 的行对我来说感觉非常不自然,而且这条线是不明显的   正确的:

    BinaryReader br = new BinaryReader(...);
    float val = br.ReadSingle(); // OK, but feels unnatural
    Single val = br.ReadSingle(); // OK and feels good
    
  •   
  • 许多使用C#的程序员都倾向于忘记其他编程   语言可以用来对付CLR,正因为如此,C#-isms进入了   类库代码。例如,微软的FCL几乎全部用C#编写   FCL团队的开发人员现在已经将方法引入了库中   数组 GetLongLength ,在C#中返回 Int64 long ,但不是   在其他语言中(如C ++ / CLI)。另一个例子是 System.Linq.Enumerable    LongCount 方法。

  •   

在我阅读完整段落之前,我没有得到他的意见。

答案 21 :(得分:70)

String(System.String)是基类库中的一个类。 string(小写)是C#中的保留工作,它是System.String的别名。 Int32 vs int与Boolean vs. bool的情况类似。这些特定于C#语言的关键字使您能够以类似于C.

的样式声明基元

答案 22 :(得分:64)

String不是关键字,可以用作标识符,而string是关键字,不能用作标识符。从功能的角度来看,两者都是一样的。

答案 23 :(得分:64)

派对迟到:我100%使用CLR类型(好吧,除非强制使用C#类型,但我不记得上一次是什么时候)。

根据Ritchie的CLR书籍,我最初是在几年前开始做的。我认为所有CLR语言最终都必须能够支持CLR类型集,因此使用CLR类型本身提供了更清晰,可能更“可重用”的代码。

现在我已经做了多年,这是一种习惯,我喜欢VS为CLR类型显示的颜色。

唯一真正的下载是自动完成使用C#类型,所以我最终重新键入自动生成的类型来指定CLR类型。

此外,现在,当我看到“int”或“string”时,我看起来真的不对,就像我在看1970年代的C代码一样。

答案 24 :(得分:58)

这是一个常规问题,真的。 string看起来更像是C / C ++风格。一般惯例是使用您选择的语言提供的任何快捷方式(Int32的int / Int)。这适用于“对象”和decimal

理论上这可能有助于将代码移植到未来的64位标准中,其中“int”可能意味着Int64,但这不是重点,我希望任何升级向导都可以更改任何{{1}为了安全起见,引用int

答案 25 :(得分:47)

没有区别。

C#关键字string映射到.NET类型System.String - 它是一个保持语言命名约定的别名。

同样,int映射到System.Int32

答案 26 :(得分:42)

Daniel Solis' book对此问题有一个引用。

  

所有预定义类型都直接映射到   基础.NET类型。 C#类型名称(字符串)只是其中的别名   .NET类型(String或System.String),因此使用.NET名称在语法上可以很好地工作   这是沮丧的。在C#程序中,您应该使用C#名称   而不是.NET名称。

答案 27 :(得分:40)

字符串是一个关键字,您不能使用字符串作为标识符。

字符串不是关键字,您可以将其用作标识符:

示例

string String = "I am a string";

关键字string是其别名  System.String除关键字问题外,两者完全相同  等效。

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

答案 28 :(得分:38)

是的,他们之间没有区别,就像boolBoolean一样。

答案 29 :(得分:33)

两者之间没有区别 - string,但在考虑其他开发人员的源代码时似乎是首选。

答案 30 :(得分:26)

其他地方没有提到的一个论点是偏好pascal case String

System.String是一种引用类型,引用类型名称按惯例为

答案 31 :(得分:23)

两者都是一样的。不同之处在于你如何使用它。 惯例是,

s tring用于变量

S tring用于调用其他String类方法

像:

string fName = "John";
string lName = "Smith";

string fullName = String.Concat(fName,lName);

if (String.IsNullOrEmpty(fName))
{
  Console.WriteLine("Enter first name");
}

答案 32 :(得分:17)

实际上没有区别

C#关键字字符串映射到.NET类型System.String - 它是一个保持语言命名约定的别名。

答案 33 :(得分:15)

String指的是一个字符串对象,它带有各种函数来操作包含的字符串。

string指的是原始类型

在C#中,它们都编译为String,但在其他语言中它们不会这样,如果你想处理String对象,你应该使用String,如果你想处理文字,你应该使用字符串。

答案 34 :(得分:15)

如果确实看到stringSystem.String之间没有区别,那就很有用了:

var method1 = typeof(MyClass).GetMethod("TestString1").GetMethodBody().GetILAsByteArray();
var method2 = typeof(MyClass).GetMethod("TestString2").GetMethodBody().GetILAsByteArray();

//...

public string TestString1()
{
    string str = "Hello World!";
    return str;
}

public string TestString2()
{
    String str = "Hello World!";
    return str;
}

两者都产生完全相同的IL字节数组:

[ 0, 114, 107, 0, 0, 112, 10, 6, 11, 43, 0, 7, 42 ]

答案 35 :(得分:14)

stringString之间存在一个实际差异。

nameof(String); // compiles
nameof(string); // doesn't compile

这是因为string是关键字(在这种情况下是别名),而String是一种类型。

其他别名也是如此。

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

答案 36 :(得分:12)

您不需要导入命名空间(使用System;)来使用string,因为它是System.String的全局别名。

要了解有关别名的详情,请查看此link

答案 37 :(得分:10)

首先,两者(字符串和字符串)不相同。 它们是有区别的: String不是关键字,可以用作标识符,而string是关键字,不能用作标识符。

我试图用不同的例子来解释: 首先,当我把“字符串s”进入Visual Studio并将鼠标悬停在它上面(没有颜色):
String Definition

那说字符串是System.String,对吗? 文档位于https://msdn.microsoft.com/en-us/library/362314fe.aspx。第二句话说“string是.NET Framework中String的别名”。

答案 38 :(得分:8)

说实话,在实践中, System.String 字符串之间通常没有区别。

C#中的所有类型都是对象,并且都来自 System.Object 类。一个区别是string是C#关键字, String 可以用作变量名。 System.String 是此类型的常规.NET名称,字符串是方便的C#名称。这是一个简单的程序,它提供了 System.String 和字符串之间的区别。

string a = new string(new char[] { 'x', 'y', 'z' });
string b = new String(new char[] { 'x', 'y', 'z' });
String c = new string(new char[] { 'x', 'y', 'z' });
String d = new String(new char[] { 'x', 'y', 'z' });
MessageBox.Show((a.GetType() == typeof(String) && a.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((b.GetType() == typeof(String) && b.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((c.GetType() == typeof(String) && c.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((d.GetType() == typeof(String) && d.GetType() == typeof(string)).ToString()); // shows true

我的编译器中的@JonSkeet

public enum Foo : UInt32 { }

正在运作。我是Visual Studio 2015社区。

答案 39 :(得分:8)

@JaredPar(C#编译器的开发者和丰富的SO用户!)在此问题上写了great blog post。我认为值得在这里分享。这是关于我们主题的一个很好的视角。

  

stringString并不是一场风格辩论

     

[...]

     

关键字string在C#中具有具体含义。它是核心运行时程序集中存在的System.String类型。运行时从本质上理解这种类型,并提供了开发人员期望的.NET字符串功能。它的存在对C#至关重要,如果不存在该类型,编译器将在尝试解析一行代码之前退出。因此string在C#代码中具有精确,明确的含义。

     

标识符String在C#中没有具体含义。它是一个标识符,它遵循所有名称查找规则,例如WidgetStudent等……它可以绑定到字符串,也可以绑定到另一个程序集中的某个类型,其目的可能完全不同于string。更糟糕的是,其定义方式可能像String s = "hello"这样的代码;继续编译。

class TricksterString { 
  void Example() {
    String s = "Hello World"; // Okay but probably not what you expect.
  }
}

class String {
  public static implicit operator String(string s) => null;
}
     

String的实际含义将始终取决于名称解析。   这意味着它取决于项目中的所有源文件以及所有   所有引用的程序集中定义的类型。简而言之   需要很多上下文来知道是什么意思。

     

在大多数情况下,Stringstring会绑定到   相同的类型。但是使用String仍然意味着开发人员要离开   他们的程序直到只有一个地方的解释   正确答案。当String绑定到错误的类型时,它可能会离开   开发人员调试几个小时,向编译器团队提交错误,   通常浪费时间,而使用string可以节省时间。

     

可视化差异的另一种方法是使用此示例:

string s1 = 42; // Errors 100% of the time  String s2 = 42; // Might
error, might not, depends on the code
     

许多人会争辩说,尽管在技术上使用String可以得到准确的信息,但仍然很好,因为很少有代码库会定义此名称的类型。或者,当定义String时,就表明代码库不正确。

     

[...]

     

您会看到String是为许多完全有效的目的而定义的:反射助手,序列化库,词法分析器,协议等…对于其中的任何String与{{1 }}的实际后果取决于使用代码的地方。

     

因此请记住,当您看到stringString的辩论时,这是关于语义而非样式的。选择字符串可使代码库具有清晰的含义。选择string并没有错,但是这为将来带来惊喜提供了方便。

注意:出于存档原因,我复制/粘贴了大多数博客文章。我忽略了某些部分,因此建议您跳过并阅读blog post

答案 40 :(得分:8)

杰弗里里希特写道:

  

另一种思考方式是自动编译C#编译器   假设您在所有人中都有以下using指令   源代码文件:

using int = System.Int32;
using uint = System.UInt32;
using string = System.String;
...
  

我看到很多开发人员感到困惑,不知道是否使用   字符串或字符串在其代码中。因为在C#string(一个关键字)中映射   完全是System.String(一个FCL类型),没有区别和   要么可以使用。

答案 41 :(得分:7)

两者之间没有区别。您可以在代码中使用其中任何一个。

Sub GoalSeekTest() Dim N As Integer Dim i As Integer N = ThisWorkbook.Sheets("Reverse DCF").Range("D1").Value For i = 2 To N If Cells(i, "P").HasFormula Then 'Messagebox for clarification MsgBox ("Formula cell: " & Cells(i, "P") _ .Address(RowAbsolute:=False, ColumnAbsolute:=False)) Cells((i), "P").GoalSeek Goal:=0, ChangingCell:=Cells((i), "J") Else MsgBox "Cell " & Cells(i, 1) _ .Address(RowAbsolute:=False, ColumnAbsolute:=False) _ & " has no formula - skipping this cell!", _ vbCritical, "Formula required!" End If Next i End Sub 是一个类(引用类型),它定义了命名空间System.String中的mscorlib。换句话说,SystemSystem.String中的一种类型。

CLRstring

中的关键字

答案 42 :(得分:7)

string等于System.String
在VS2015中,如果你写这个

System.String str;

比编译器会显示优化它的潜在修复方法,并且在应用该修复后,它将如下所示

string str;

答案 43 :(得分:7)

字符串是用于表示文字的连续字符

String对象是表示字符串的 System.Char对象的连续集合; System.Char对象对应于UTF-16代码单元。

String对象的值是System.Char对象的顺序集合的内容,该值是不可变的(即,它是只读的)。

有关字符串不变性的更多信息,请参阅msdn中的Immutability和StringBuilder类部分。

内存中String对象的最大大小为2GB,即大约10亿个字符。

注意:答案摘自msdn帮助部分。您可以在备注部分

下查看完整内容here in msdn String Class主题

答案 44 :(得分:7)

MSDN文档的上下文中,String类的记录与任何其他数据类型一样(例如XmlReader,{{1} })在 BCL

并且StreamReader被记录为关键字(C#参考)或任何基本的C#语言构造(例如stringfor,{{1 }})。

<强> Reference

答案 45 :(得分:6)

字符串: String对象称为immutable(只读),因为一旦创建了它就无法修改它的值。看似修改String对象的方法实际上返回一个包含修改的新String对象。如果有必要修改类似字符串的对象的实际内容

string:字符串类型表示零个或多个Unicode字符的序列。 string是.NET Framework中String的别名。 string是内在的C#数据类型,是系统提供的类型“System.String”的别名。 C#规范声明,作为一种样式,关键字(字符串)优先于整个系统类型名称(System.String或String)。 虽然string是引用类型,但是定义了相等运算符(==和!=)来比较字符串对象的值,而不是引用。这使得对字符串相等性的测试更加直观。例如:

字符串与&amp;的区别字符串:

  • string通常用于声明,而String用于访问静态字符串方法
  • 您可以使用'string'声明使用预定义类型'string'的字段,属性等,因为C#规范告诉我这是一种很好的风格。
  • 您可以使用'String'来使用系统定义的方法,例如String.Compare等。它们最初是在'System.String'上定义的,而不是'string'。在这种情况下,'string'只是别名。
  • 在与其他系统通信时,您也可以使用'String'或'System.Int32',特别是如果它们符合CLR。即 - 如果我从其他地方获取数据,我会将其反序列化为System.Int32而不是'int',如果定义的原点不是C#系统。

答案 46 :(得分:6)

在C#中,string是System.String(String)的缩写版本。它们的意思基本相同。

就像有人提到的那样,它就像boolBoolean一样,差别不大......

答案 47 :(得分:6)

我更喜欢使用string,因为这种类型的使用非常多,我不希望语​​法高亮显示器将其与所有其他类混合使用。虽然它是一个类,但它更像是一个原语,因此我认为不同的高亮颜色是合适的。

如果您右键点击string关键字并从上下文菜单中选择Go to definition,它会带您进入String课程 - 它只是语法糖,但它提高了可读性imo。

答案 48 :(得分:6)

正如所指出的,它们是相同的,string只是String的别名。

对于它的价值,我使用字符串来声明类型 - 变量,属性,返回值和参数。这与其他系统类型的使用一致 - int, bool, var等(尽管Int32Boolean也是正确的。)

在String类上使用静态方法时使用String,如String.Split()String.IsNullOrEmpty()。我认为这更有意义,因为这些方法属于一个类,并且与我使用其他静态方法的方式一致。

答案 49 :(得分:5)

stringSystem.String的简称。 StringSystem.StringCTS(Common Type System)中字符串的名称。

答案 50 :(得分:5)

据我所知,string只是System.String的别名,boolobjectint存在类似的别名......唯一微妙的区别是你可以使用string而没有“使用System;”指令,而String需要它(否则你应该完全指定System.String。)

哪个最好用,我想这是一个品味问题。我个人更喜欢string,但我不是宗教问题。

答案 51 :(得分:5)

字符串:代表一个类

字符串:代表别名

  

这只是微软的编码惯例。

答案 52 :(得分:4)

string是.NET Framework中String的别名。

Where&#34; String&#34;实际上是System.String.

我会说它们是可以互换的,你应该在何时何地使用其中一种没有区别。

最好与你使用的那个一致。

为了它的价值,我使用string来声明类型 - 变量,属性,返回值和参数。这与其他系统类型的使用一致 - int, bool, var等(尽管Int32Boolean也是正确的。)

在String类上使用静态方法时使用String,如String.Split()String.IsNullOrEmpty()。我认为这更有意义,因为这些方法属于一个类,并且与我使用其他静态方法的方式一致。

答案 53 :(得分:4)

string是System.String的快捷方式。唯一的区别是您不需要引用System.String命名空间。因此,使用字符串比使用String更好。

答案 54 :(得分:4)

您已经知道string只是System.String的别名。但是我该怎么用呢?只是个人喜好。

就我而言,我喜欢使用string而不是System.String,因为String需要名称空间using System;或全名System.String

所以我相信别名string是为简单起见而创建的,我喜欢它!

答案 55 :(得分:3)

通常的做法是使用C#关键字声明变量。 实际上,每种C#类型在.NET中都有一个等效项。再举一个例子,C#中的short和int映射到.NET中的Int16和Int32。因此,从技术上讲,string和String之间没有区别,但是 在C#中,字符串是.NET框架中String类的别名。

答案 56 :(得分:2)

以上所有内容基本上都是正确的。一个可以检查一下。只需写一个简短的方法

public static void Main()
{
    var s = "a string";
}

编译它并用.exe打开ildasm来查看

.method private hidebysig static void  Main(string[] args) cil managed
{
  .entrypoint
  // Code size       8 (0x8)
  .maxstack  1
  .locals init ([0] string s)
  IL_0000:  nop
  IL_0001:  ldstr      "a string"
  IL_0006:  stloc.0
  IL_0007:  ret
} // end of method Program::Main

然后将var更改为stringString,进行编译,并以ildasm打开,然后查看IL不变。它还显示了该语言的创建者在定义变量时更喜欢string(破坏者:在调用成员时,他们更喜欢String)。

答案 57 :(得分:2)

Stringstring的类。如果从using语句中删除System命名空间,则可以看到String已经消失,但string仍然在这里。 string是String的关键字。喜欢
 int and Int32
short and Int16
long and Int64

   因此,关键字只是使用类的某些单词。这些关键字由C#指定(因此是Microsoft,因为C#是Microsoft的)。简而言之,没有区别。使用string or String。没关系他们是一样的。

答案 58 :(得分:1)

从技术上讲,这两者是相同的,但略有不同。 “字符串”是数据类型,而“字符串”表示类。 “字符串”是System.String的别名。在执行时,两个都编译为相同的代码。语法荧光笔是另一个不同之处。

现在让我们检查一下代码片段以了解这两者。

    using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Text;  
    using System.Threading.Tasks;  
    namespace ConsoleApplication2  
    {  
        class Program  
        {  
            static void Main(string[] args)  
            {  
                string FirstName = ".Net";  
                String Lastname = "Snippets";  
                Console.WriteLine(FirstName + " " + Lastname);  
                Console.ReadLine();  
            }  
        }  
    }  

答案 59 :(得分:1)

C# 中的 stringString 之间没有重大区别。

String 是 .NET 框架中 System 命名空间中的一个类。完全限定名称是 System.String。小写字符串是 System.String 的别名。

但建议在声明变量时使用 string,例如:

string str = "Hello";

我们可以使用 String,同时对 String.IsNullOrEmpty() 之类的字符串使用任何内置方法。

这两者之间还有一个区别就是在使用 String 之前,我们必须在 cs 文件中导入系统命名空间,而 string 可以直接使用。

答案 60 :(得分:1)

使用string声明一个字符串变量,但是在访问其静态成员之一时使用String类:

String.Format()

变量

string name = "";

答案 61 :(得分:1)

许多新手C#程序员提出的问题之一是: “ string和String有什么区别?” 在C#中,字符串是.NET框架中String类的别名。实际上,每种C#类型在.NET中都有一个等效项。  再举一个例子,C#中的short和int映射到.NET中的Int16和Int32。

因此,从技术上讲,string和String之间没有区别,但是通常的做法是使用C#关键字声明变量。 我几乎没有看到有人用Int32声明一个整数! 唯一的微小区别是,如果您使用String类,则需要在文件顶部导入System命名空间,而在使用string关键字时则不必这样做。 许多开发人员更喜欢使用string声明一个字符串变量,但是在访问其静态成员之一时使用String类:

String.Format()

答案 62 :(得分:0)

C#中的字符串和字符串之间的区别

许多C#新手都会问的一个问题是:“字符串和字符串之间有什么区别?”

在C#中,字符串是.NET框架中String类的别名。实际上,每种C#类型在.NET中都有一个等效项。再举一个例子,C#中的short和int映射到.NET中的Int16和Int32。

因此,从技术上讲,string和String之间没有区别,但是通常的做法是使用C#关键字声明变量。我几乎没有看到有人用Int32声明整数!

仅有的微小区别是,如果使用String类,则需要在文件顶部导入System名称空间,而在使用string关键字时不必这样做。

许多开发人员更喜欢使用string声明一个字符串变量,但是在访问其静态成员之一时使用String类:String.Format()

在C#中创建类型别名:link

答案 63 :(得分:0)

它将编译:

public class MyClass<String>
{
}

这不是:

public class MyClass<string>
{
}

答案 64 :(得分:0)

有很多人(例如杰弗里·里希特(Jeffrey Richter)在他的书CLR Via C#中)说System.Stringstring之间没有区别,System.Int32和{{ 1}},但是我们必须对这个问题进行更深入的区分才能真正榨汁,这样我们才能从中获得所有营养价值(编写更好的代码)。

A。他们是一样的...

  1. 编译器。
  2. 给开发者。 (我们知道#1并最终实现了自动驾驶。)

B。它们在名气和非C#上下文中是不同的。不一样...

  1. 其他非C#语言
  2. 在优化的CIL(是MSIL)上下文(.NET VM汇编语言)中
  3. 在以平台为目标的上下文中-.NET Framework或Mono或任何CIL类型的区域
  4. 针对多种.NET语言(例如VB.NET,F#等)的书中

因此,真正的答案是仅因为C#必须与其他语言共同拥有.NET空间,这个问题甚至存在。

C。总结一下...

您在仅C#的目标受众中使用intstring以及其他C#类型(询问问题,谁将阅读此代码,或使用此库)。对于内部公司,如果仅使用C#,则请坚持使用C#类型。

...并且您在面向多语言或框架的受众中使用intSystem.String(当C#不是唯一的受众时)。对于您的内部组织,如果您还使用VB.NET或F#或任何其他.NET语言,或开发供可能使用的客户使用的库,则应在这些情况下使用“框架”类型,以便每个人都可以理解您的界面,无论它们来自什么宇宙。 (反正System.Int32的克林贡语是什么?)

HTH。

答案 65 :(得分:0)

好问题! 用简单的话来说:

string - is datatype 

String - Class Name

例如:

string Name="tata"; //datatype is string => Happy Compiler :)

String Name="tata"; //Unknown datatype => Unhappy Compiler :(

当您将鼠标悬停在String编译器上说要使用

时,这就是事情
System.String Name="tata";

不要困惑! 希望这会有所帮助!

答案 66 :(得分:-1)

字符串vs字符串www.javatpoint.com的图像结果 在C#中,string是.NET框架中String类的别名。实际上,每种C#类型在.NET中都有一个等效项。
另一个小差异是,如果使用String类,则需要导入System名称空间,而使用string关键字时不必导入名称空间

答案 67 :(得分:-5)

String只是String类的别名。如果你想使用字符串类的函数,那么你应该使用String,否则你应该坚持使用字符串。例如,如果要格式化字符串,则应使用String类来使用String.Format(),但如果您只想定义字符串,则应使用string test=""; 请注意,它们都是参考类型。