I know this is a dumb question and I guess it must have been asked before. However I am unable to find an answer to my question.
Here is some sample code (which of course does not compile) to outline my problem:
class test
{
int[] val1;
string val2;
static bool somefunction(test x, test y)
{
dosomestuff()
test result;
while(result is nothing)
{
if(somecondition){result=new test(something);}
}
}
}
The problem which I have is in the following line:
while(result is nothing)
This is the syntax from VB, which of course is not what the C# compiler accepts. Could somebody tell me how to resolve the problem?
Use the typeof operator to check if a variable is defined or initialized, e.g. if (typeof a !== 'undefined') {} . If the the typeof operator doesn't return a string of "undefined" , then the variable is defined.
There is no way in the C++ language to check whether a variable is initialized or not (although class types with constructors will be initialized automatically). Instead, what you need to do is provide constructor(s) that initialize your class to a valid state.
In c programming language, variable can be initialized in the declaration statement of any block (either it may main's block or any other function's block). While declaring a variable you can provide a value to the variable with assignment operator.
Initialization of Variable int a=10; int a=b+c; a=10; a=b+c; Multiple variables can be initialized in a single statement by single value, for example, a=b=c=d=e=10; NOTE: C variables must be declared before they are used in the c program.
TL;DR:
if (Object.Equals(
myVariable
, default(
MyVariableType
)))
myVariable
and MyVariableType
.if (myVariable == null)
will not work[1]with value types.
(See further below for short intros to reference types vs. value types and struct
s.)
The value types mainly are struct
s (e.g. DateTime
), including[2] the simple types like int
, and enum
erations. Value types don't support a null
value (intrinsically).
The exception and the fix to this are nullable types: Essentially these add null
to the possible values of a struct type. They are structurally the same as the Maybe<T>
you might know from other languages[3]. You create them with ValueType?
(e.g. int?
) which is syntactic sugar for Nullable<ValueType>
.
if (Object.Equals(myVariable, default(MyVariableType)))
(This will work both for reference types (objects) and value types.)
Note that you have to replace MyVariableType
manually – unfortunately you can not do
if (Object.Equals(myVariable, default(myVariable.GetType())))
because default()
only accepts a type name directly. (I suppose it evaluates at compile-time.)
Put simply, structs are cut-down classes. Imagine classes that don’t support inheritance or finalizers, and you have the cut-down version: the struct. Structs are defined in the same way as classes (except with the
struct
keyword), and apart from the limitations just described, structs can have the same rich members, including fields, methods, properties and operators.
[Cited from: http://www.albahari.com/valuevsreftypes.aspx ]
Classes are reference types: A class variable (or more specifically, its memory area) only contains a pointer to an other memory area, where the actual object instance data is stored.
Value type variables directly contain the data. This may yield a speed benefit due to cache locality and saving the lookup. But it may also be detrimental to performance in the case of more complex structs.
Footnotes:
[1] It does not even throw an error. myVariable == null
will always just yield false
, because your myVariable
will be initialized with the non-null
default value (zero (equivalent) or a struct of zeros and null
s). This default value is available with default(Type)
.
[2] Technically the simple types (all built-in types except string
and object
) are structs. Side note: The built-in types are aliases for types from the System namespace.
[3] E.g. in Haskell. In C# Maybe<T>
is not built-in, but can be implemented. It provides Nothing
as a more explicit/self-documenting version of null
both for classes and structs.
[4] There is no [4]. No really, you can go and check.
The syntax you are looking for is:
while (result == null)
You also have to set result = null;
to start with also
while (result == null)
while (result ==null )
if that's what you mean
Although you have an answer you're happy with, there's something behind this you may find interesting or helpful.
There is a difference between C# and VB.NET. In VB.NET you can write:
Dim b as Boolean
And in C# you can write:
bool b;
They are subtly different. In VB.NET, b
has been given the value false (in other words, it has already been initialized). In C#, b
has no value (it is uninitialized). C# goes to a lot of effort to make sure you cannot examine the value of a variable that has never been initialized.
So you are not testing whether the variable is initialized. In VB.NET there is no such thing as an uninitialized variable. In C# it is impossible to get the value of an uninitialized variable in order to compare it with anything.
You're testing whether the variable has been initialized to null
or Nothing
.
while(result == null)
The equivalent of nothing in C# is null.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With