The comments right before that line of code are telling you exactly what's going on. The & sign after a type name indicates that it's a reference type, and the @ before a variable name generates a reference to that variable.
(The @ sign can also be used in C# code to "escape" keywords for use as variable names but that's not what is happening here. "pageBounds" is not a C# keyword.)
Note that this is not valid C# syntax -- you cannot take a reference to a local variable in C#, although the CLR supports it. (NOTE: As of C# 7.0, this is no longer true; the syntax is described here, but it does not use the &
so this decompiled code is still invalid C#).
Creating a reference to a local variable happens implicitly when you use ref
and out
parameters, for example, but the keywords are used instead of explicitly typing the parameters as reference. (e.g. if you had an out int x
, internally that variable is of type Int32&
.) The intent of the code, if it were legal C#, would be that pageBounds
and local
were the same instance with two different names; anything you do to one happens to the other. So, for example, this illegal code:
Rectangle pageBounds;
Rectangle& local = @pageBounds;
local = new Rectangle();
would be the same as this legal code:
Rectangle pageBounds = new Rectangle();
If you tried to compile the code as-decompiled, you would get an error because the compiler treats & as the bitwise and, and will complain that you used a type as if it were a variable. But that's ok because you didn't get it from a C# source file. You decompiled an IL method to get it, and there are a lot of things you can do in IL that are illegal in C#. This happens all the time when you decompile code; you see illegal class and method names for example. It just means that the compiler generated IL based on the original code that does not translate directly back into C#, but behaves the way you wanted. The code you are getting back is simple the decompiler's best attempt to produce C# code from the IL it has.
You can see examples of the sort of code that produces these references in the numerous Jetbrains bug reports about them:
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…