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

Question

示例(注意案例):

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

每种使用的准则是什么？有什么区别？

Answer 1

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

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

例如

string place = "world";

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

例如

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

这是Microsoft在其示例中倾向于使用的样式.

看来这个领域的指导可能已经改变,因为StyleCop现在强制使用C#特定的别名.

Answer 2

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

正如其他人所说,string是别名System.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

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

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

在某种情况下,您必须使用别名:明确指定枚举的基础类型时.例如:

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

这只是一个的规范定义枚举声明的方式事情-冒号后的部分必须是整体式的生产,这是一个标志sbyte,byte,short,ushort,int,uint,long,ulong,char...,而不是一个类型生产为例如,由变量声明使用.它并不表示任何其他差异.

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

Answer 3

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

我可以对(int,System.Int32)等说同样的话.

Answer 4

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

• 我看到许多开发人员感到困惑,不知道是否在他们的代码中使用字符串或字符串.因为在C#中,字符串(关键字)完全映射到System.String(一种FCL类型),所以没有区别,任何一种都可以使用.
• 在C#中,长映射到System.Int64,但是在不同的编程语言中,long可以映射到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#世界,但我最终试图使我的代码看起来像框架代码.

Answer 5

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

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

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

如果你真的想要一个名为string的变量名,你可以@用作前缀:

StringBuilder @string = new StringBuilder();

另一个重要区别:Stack Overflow以不同的方式强调它们.

Answer 6

有一个区别 -你不能使用String没有using System;事先.

Answer 7

它已被覆盖; 但是,你不能用于string反思; 你必须使用String.

Answer 8

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

至于指导方针,我不会陷入困境,只是使用你想要的任何东西 - 生活中有更重要的事情,无论如何代码都是一样的.

如果你发现自己构建的系统中,需要指定要使用的整数的大小,因此倾向于使用Int16,Int32,UInt16,UInt32等那么它可能看起来更自然的使用String-和不同的.NET语言之间来回移动时,它可能让事情更容易理解 - 否则我会使用string和int.

Answer 9

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

条件和控制关键字(如if,, switch和return)是小写的,并且是深蓝色(默认情况下).我宁愿在使用和格式方面没有分歧.

考虑:

String someString; 
string anotherString; 

Answer 10

string并且String在所有方面都是相同的(除了大写的"S").无论如何都没有性能影响.

string由于语法高亮,大多数项目都首选小写

Answer 11

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

string 是C#中的一个类型.

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

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

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

Answer 12

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

但现在需要长篇文章答案.

当我们谈论.NET有两个不同的东西一个有.NET框架和其他有语言(C#,VB.NET等等),它使用的框架.

" System.String"aka"String"(大写"S")是.NET框架数据类型,而"string"是C#数据类型.

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

String s = "I am String";

要么

string s = "I am String";

同样,其他c#数据类型也有别名,如下所示: -

object:System.Object,string:System.String,bool:System.Boolean,byte:System.Byte,sbyte:System.SByte,short:System.Int16依此类推

从程序员的角度来看,这个百万美元的问题那么何时使用"String"和"string"？

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

在下面的代码中,左侧是变量声明,它使用"string"声明.在右侧,我们调用一种方法,因此"字符串"更明智.

string s = String.ToUpper() ;

Answer 13

小写string是别名System.String.它们是相同的C#.

有过是否应使用系统类型(辩论System.Int32,System.String等)类型或C# aliases(int,string,等).我个人认为你应该使用C# aliases,但这只是我个人的偏好.

Answer 14

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

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

Answer 15

两者都是一样的.但从编码指南的角度来看,最好使用string而不是String.这是开发人员通常使用的.例如,而不是使用Int32我们使用intas intasiasInt32

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

Answer 16

正如其他人所说,他们是一样的.了StyleCop规则,默认情况下,将强制你使用string的C#代码风格的最佳实践,引用时除外System.String静态函数,如String.Format,String.Join,String.Concat,等...

Answer 17

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在其他上下文中使用,其中类型是语法上唯一的可能性.例如,String local = "Hi mum!";可以是OK(取决于命名空间和using指令).

更糟糕的是:说String.Concat(someSequence)可能(取决于usings)转到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始终是一个钢琴弦,MyPiano.String.不存在任何成员(static或不Format存在)(或从其基类继承).而且价值"Goodbye"无法转化为它.

Answer 18

使用系统类型可以更容易地在C#和VB.Net之间进行移植,如果你是这样的话.

Answer 19

反对什么似乎其他程序员是常有的事,我更喜欢String过string,只是为了强调一个事实,即String是引用类型,如乔恩斯基特提及.

Answer 20

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

Answer 21

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

C#语言规范指出,"作为一种风格问题,使用关键字比使用完整的系统类型名称更受青睐."我不同意语言规范; 我更喜欢使用FCL类型名称并完全避免基本类型名称.实际上,我希望编译器甚至不提供原始类型名称,并强迫开发人员使用FCL类型名称.这是我的理由:

• 我看到许多开发人员感到困惑,不知道是否在他们的代码中使用字符串 或字符串.因为在C#string(一个关键字)中精确映射到 System.String(一种FCL类型),所以没有区别,任何一种都可以使用.类似地,我听说有些开发人员说当应用程序在32位操作系统上运行时,int表示32位整数,当应用程序在64位操作系统上运行时,它表示64位整数.这句话绝对是错误的:在C#中,int总是映射到System.Int32,因此它表示一个32位整数,而不管代码运行的操作系统如何.如果程序员在他们的代码中使用Int32,那么这种潜在的混淆也会被消除.

• 在C#中,长映射到System.Int64,但是在不同的编程语言中,long 可以映射到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
  

• 许多使用C#的程序员都倾向于忘记可以使用其他编程语言来对抗CLR,因此,C#-isms会进入类库代码.例如,微软的FCL几乎全部用C#编写,FCL团队的开发人员现在已经在库中引入了方法,例如 Array的GetLongLength,它返回一个在C#中很长的Int64值,但在其他语言中却没有(比如C++)/CLI).另一个例子是System.Linq.Enumerable的 LongCount方法.

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

Answer 22

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

Answer 23

String不是关键字,它可以用作标识符,string而是关键字,不能用作标识符.并且在功能上看两者都是一样的.

Answer 24

聚会迟到:我100%使用CLR类型(好吧,除非被迫使用C#类型,但我不记得最后一次是什么时候).

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

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

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

而且,现在,当我看到"int"或"string"时,我看起来真的很不对劲,就像我在看1970年代的C代码一样.

Answer 25

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

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

Answer 26

没有区别.

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

同样,int映射到System.Int32.

Answer 27

Daniel Solis的书中引用了这个问题.

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

Answer 28

string是关键字,您不能使用string作为标识符.

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

例

string String = "I am a string";

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

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

Answer 29

是的,他们之间没有区别,就像bool和Boolean.

Answer 30

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

Answer 31

在其他地方没有提到的一个论点更喜欢pascal案例String:

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

Answer 32

@JaredPar（C＃编译器的开发者和多产的SO用户！）就此问题撰写了一篇很棒的博客文章。我认为值得在这里分享。这是关于我们主题的一个很好的观点。

stringvs. String不是一场风格辩论

[...]

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

标识符String虽然在C＃中没有具体含义。它是通过所有的名字查找规则推移的标识符Widget，Student等...它可以结合串或者它可以结合到一个类型在另一组件完全其目的可以比完全不同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将始终取决于名称解析。这意味着它取决于项目中的所有源文件以及所有引用的程序集中定义的所有类型。简而言之，要了解它的含义需要相当多的上下文。

确实，在绝大多数情况下String，string它将绑定到相同类型。但是使用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与string具有真正的影响取决于在代码中使用。

因此，请记住，当您看到Stringvs. string辩论时，这是关于语义而不是样式的。选择字符串可使代码库具有清晰的含义。选择String并没有错，但它为将来的惊喜打开了大门。

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

Answer 33

两者都是一样的.区别在于你如何使用它.公约是,

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");
}

Answer 34

实际上没有区别

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

Answer 35

string和之间有一个实际的区别String.

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   |

Answer 36

如果确实看到string和之间没有区别是有用的System.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 ]

Answer 37

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

string 指原始类型

在C#中,它们都编译为String,但在其他语言中它们不是,因此如果要处理String对象,则应使用String,如果要处理文字,则应使用字符串.

Answer 38

您不需要使用import namespace(using System;),string因为它是全局别名System.String.

要了解有关别名的更多信息,请查看此链接.

Answer 39

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

我试图用不同的例子来解释:首先,当我把"string s"时 进入Visual Studio并将鼠标悬停在它上面(没有颜色):

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

Answer 40

杰弗里里希特写道:

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

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

我看到许多开发人员感到困惑,不知道是否在他们的代码中使用字符串或字符串.因为在C#string(一个关键字)中精确映射到System.String(一种FCL类型),所以没有区别,任何一种都可以使用.

Answer 41

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

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

string&String之间的区别:

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

Answer 42

说实话,在实践中,System.String和string之间通常没有区别.

C#中的所有类型都是对象,所有类型都派生自System.Object类.一个区别是string是一个C#关键字,String可以用作变量名.System.String是这种类型的传统.NET名称,字符串是方便的C#名称.这是一个简单的程序,它显示了System.String和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社区.

Answer 43

在的上下文MSDN文档,String类是记录像任何其它数据类型(例如,XmlReader,StreamReader)在BCL.

并string进行了说明像关键字(C#参考)或类似的任何基本的C#语言构造(例如,for,while,default).

参考.

Answer 44

正如所指出的,它们是同一个东西,string只是一个别名String.

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

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

Answer 45

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

System.String是mscorlib命名空间中定义的类(引用类型)System.换句话说,System.String是一种类型CLR.

string 是一个关键字 C#

Answer 46

如果你写这个,字符串等于VS2015中的System.String

System.String str;

比编译器将显示优化它的潜在修复,并在应用该修复后它将看起来像这样

string str;

Answer 47

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

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

Answer 48

一个字符串是一个连续的字符集,用来表示文本.

甲字符串对象是System.Char对象的有序集合表示的字符串; System.Char对象对应于UTF-16代码单元.

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

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

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

注意:答案摘自msdn帮助部分.您可以在备注部分下的msdn String Class主题中查看完整内容

Answer 49

在C#中,string是System.String(String)的简短版本.它们基本上意味着同样的事情.

就像有人提到的那样,它就像,bool并Boolean没有太大的区别......

Answer 50

据我所知,string只是一个别名System.String,并存在类似的别名bool,object,int...唯一的细微差别是,你可以使用string不带"使用System;"指令,而字符串需要它(否则你应该指定System.String全) .

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

Answer 51

字符串：代表一个类

字符串：代表别名

这只是Microsoft的编码约定。

Answer 52

string是的简称System.String。 String或是System.String中的字符串名称CTS(Common Type System)。

Answer 53

string是.NET Framework中String的别名。

实际上是“字符串” System.String.

我要说的是它们是可互换的，在何时何地使用一种或另一种没有什么区别。

最好与您使用过的一致。

对于它的价值，我string用来声明类型-变量，属性，返回值和参数。这与其他系统类型（int, bool, var等等）的使用是一致的（尽管Int32并且Boolean也是正确的）。

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

Answer 54

如您所知string，只是的别名System.String。但是我该怎么用呢？这只是个人喜好。

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

因此，我相信别名 string是为简单起见而创建的，我喜欢它！

Answer 55

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

Answer 56

String是 的类string。如果您System从 using 语句中删除命名空间，您可以看到它String已经消失但string仍然存在。string是字符串的关键字。Like 所以关键字只是一些使用类的词。这些关键字是由 C# 指定的（所以是 Microsoft，因为 C# 是 Microsoft 的）。简而言之，没有区别。使用. 那没关系。他们是一样的。
int and Int32
short and Int16
long and Int64
string or String

Answer 57

以上基本都是正确的。可以查一查。只写一个简短的方法

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为stringand String，编译，打开 withildasm并查看IL没有变化。它还显示语言的创建者更喜欢string在定义变量时（剧透：在调用他们喜欢的成员时String）。

Answer 58

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

Answer 59

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

String.Format()

多变的

string name = "";

Answer 60

有很多人（例如 Jeffrey Richter 在他的书《CLR Via C# 》中）说System.String和string、以及 和System.Int32之间没有区别int，但我们必须更深入地区分，才能真正从这个问题中榨取汁液，这样我们就可以得到所有内容它的营养价值（编写更好的代码）。

答：他们是一样的...

1. 给编译器。
2. 给开发商。（我们知道#1并最终实现自动驾驶。）

B. 它们在 Famework 和非 C# 上下文中不同。不同的...

1. 到非 C# 的其他语言
2. 在优化的 CIL（是 MSIL）上下文中（.NET VM 汇编语言）
3. 在面向平台的上下文中——.NET Framework 或 Mono 或任何 CIL 类型区域
4. 在一本针对多种 .NET 语言（例如 VB.NET、F# 等）的书中

因此，真正的答案是，只是因为 C# 必须与其他语言共同拥有 .NET 空间，所以这个问题才存在。

C、总结一下...

您可以在仅限 C# 的目标受众中使用string和int以及其他 C# 类型（提出问题，谁将阅读此代码或使用此库）。对于您的内部公司，如果您只使用 C#，则坚持使用 C# 类型。

...并且您在多语言或框架目标受众中使用System.Stringand System.Int32（当 C# 不是唯一受众时）。对于您的内部组织，如果您还使用 VB.NET 或 F# 或任何其他 .NET 语言，或者开发供可能使用的客户使用的库，那么您应该在这些上下文中使用“Frameworky”类型，以便每个人都可以理解您的界面，无论他们来自哪个宇宙。（克林贡语System.String到底是做什么用的？）

HTH。

Answer 61

stringC#和C#之间没有重大区别String。

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

但建议string在声明变量时使用，例如：

string str = "Hello";

我们可以使用Stringwhile 对字符串使用任何内置方法，例如String.IsNullOrEmpty().

另外这两者的一个区别就是使用之前String我们必须在cs文件中导入系统命名空间，然后string才能直接使用。

Answer 62

本质上， C#和C#之间没有区别 。stringString

String是 .NET 框架中 System 命名空间下的一个类System.String，而小写string是 的别名System.String。

记录两种类型的全名可以证明这一点

string s1= "hello there 1";
String s2 = "hello there 2";
        
Console.WriteLine(s1.GetType().FullName); // System.String
Console.WriteLine(s2.GetType().FullName); // System.String

建议使用stringover String，但这确实是一个选择的问题。大多数开发人员习惯string在 C# 中声明变量，并使用System.String类来使用任何内置字符串方法，例如方法String.IsNullOrEmpty()。