示例（注意情况）：

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

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

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

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

例如

string place = "world";

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

例如

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

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

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

为了完整起见，这里有一些相关信息的摘要……

正如其他人指出的那样，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类。

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

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

我听说过的关于在C＃中使用提供的类型别名的最佳答案来自Jeffrey Richter在他的书CLR Via C＃中。这是他的3个原因：

• 我看到许多开发人员感到困惑，他们不知道在他们的代码中使用string还是String。因为在C＃中，字符串（关键字）精确地映射到System.String（FCL类型），所以没有区别，并且两者都可以使用。
• 在C＃中，long映射到System.Int64，但是在另一种编程语言中，long可以映射到Int16或Int32。实际上，C ++ / CLI实际上确实像Int32一样对待。如果某人阅读一种语言的源代码，如果习惯于使用另一种编程语言进行编程，则很容易会误解该代码的意图。事实上，大多数语言甚至不会把长的关键字，将无法编译代码，使用它。
• 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＃世界中陷于困境，但最终还是试图使我的代码看起来像框架代码。

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

如果由于某种原因您想要一个名为string的变量，那么您只会看到以下第一个编译：

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

如果您确实想要一个名为string的变量名，则可以将其@用作前缀：

StringBuilder @string = new StringBuilder();

另一个重要的区别：堆栈溢出以不同的方式突出显示它们。

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

上面已经讲过了；但是，您不能string进行反思；您必须使用String。

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

至于指导原则，我不会陷入困境，只要使用您喜欢的任何方式，生活中就会有更重要的事情，而且代码无论如何都将是相同的。

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

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

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

考虑：

String someString; 
string anotherString; 

string并且String在所有方面都相同（大写字母“ S”除外）。两种方式都不会影响性能。

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

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

string 是C＃中的类型。

System.String 是CLR中的一种。

与CLR一起使用C＃时，string将映射到System.String。

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

该YouTube视频实际上演示了它们之间的区别。

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

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

“ System.String”又名“字符串”（大写的“ S”）是.NET框架数据类型，而“字符串”是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等

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

避免混淆的第一件事是始终使用其中之一。但是从最佳实践的角度来看，当您进行变量声明时，最好使用“字符串”（小“ s”），并且将其用作类名时，则首选“字符串”（大写“ S”）。

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

string s = String.ToUpper() ;

小写字母string是的别名System.String。它们在中是相同的C#。

有过是否应使用系统类型（辩论System.Int32，System.String等）类型或C# aliases（int，string，等）。我个人认为您应该使用C# aliases，但这只是我个人的偏爱。

string只是的别名System.String。编译器将相同地对待它们。

唯一实际的不同是您提到的语法突出显示，using System如果使用则必须编写String。

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

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

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

6年零5个月后的新答案（精进）。

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

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

首先，when 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。

其次，when 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"不能转换为它。

使用System类型可以使在C＃和VB.Net之间进行移植更加容易，如果您喜欢这种事情的话。

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

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

我只想在Ritchers的书中将其添加到lfousts答案中：

C＃语言规范指出：“就样式而言，使用关键字胜于使用完整的系统类型名称。” 我不同意语言规范；我更喜欢使用FCL类型名称，而完全避免使用原始类型名称。实际上，我希望编译器甚至不提供原始类型名称，而强迫开发人员改用FCL类型名称。这是我的原因：

• 我看到许多开发人员感到困惑，他们不知道在他们的代码中使用string 还是String。因为在C＃中，字符串（关键字）完全映射到 System.String（FCL类型），所以没有区别，并且两者都可以使用。同样，我听过一些开发人员说，当应用程序在32位操作系统上运行时，int表示一个32位整数，而当应用程序在64位操作系统上运行时，它表示一个64位整数。该语句绝对是错误的：在C＃中，int始终映射到System.Int32，因此，无论代码运行在哪个OS上，它都表示一个32位整数。如果程序员会使用在其代码int32中，那么这种潜在的混乱也被消除了。

• 在C＃中，long映射到System.Int64，但是在另一种编程语言中，long 可以映射到Int16或Int32。实际上，C ++ / CLI确实将Int32视为长期使用。如果某人阅读一种语言的源代码，如果习惯于使用另一种编程语言进行编程，则很容易会误解该代码的意图。事实上，大多数语言甚至不会把长的关键字，将无法编译代码，使用它。

• 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＃原理潜入了类库代码中。例如，Microsoft的FCL几乎完全是用C＃编写的，并且FCL团队的开发人员现在已将方法引入到库中，例如 Array的GetLongLength，该方法返回的Int64值在C＃中很长，但在其他语言（例如C ++）中却不是/ CLI）。另一个示例是System.Linq.Enumerable的 LongCount方法。

在阅读全文之前，我没有听他的意见。

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

String不是关键字，可以用作标识符，string而是关键字，不能用作标识符。并且在功能上都相同。

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

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

迟到了：我100％的时间都使用CLR类型（嗯，除非被迫使用C＃类型，但我不记得上一次是什么时候）。

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

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

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

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

没有区别。

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

同样，int映射到System.Int32。

丹尼尔·索利斯（Daniel Solis）的书中有一个关于这个问题的报价。

所有预定义的类型都直接映射到基础.NET类型。C＃类型名称（字符串）只是.NET类型（字符串或System.String）的别名，因此尽管不建议使用.NET名称，但在语法上可以正常使用。在C＃程序中，应使用C＃名称而不是.NET名称。

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

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

例

string String = "I am a string";

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

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

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

@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并没有错，但它为将来的惊喜打开了大门。

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