在方法内部使用 const 而不是变量的优点

每当我在一个方法中有局部变量时，ReSharper 建议将它们转换为常量:

// instead of this:
var s = "some string";
var flags = BindingFlags.Public | BindingFlags.Instance;


// ReSharper suggest to use this:
const string s = "some string";
const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;

考虑到这些是真正的常量值(而不是变量) ，我理解 ReSharper 建议将它们改为常量。

但除此之外，使用 const (例如更好的性能)还有什么其他好处可以证明使用 const BindingFlags而不是方便易读的 var关键字是合理的呢？

顺便说一下: 我刚刚在这里发现了一个类似的问题: Resharper 总是建议我用 const string 代替 string，但是我认为它更多的是关于一个类的字段，我的问题是关于局部变量/常量的。

45243 次浏览
小开

A const value is also 'shared' between all instances of an object. It could result in lower memory usage as well.

As an example:

public class NonStatic
{
int one = 1;
int two = 2;
int three = 3;
int four = 4;
int five = 5;
int six = 6;
int seven = 7;
int eight = 8;
int nine = 9;
int ten = 10;
}


public class Static
{
static int one = 1;
static int two = 2;
static int three = 3;
static int four = 4;
static int five = 5;
static int six = 6;
static int seven = 7;
static int eight = 8;
static int nine = 9;
static int ten = 10;
}

Memory consumption is tricky in .Net and I won't pretend to understand the finer details of it, but if you instantiate a list with a million 'Static' it is likely to use considerably less memory than if you do not.

    static void Main(string[] args)
{
var maxSize = 1000000;
var items = new List<NonStatic>();
//var items = new List<Static>();


for (var i=0;i<maxSize;i++)
{
items.Add(new NonStatic());
//items.Add(new Static());
}


Console.WriteLine(System.Diagnostics.Process.GetCurrentProcess().WorkingSet64);
Console.Read();
}

When using 'NonStatic' the working set is 69,398,528 compared to only 32,423,936 when using static.

小开
最佳答案

The compiler will throw an error if you try to assign a value to a constant, thus possibly preventing you from accidentally changing it.

Also, usually there is a small performance benefit to using constants vs. variables. This has to do with the way they are compiled to the MSIL, per this MSDN magazine Q&A:

Now, wherever myInt is referenced in the code, instead of having to do a "ldloc.0" to get the value from the variable, the MSIL just loads the constant value which is hardcoded into the MSIL. As such, there's usually a small performance and memory advantage to using constants. However, in order to use them you must have the value of the variable at compile time, and any references to this constant at compile time, even if they're in a different assembly, will have this substitution made.

Constants are certainly a useful tool if you know the value at compile time. If you don't, but want to ensure that your variable is set only once, you can use the readonly keyword in C# (which maps to initonly in MSIL) to indicate that the value of the variable can only be set in the constructor; after that, it's an error to change it. This is often used when a field helps to determine the identity of a class, and is often set equal to a constructor parameter.

小开

The const keyword tells the compiler that it can be fully evaluated at compile time. There is a performance & memory advantage to this, but it is small.

小开

Constants in C# provide a named location in memory to store a data value. It means that the value of the variable will be known in compile time and will be stored in a single place.

When you declare it, it is kind of 'hardcoded' in the Microsoft Intermediate Language (MSIL).

Although a little, it can improve the performance of your code. If I'm declaring a variable, and I can make it a const, I always do it. Not only because it can improve performance, but also because that's the idea of constants. Otherwise, why do they exist?

Reflector can be really useful in situations like this one. Try declaring a variable and then make it a constant, and see what code is generated in IL. Then all you need to do is see the difference in the instructions, and see what those instructions mean.

小开

const is a compile time constant - that means all your code that is using the const variable is compiled to contain the constant expression the const variable contains - the emitted IL will contain that constant value itself.

This means the memory footprint is smaller for your method because the constant does not require any memory to be allocated at runtime.

小开

As per my understanding Const values do not exist at run time - i.e. in form of a variable stored in some memory location - they are embeded in MSIL code at compile time . And hence would have an impact on performance. More over run-time would not be required to perform any house keeping (conversion checks / garbage collection etc) on them as well, where as variables require these checks.

小开

Besides the small performance improvement, when you declare a constant you are explicitly enforcing two rules on yourself and other developers who will use your code

  1. I have to initialize it with a value right now i can't to do it any place else.
  2. I cannot change its value anywhere.

In code its all about readability and communication.

小开

tl;dr for local variables with literal values, const makes no difference at all.

Your distinction of "inside methods" is very important. Let's look at it, then compare it with const fields.

Const local variables

The only benefit of a const local variable is that the value cannot be reassigned.

However const is limited to primitive types (int, double, ...) and string, which limits its applicability.

Digression: There are proposals for the C# compiler to allow a more general concept of 'readonly' locals (here) which would extend this benefit to other scenarios. They will probably not be thought of as const though, and would likely have a different keyword for such declarations (i.e. let or readonly var or something like that).

Consider these two methods:

private static string LocalVarString()
{
var s = "hello";
return s;
}


private static string LocalConstString()
{
const string s = "hello";
return s;
}

Built in Release mode we see the following (abridged) IL:

.method private hidebysig static string LocalVarString() cil managed
{
ldstr        "hello"
ret
}


.method private hidebysig static string LocalConstString() cil managed
{
ldstr        "hello"
ret
}

As you can see, they both produce the exact same IL. Whether the local s is const or not has no impact.

The same is true for primitive types. Here's an example using int:

private static int LocalVarInt()
{
var i = 1234;
return i;
}


private static int LocalConstInt()
{
const int i = 1234;
return i;
}

And again, the IL:

.method private hidebysig static int32 LocalVarInt() cil managed
{
ldc.i4       1234
ret
}


.method private hidebysig static int32 LocalConstInt() cil managed
{
ldc.i4       1234
ret
}

So again we see no difference. There cannot be a performance or memory difference here. The only difference is that the developer cannot re-assign the symbol.

Const fields

Comparing a const field with a variable field is different. A non-const field must be read at runtime. So you end up with IL like this:

// Load a const field
ldc.i4       1234


// Load a non-const field
ldsfld       int32 MyProject.MyClass::_myInt

It's clear to see how this could result in a performance difference, assuming the JIT cannot inline a constant value itself.

Another important difference here is for public const fields that are shared across assemblies. If one assembly exposes a const field, and another uses it, then the actual value of that field is copied at compile time. This means that if the assembly containing the const field is updated but the using assembly is not re-compiled, then the old (and possibly incorrect) value will be used.

Const expressions

Consider these two declarations:

const int i = 1 + 2;
int i = 1 + 2;

For the const form, the addition must be computed at compile time, meaning the number 3 is kept in the IL.

For the non-const form, the compiler is free to emit the addition operation in the IL, though the JIT would almost certainly apply a basic constant folding optimisation so the generated machine code would be identical.

The C# 7.3 compiler emits the ldc.i4.3 opcode for both of the above expressions.


提交答案