.net:c#中的String和String有什么区别?


例子(注意案例):

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

每种方法的使用指南是什么?有什么不同呢?

相关讨论

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

至于指南，通常建议在引用对象时使用string。

如。

1
string place ="world";

同样，如果您需要特别引用该类，我认为一般建议使用String。

如。

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

这是微软在他们的示例中倾向于使用的样式

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

相关讨论

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

正如其他人所指出的，string是System.String的别名。它们编译成相同的代码，因此在执行时没有任何区别。这只是c#中的别名之一。完整名单如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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。

在规范中，值类型别名称为"简单类型"。文字可以用于任何简单类型的常量值;没有其他值类型具有可用的文字形式。(与VB相比，VB允许DateTime文字，并且也有别名。)

有一种情况必须使用别名:当显式地指定枚举的基础类型时。例如:

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

这只是规范定义enum声明的方式问题——冒号后面的部分必须是整型产品，它是sbyte、byte、short、ushort、int、uint、long、ulong、char的一个标记……例如，与变量声明中使用的类型生成相反。它没有显示任何其他的区别。

最后，当涉及到使用哪个时:就我个人而言，我在实现中到处都使用别名，但是对于任何api都使用CLR类型。在实现方面使用什么并不重要——团队之间的一致性很好，但是没有人会在意。另一方面，如果您在API中引用类型，那么以一种语言中立的方式引用类型是非常重要的。一个名为ReadInt32的方法是明确的，而一个名为ReadInt的方法需要解释。例如，调用者可以使用为Int16定义int别名的语言。. net框架设计人员遵循了这种模式，BitConverter、BinaryReader和Convert类中有很好的例子。

相关讨论

String代表System.String，它是. net框架类型。string是c#语言中用于System.String的别名。它们都是用IL(中间语言)编译成System.String的，所以没有区别。选择你喜欢的，然后使用它。如果您使用c#编写代码，我更喜欢string，因为它是一个c#类型别名，c#程序员都知道它。

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

相关讨论

关于在c#中使用所提供的类型别名，我所听到的最佳答案来自Jeffrey Richter在他的书CLR Via c#中。以下是他的三个理由:

I've seen a number of developers confused, not knowing whether to use string or String in their code. Because in C# the string (a keyword) maps exactly to System.String (an FCL type), there is no difference and either can be used.
In C#, long maps to System.Int64, but in a different programming language, long could map to an Int16 or Int32. In fact, C++/CLI does in fact treat long as an Int32. Someone reading source code in one language could easily misinterpret the code's intention if he or she were used to programming in a different programming language. In fact, most languages won't even treat long as a keyword and won't compile code that uses it.
The FCL has many methods that have type names as part of their method names. For example, the BinaryReader type offers methods such as ReadBoolean, ReadInt32, ReadSingle, and so on, and the System.Convert type offers methods such as ToBoolean, ToInt32, ToSingle, and so on. Although it's legal to write the following code, the line with float feels very unnatural to me, and it's not obvious that the line is correct:

1
2
3
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的变量，你只会看到其中的第一个编译:

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

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

1
StringBuilder @string = new StringBuilder();

另一个关键区别是:堆栈溢出以不同的方式突出显示它们。

相关讨论

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

相关讨论

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

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

至于指导方针，我不会陷得太深，只要你喜欢就好了——生活中还有更重要的事情，代码也会是一样的。

如果你发现自己构建系统,有必要指定要使用整数的大小,所以倾向于使用Int16, Int32, UInt16、UInt32等那么就会更自然的使用String -当移动之间不同的。net语言可能会让事情更容易理解,否则我会使用字符串和整数。

相关讨论

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

条件和控制关键字(如if、switch和return)为小写，颜色为深蓝色(默认情况下)。我不希望在使用和格式上有分歧。

考虑:

1
2
String someString;
string anotherString;
相关讨论

string和String在所有方面都是相同的(大写字母"S"除外)。这两种方法都不影响性能。

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

相关讨论

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

string是c#中的一种类型。

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

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

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

相关讨论

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

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

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

enter image description here

a.k."System.String"。"String"(大写"S")是.NET框架数据类型，而"String"是C#数据类型。

enter image description here

简言之，"String"是"String"的别名(用不同的名称调用相同的东西)。因此，从技术上讲，下面的代码语句将给出相同的输出。

1
String s ="I am String";

或

1
string s ="I am String";

同样，还有其他c#数据类型的别名，如下所示:-

对象:System.Object、字符串:System.String、bool: System.Boolean、字节:System.Byte、sbyte: System.SByte、short: System.Int16等等

现在，从程序员的角度来看，最重要的问题是什么时候使用"String"和"String" ?

避免混淆的第一件事是始终使用其中之一。但是从最佳实践的角度来看，当您进行变量声明时，最好使用"string"(小写的"s")，当您使用它作为类名时，则首选"string"(大写的"s")。

在下面的代码中，左边是一个变量声明，它使用"string"声明。在右边，我们正在调用一个方法，因此"String"更合理。

1
string s = String.ToUpper() ;
相关讨论

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

惟一的实际区别是您提到的语法高亮显示，如果使用String，则必须编写using System。

相关讨论

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

对于应该使用系统类型(System.Int32、System.String等)还是使用C# aliases (int、string等)，存在争议。我个人认为你应该使用C# aliases，但那只是我个人的偏好。

相关讨论

两者都是相同的。但是从编码准则的角度来看，使用string比使用String更好。这是开发人员通常使用的方法。例如，我们不使用Int32而是使用int，因为int是Int32的别名。

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

就像其他人说的，它们是一样的。默认情况下，StyleCop规则将强制您使用string作为c#代码风格的最佳实践，除非引用System.String静态函数，如String.Format、String.Join、String.Concat等……

相关讨论

使用系统类型可以更容易地在c#和VB之间进行移植。如果你对这类事情感兴趣的话。

相关讨论

与其他程序员中常见的实践相反，我更喜欢String而不是string，这只是为了强调一个事实，即String是引用类型，正如Jon Skeet所提到的。

string是System.String的别名(或简写)。这意味着，通过输入string，我们的意思是System.String。您可以在think链接中阅读更多信息:"string"是System.String的别名/缩写。

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

我想补充一下lfousts的回答，来自Ritchers的书:

The C# language specification states,"As a matter of style, use of the keyword is favored over
use of the complete system type name." I disagree with the language specification; I prefer
to use the FCL type names and completely avoid the primitive type names. In fact, I wish that
compilers didn’t even offer the primitive type names and forced developers to use the FCL
type names instead. Here are my reasons:

I’ve seen a number of developers confused, not knowing whether to use string
or String in their code. Because in C# string (a keyword) maps exactly to
System.String (an FCL type), there is no difference and either can be used. Similarly,
I’ve heard some developers say that int represents a 32-bit integer when the application
is running on a 32-bit OS and that it represents a 64-bit integer when the application
is running on a 64-bit OS. This statement is absolutely false: in C#, an int always maps
to System.Int32, and therefore it represents a 32-bit integer regardless of the OS the
code is running on. If programmers would use Int32 in their code, then this potential
confusion is also eliminated.

In C#, long maps to System.Int64, but in a different programming language, long
could map to an Int16 or Int32. In fact, C++/CLI does treat long as an Int32.
Someone reading source code in one language could easily misinterpret the code’s
intention if he or she were used to programming in a different programming language.
In fact, most languages won’t even treat long as a keyword and won’t compile code
that uses it.

The FCL has many methods that have type names as part of their method names. For
example, the BinaryReader type offers methods such as ReadBoolean, ReadInt32,
ReadSingle, and so on, and the System.Convert type offers methods such as
ToBoolean, ToInt32, ToSingle, and so on. Although it’s legal to write the following
code, the line with float feels very unnatural to me, and it’s not obvious that the line is
correct:

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

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

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

迟到:我100%的时间都在使用CLR类型(好吧，除非被迫使用c#类型，但我不记得上次是什么时候)。

我最初是在几年前开始做的，根据里奇的CLR书籍。对我来说，所有CLR语言最终都必须能够支持一组CLR类型是有意义的，所以您自己使用CLR类型可以提供更清晰的、可能更"可重用"的代码。

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

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

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

相关讨论

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

这是惯例问题，真的。string看起来更像C/ c++风格。一般惯例是使用您选择的语言提供的任何快捷方式(int/ int for Int32)。这同样适用于"object"和decimal。

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

没有区别。

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

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

相关讨论

6年零5个月后的新答案(拖延)。

string是一个保留的c#关键字，它总是有一个固定的含义，而String只是一个普通的标识符，它可以引用任何东西。根据当前类型、当前名称空间和应用的using指令的成员及其位置，String可以是与global::System.String不同的值或类型。

我将提供两个using指令不起作用的例子。

首先，当String是当前类型的值(或局部变量)时:

1
2
3
4
5
6
7
8
9
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)很可能(取决于using)转到Linq扩展方法Enumerable.Concat。它不会转到静态方法string.Concat。

其次，当String是另一种类型时，嵌套在当前类型中:

1
2
3
4
5
6
7
8
9
10
11
12
class MyPiano
{
  protected class String
  {
  }

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

Example方法中的任何语句都不能编译。这里String总是一根钢琴弦，MyPiano.String。它上面不存在成员(static或不存在)(或从基类继承)。值"Goodbye"不能转换为它。

相关讨论

丹尼尔·索利斯(Daniel Solis)的书中有一段关于这个问题的引文。

All the predefined types are mapped directly to
underlying .NET types. The C# type names (string) are simply aliases for the
.NET types (String or System.String), so using the .NET names works fine syntactically, although
this is discouraged. Within a C# program, you should use the C# names
rather than the .NET names.

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

字符串不是关键字，你可以用它作为标识符:

例子

1
string String ="I am a string";

关键字string是…的别名System.String除了关键字问题外，这两个问题是完全相同的等价的。

1
 typeof(string) == typeof(String) == typeof(System.String)
相关讨论

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

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

有一个参数没有在其他地方提到，更喜欢pascal case String:

System.String是一个引用类型，按照惯例，引用类型名是pascal case。

相关讨论

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

字符串用于变量

String用于调用其他String类方法

如:

1
2
3
4
5
6
7
8
9
string fName ="John";
string lName ="Smith";

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

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

实际上没有区别

c#关键字字符串映射到. net类型系统。字符串——它是一个别名，保持了该语言的命名约定。

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

string引用一个基本类型

在c#中，它们都编译成String，但在其他语言中，它们不编译成String，所以如果想处理String对象，应该使用String;如果想处理文字，应该使用String。

相关讨论

如果真的看到string和System.String之间没有区别是有用的:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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字节数组:

1
[ 0, 114, 107, 0, 0, 112, 10, 6, 11, 43, 0, 7, 42 ]
相关讨论

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

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

这是因为string是关键字(在本例中是别名)，而String是类型。

其他别名也是如此。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 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   |

您不需要导入名称空间(使用System;)来使用string，因为它是System.String的全局别名。

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

首先，两个(弦和放大器;字符串)是不一样的。这是有区别的:String不是关键字，它可以用作标识符，而String是关键字，不能用作标识符。

我试着用不同的例子来解释:首先，当我把"string s;"放入Visual Studio并悬停在它上面时，我得到(没有颜色):String Definition

这说明字符串是系统。字符串,对吧?文档位于https://msdn.microsoft.com/en-us/library/362314fe.aspx。第二句是"string是. net框架中string的别名。"

相关讨论

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

System.String是在名称空间System中定义了mscorlib的类(引用类型)。换句话说，System.String是CLR中的一个类型。

string是C#中的一个关键字

杰弗里·里写:

Another way to think of this is that the C# compiler automatically
assumes that you have the following using directives in all of your
source code files:

1
2
3
4
using int = System.Int32;
using uint = System.UInt32;
using string = System.String;
...

I’ve seen a number of developers confused, not knowing whether to use
string or String in their code. Because in C# string (a keyword) maps
exactly to System.String (an FCL type), there is no difference and
either can be used.

老实说，在实践中，制度之间通常没有区别。字符串和字符串。

c#中的所有类型都是对象，并且都是从System派生的。对象类。一个不同之处在于string是c#关键字，您可以使用string作为变量名。系统。String是这种类型的常规. net名称，String是方便的c#名称。这是一个简单的程序，它显示了不同的系统。字符串和字符串。

1
2
3
4
5
6
7
8
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) &amp;&amp; a.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((b.GetType() == typeof(String) &amp;&amp; b.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((c.GetType() == typeof(String) &amp;&amp; c.GetType() == typeof(string)).ToString()); // shows true
MessageBox.Show((d.GetType() == typeof(String) &amp;&amp; d.GetType() == typeof(string)).ToString()); // shows true

@JonSkeet在我的编译器中

1
public enum Foo : UInt32 { }

是有效的。我有Visual Studio 2015社区。

在MSDN文档的上下文中，String类与BCL中的任何其他数据类型(例如，XmlReader、StreamReader)一样被文档化。

string像关键字(c# Reference)或任何基本的c#语言构造(例如，for、while、default)一样被记录下来。

参考。

正如所指出的，它们是相同的东西，string只是String的别名。

值得注意的是，我使用string来声明类型——变量、属性、返回值和参数。这与使用其他系统类型(int, bool, var etc)是一致的(尽管Int32和Boolean也是正确的)。

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

string等于System.String在VS2015中如果你写这个

1
System.String str;

然后编译器会显示潜在的修复程序来优化它，在应用了修复程序之后，它会像这样

1
string str;

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

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

String对象的值是系统的顺序集合的内容。Char对象，并且该值是不可变的(即，它是只读的)。

有关字符串的不可变性的更多信息，请参见msdn中的不可变性和StringBuilder类部分。

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

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

在c#中，string是System的简短版本。字符串(字符串)。它们的意思基本相同。

就像有人提到的，它就像bool和Boolean一样，没什么区别。

String: String对象被称为不可变的(只读的)，因为它的值一旦创建就不能被修改。看起来修改字符串对象的方法实际上返回一个包含修改的新字符串对象。如果需要修改类字符串对象的实际内容

string: string类型表示一个由0个或多个Unicode字符组成的序列。string是. net框架中string的别名。string是固有的c#数据类型，是系统提供的类型"system . string"的别名。c#规范声明，作为一个样式问题，关键字(字符串)优先于完整的系统类型名称(系统)。字符串或字符串)。虽然string是一种引用类型，但是定义了相等运算符(==和!=)来比较string对象的值，而不是引用。这使得字符串相等性的测试更加直观。例如:

弦与放大器的区别;字符串:

string通常用于声明，而String用于访问静态字符串方法您可以使用'string'来声明使用预定义类型'string'的字段、属性等，因为c#规范告诉我这是一种很好的样式。您可以使用'String'来使用系统定义的方法，比如String。比较等。它们最初是在"System"上定义的。字符串",而不是"字符串"。在本例中，'string'只是一个别名。您还可以使用'String'或'System。当与其他系统通信时，特别是与clr兼容时。也就是说，如果我从其他地方获取数据，我会将其反序列化到一个系统中。如果根据定义，起源不是c#系统，那么应该是Int32而不是int。

相关讨论

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

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

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

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

字符串:表示一个类

字符串:表示别名

It's just a coding convention from microsoft .

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

string是. net框架中string的别名。

其中"String"实际上是System.String.

我想说的是，它们是可以互换的，在什么时候、什么地方使用它们没有区别。

但是，最好与您使用的是哪个一致。

值得注意的是，我使用string来声明类型——变量、属性、返回值和参数。这与使用其他系统类型—int, bool, var etc是一致的(尽管Int32和Boolean也是正确的)。

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

您已经知道string只是System.String的别名。但是我应该用什么呢?这只是个人喜好。

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

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

字符串是System.String的快捷方式。惟一的区别是您不需要引用System.String名称空间。所以使用字符串比使用字符串更好。

通常使用c#关键字声明变量。事实上，每个c#类型在。net中都有一个等价的。另一个例子是，c#中的short和int映射到. net中的Int16和Int32。从技术上讲，字符串和字符串没有区别，但是在c#中，string是. net framework中的string类的别名。

String是string的类。如果从使用语句中删除System名称空间，您可以看到String已经消失，但是string仍然在这里。string是字符串的关键字。就像int and Int32
short and Int16
long and Int64关键字就是一些使用类的单词。这些关键字由c#指定(所以是Microsoft，因为c#是Microsoft的)。简单地说，没有区别。使用string or String。这并不重要。他们是相同的。

String只是String类的别名。如果你想使用string类的函数，那么你应该使用string else，你应该坚持使用string。例如，如果您想格式化一个字符串，那么您应该使用string类来使用String.Format()，但是如果您只是想定义字符串，那么您应该使用string test="";请注意，它们都是引用类型。