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

就准则而言，通常建议在引用对象时随时使用。string

例如

string place = "world";

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

例如

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

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

看来，此领域的指南可能已更改，因为 StyleCop 现在强制使用 C# 特定的别名。

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

至于指导方针，我不会太陷入困境，随心所欲地使用——生活中有更重要的事情，无论如何代码都是一样的。

如果你发现自己在构建系统中需要指定你正在使用的整数的大小，因此倾向于使用、、等，那么使用起来可能看起来更自然——当在不同的 .net 语言之间移动时，它可能会使事情更容易理解——否则我会使用 string 和 int。Int16Int32UInt16UInt32String

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

关于是否应该使用系统类型（、等）类型或（、等）类型存在争议。我个人认为你应该使用 ，但这只是我个人的喜好。System.Int32System.StringC# aliasesintstringC# aliases

我听说过的关于在 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# 世界了，但我最终试图让我的代码看起来像框架代码。

这是一个惯例问题，真的。 只是看起来更像 C/C++ 风格。一般的约定是使用您选择的语言提供的任何快捷方式（int/Int 表示）。这适用于“对象”，也是如此。stringInt32decimal

从理论上讲，这可能有助于将代码移植到将来的某个 64 位标准中，其中“int”可能意味着 ，但这不是重点，我希望任何升级向导都会更改任何引用，只是为了安全起见。Int64intInt32

有一个区别 - 没有事先就无法使用。Stringusing System;

更新：

"String"with a capital 是一个关键字，它引用 .NET Framework 的基类库中的内置字符串数据类型。它是表示字符序列的引用类型。"S"

另一方面，小写是类型的别名，这意味着它们本质上是一回事。“string”的使用只是指代类型的一种简写方式，它在 C# 代码中更常用。"string""s""System.String""System.String"

两者在 C# 中是可以互换的，您可以使用其中任何一个来声明字符串类型的变量。"String""string"

String myString = "Hello World"; // using the String keyword
string myString = "Hello World"; // using the string alias

但是，建议在 C# 代码中使用别名，以便与语言的其余语法和约定保持一致。"string"

在这里，您可以阅读有关 C# 字符串的更多信息

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

条件关键字和控制关键字（如 、 和 ）为小写，颜色为深蓝色（默认）。我宁愿不要在使用和格式上有分歧。ifswitchreturn

考虑：

String someString; 
string anotherString; 

如果您喜欢这种事情，使用系统类型可以更轻松地在 C# 和 VB.Net 之间移植。

string并且在所有方面都相同（大写的“S”除外）。无论哪种方式，都不会对性能产生影响。String

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

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

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

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

我可以对（int，System.Int32）等说同样的话。

两者都是一样的。但从编码指南的角度来看，最好使用而不是 .这是开发人员通常使用的。例如，我们使用 as is 别名来代替stringStringInt32intintInt32

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

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

正如其他人所指出的，是 的别名。假设你的代码 using 编译为（即你没有针对其他不同类型的命名空间的 using 指令），它们编译为相同的代码，因此在执行时没有任何区别。这只是 C# 中的别名之一。完整列表如下：stringSystem.StringStringSystem.StringString

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

除了 和 之外，别名都是值类型。 是值类型，但不是 CLR 中的基元类型。唯一没有别名的基元类型是 。stringobjectdecimalSystem.IntPtr

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

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

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

这只是规范定义枚举声明的方式问题 - 冒号后面的部分必须是积分型生产，它是 、 、例如，与变量声明使用的类型生产相反。它并不表示任何其他差异。sbytebyteshortushortintuintlongulongchar

最后，当谈到使用哪个时：就我个人而言，我在实现中使用别名，但对任何 API 都使用 CLR 类型。在实现方面，你使用哪个并不重要——你的团队之间的一致性很好，但没有人会在乎。另一方面，如果你在 API 中引用某个类型，你要以与语言无关的方式进行引用，这一点非常重要。调用的方法是明确的，而调用的方法需要解释。例如，调用方可能使用定义 的别名的语言。.NET Framework 设计人员遵循了此模式，很好的示例位于 和 类中。ReadInt32ReadIntintInt16BitConverterBinaryReaderConvert

上面已经介绍过了;但是，您不能在反射中使用;您必须使用 .stringString

正如其他人所说，它们是一样的。默认情况下，StyleCop 规则将强制您用作 C# 代码样式最佳实践，除非引用静态函数（如 、 、 等）...stringSystem.StringString.FormatString.JoinString.Concat

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

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

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

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

StringBuilder @string = new StringBuilder();

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

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

string 是 C# 中的一种类型。

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

将 C# 与 CLR 一起使用时，字符串将映射到 System.String。

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

我只想把这个添加到 lfousts 的答案中，来自 Ritchers 的书：

C# 语言规范指出，“作为风格问题，关键字的使用优先于 使用完整的系统类型名称。我不同意语言规范;我更喜欢 使用 FCL 类型名称并完全避免使用原始类型名称。事实上，我希望 编译器甚至没有提供原始类型名称，并迫使开发人员使用 FCL 请改为键入名称。以下是我的原因：

• 我看到许多开发人员感到困惑，不知道在他们的代码中使用字符串还是字符串。因为在 C# 中，字符串（关键字）完全映射到 System.String（FCL 类型），所以没有区别，可以使用其中任何一个。同样地 我听过一些开发人员说 int 表示一个 32 位整数，当应用程序 在 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 等方法。 虽然写以下内容是合法的 代码，带有浮点数的行对我来说感觉很不自然，而且该行并不明显 正确：

  BinaryReader br = new BinaryReader(...);
  float val = br.ReadSingle(); // OK, but feels unnatural
  Single val = br.ReadSingle(); // OK and feels good
  

• 许多专门使用 C# 的程序员往往会忘记其他编程 语言可以用于 CLR，因此，C#-isms 悄悄进入 类库代码。例如，Microsoft 的 FCL 几乎完全是用 C# 编写的，并且 FCL 团队的开发人员现在已经将方法引入到库中，例如 Array 的 GetLongLength，它返回一个 Int64 值，该值在 C# 中为 long，但不是 在其他语言（如 C++/CLI）中。另一个示例是 System.Linq.Enumerable 的 LongCount 方法。

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

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

与其他程序员的常见做法相反，我更喜欢 ，只是为了强调一个引用类型，正如 Jon Skeet 所提到的。StringstringString

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

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

没有区别。

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

同样，映射到 .intSystem.Int32

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

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

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

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

唯一真正的缺点是自动完成使用 C# 类型，因此我最终重新键入自动生成的类型以指定 CLR 类型。

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

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

System.String是引用类型，引用类型名称按照约定为 Pascal 大小写。

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

string指基元类型

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

是的，它们之间没有区别，就像 和 .boolBoolean

丹尼尔·索利斯（Daniel Solis）的书中引用了这个问题。

所有预定义类型都直接映射到 基础 .NET 类型。C# 类型名称（字符串）只是 .NET 类型（String 或 System.String），因此使用 .NET 名称在语法上效果很好，尽管 不鼓励这样做。在 C# 程序中，应使用 C# 名称 而不是 .NET 名称。

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

但现在需要一个很长的文本答案。

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

"System.String“ 又名”字符串“（大写”S“）是框架数据类型，而”字符串“是数据类型。.NETC#

简而言之，“String”是“string”的别名（用不同的名称称呼相同的事物）。因此，从技术上讲，以下两个代码语句将给出相同的输出。

String s = "I am String";

或

string s = "I am String";

同样，其他 C# 数据类型也有别名，如下所示：

object： 、 string： 、 bool： 、 byte： 、 sbyte： 、 short： 等。System.ObjectSystem.StringSystem.BooleanSystem.ByteSystem.SByteSystem.Int16

现在，从程序员的角度来看，这是一个价值百万美元的问题：那么什么时候使用“字符串”和“字符串”呢？

避免混淆的第一件事是始终如一地使用其中之一。但从最佳实践的角度来看，当你进行变量声明时，最好使用“string”（小“s”），当你将其用作类名时，最好使用“String”（大写“S”）。

在下面的代码中，左侧是一个变量声明，它是使用“字符串”声明的。在右侧，我们正在调用一个方法，因此“String”更明智。

string s = String.ToUpper() ;

几乎没有区别

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

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

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

字符串和字符串之间的区别：

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

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

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

例

string String = "I am a string";

关键字是别名，除了关键字问题之外，两者完全是 等效。stringSystem.String

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

string 是 .NET Framework 中 String 的别名。

其中“String”实际上是System.String.

我想说的是，它们是可以互换的，在何时何地使用一个或另一个没有区别。

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

就其价值而言，我用它来声明类型 - 变量、属性、返回值和参数。这与其他系统类型的使用一致 - 等（尽管并且也是正确的）。stringint, bool, varInt32Boolean

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

据我所知，只是 的别名，并且存在类似的别名 ， ， ...唯一细微的区别是，你可以在没有“using ”指令的情况下使用，而 String 需要它（否则你应该完整指定）。stringSystem.StringboolobjectintstringSystem;System.String

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

在 MSDN 文档的上下文中，类与 BCL 中的任何其他数据类型（例如 、 ）一样被记录。StringXmlReaderStreamReader

并且像关键字（C# 参考）或任何基本的 C# 语言构造（例如，、、）一样记录。stringforwhiledefault

参考资料。

您不需要导入命名空间（使用 ;)因为它是 的全局别名。SystemstringSystem.String

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

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

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

我将举两个例子，说明使用指令无济于事。

---

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

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

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

上面的内容不会编译，因为没有名为 的非静态成员，并且没有应用扩展方法。在上述情况下，仍然可以在其他上下文中使用，其中类型在语法上是唯一的可能性。例如，可以（取决于命名空间和指令）。IEnumerable<>FormatStringString local = "Hi mum!";using

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

---

其次，什么时候是另一种类型，嵌套在当前类型中：String

class MyPiano
{
  protected class String
  {
  }

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

方法中的两个语句都不会编译。这里总是一根钢琴弦，.它上面不存在任何成员（或不存在成员）（或从其基类继承）。并且该值无法转换为它。ExampleStringMyPiano.StringstaticFormat"Goodbye"

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

string 用于变量

String 用于调用其他 String 类方法

喜欢：

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

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

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

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

如前所述，它们是一回事，只是 的别名。stringString

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

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

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

System.String是在命名空间中定义的类（引用类型）。换言之，是 中的类型。mscorlibSystemSystem.StringCLR

string是 中的关键字C#

老实说，在实践中，通常 和 之间没有区别。System.Stringstring

C# 中的所有类型都是对象，并且都派生自类。一个区别是 string 是 C# 关键字，您可以用作变量名称。 是这种类型的常规 .NET 名称，字符串是方便的 C# 名称。这是一个简单的程序，它显示了 和 string 之间的区别。System.ObjectStringSystem.StringSystem.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 社区。

String ：表示一个类

string ：表示别名

这只是微软的编码约定。

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

System.String str;

编译器将显示潜在的修复程序来优化它，并且在应用该修复程序后，它将如下所示

string str;

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

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

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

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

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

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

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

注意：答案摘自 msdn 帮助部分。您可以在“备注”部分下的 msdn 字符串类主题中查看完整内容

在 C# 中，string 是 System.String （String） 的简写版本。它们基本上意味着同样的事情。

就像和一样，没有太大区别..boolBoolean

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

和 之间有一个实际的区别。stringString

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

这是因为 is 关键字（在本例中为别名），而 is 类型。stringString

其他别名也是如此。

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

杰弗里·里希特（Jeffrey Richter）写道：

另一种思考方式是 C# 编译器自动 假设您在所有 源代码文件：using

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

我见过很多开发者一头雾水，不知道该不该用 string 或 String 在他们的代码中。因为在 C# 中字符串（关键字）映射 与 System.String（FCL 类型）完全一致，没有区别，并且 两者都可以使用。

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

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

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

如您所知，它只是 的别名。但是我应该使用什么呢？这只是个人喜好。stringSystem.String

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

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

string 是 的快捷方式。唯一的区别是不需要引用命名空间。所以使用 string 比使用 String 更好。System.StringSystem.String

String是 的类。如果从 using 语句中删除命名空间，您可以看到它已经消失，但仍然存在。 是 String 的关键字。像

这样，关键字只是一些使用类的单词。这些关键字由 C# 指定（所以 Microsoft，因为 C# 是 Microsoft 的）。简而言之，没有区别。用。没关系。它们是一样的。stringSystemStringstringstringint and Int32
short and Int16
long and Int64string or String

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

@JaredPar（C# 编译器的开发人员和多产的 SO 用户！）就此问题写了一篇很棒的博客文章。我认为值得在这里分享。这是对我们主题的一个很好的视角。

string与。 不是风格之争String

[...]

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

不过，该标识符在 C# 中没有具体含义。它是一个标识符，它通过所有名称查找规则，如、等......它可以绑定到字符串，也可以绑定到另一个程序集中的类型，其用途可能与 完全不同。更糟糕的是，它可以以这样的方式定义代码，如 ;继续编译。StringWidgetStudentstringString 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;
}

will 的实际含义始终取决于名称解析。 这意味着它依赖于项目中的所有源文件和所有 在所有引用的程序集中定义的类型。简而言之，它 需要相当多的上下文才能知道它的含义。String

诚然，在绝大多数情况下，将绑定到 相同的类型。但仍然使用意味着开发人员正在离开 他们的程序在只有一个的地方进行口译 正确答案。何时绑定到错误的类型，它可以离开 开发人员调试数小时，在编译器团队中提交错误，以及 通常浪费时间，而使用 .StringstringStringStringstring

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

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

许多人会争辩说，虽然这是信息，但在技术上是准确的，使用起来仍然没问题，因为代码库定义这种名称的类型是极其罕见的。或者，当被定义时，它是代码库错误的标志。StringString

[...]

你会看到它被定义为许多完全有效的目的：反射助手、序列化库、词法分析器、协议等......对于这些库中的任何一个，与。 根据代码的使用位置，会产生实际后果。StringStringstring

所以请记住，当你看到 vs. 争论这是关于语义，而不是风格。选择字符串会为您的代码库提供清晰的含义。选择没有错，但它为未来的惊喜敞开了大门。StringstringString

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

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

String.Format()

变量

string name = "";

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

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

编译并打开它查看.exeildasm

.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

然后改为 AND 、编译、打开方式和 SEE 不会改变。它还显示了语言的创建者在定义变量时更喜欢（剧透：在调用成员时，他们更喜欢）。varstringStringildasmILstringString

字符串与字符串的图像结果 www.javatpoint.com 在 C# 中，是 .NET Framework 中类的别名。事实上，每个 C# 类型在 .NET 中都有一个等效项。
另一个小区别是，如果你使用类，你需要导入命名空间，而当你使用关键字时，你不必导入命名空间stringStringStringSystemstring

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

一个。他们是一样的......

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# 的目标受众中使用 and 和其他 C# 类型（询问问题，谁将阅读此代码，或使用此库）。对于您的内部公司，如果您只使用 C#，请坚持使用 C# 类型。stringint

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

HTH。

在 C# 中，和 之间没有重大区别。stringString

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

但建议在声明以下变量时使用：string

string str = "Hello";

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

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

从本质上讲，在 C# 中 和 之间没有区别。stringString

String是 .NET Framework 中 System 命名空间中的一个类，而小写是 的别名。System.StringstringSystem.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

建议过度使用，但这确实是一个选择问题。大多数开发人员使用C#声明变量，并使用class来使用任何内置的字符串方法，例如，该方法。stringStringstringSystem.StringString.IsNullOrEmpty()

至少有 4 个区别：

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

2-你不能在没有“使用系统”的情况下使用字符串，所以你使用“字符串”编写的代码更少。

3-“字符串”比“字符串”更好的命名约定，因为它是一种类型，而不是可变的。

4- “string”是大多数编码编辑器中突出显示的 C# 关键字和语法，但不是“String”。

一个很好的方法是 string 是一种数据类型，其中 String 是一种类类型。每种方法都有不同的方法，使用哪一种取决于您的需要。

C# 中 string 和 String 之间的微小区别。字符串只是系统的别名。字符串。string 和 Strings 的编译方式相同。答案很简单。string 是关键字，提供有限的功能，主要使用字符串创建变量，如 （string name = “Abrar”）。或者我们可以说它是我们特别用于字母的数据类型。String 是一个类，它提供了一组丰富的函数和属性来操作字符串。希望你很容易理解。

在 C# 中，和 都用于表示字符串，但它们在上下文中的使用略有不同：Stringstring

1. 字符串（小写 s）：

   • 这是 C# 中的一个关键字。
   • 它是 .NET 类的别名。System.String
   • 您可以在 C# 代码中的任何位置使用它。

2. 字符串（大写 S）：

   • 这表示 .NET Framework 中的类。System.String
   • 要在不限定的情况下使用（使用大写字母 S），通常需要在代码文件的顶部有一个指令;否则，您需要将其用作 .Stringusing System;System.String

下面是一个快速比较：

• 初始化：

  string s1 = "Hello";
  System.String s2 = "World";
  

• 方法用法：

  string s1 = "hello";
  int length = s1.Length; // Using the string keyword
  
  String s2 = "world";
  int length2 = s2.Length; // Using the String class
  

实际差异：

• 在功能方面，它们之间没有区别。在下面，它们都表示 .NET 中的同一类。System.String

• 它更像是一种样式偏好，尽管（小写）由于其更简洁的性质而更常用于变量声明，而（大写）在静态方法调用中经常出现，例如，尽管两者都不少见。stringStringString.IsNullOrEmpty(...)string.IsNullOrEmpty(...)

• C# 语言还具有其他类型的类似关键字到类的映射，例如 （）、（） 和 （）。intSystem.Int32floatSystem.SingleboolSystem.Boolean