blocks|key|121671|text|我用JustDecompile看了一下CIL。内部==被转换为CIL+ceq操作码。换句话说，它是原始的CLR相等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|121672|我很好奇，在比较两个双精度值时，C#编译器是否会引用ceq或==操作符。在我提出的简单示例中(如下所示)，它使用了ceq。|121673|此程序：|121674|void+Main()
{
++++double+x+=+1;
++++double+y+=+2;

++++if+(x+==+y)
++++++++Console.WriteLine("Something+bad+happened!");
++++else
++++++++Console.WriteLine("All+is+right+with+the+world");
}|code-block|syntax|javascript|121675|生成以下CIL+(请注意标签为IL_0017的语句)：|121676|IL_0000:++nop
IL_0001:++ldc.r8++++++00+00+00+00+00+00+F0+3F
IL_000A:++stloc.0+++++//+x
IL_000B:++ldc.r8++++++00+00+00+00+00+00+00+40
IL_0014:++stloc.1+++++//+y
IL_0015:++ldloc.0+++++//+x
IL_0016:++ldloc.1+++++//+y
IL_0017:++ceq
IL_0019:++stloc.2
IL_001A:++ldloc.2
IL_001B:++brfalse.s+++IL_002A
IL_001D:++ldstr+++++++"Something+bad+happened!"
IL_0022:++call++++++++System.Console.WriteLine
IL_0027:++nop
IL_0028:++br.s++++++++IL_0035
IL_002A:++ldstr+++++++"All+is+right+with+the+world"
IL_002F:++call++++++++System.Console.WriteLine
IL_0034:++nop
IL_0035:++ret|121677|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Common_Intermediate_Language|1|https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.ceq.aspx^0|P|2|J|3|0|Z|3|1|0|Q|3|U|2|1L|3|0|0|0|F|7|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@$9|15|A|16|1|17]|$9|18|A|19|1|1A]]|E|$]]|$1|F|3|G|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1I|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1J|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1N|8|@]|D|@]|E|$M|N]]|$1|S|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]]]

I took a look at the <a href="http://en.wikipedia.org/wiki/Common_Intermediate_Language" rel="nofollow">CIL</a> with JustDecompile. The inner <code>==</code> gets translated to the CIL <a href="https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.ceq.aspx" rel="nofollow">ceq</a> op code. In other words, it's primitive CLR equality.

I was curious to see if the C# compiler would reference <code>ceq</code> or the <code>==</code> operator when comparing two double values. In the trivial example I came up with (below), it used <code>ceq</code>.

This program:

<pre><code>void Main()
{
 double x = 1;
 double y = 2;

 if (x == y)
 Console.WriteLine("Something bad happened!");
 else
 Console.WriteLine("All is right with the world");
}
</code></pre>

generates the following CIL (note the statement with label <code>IL_0017</code>):

<pre><code>IL_0000: nop
IL_0001: ldc.r8 00 00 00 00 00 00 F0 3F
IL_000A: stloc.0 // x
IL_000B: ldc.r8 00 00 00 00 00 00 00 40
IL_0014: stloc.1 // y
IL_0015: ldloc.0 // x
IL_0016: ldloc.1 // y
IL_0017: ceq
IL_0019: stloc.2
IL_001A: ldloc.2
IL_001B: brfalse.s IL_002A
IL_001D: ldstr "Something bad happened!"
IL_0022: call System.Console.WriteLine
IL_0027: nop
IL_0028: br.s IL_0035
IL_002A: ldstr "All is right with the world"
IL_002F: call System.Console.WriteLine
IL_0034: nop
IL_0035: ret
</code></pre>

blocks|key|2672869|text|实际上，编译器会将==操作符转换为ceq+IL代码，并且不会调用您提到的操作符。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2672870|在源代码中使用运算符的原因可能是，它可以从C#以外的语言调用，这些语言不会直接(或通过反射)将其转换为CEQ调用。运算符中的代码将被编译为CEQ，因此没有无限递归。|2672871|实际上，如果您通过反射调用运算符，您可以看到运算符被调用(而不是CEQ指令)，并且显然不是无限递归的(因为程序按预期终止)：|2672872|double+d1+=+1.1;
double+d2+=+2.2;

MethodInfo+mi+=+typeof(Double).GetMethod("op_Equality",+BindingFlags.Static+%7C+BindingFlags.Public+);

bool+b+=+(bool)(mi.Invoke(null,+new+object[]+{d1,d2}));|code-block|syntax|javascript|2672873|结果IL+(由LinqPad+4编译)：|2672874|IL_0000:++nop+++++++++
IL_0001:++ldc.r8++++++9A+99+99+99+99+99+F1+3F+
IL_000A:++stloc.0+++++//+d1
IL_000B:++ldc.r8++++++9A+99+99+99+99+99+01+40+
IL_0014:++stloc.1+++++//+d2
IL_0015:++ldtoken+++++System.Double
IL_001A:++call++++++++System.Type.GetTypeFromHandle
IL_001F:++ldstr+++++++"op_Equality"
IL_0024:++ldc.i4.s++++18+
IL_0026:++call++++++++System.Type.GetMethod
IL_002B:++stloc.2+++++//+mi
IL_002C:++ldloc.2+++++//+mi
IL_002D:++ldnull++++++
IL_002E:++ldc.i4.2++++
IL_002F:++newarr++++++System.Object
IL_0034:++stloc.s+++++04+//+CS$0$0000
IL_0036:++ldloc.s+++++04+//+CS$0$0000
IL_0038:++ldc.i4.0++++
IL_0039:++ldloc.0+++++//+d1
IL_003A:++box+++++++++System.Double
IL_003F:++stelem.ref++
IL_0040:++ldloc.s+++++04+//+CS$0$0000
IL_0042:++ldc.i4.1++++
IL_0043:++ldloc.1+++++//+d2
IL_0044:++box+++++++++System.Double
IL_0049:++stelem.ref++
IL_004A:++ldloc.s+++++04+//+CS$0$0000
IL_004C:++callvirt++++System.Reflection.MethodBase.Invoke
IL_0051:++unbox.any+++System.Boolean
IL_0056:++stloc.3+++++//+b
IL_0057:++ret+|2672875|有趣的是-整型类型不存在相同的运算符(无论是在参考源中还是通过反射)，只有Single、Double、Decimal、String和DateTime，这反驳了我的理论，即它们存在是为了从其他语言调用。显然，在没有这些运算符的情况下，您可以在其他语言中将两个整数等同起来，因此我们又回到了“为什么它们存在于double”的问题上。|2672876|entityMap^0|9|2|H|3|0|1F|3|1X|3|0|W|3|0|0|0|0|11|6|18|6|1F|7|1N|6|1U|8|48|6|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|19|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1B|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1P|8|@]|D|@]|E|$]]]|V|$]]

In reality, the compiler will turn the <code>==</code> operator into a <code>ceq</code> IL code, and the operator you mention will not be called.

The reason for the operator in the source code is likely so it can be called from languages other than C# that do not translate it into a <code>CEQ</code> call directly (or through reflection). The code within the operator will be compiled to a <code>CEQ</code>, so there is no infinite recursion.

In fact, if you call the operator via reflection, you can see that the operator is called (rather than a <code>CEQ</code> instruction), and obviously is not infinitely recursive (since the program terminates as expected):

<pre><code>double d1 = 1.1;
double d2 = 2.2;

MethodInfo mi = typeof(Double).GetMethod("op_Equality", BindingFlags.Static | BindingFlags.Public );

bool b = (bool)(mi.Invoke(null, new object[] {d1,d2}));
</code></pre>

Resulting IL (compiled by LinqPad 4):

<pre><code>IL_0000: nop 
IL_0001: ldc.r8 9A 99 99 99 99 99 F1 3F 
IL_000A: stloc.0 // d1
IL_000B: ldc.r8 9A 99 99 99 99 99 01 40 
IL_0014: stloc.1 // d2
IL_0015: ldtoken System.Double
IL_001A: call System.Type.GetTypeFromHandle
IL_001F: ldstr "op_Equality"
IL_0024: ldc.i4.s 18 
IL_0026: call System.Type.GetMethod
IL_002B: stloc.2 // mi
IL_002C: ldloc.2 // mi
IL_002D: ldnull 
IL_002E: ldc.i4.2 
IL_002F: newarr System.Object
IL_0034: stloc.s 04 // CS$0$0000
IL_0036: ldloc.s 04 // CS$0$0000
IL_0038: ldc.i4.0 
IL_0039: ldloc.0 // d1
IL_003A: box System.Double
IL_003F: stelem.ref 
IL_0040: ldloc.s 04 // CS$0$0000
IL_0042: ldc.i4.1 
IL_0043: ldloc.1 // d2
IL_0044: box System.Double
IL_0049: stelem.ref 
IL_004A: ldloc.s 04 // CS$0$0000
IL_004C: callvirt System.Reflection.MethodBase.Invoke
IL_0051: unbox.any System.Boolean
IL_0056: stloc.3 // b
IL_0057: ret 
</code></pre>

Interestingly - the same operators do NOT exist (either in the reference source or via reflection) for integral types, only <code>Single</code>, <code>Double</code>, <code>Decimal</code>, <code>String</code>, and <code>DateTime</code>, which disproves my theory that they exist to be called from other languages. Obviously you can equate two integers in other languages without these operators, so we're back to the question "why do they exist for <code>double</code>"?

blocks|key|121713|text|原始类型的来源可能会令人困惑。您看过Double结构的第一行吗？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|121714|通常你不能像这样定义一个递归结构：|121715|public+struct+Double+:+IComparable,+IFormattable,+IConvertible
++++++++,+IComparable<Double>,+IEquatable<Double>
{
++++internal+double+m_value;+//+Self-recursion+with+endless+loop?
++++//+...
}|code-block|syntax|javascript|121716|基元类型在CIL中也有其本机支持。通常，它们不会被视为面向对象的类型。如果double在CIL中用作float64，则它只是一个64位的值。但是，如果将其作为通常的.NET类型处理，则它包含一个实际值，并且它像任何其他类型一样包含方法。|121717|因此，您在这里看到的是运算符的相同情况。通常，如果您直接使用double类型，它将永远不会被调用。顺便说一句，它在CIL中的源代码如下：|121718|.method+public+hidebysig+specialname+static+bool+op_Equality(float64+left,+float64+right)+cil+managed
{
++++.custom+instance+void+System.Runtime.Versioning.NonVersionableAttribute::.ctor()
++++.custom+instance+void+__DynamicallyInvokableAttribute::.ctor()
++++.maxstack+8
++++L_0000:+ldarg.0
++++L_0001:+ldarg.1
++++L_0002:+ceq
++++L_0004:+ret
}|121719|如您所见，没有无限循环(使用ceq仪器而不是调用System.Double::op_Equality)。因此，当将double视为对象时，将调用operator方法，该方法最终将在CIL级别上作为float64原语类型来处理它。|121720|entityMap^0|I|6|0|0|0|1E|7|0|0|0|E|3|O|Q|2Q|7|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|J|7|15|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|V|$]]

The source of the primitive types can be confusing. Have you seen the very first line of the <code>Double</code> struct?

Normally you cannot define a recursive struct like this:

<pre><code>public struct Double : IComparable, IFormattable, IConvertible
 , IComparable&lt;Double&gt;, IEquatable&lt;Double&gt;
{
 internal double m_value; // Self-recursion with endless loop?
 // ...
}
</code></pre>

Primitive types have their native support in CIL as well. Normally they are not treated like object-oriented types. A double is just a 64-bit value if it is used as <code>float64</code> in CIL. However, if it is handled as a usual .NET type, it contains an actual value and it contains methods like any other types.

So what you see here is the same situation for operators. Normally if you use the double type type directly, it will never be called. BTW, its source looks like this in CIL:

<pre><code>.method public hidebysig specialname static bool op_Equality(float64 left, float64 right) cil managed
{
 .custom instance void System.Runtime.Versioning.NonVersionableAttribute::.ctor()
 .custom instance void __DynamicallyInvokableAttribute::.ctor()
 .maxstack 8
 L_0000: ldarg.0
 L_0001: ldarg.1
 L_0002: ceq
 L_0004: ret
}
</code></pre>

As you can see, there is no endless loop (the <code>ceq</code> instrument is used instead of calling the <code>System.Double::op_Equality</code>). So when a double is treated like an object, the operator method will be called, which will eventually handle it as the <code>float64</code> primitive type on the CIL level.

blocks|key|118823|text|这里的主要混淆是假设所有的.NET库(在本例中是扩展的Numerics库，它不是BCL的一部分)都是用标准C#编写的。情况并不总是这样，不同的语言有不同的规则。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|118824|在标准C#中，由于操作符重载解析的工作方式，您所看到的代码片段将导致堆栈溢出。但是，代码实际上并不是标准的C#+--它基本上使用了C#编译器中未记录的特性。它不是调用操作符，而是发出以下代码：|118825|ldarg.0
ldarg.1
ceq
ret|code-block|syntax|javascript|118826|就是这样:)没有100%25等价的C#代码--这在你自己的类型的C#中是不可能的。|118827|即使这样，在编译C#代码时也不会使用实际的运算符-编译器会进行大量优化，就像本例中一样，它只用简单的ceq替换了op_Equality调用。同样，您不能在自己的DoubleEx结构中复制它-这是编译器的魔力。|offset|length|style|CODE|118828|这在.NET中肯定不是独有的情况--有很多代码是无效的、标准的C#。原因通常是(a)编译器黑客和(b)一种不同的语言，以及奇怪的(c)运行时黑客(我正在看着你，Nullable!)。|118829|由于Roslyn+C#编译器是oepn源代码，我实际上可以向您指出决定重载解决方案的位置：|118830|The+place+where+all+binary+operators+are+resolved|118831|The+"shortcuts"+for+intrinsic+operators|118832|当您查看快捷方式时，您将看到double和double之间的相等会导致内部double运算符，而不是定义在类型上的实际==运算符。.NET类型系统必须假装Double是一个类似于其他类型的类型，但C#并非如此--+double是C#中的一个原语。|118833|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/dotnet/roslyn/blob/a4e375b95953e471660e9686a46893c97db70b0e/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorOverloadResolution.cs|1|https://github.com/dotnet/roslyn/blob/a4e375b95953e471660e9686a46893c97db70b0e/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorEasyOut.cs^0|0|0|0|0|1E|3|1K|B|28|8|0|28|8|0|0|0|1D|0|0|0|13|1|0|1N|2|25|6|2Z|6|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1D|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1E|8|@$M|1F|N|1G|O|P]|$M|1H|N|1I|O|P]|$M|1J|N|1K|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1L|8|@$M|1M|N|1N|O|P]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1O|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1P|8|@]|9|@$M|1Q|N|1R|1|1S]]|A|$]]|$1|W|3|X|5|6|7|1T|8|@]|9|@$M|1U|N|1V|1|1W]]|A|$]]|$1|Y|3|Z|5|6|7|1X|8|@$M|1Y|N|1Z|O|P]|$M|20|N|21|O|P]|$M|22|N|23|O|P]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|24|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]|18|$5|13|14|15|A|$16|19]]]]

The main confusion here is that you're assuming that all .NET libraries (in this case, the Extended Numerics Library, which is not a part of the BCL) are written in standard C#. This isn't always the case, and different languages have different rules.

In standard C#, the piece of code you're seeing would result in a stack overflow, due to the way operator overload resolution works. However, the code isn't actually in standard C# - it basically uses undocumented features of the C# compiler. Instead of calling the operator, it emits this code:

<pre><code>ldarg.0
ldarg.1
ceq
ret
</code></pre>

That's it :) There is no 100% equivalent C# code - this simply isn't possible in C# with your own type.

Even then, the actual operator isn't used when compiling C# code - the compiler does a bunch of optimizations, like in this case, where it replaces the <code>op_Equality</code> call with just the simple <code>ceq</code>. Again, you can't replicate this in your own <code>DoubleEx</code> struct - it's compiler magic.

This certainly isn't a unique situation in .NET - there's plenty of code that isn't valid, standard C#. The reasons are usually (a) compiler hacks and (b) a different language, with the odd (c) runtime hacks (I'm looking at you, <code>Nullable</code>!).

Since the Roslyn C# compiler is oepn source, I can actually point you at the place where overload resolution is decided: 

<a href="https://github.com/dotnet/roslyn/blob/a4e375b95953e471660e9686a46893c97db70b0e/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorOverloadResolution.cs">The place where all binary operators are resolved</a>

<a href="https://github.com/dotnet/roslyn/blob/a4e375b95953e471660e9686a46893c97db70b0e/src/Compilers/CSharp/Portable/Binder/Semantics/Operators/BinaryOperatorEasyOut.cs">The "shortcuts" for intrinsic operators</a>

When you look at the shortcuts, you'll see that equality between double and double results in the intrinsic double operator, never in the actual <code>==</code> operator defined on the type. The .NET type system has to pretend that <code>Double</code> is a type like any other, but C# doesn't - <code>double</code> is a primitive in C#.

blocks|key|118871|text|正如微软文档中有关System.Runtime.Versioning命名空间的说明:此命名空间中的类型旨在在.NET框架内使用，而不是供用户使用applications.The+System.Runtime.Versioning命名空间包含支持.NET框架并行实现中的版本控制的高级类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|118872|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

As indicated in the Microsoft documentation for the System.Runtime.Versioning Namespace:The types found in this namespace are intended for use within the .NET Framework and not for user applications.The System.Runtime.Versioning namespace contains advanced types that support versioning in side by side implementations of the .NET Framework.

For some reason I was sneaking into the .NET Framework source for the class <a href="http://referencesource.microsoft.com/#mscorlib/system/double.cs,159" rel="noreferrer"><code>Double</code></a> and found out that the declaration of <code>==</code> is:

<pre><code>public static bool operator ==(Double left, Double right) {
 return left == right;
}
</code></pre>

The same logic applies for every operator.

<hr>

<ul>
<li>What's the point of such a definition? </li>
<li>How does it work?</li>
<li>Why doesn't it create an infinite recursion?</li>
</ul>

Definition of "==" operator for Double

编译器

出于某种原因，我偷偷进入类的.NET框架源代码，发现==的声明是：public static bool operator ==(Double left, Double right) {    return left == right;}同样的逻辑也适用于每个运算符。这样定义的意义是什么？它是如何工作的？为什么不创建无限...

问Double "==“运算符的定义
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Double "==“运算符的定义EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Double "==“运算符的定义
EN