#0是C#中#1的别名。
所以从技术上讲，没有区别。就像#0vs.#1。

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

e. g.

string place = "world";

同样，我认为如果你需要特别引用类，通常建议使用String。

e. g.

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

这是Microsoft在他们的例子中倾向于使用的样式。

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

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

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

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

小写string是System.String的别名。在C#中是一样的。

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

关于在C#中使用提供的类型别名，我听过的最好的答案来自Jeffrey Richter在他的书CLR Via C#中。以下是他的3个原因：

• 我见过许多开发人员感到困惑，不知道在他们的代码中是使用字符串还是String。因为在C#中，字符串（关键字）精确映射到System. String（FCL类型），所以没有区别，两者都可以使用。
• 在C#中，长期映射到系统名称，但在不同的编程语言中，长期可以映射到Int16或Int32。事实上，C++ /CLI确实将long视为Int32。阅读一种语言源代码的人，如果习惯于使用不同的编程语言，很容易误解代码的意图。事实上，大多数语言甚至不会将长期视为关键字，也不会编译使用它的代码。
• FCL有许多方法，都将类型名作为方法名的一部分。例如，BinaryReader类型提供了可读布尔值、是否必读、读单曲等方法，系统转码类型提供了ToBoolean、ToInt32、到单人等方法。虽然写下面的代码是合法的，但是带有浮点数的行给我感觉很不自然，并且不明显这行是正确的：

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

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

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

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

有一点不同-你不能在没有using System;的情况下使用String。

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

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

考虑：

String someString;string anotherString;

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

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

由于语法高亮显示，小写string在大多数项目中是首选

string只是System.String的别名。编译器会同等对待它们。

唯一实际的区别是你提到的语法突出显示，如果你使用String，你必须写using System。

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

我可以说同样的关于（#0，#1）等。

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

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

为了完整起见，这里有一个相关信息的大脑转储…

正如其他人所指出的，string是System.String的别名。假设您使用String的代码编译为System.String（即您没有其他String类型的命名空间的使用指令），它们编译为相同的代码，因此在执行时没有任何区别。这只是C#中的别名之一。完整列表是：

object:  System.Objectstring:  System.Stringbool:    System.Booleanbyte:    System.Bytesbyte:   System.SByteshort:   System.Int16ushort:  System.UInt16int:     System.Int32uint:    System.UInt32long:    System.Int64ulong:   System.UInt64float:   System.Singledouble:  System.Doubledecimal: System.Decimalchar:    System.Char

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

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

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

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

这只是规范定义枚举声明的方式的问题-冒号之后的部分必须是整型生产，这是sbyte，byte，short，ushort，int，uint，long，ulong，char…的一个标记，而不是变量声明使用的byte0生产。它不表示任何其他区别。

最后，说到使用哪个：就我个人而言，我在任何地方都使用别名来实现，但任何API都使用CLR类型。你在实现方面使用什么真的不太重要——你的团队之间的一致性很好，但其他人不会关心。另一方面，如果你在API中引用类型，你必须以语言中立的方式这样做，这一点非常重要。名为ReadInt32的方法是明确的，而名为ReadInt的方法需要解释。例如，调用者可能使用的语言为Int16定义了int别名。的.NET框架设计者遵循这种模式，BitConverter、BinaryReader和Convert类中有很好的例子。

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

默认情况下，StyleCop规则将强制您使用string作为C#代码风格的最佳实践，除非引用System.String静态函数，例如String.Format、String.Join、String.Concat等…

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

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

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

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

StringBuilder @string = new StringBuilder();

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

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

#0是C#中的类型。

#0是CLR中的类型。

当您将C#与CLR#0一起使用时，将映射到#1。

理论上，您可以实现一个生成Java字节码的C#编译器。该编译器的合理实现可能会将#0映射到#1，以便与Java运行时库进行互操作。

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

C#语言规范指出，“就风格而言，关键字的使用优于使用完整的系统类型名称。”我不同意语言规范；我更喜欢使用FCL类型名称并完全避免使用原始类型名称。事实上，我希望编译器甚至没有提供原始类型名称，并强迫开发人员使用FCL以下是我的理由：

• 我看到许多开发人员感到困惑，不知道是否使用string或代码中的String。因为在C#字符串（关键字）中准确映射到系统名称（FCL类型），没有区别，两者都可以使用。类似地，我听到一些开发人员说int代表一个32位整数，当应用程序在32位操作系统上运行，并且它表示64位整数，当应用程序在64位操作系统上运行。这种说法绝对是错误的：在C#中，int总是映射系统名称，因此它表示一个32位整数，而不管操作系统如果程序员在他们的代码中使用Int32，那么这种潜力混乱也消除了。

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

• FCL有许多方法将类型名称作为其方法名称的一部分。对于例如，BinaryReader类型提供了可读布尔值、是否必读、读单曲，依此类推，系统转码类型提供了如下方法ToBoolean、ToInt32、到单人等等。尽管写以下内容是合法的代码，浮动的行对我来说感觉很不自然，而且该行并不明显正确：

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

• Many programmers that use C# exclusively tend to forget that other programminglanguages can be used against the CLR, and because of this, C#-isms creep into theclass library code. For example, Microsoft’s FCL is almost exclusively written in C# anddevelopers on the FCL team have now introduced methods into the library such asArray’s GetLongLength, which returns an Int64 value that is a long in C# but notin other languages (like C++/CLI). Another example is System.Linq.Enumerable’sLongCount method.

I didn't get his opinion before I read the complete paragraph.

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

与其他程序员的常见做法相反，我更喜欢String而不是string，只是为了强调String是引用类型的事实，正如Jon Skeet提到的那样。

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

string是System.String的别名（或速记）。这意味着，通过键入string，我们意味着System.String。您可以在思考链接中阅读更多信息：'string'是System. String的别名/缩写。

没有区别。

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

类似地，int映射到System.Int32。

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

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

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

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

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

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

一个在其他地方没有提到的参数更喜欢PASCAL情况String：

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

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

string表示原始类型

在C#中，它们都编译为String，但在其他语言中它们没有，所以如果你想处理String对象，你应该使用String，如果你想处理文字，你应该使用string。

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

有一个关于这个问题的引用来自丹尼尔·索利斯的书。

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

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

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

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

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

简而言之，“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”更合理。

string s = String.ToUpper() ;

几乎没有区别

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

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

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

string和String的区别：

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

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

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

示例

string String = "I am a string";

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

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

string是. NET Framework中String的别名。

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

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

不过，最好与你使用的哪一个保持一致。

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

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

据我所知，string只是System.String的别名，bool、object、int也有类似的别名……唯一细微的区别是，你可以使用string而不需要“使用System;”指令，而String需要它（否则你应该完整地指定System.String）。

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

在MSDN文档的上下文中，String类与BCL中的任何其他数据类型（e. g.、XmlReader、StreamReader）一样被记录。

string被记录为关键字（C#参考）或任何基本的C#语言结构（e. g.、for、while、default）。

参考

您不需要导入命名空间（使用System；）来使用string，因为它是System.String的全局别名。

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

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

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

我将提供两个例子#0指令没有帮助。

首先，当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!";可能是确定的（取决于命名空间和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"无法转换为它。

两者都是一样的，区别在于你如何使用它。#36825；，

<的trong>的tring用于变量

String用于调用其他String类方法

喜欢：

string fName = "John";string lName = "Smith";
string fullName = String.Concat(fName,lName);
if (String.IsNullOrEmpty(fName)){Console.WriteLine("Enter first name");}

如果真的看到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 ]

正如所指出的，它们是一样的，string只是String的别名。

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

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

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

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

string是C#中的关键字

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

C#中的所有类型都是对象，并且都派生自System.Object类。一个区别是字符串是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 trueMessageBox.Show((b.GetType() == typeof(String) && b.GetType() == typeof(string)).ToString()); // shows trueMessageBox.Show((c.GetType() == typeof(String) && c.GetType() == typeof(string)).ToString()); // shows trueMessageBox.Show((d.GetType() == typeof(String) && d.GetType() == typeof(string)).ToString()); // shows true

@JonSkeet在我的编译器中

public enum Foo : UInt32 { }

我有Visual Studio 2015社区。

String：表示一个类

字符串：表示别名

这只是微软的一个编码约定。

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

System.String str;

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

string str;

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

如果您右键单击string关键字并从上下文菜单中选择Go to definition，它会将您带到String类-这只是语法糖，但它提高了易读性。

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

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

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

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

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

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

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

就像bool和Boolean一样，没有太大的区别。

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

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

nameof(String); // compilesnameof(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   |

Jeffrey Richter写道：

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

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

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

首先，string和String并不相同。有一个区别：String不是关键字，它可以用作标识符，而string是关键字，不能用作标识符。

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

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

正如你已经知道的，string只是System.String的别名。但是我应该用什么呢？这只是个人偏好。

在我的例子中，我喜欢使用string而不是System.String，因为String需要命名空间using System;或全名System.String。

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

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

String是string的类。如果您从使用语句中删除System命名空间，您可以看到String已经消失，但string仍然存在。string是String的关键字。就像
int和Int32
短且int16
long和Int64
所以关键字只是一些使用类的单词。这些关键字由C#指定（所以是Microsoft，因为C#是Microsoft的）。简单地说，没有区别。使用string or String。那没关系。它们是一样的。

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

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

string vs.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 timeString s2 = 42; // Might error, might not, depends on the code

许多人会争辩说，虽然这在技术上是准确的，但使用String仍然可以，因为代码库定义此名称的类型非常罕见。或者，当定义String时，它是一个糟糕的代码库的标志。

[…]

您将看到String是为许多完全有效的目的定义的：反射帮助程序、序列化库、词法分析器、协议等……对于这些库中的任何一个，String与string都有实际的后果，具体取决于代码的使用位置。

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

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

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

String.Format()

变量

string name = "";

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

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

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

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

然后将var更改为string和String，编译，使用ildasm打开并查看IL没有更改。它还显示该语言的创建者在定义变量时只喜欢string（剧透：调用成员时他们更喜欢String）。

字符串vs String的图像结果www.javatpoint.com在C#中，string是. NET框架中String类的别名。事实上，每个C#类型在. NET中都有一个等效的。
还有一点不同是如果您使用String类，则需要导入System命名空间，而使用string关键字时则不必导入命名空间

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

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

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

嗯。

在C#中，string和String之间没有太大的区别。

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

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

string str = "Hello";

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

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

本质上，C#中的之间没有区别string和String。

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

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

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

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

至少有四个不同点：

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

2.如果没有“使用System”，您就无法使用String，因此使用“string”编写的代码较少。

3-'String'比'string'更好的命名约定，因为它是一个类型而不是变量。

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

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