private const string requireNonPrintableChar = new string('\x0005', 1);
I do not expect this value to change. I was told once upon a time it's good practise to use const for values you don't expect to change.
However msbuild is saying:
"Error 1 The expression being assigned to requireNonPrintableChar' must be constant"
am assuming that char doesn't count as a const but why?
The msdn says it can be a string which I believe it is.
Simply do:
private const string requireNonPrintableChar = "\x0005";
new string('\x0005', 1) is an expression that does get evaluated to a string, but it is not a compile-time constant, and const fields can only be assigned values which can be evaluated at compile time.
A constant has to be defined directly. You can't use functions to get your const value.
Instead of doing this
const string MY_CONST = test();
static string GetValue()
{
return "Hello";
}
You should do this
const string MY_CONST = "Hello";
If you want to use method initialization you could use static readonly like this
private static readonly string requireNonPrintableChar = new string('\x0005', 1);
Source
You can do what w0lf said:
private const string requireNonPrintableChar = "\x0005";
But if you want your second paramter for cound, use:
private static readonly string requireNonPrintableChar = new string('\x0005', 1); // should be greater than 1
Related
This question already has answers here:
Why does interpolating a const string result in a compiler error?
(6 answers)
Closed 3 years ago.
I was writing this piece of code:
public const int MAJOR_VERSION = 3;
public const int MINOR_VERSION = 3;
public const string VERSION_STRING = $"v.{MAJOR_VERSION}{MINOR_VERSION}";
And, maybe not surprisingly, the compiler was complaining:
"The expression being assigned to VERSION_STRING must be constant"
I understand that const expressions are meant to be propagated by the compiler, but in this particular case, the string can very easily be statically created because it depends only on other constants.
So perhaps someone can explain to me why this is not already a feature of the language?
Or maybe even, why it's silly of me to ask such a question..
Thanks in advance. :)
You have this error because the $ symbol in front of a string is a shortcut for calling String.Format(). String.Format() being a method, its return value cannot be stored in a constant.
When we use const keyword, then the values of string interpolation must be a compile-time constant. Using a string interpolation requires .NET code to execute which can only occur when the application is running, not during compile time.
So instead of const you can use static readonly:
public const int MAJOR_VERSION = 3;
public const int MINOR_VERSION = 3;
public static readonly string VERSION_STRING = $"v.{MAJOR_VERSION}{MINOR_VERSION}";
The string you are trying to set is not a constant value, because it is derived from other variables/constants.
Try static readonly instead
public static readonly string VERSION = $"v.{MAJOR_VERSION}{MINOR_VERSION}";
To explain why the C# team couldn't have made this a compile time feature:
The result of $"{}" or string.Format() can vary at runtime depending on the culture of the machine it's running on at the time.
For example see here that the VERSION is a constant but the resulting strings are different.
const double VERSION = 3.3;
string withDots = String.Format(new System.Globalization.CultureInfo("en-GB"), "{0:N}", VERSION));
// "3.3"
string withCommas = String.Format(new System.Globalization.CultureInfo("fr-FR"), "{0:N}", VERSION));
// "3,3"
Can seems to be strange, but is there a way to declare or convert variable to constante something like :
string myVariable = "MyString";
const string myConstant = myVariable ;
I need this to answer to my problem:
linq to sql startwith performance indexed columns
thanks
no there is no way to do this for Const Const values are burned directly into the call-site at compile time, Instead you could make it readonly and assign it in the constructor
something like
string myVariable = "MyString";
readonly string myConstant="test" ;
public MyClass()
{
myConstant= myVariable ;
}
No, you cannot initialize a constant using the value of a variable.
Constants must be known at compile time, and the value of a variable is not known until runtime, making it conceptually impossible.
Otherwise, change your first variable to a constant like below :
const string myVariable = "MyString";
const string myConstant = myVariable ;
No, you can't use a variable to initialize a field. The compiler may re-arrange the order these are initialized in, myConstant could be initialized first, in which case myVariable would be not be set.
Constants cannot vary because they are not variables setting it to a variable would be varying it. So the answer is no at least not at runtime.
Maybe you just want something that can't be set many places then readonly might work.
reference: http://msdn.microsoft.com/en-us/library/acdd6hb7.aspx
public readonly string _myROString = "set once";
Well is not possible. But someone find an answer to my initial question without constant. thanks
linq to sql startwith performance indexed columns
This answer does not provide solution to the question posted; But may satisfy the requirement for some viewers who like to access string in a static manner which should be appended with other strings,
public enum NameTypes
{
First, Last
}
public static class UserDetails
{
public static string NameText = "Name Info: " + NameTypes.First.ToString();
}
I'm having this problem and searching for solutions, but didn't find a situation similar to mine.Here's what I have:
in a class file X.cs:
namespace BlaBla{
public class X{
public const string foo = "foo";
// other code
}
public class Y{
public const int bar = 0;
}
}
and in some other class, I'm writing:
private const string someString = X.foo + Y.bar + "";
it keeps giving me a compile error:
The Expression assigned to someString must be constant
although they are both constant! when I remove Y.bar the error is removed and I dont know why. Any help ?
You're using the const keyword wrong. You probably want to define someString as:
private readonly someString = X.foo + Y.bar;
When a variable is marked as const they are compiled in to the assembly and then optimised. While Y.bar is defined as const, you're implicitly invoking its ToString() method which makes it not constant.
You're including a conversion from int to string. Even though the int is a constant, the conversion isn't considered a constant expression.
You can demonstrate that more simply:
class Test
{
const int X = 10;
const string Y = "X: " + X;
}
See section 7.19 of the C# specification for more details about what counts as a constant expression.
The expression looks constant, but it requires evaluation so that value can be figured out.
Is there any specification for the order in which static readonly parameters are initialized?
In the following example, can one be sure, the array is always created with a length of 6?
public class Foo {
private static readonly int MAX_STACKSIZE = 6;
private static readonly int[] m_stack = new int[MAX_STACKSIZE];
}
Or is there any chance of m_stack being initialized before MAX_STACKSIZE ?
#Edit: changed const to static readonly
EDIT: This answer was written when the sample code contained "const" instead of "static readonly". It's not valid for the current version of the question - I may write another answer to deal with that at some point, but I don't have time right now.
That won't be valid C# anyway, as you can't set a const int[] to anything other than null.
However, in the more general case, section 10.4 of the C# spec applies:
Constants are permitted to depend on other constants within the same program as long as the dependencies are not of a circular nature. The compiler automatically arranges to evaluate the constant declarations in the appropriate order.
It then gives the following example:
class A
{
public const int X = B.Z + 1;
public const int Y = 10;
}
class B
{
public const int Z = A.Y + 1;
}
and says...
the compiler first evaluates A.Y, then evaluates B.Z, and finally evaluates A.X, producing the values 10, 11 and 12 in that order.
I know this is probably just a terminology mismatch but if i'm not mistaken i believe c# is? unless i'm missing something obvious??
...
private const uint URL_COUNT = 18;
private string[] _urls;
public Redirector()
{
this._urls = new string[URL_COUNT];
...
}
...
Results in “A constant value is expected “ and underlines URL_COUNT in the array definition??
Whats URL_COUNT if it isn’t a const -ant value?!?!
EDIT
Phew, i thought for a second then i was going mad. I'm glad no one could repro this as that means it's just a local thing.
Thanks for your help guys.
This will only fail to compile when you supply both the dimension lengths and an array initializer. For example:
this._urls = new string[URL_COUNT];
will be fine, but:
this._urls = new string[URL_COUNT] { "One", "Two" };
will not. The latter requires a constant expression. Note that a const variable is not a constant expression, just a constant value. From the C# specification (3.0) par 12.6:
When an array creation expression
includes both explicit dimension
lengths and an array initializer, the
lengths must be constant expressions
and the number of elements at each
nesting level must match the
corresponding dimension length.
It is a constant and should work fine. The following code compiled fine for me with the C# 3 compiler:
using System;
class Foo
{
private const uint URL_COUNT = 18;
private string[] _urls;
public Foo()
{
this._urls = new string[URL_COUNT];
}
}
This works too, without any complaints from the compiler.
class Foo {
private const uint URL_COUNT = 18;
private readonly string[] _urls = new string[URL_COUNT];
}