C＃中字符串和字符串有什么区别？

时间：2008-08-10 07:18:02

标签： c# .net string types alias

示例（注意案例）：

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

每种用途的 指南 是什么？什么是 差异 ？

68 个答案:

答案 0 :(得分：5604)

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

就指南而言，通常建议您在引用某个对象时使用string。

e.g。 

string place = "world";

同样，我认为如果您需要专门参考该课程，通常建议使用String。

e.g。

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

这是Microsoft倾向于在their examples中使用的样式。

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

答案 1 :(得分：3237)

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

正如其他人所说，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。

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

有一种情况是 使用别名：明确指定枚举的基础类型时。例如：

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

这只是规范定义枚举声明的方式问题 - 冒号之后的部分必须是整数类型生成，这是sbyte的一个标记，{{ 1}}，byte，short，ushort，int，uint，long，ulong ...相反例如，变量声明所使用的类型生产。它没有表明任何其他差异。

最后，当谈到使用它时：我个人在各处使用别名来实现，但是任何API都使用CLR类型。你在实施方面使用它并不重要 - 团队之间的一致性很好，但没有人会关心。另一方面，如果您在API中引用类型，则以语言中立的方式执行此操作，这一点非常重要。名为char的方法是明确的，而名为ReadInt32的方法需要解释。例如，调用者可能正在使用为ReadInt定义int别名的语言。 .NET框架设计人员遵循了这种模式，Int16，BitConverter和BinaryReader类中有很好的例子。

答案 2 :(得分：655)

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

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

答案 3 :(得分：465)

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

  
      
  • 我看到许多开发人员感到困惑，不知道是否在他们的代码中使用字符串或字符串。因为在C＃中，字符串（一个关键字）完全映射到System.String（一种FCL类型），所以没有区别，可以使用它们。
    •   
  • 在C＃中，长映射到 System.Int64 ，但在其他编程语言中，长可映射到 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

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

答案 4 :(得分：420)

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

如果由于某种原因你想要一个名为 string 的变量，你只能看到第一个这样的编译：

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

如果您确实需要名为 string 的变量名称，可以使用@作为前缀：

StringBuilder @string = new StringBuilder();

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

答案 5 :(得分：362)

存在一个差异 - 您事先没有String就无法使用using System;。

答案 6 :(得分：292)

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

答案 7 :(得分：233)

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

至于指导方针，我不会太陷入困境，只是使用你想要的任何东西 - 生活中有更重要的事情，代码也会是相同的。

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

答案 8 :(得分：191)

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

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

考虑：

String someString; 
string anotherString;

答案 9 :(得分：179)

string和String在所有方面都相同（大写“S”除外）。无论如何都没有性能影响。

由于语法高亮显示

，大多数项目都首选小写string

答案 10 :(得分：170)

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

string 是C＃中的一种类型。

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

当您将CL＃与CLR一起使用时 string 将映射到 System.String 。

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

答案 11 :(得分：156)

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

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

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

enter image description here

“System.String”a.k.a“字符串”（大写字母“S”）是.NET框架数据类型，而“字符串”是C#数据类型。

enter image description here

简而言之，“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 s = String.ToUpper() ;

答案 12 :(得分：147)

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

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

答案 13 :(得分：144)

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

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

答案 14 :(得分：130)

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

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

答案 15 :(得分：110)

正如其他人所说，他们是一样的。默认情况下，StyleCop规则会强制您使用string作为C＃代码样式的最佳做法，除非引用System.String静态函数，例如String.Format，String.Join，{ {1}}等等......

答案 16 :(得分：91)

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

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

我将提供两个 using指令无法帮助的示例。

首先，当String是当前类型（或本地变量）的 值 时：

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

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

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

更糟糕：说String.Concat(someSequence)可能（取决于using）转到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始终是钢琴string，MyPiano.String。没有成员（static或不）Format存在于其上（或从其基类继承）。并且值"Goodbye"无法转换为它。

答案 17 :(得分：90)

使用系统类型可以更容易地在C＃和VB.Net之间进行移植，如果您遇到这种情况。

答案 18 :(得分：83)

对于其他程序员的常见做法，我更喜欢String而非string，只是为了强调String是一种参考类型，正如Jon Skeet所提到的那样。 / p>

答案 19 :(得分：78)

string是System.String的别名（或简写）。这意味着，通过输入string，我们的意思是System.String。您可以在思考链接中阅读更多内容：'string' is an alias/shorthand of System.String.

答案 20 :(得分：70)

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

的样式声明基元

答案 21 :(得分：70)

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

  

C＃语言规范指出，“作为一种风格，关键字的使用受到青睐   使用完整的系统类型名称。“我不同意语言规范;我更喜欢   使用FCL类型名称并完全避免基本类型名称。事实上，我希望如此   编译器甚至没有提供原始类型名称，并迫使开发人员使用FCL   改为输入名称。以下是我的理由：

     
      

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

    •   

  • 在C＃中，长映射到 System.Int64 ，但使用其他编程语言长   可以映射到 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＃-isms进入了   类库代码。例如，微软的FCL几乎全部用C＃编写   FCL团队的开发人员现在已经将方法引入了库中   数组的 GetLongLength ，在C＃中返回 Int64 值 long ，但不是   在其他语言中（如C ++ / CLI）。另一个例子是 System.Linq.Enumerable    LongCount 方法。

    •   

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

答案 22 :(得分：64)

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

答案 23 :(得分：64)

派对迟到：我100％使用CLR类型（好吧，除非强制使用C＃类型，但我不记得上一次是什么时候）。

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

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

唯一真正的下载是自动完成使用C＃类型，所以我最终重新键入自动生成的类型来指定CLR类型。

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

答案 24 :(得分：58)

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

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

答案 25 :(得分：47)

没有区别。

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

同样，int映射到System.Int32。

答案 26 :(得分：42)

Daniel Solis' book对此问题有一个引用。

  

所有预定义类型都直接映射到   基础.NET类型。 C＃类型名称（字符串）只是其中的别名   .NET类型（String或System.String），因此使用.NET名称在语法上可以很好地工作   这是沮丧的。在C＃程序中，您应该使用C＃名称   而不是.NET名称。

答案 27 :(得分：40)

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

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

示例 

string String = "I am a string";

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

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

答案 28 :(得分：38)

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

答案 29 :(得分：33)

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

答案 30 :(得分：26)

其他地方没有提到的一个论点是偏好pascal case String：

System.String是一种引用类型，引用类型名称按惯例为 。

答案 31 :(得分：23)

两者都是一样的。不同之处在于你如何使用它。 惯例是，

s tring用于变量

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

像：

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

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

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

答案 32 :(得分：17)

实际上没有区别

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

答案 33 :(得分：15)

如果确实看到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 ]

答案 34 :(得分：15)

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

string指的是原始类型

在C＃中，它们都编译为String，但在其他语言中它们不会这样，如果你想处理String对象，你应该使用String，如果你想处理文字，你应该使用字符串。

答案 35 :(得分：14)

string和String之间存在一个实际差异。

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

答案 36 :(得分：12)

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

要了解有关别名的详情，请查看此link。

答案 37 :(得分：10)

首先，两者（字符串和字符串）不相同。 它们是有区别的： String不是关键字，可以用作标识符，而string是关键字，不能用作标识符。

我试图用不同的例子来解释： 首先，当我把“字符串s”进入Visual Studio并将鼠标悬停在它上面（没有颜色）：
String Definition

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

答案 38 :(得分：8)

@JaredPar（C＃编译器的开发者和丰富的SO用户！）在此问题上写了great blog post。我认为值得在这里分享。这是关于我们主题的一个很好的视角。

  

string和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与{{1 }}的实际后果取决于使用代码的地方。

     

因此请记住，当您看到string与String的辩论时，这是关于语义而非样式的。选择字符串可使代码库具有清晰的含义。选择string并没有错，但是这为将来带来惊喜提供了方便。

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

答案 39 :(得分：8)

说实话，在实践中， System.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社区。

答案 40 :(得分：8)

杰弗里里希特写道：

  

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

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

我看到很多开发人员感到困惑，不知道是否使用   字符串或字符串在其代码中。因为在C＃string（一个关键字）中映射   完全是System.String（一个FCL类型），没有区别和   要么可以使用。

答案 41 :(得分：7)

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

中

并且StreamReader被记录为关键字（C＃参考）或任何基本的C＃语言构造（例如，string，for，{{1 }}）。

<强> Reference

答案 42 :(得分：7)

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

Sub GoalSeekTest() Dim N As Integer Dim i As Integer N = ThisWorkbook.Sheets("Reverse DCF").Range("D1").Value For i = 2 To N If Cells(i, "P").HasFormula Then 'Messagebox for clarification MsgBox ("Formula cell: " & Cells(i, "P") _ .Address(RowAbsolute:=False, ColumnAbsolute:=False)) Cells((i), "P").GoalSeek Goal:=0, ChangingCell:=Cells((i), "J") Else MsgBox "Cell " & Cells(i, 1) _ .Address(RowAbsolute:=False, ColumnAbsolute:=False) _ & " has no formula - skipping this cell!", _ vbCritical, "Formula required!" End If Next i End Sub 是一个类（引用类型），它定义了命名空间System.String中的mscorlib。换句话说，System是System.String中的一种类型。

CLR是string

中的关键字

答案 43 :(得分：7)

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

System.String str;

比编译器会显示优化它的潜在修复方法，并且在应用该修复后，它将如下所示

string str;

答案 44 :(得分：7)

字符串是用于表示文字的连续字符。

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

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

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

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

注意：答案摘自msdn帮助部分。您可以在备注部分

下查看完整内容here in msdn String Class主题

答案 45 :(得分：6)

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

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

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

答案 46 :(得分：6)

我更喜欢使用string，因为这种类型的使用非常多，我不希望语​​法高亮显示器将其与所有其他类混合使用。虽然它是一个类，但它更像是一个原语，因此我认为不同的高亮颜色是合适的。

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

答案 47 :(得分：6)

在C＃中，string是System.String（String）的缩写版本。它们的意思基本相同。

就像有人提到的那样，它就像bool和Boolean一样，差别不大......

答案 48 :(得分：6)

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

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

字符串与＆amp;的区别字符串：

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

答案 49 :(得分：5)

据我所知，string只是System.String的别名，bool，object，int存在类似的别名......唯一微妙的区别是你可以使用string而没有“使用System;”指令，而String需要它（否则你应该完全指定System.String。）

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

答案 50 :(得分：5)

字符串：代表一个类

字符串：代表别名

  

这只是微软的编码惯例。

答案 51 :(得分：5)

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

答案 52 :(得分：4)

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

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

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

答案 53 :(得分：4)

string是System.String的快捷方式。唯一的区别是您不需要引用System.String命名空间。因此，使用字符串比使用String更好。

答案 54 :(得分：4)

string是.NET Framework中String的别名。

Where＆＃34; String＆＃34;实际上是System.String.

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

最好与你使用的那个一致。

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

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

答案 55 :(得分：3)

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

答案 56 :(得分：2)

String是string的类。如果从using语句中删除System命名空间，则可以看到String已经消失，但string仍然在这里。 string是String的关键字。喜欢
 int and Int32
short and Int16
long and Int64
   因此，关键字只是使用类的某些单词。这些关键字由C＃指定（因此是Microsoft，因为C＃是Microsoft的）。简而言之，没有区别。使用string or String。没关系他们是一样的。

答案 57 :(得分：2)

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

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更改为string和String，进行编译，并以ildasm打开，然后查看IL不变。它还显示了该语言的创建者在定义变量时更喜欢string（破坏者：在调用成员时，他们更喜欢String）。

答案 58 :(得分：1)

C# 中的 string 和 String 之间没有重大区别。

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

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

string str = "Hello";

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

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

答案 59 :(得分：1)

从技术上讲，这两者是相同的，但略有不同。 “字符串”是数据类型，而“字符串”表示类。 “字符串”是System.String的别名。在执行时，两个都编译为相同的代码。语法荧光笔是另一个不同之处。

现在让我们检查一下代码片段以了解这两者。

    using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Text;  
    using System.Threading.Tasks;  
    namespace ConsoleApplication2  
    {  
        class Program  
        {  
            static void Main(string[] args)  
            {  
                string FirstName = ".Net";  
                String Lastname = "Snippets";  
                Console.WriteLine(FirstName + " " + Lastname);  
                Console.ReadLine();  
            }  
        }  
    }

答案 60 :(得分：1)

许多新手C＃程序员提出的问题之一是： “ string和String有什么区别？” 在C＃中，字符串是.NET框架中String类的别名。实际上，每种C＃类型在.NET中都有一个等效项。  再举一个例子，C＃中的short和int映射到.NET中的Int16和Int32。

因此，从技术上讲，string和String之间没有区别，但是通常的做法是使用C＃关键字声明变量。 我几乎没有看到有人用Int32声明一个整数！ 唯一的微小区别是，如果您使用String类，则需要在文件顶部导入System命名空间，而在使用string关键字时则不必这样做。 许多开发人员更喜欢使用string声明一个字符串变量，但是在访问其静态成员之一时使用String类：

String.Format()

答案 61 :(得分：1)

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

String.Format()

变量

string name = "";

答案 62 :(得分：0)

有很多人（例如杰弗里·里希特（Jeffrey Richter）在他的书CLR Via C#中）说System.String和string之间没有区别，System.Int32和{{ 1}}，但是我们必须对这个问题进行更深入的区分才能真正榨汁，这样我们才能从中获得所有营养价值（编写更好的代码）。

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

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

HTH。

答案 63 :(得分：0)

C＃中的字符串和字符串之间的区别

许多C＃新手都会问的一个问题是：“字符串和字符串之间有什么区别？”

在C＃中，字符串是.NET框架中String类的别名。实际上，每种C＃类型在.NET中都有一个等效项。再举一个例子，C＃中的short和int映射到.NET中的Int16和Int32。

因此，从技术上讲，string和String之间没有区别，但是通常的做法是使用C＃关键字声明变量。我几乎没有看到有人用Int32声明整数！

仅有的微小区别是，如果使用String类，则需要在文件顶部导入System名称空间，而在使用string关键字时不必这样做。

许多开发人员更喜欢使用string声明一个字符串变量，但是在访问其静态成员之一时使用String类：String.Format（）

在C＃中创建类型别名：link

答案 64 :(得分：0)

它将编译：

public class MyClass<String>
{
}

这不是：

public class MyClass<string>
{
}

答案 65 :(得分：0)

好问题！ 用简单的话来说：

string - is datatype 

String - Class Name

例如：

string Name="tata"; //datatype is string => Happy Compiler :)

和

String Name="tata"; //Unknown datatype => Unhappy Compiler :(

当您将鼠标悬停在String编译器上说要使用

时，这就是事情 
System.String Name="tata";

不要困惑！ 希望这会有所帮助！

答案 66 :(得分：-1)

字符串vs字符串www.javatpoint.com的图像结果 在C＃中，string是.NET框架中String类的别名。实际上，每种C＃类型在.NET中都有一个等效项。
另一个小差异是，如果使用String类，则需要导入System名称空间，而使用string关键字时不必导入名称空间

答案 67 :(得分：-5)

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

相关问题
最新问题