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

Question

示例（注意大小写）：

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

每种的使用指南是什么？有什么区别？

score 6728 · Accepted Answer

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

就准则而言，通常建议在string您引用对象的任何时候使用。

例如

string place = "world";

String同样，如果您需要专门引用该类，我认为通常建议使用它。

例如

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

这是微软在他们的例子中倾向于使用的风格。

看来这方面的指导可能已经改变，因为StyleCop现在强制使用 C# 特定别名。

score 3689 · Accepted Answer

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

正如其他人所指出的，string是的别名System.String。假设您的代码使用String编译为System.String（即您没有针对其他具有不同String类型的命名空间的 using 指令），它们编译为相同的代码，因此在执行时没有任何区别。这只是 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

除了stringand object，别名都是值类型。decimal是值类型，但不是 CLR 中的原始类型。唯一没有别名的原始类型是System.IntPtr.

在规范中，值类型别名被称为“简单类型”。字面量可用于每个简单类型的常量值；没有其他值类型具有可用的文字形式。（将此与 VB 进行比较，它允许DateTime文字，并且也有一个别名。）

在一种情况下，您必须使用别名：显式指定枚举的基础类型时。例如：

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类中。

score 791 · Accepted Answer

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

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

score 557 · Accepted Answer

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

我看到许多开发人员感到困惑，不知道在他们的代码中使用字符串还是字符串。因为在 C# 中，字符串（关键字）完全映射到 System.String（FCL 类型），所以没有区别，都可以使用。

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

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

score 495 · Accepted Answer

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

如果出于某种原因你想要一个名为string的变量，你只会看到这些编译中的第一个：

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

如果你真的想要一个名为string的变量名，你可以使用@它作为前缀：

StringBuilder @string = new StringBuilder();

另一个关键区别：Stack Overflow 以不同的方式突出显示它们。

score 434 · Accepted Answer

434

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

于 2008-08-27T18:21:37.670 回答

score 337 · Accepted Answer

337

上面已经介绍过了；但是，您不能string在反射中使用；你必须使用String.

于 2008-10-19T01:04:57.860 回答

score 293 · Accepted Answer

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

至于指导方针，我不会陷入困境，只使用你喜欢的任何一个 - 生活中有更重要的事情，无论如何代码都是一样的。

如果您发现自己构建的系统需要指定您正在使用的整数的大小并因此倾向于使用Int16, Int32,等UInt16，UInt32那么使用起来可能看起来更自然String- 当在不同的 .net 语言之间移动时它可能会让事情更容易理解——否则我会使用字符串和整数。

score 233 · Accepted Answer

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

条件和控制关键字（如if、switch和return）是小写的，颜色为深蓝色（默认情况下）。我宁愿没有使用和格式的分歧。

考虑：

String someString; 
string anotherString;

score 210 · Accepted Answer

string并且String在所有方面都是相同的（除了大写的“S”）。两种方式都没有性能影响。

string由于语法突出显示，大多数项目中首选小写

score 205 · Accepted Answer

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

string是 C# 中的一种类型。

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

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

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

score 203 · Accepted Answer

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

但现在是一个很长的文字答案。

当我们谈论.NET有两种不同的东西时，一种是框架，另一种是使用该框架.NET的语言（C#等）。VB.NET

在此处输入图像描述

“ System.String”又名“String”（大写“S”）是一种.NET框架数据类型，而“string”是一种C#数据类型。

在此处输入图像描述

简而言之，“字符串”是“字符串”的别名（相同的东西用不同的名称称呼）。所以从技术上讲，下面的两个代码语句都会给出相同的输出。

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() ;

score 183 · Accepted Answer

小写string是System.String. 它们在C#.

关于您应该使用系统类型（System.Int32、System.String等）还是C# aliases（int、等）类型存在争议string。我个人认为您应该使用C# aliases，但这只是我个人的偏好。

score 166 · Accepted Answer

string只是System.String. 编译器会对它们一视同仁。

唯一实际的区别是您提到的语法突出显示，using System如果您使用String.

score 153 · Accepted Answer

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

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

score 128 · Accepted Answer

正如其他人所说，他们是一样的。默认情况下，StyleCop 规则将强制您将其string用作 C# 代码样式最佳实践，除非在引用System.String静态函数时，例如String.Format, String.Join,String.Concat等...

score 116 · Accepted Answer

6 年零 5 个月后的新答案（拖延）。

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

我将提供using指令无济于事的两个示例。

首先，whenString是当前类型的值（或局部变量）：

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!";可能没问题（取决于命名空间和using指令）。

更糟糕的是：说String.Concat(someSequence)可能（取决于usings）去 Linq 扩展方法Enumerable.Concat。它不会转到静态方法string.Concat。

其次，whenString是另一种类型，嵌套在当前类型中：

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"无法转换为它。

score 105 · Accepted Answer

使用系统类型可以更容易地在 C# 和 VB.Net 之间进行移植，如果你喜欢这种东西的话。

score 94 · Accepted Answer

正如 Jon Skeet 所提到的，与其他程序员中似乎很常见的做法相比，我更喜欢String，string只是为了强调String引用类型这一事实。

score 87 · Accepted Answer

string是的别名（或简写）System.String。这意味着，通过键入string我们的意思是System.String. 您可以在 think link 中阅读更多内容：'string' 是 System.String 的别名/简写。

score 85 · Accepted Answer

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

C# 语言规范指出，“就风格而言，使用关键字优于使用完整的系统类型名称。” 我不同意语言规范；我更喜欢使用 FCL 类型名称并完全避免使用原始类型名称。事实上，我希望编译器甚至不提供原始类型名称，而是强制开发人员使用 FCL 类型名称。以下是我的理由：
我看到许多开发人员感到困惑，不知道在他们的代码中使用字符串 还是字符串。因为在 C# 中字符串（一个关键字）完全映射到 System.String（一个 FCL 类型），所以没有区别，都可以使用。同样，我听到一些开发人员说，当应用程序在 32 位操作系统上运行时， int表示 32 位整数，而当应用程序在 64 位操作系统上运行时，它表示 64 位整数。这种说法是绝对错误的：在 C# 中，一个int总是映射到System.Int32，因此它表示一个 32 位整数，而不管代码运行在什么操作系统上。如果程序员会使用Int32在他们的代码中，那么这种潜在的混淆也被消除了。

在 C# 中，long映射到System.Int64，但在不同的编程语言中，long 可以映射到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# 主义潜入类库代码中。例如，微软的 FCL 几乎完全是用 C# 编写的，FCL 团队的开发人员现在已经在库中引入了诸如 Array的GetLongLength之类的方法，它返回一个Int64值，在 C# 中是long但在其他语言中没有（如 C++ /CLI）。另一个例子是System.Linq.Enumerable的 LongCount方法。

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

score 75 · Accepted Answer

这是一个约定俗成的问题，真的。 string只是看起来更像 C/C++ 风格。一般约定是使用您选择的语言提供的任何快捷方式（int/Int for Int32）。这也适用于“对象” decimal。

从理论上讲，这可能有助于将代码移植到某些未来的 64 位标准中，其中“int”可能意味着Int64，但这不是重点，我希望任何升级向导都可以更改任何int引用以Int32确保安全。

score 75 · Accepted Answer

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

score 71 · Accepted Answer

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

score 70 · Accepted Answer

迟到：我 100% 的时间都使用 CLR 类型（好吧，除非被迫使用 C# 类型，但我不记得上次是什么时候）。

根据 Ritchie 的 CLR 书籍，我最初是在几年前开始这样做的。对我来说，所有 CLR 语言最终都必须能够支持一组 CLR 类型是有道理的，因此自己使用 CLR 类型可以提供更清晰、可能更“可重用”的代码。

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

唯一真正令人沮丧的是自动完成使用 C# 类型，所以我最终重新键入自动生成的类型来指定 CLR 类型。

另外，现在，当我看到“int”或“string”时，我觉得它真的很不对劲，就像我在看 1970 年代的 C 代码一样。

score 66 · Accepted Answer

@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是为许多完全有效的目的而定义的：反射帮助器、序列化库、词法分析器、协议等……对于这些库中的任何一个，Stringvs.都会string产生实际后果，具体取决于代码的使用位置。

所以请记住，当你看到String与string辩论的时候，这是关于语义的，而不是风格。选择字符串为您的代码库赋予了清晰的意义。选择String并没有错，但它为未来的惊喜敞开了大门。

注意：出于存档原因，我复制/粘贴了大部分博客文章。我忽略了一些部分，所以如果可以的话，我建议你跳过并阅读博客文章。

score 53 · Accepted Answer

没有区别。

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

同样，int映射到System.Int32。

score 50 · Accepted Answer

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

所有预定义类型都直接映射到基础 .NET 类型。C# 类型名称（字符串）只是 .NET 类型（String 或 System.String）的别名，因此在语法上使用 .NET 名称可以正常工作，尽管不鼓励这样做。在 C# 程序中，您应该使用 C# 名称而不是 .NET 名称。

score 44 · Accepted Answer

44

是的，它们之间没有区别，就像booland一样Boolean。

于 2012-10-08T08:22:11.047 回答

score 44 · Accepted Answer

string是关键字，不能使用 string 作为标识符。

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

例子

string String = "I am a string";

除了关键字问题之外，关键字string 是别名 System.String，两者完全相同。

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

score 36 · Accepted Answer

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

score 28 · Accepted Answer

一个没有在其他地方提到的更喜欢帕斯卡案例的论点String：

System.String是一个引用类型，并且引用类型的名称按照约定是帕斯卡大小写。

score 25 · Accepted Answer

两者都是一样的。区别在于你如何使用它。约定是，

s字符串用于变量

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

像：

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

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

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

score 22 · Accepted Answer

几乎没有区别

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

score 22 · Accepted Answer

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

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

这是因为stringis 是一个关键字（在这种情况下是别名），而Stringis 是一个类型。

其他别名也是如此。

| 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   |

score 16 · Accepted Answer

string如果真正看到and之间没有区别是有用的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 ]

score 15 · Accepted Answer

在 C# 中，string 是 System.String (String) 的简写版本。它们基本上是同一个意思。

bool和和一样Boolean，差别不大。。

score 14 · Accepted Answer

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

string指原始类型

在 C# 中，它们都编译为 String，但在其他语言中，它们不会，因此如果要处理 String 对象，则应使用 String；如果要处理文字，则应使用 string。

score 14 · Accepted Answer

您不需要使用导入命名空间（使用System;），string因为它是System.String.

要了解有关别名的更多信息，您可以查看此链接。

score 13 · Accepted Answer

首先，两者string&String不一样。有一个区别： String不是关键字，可以用作标识符，string而是关键字，不能用作标识符。

我试图用不同的例子来解释：首先，当我string s; 进入 Visual Studio 并将鼠标悬停在它上面时，我得到（没有颜色）：

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

score 10 · Accepted Answer

老实说，在实践中，System.String和之间通常没有区别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 社区。

score 10 · Accepted Answer

杰弗里·里希特写道：

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

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

我看到许多开发人员感到困惑，不知道在他们的代码中使用字符串还是字符串。因为在 C# 中字符串（一个关键字）完全映射到 System.String（一个 FCL 类型），所以没有区别，都可以使用。

score 9 · Accepted Answer

String： String 对象被称为不可变（只读），因为它的值一旦创建就无法修改。看似修改 String 对象的方法实际上会返回一个包含修改的新 String 对象。如果需要修改类字符串对象的实际内容

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

字符串和字符串的区别：

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

score 9 · Accepted Answer

两者没有区别。您可以在代码中使用它们中的任何一个。

System.Stringmscorlib是在命名空间中定义的类（引用类型）System。换句话说，System.String是CLR.

string是关键字C#

score 8 · Accepted Answer

在MSDN 文档的上下文中，String类的文档与BCL中的任何其他数据类型（例如, XmlReader）一样。StreamReader

并且string被记录为关键字（C# 参考）或任何基本的 C# 语言结构（例如, for, while, default）。

参考。

score 8 · Accepted Answer

正如所指出的，它们是同一件事，string只是String.

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

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

score 8 · Accepted Answer

string如果您这样写，则等于System.String在 VS2015 中：

System.String str;

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

string str;

score 8 · Accepted Answer

我更喜欢使用string这种类型，因为我不希望语法荧光笔将它与所有其他类混合在一起。虽然它是一个类，但它更像是一个基元，因此我认为不同的高亮颜色是合适的。

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

score 8 · Accepted Answer

字符串是用于表示文本的字符的顺序集合。

String 对象是表示字符串的 System.Char 对象的顺序集合；一个 System.Char 对象对应一个 UTF-16 代码单元。

String 对象的值是 System.Char 对象的顺序集合的内容，并且该值是不可变的（即，它是只读的）。

有关字符串不变性的详细信息，请参阅 msdn 中的不变性和 StringBuilder 类部分。

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

注意：答案是从 msdn 帮助部分中提取的。您可以在备注部分下的 msdn 字符串类主题中查看完整内容

score 8 · Accepted Answer

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

score 7 · Accepted Answer

据我所知，string这只是 , 的别名，而, , ...System.String也存在类似的别名.boolobjectintstringSystem;System.String

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

score 7 · Accepted Answer

7

String : 代表一个类

string : 代表一个别名

这只是 microsoft 的编码约定。

于 2016-12-11T00:38:13.490 回答

score 7 · Accepted Answer

如您所知string，它只是System.String. 但是我应该使用什么？这只是个人喜好。

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

所以我相信别名 string是为了简单而创建的，我喜欢它！

score 7 · Accepted Answer

string 是System.String. 唯一的区别是您不需要引用System.String命名空间。所以使用字符串比使用字符串更好。

score 7 · Accepted Answer

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

score 6 · Accepted Answer

string 是.NET Framework中String的别名。

“字符串”实际上在哪里System.String.

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

最好与您使用的那个保持一致。

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

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

score 6 · Accepted Answer

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

score 5 · Accepted Answer

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

String.Format()

多变的

string name = "";

score 5 · Accepted Answer

以上基本都是对的。可以检查一下。只写一个简短的方法

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

score 4 · Accepted Answer

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

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

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

string str = "Hello";

我们可以String在使用任何内置方法的同时使用字符串，例如String.IsNullOrEmpty().

这两者之间的另一个区别是在使用之前String我们必须在cs文件中导入系统名称空间，并且string可以直接使用。

score 3 · Accepted Answer

字符串与字符串的图像结果www.javatpoint.com 在 C# 中，是.NET 框架string中类的别名。String事实上，每种 C# 类型在 .NET 中都有对应的。
另一个小区别是，如果使用String类，则需要导入命名空间，而使用关键字System时则不必导入命名空间string

score 3 · Accepted Answer

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

A. 他们是一样的...

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

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

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

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

C. 总结...

您在仅限 C# 的目标受众中使用stringand和其他 C# 类型（询问问题，谁将阅读此代码或使用此库）。int对于您的内部公司，如果您只使用 C#，那么请坚持使用 C# 类型。

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

HTH。

score 1 · Accepted Answer

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

String是 .NET 框架中 System 命名空间下的一个类System.String，而小写字母string是 .NET 的别名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()方法。

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

63 回答 63

这是微软在他们的例子中倾向于使用的风格。

`string`vs.`String`不是风格辩论

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

63 回答 63

这是微软在他们的例子中倾向于使用的风格。

stringvs.String不是风格辩论

Related

Reference

`string`vs.`String`不是风格辩论