CODEWITHSUNDEEP
c#.netvariablesinstance-variables
Cătălin Rădoi
Cătălin Rădoi

Reputation: 1894

Ensure Variable Initialization C#

Consider this code:

public string Variable1 { get; set;}
public int Variable2 { get; set;}

public void Function()
{
 // Has been Variable1 Initialized?
}

Inside the function, I want to know if a value has been sent to Variable1 & Variable2, prior to the function call,

even if the DEFAULT values have been sent, that's ok (null for string & 0 for int)

Upvotes: 7

Views: 887

Answers (4)

Alex Voskresenskiy
Alex Voskresenskiy

Reputation: 2233

Consider using a simple wrapper like this:

public struct AssignableProperty<T>
{
    private T _value;

    public T Value
    {
        get { return _value; }
        set
        {
            WasAssigned = true;
            _value = value;
        }
    }

    public bool WasAssigned { get; private set; }

    public static implicit operator AssignableProperty<T>(T data)
    {
        return new AssignableProperty<T>() { Value = data };
    }

    public static bool operator ==(AssignableProperty<T> initial, T data)
    {
        return initial.Value.Equals(data);
    }

    public static bool operator !=(AssignableProperty<T> initial, T data)
    {
        return !initial.Value.Equals(data);
    }

    public override string ToString()
    {
        return Value.ToString();
    }
}

Then your class'll look like this:

public class Test
{
    public AssignableProperty<string> Variable1 { get; set; }
    public AssignableProperty<int> Variable2 { get; set; }

    public void Function()
    {
        if(Variable1.WasAssigned&&Variable2.WasAssigned)
            //do stuff
    }
}

You can go further and add throw Exception or contract to getter, so if somebody'll try to access uninitialized value it'll throw an exception or show you warning

Upvotes: 8

Kryptos
Kryptos

Reputation: 875

Some basics about default value in C#:

When an instance of a class (or struct) is created, all fields are initialized to their respective default value.

For reference types, it will be null. For value types, it will be equivalent to 0. This is easily explains as the memory management ensures that new allocated memory is initialized to 0x0 bytes.

Auto-properties hide the generated field, but there is one. So the same rules apply.

Now to answer your question, the best way to make sure that values are initialized is to make a constructor with one parameter for each field/property and to hide the default constructor with no parameters:

public Yourtype(String param1, Int32 param2)
{
    this.Variable1 = param1;
    this.Variable2 = param2;
}

private Yourtype() { }

Other alternatives is described in @Sean and @Alex answers if only a subset of properties/fields needs to be initialized/checked. But this hides some overhead (one bool for each property/field and some indirection).

Upvotes: 2

Sean
Sean

Reputation: 62532

For the reference types you'll need to add a flag:

string m_Variable1;
bool m_IsVariable1Set;

public string Variable1
{
  get{return m_Variable1;}
  set{m_IsVariable1Set = true; m_Variable1 = value;}
}

For the value types you can use a nullable value

int? m_Variable2;

int Variable2
{
  get{return m_Variable2.GetValueOrDefault();}
  set{m_Variable2 = value;}
}

Which you can then check to see if it's been set by using m_Variable2.HasValue.

Upvotes: 0

Charles
Charles

Reputation: 67

Well you can simply do a check on both variables to see if they have any value assigned to them in your function

public void Function()
{

    if (String.IsNullOrEmpty(Variable1) && Variable2 ==0 )
    {
      // Variables are not assigned
    }

}

Upvotes: -2

Related Questions