Reputation: 26632
I want to check if a variable is initialized at run time, programmatically. To make the reasons for this less mysterious, please see the following incomplete code:
string s;
if (someCondition) s = someValue;
if (someOtherCondition) s = someOtherValue;
bool sIsUninitialized = /* assign value correctly */;
if (!sIsUninitialized) Console.WriteLine(s) else throw new Exception("Please initialize s.");
And complete the relevant bit.
One hacky solution is to initialize s with a default value:
string s = "zanzibar";
And then check if it changed:
bool sIsUninitialized = s == "zanzibar";
However, what if someValue
or someOtherValue
happen to be "zanzibar" as well? Then I have a bug. Any better way?
Upvotes: 40
Views: 113098
Reputation: 1014
I would suggest initializing the variable with null
:
MyType? myVar = null;
You can then check whether it has been set to an non-null value using:
var isSet = myVar != null;
Upvotes: 0
Reputation: 184
I would agree with Vytalyi that a default value of null should be used when possible, however, not all types (like int) are nullable. You could allocate the variable as a nullable type as explained by David W, but this could break a lot of code in a large codebase due to having to refine the nullable type to its primitive type before access.
This generic method extension should help for those who deal with large codebases where major design decisions were already made by a predecessor:
public static bool IsDefault<T>(this T value)
=> ((object) value == (object) default(T));
If you are staring from scratch, just take advantage of nullable types and initialize it as null; that C# feature was implemented for a reason.
Upvotes: 1
Reputation: 102793
Code won't even compile if the compiler knows a variable hasn't been initialized.
string s;
if (condition) s = "test";
// compiler error here: use of unassigned local variable 's'
if (s == null) Console.Writeline("uninitialized");
In other cases you could use the default
keyword if a variable may not have been initialized. For example, in the following case:
class X
{
private string s;
public void Y()
{
Console.WriteLine(s == default(string)); // this evaluates to true
}
}
The documentation states that default(T) will give null
for reference types, and 0
for value types. So as pointed out in the comments, this is really just the same as checking for null.
This all obscures the fact that you should really initialize variables, to null
or whatever, when they are first declared.
Upvotes: 28
Reputation: 8236
In general, assign the default to be null
or String.Empty
. For situations where you cannot use those "empty" values, define a constant to represent your application-specific uninitialized value:
const string UninitializedString = "zanzibar";
Then reference that value whenever you want to initialize or test for initialization:
string foo = UnininitializedString;
if (foo == UninitiaizedString) {
// Do something
}
Remember that strings are immutable constants in C# so there is really only one instance of UninitializedString
(which is why the comparison works).
Upvotes: -4
Reputation: 10184
With C# 2.0, you have the Nullable operator that allows you to set an initial value of null for heretofore value types, allowing for such things as:
int? x = null;
if (x.HasValue)
{
Console.WriteLine("Value for x: " + num.Value);
}
Which yields: "Value for x: Null".
Upvotes: 13
Reputation: 23986
Here's one way:
string s;
if (someCondition) { s = someValue; }
else if (someOtherCondition) { s = someOtherValue; }
else { throw new Exception("Please initialize s."); }
Console.WriteLine(s)
This might be preferable for checking if the string is null, because maybe someValue is a method that can sometimes return null. In other words, maybe null is a legitimate value to initialize the string to.
Personally I like this better than an isInitialized
flag. Why introduce an extra flag variable unless you have to? I don't think it is more readable.
Upvotes: 3
Reputation: 33738
I pick initialization values that can never be used, typical values include String.Empty
, null
, -1
, and a 256 character random string generator .
Upvotes: 0
Reputation: 727067
You can keep a separate flag that indicates that the string has been initialized:
string s = null;
bool init = false;
if (conditionOne) {
s = someValueOne;
init = true;
}
if (conditionTwo) {
s = someValueTwo;
init = true;
}
if (!init) {
...
}
This will take care of situations when s
is assigned, including the cases when it is assigned null
, empty string, or "zanzibar"
.
Another solution is to make a static string to denote "uninitialized" value, and use Object.ReferenceEquals
instead of ==
to check if it has changed. However, the bool
variable approach expresses your intent a lot more explicitly.
Upvotes: 2