字符串 = 字符串 + int：幕后有什么？

发布于 2024-09-12 07:13:23 字数 364 浏览 3 评论 0原文

在 C# 中，您可以隐式连接一个字符串和一个整数：

string sth = "something" + 0;

我的问题是：

为什么，假设您可以隐式连接一个字符串和一个 int，C# 不允许像这样初始化字符串：
```
字符串 sth = 0; // 错误：无法将源类型“int”转换为目标类型“string”
```
C# 如何将 0 转换为字符串。是 0.ToString() 或 (string)0 还是其他什么？
如何找到上一个问题的答案？

原文

In C# you can implicitly concatenate a string and let's say, an integer:

string sth = "something" + 0;

My questions are:

Why, by assuming the fact that you can implicitly concatenate a string and an int, C# disallows initializing strings like this:
```
string sth = 0; // Error: Cannot convert source type 'int' to target type 'string'
```
How C# casts 0 as string. Is it 0.ToString() or (string)0 or something else?
How to find an answer of the previous question?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

舟遥客 2024-09-19 07:13:23

它编译为对 String.Concat(object, object)，如下所示：（

string sth = String.Concat("something", 0);

请注意，该特定行实际上会被编译器优化掉）

此方法定义如下：（取自 .Net 参考源）

    public static String Concat(Object arg0, Object arg1) {
        if (arg0==null) {
            arg0 = String.Empty; 
        }

        if (arg1==null) { 
            arg1 = String.Empty;
        } 
        return Concat(arg0.ToString(), arg1.ToString());
    }

（这会调用 String.Concat (string, string))

要发现这一点，您可以使用 ildasm 或 Reflector（在 IL 或没有优化的 C# 中）来查看 + 的内容行编译为.

It compiles to a call to String.Concat(object, object), like this:

string sth = String.Concat("something", 0);

(Note that this particular line will actually be optimized away by the compiler)

This method is defined as follows: (Taken from the .Net Reference Source)

    public static String Concat(Object arg0, Object arg1) {
        if (arg0==null) {
            arg0 = String.Empty; 
        }

        if (arg1==null) { 
            arg1 = String.Empty;
        } 
        return Concat(arg0.ToString(), arg1.ToString());
    }

(This calls String.Concat(string, string))

To discover this, you can use ildasm, or Reflector (in IL or in C# with no optimizations) to see what the + line compiles to.

回复收藏 0 原文

司马昭之心 2024-09-19 07:13:23

C# 4 规范第 7.8.4 节对此进行了规定：

对于x + y形式的运算，
二元运算符重载解析
(§7.3.4) 用于选择
具体运营商实施。这
操作数被转换为
所选参数类型
运算符和结果的类型
是运算符的返回类型。
预定义的加法运算符是
下面列出。对于数字和
枚举类型，预定义的
加法运算符计算总和
两个操作数。当其中之一或两者
操作数是字符串类型，
预定义的加法运算符
连接字符串表示形式
操作数。

最后一句话与这种情况最相关。

然后后来：

字符串连接
字符串运算符 +(字符串 x, 字符串 y);

字符串运算符 +(字符串 x, 对象 y);

字符串运算符 +(对象 x, 字符串 y);
二进制+的这些重载
运算符执行字符串连接。
如果字符串连接的操作数
为 null，空字符串是
取代。否则，任何非字符串
参数被转换为其字符串
通过调用虚拟表示
从类型继承的 ToString 方法
目的。如果 ToString 返回 null，则
空字符串被替换。

它指定如何将整数转换为字符串。

结果：

字符串连接的结果
运算符是一个字符串，由以下内容组成
左操作数的字符
接下来是字符
右操作数。字符串
连接运算符永远不会返回
空值。

执行连接的实际方法是特定于实现的，但正如其他答案中所述，MS 实现使用 string.Concat。

This is specified in section 7.8.4 of the C# 4 spec:

For an operation of the form x + y,
binary operator overload resolution
(§7.3.4) is applied to select a
specific operator implementation. The
operands are converted to the
parameter types of the selected
operator, and the type of the result
is the return type of the operator.
The predefined addition operators are
listed below. For numeric and
enumeration types, the predefined
addition operators compute the sum of
the two operands. When one or both
operands are of type string, the
predefined addition operators
concatenate the string representation
of the operands.

The last sentence is the most relevant one to this situation.

Then later:

String concatenation
string operator +(string x, string y);

string operator +(string x, object y);

string operator +(object x, string y);
These overloads of the binary +
operator perform string concatenation.
If an operand of string concatenation
is null, an empty string is
substituted. Otherwise, any non-string
argument is converted to its string
representation by invoking the virtual
ToString method inherited from type
object. If ToString returns null, an
empty string is substituted.

That specifies how the integer is converted into a string.

And the result:

The result of the string concatenation
operator is a string that consists of
the characters of the left operand
followed by the characters of the
right operand. The string
concatenation operator never returns a
null value.

The actual means of performing concatenation is implementation-specific, but as noted in other answers, the MS implementation uses string.Concat.

回复收藏 0 原文

~没有更多了~