Variable value assign and retrieve

Question

How does variable assigning (setting) and retrieve value works in the background? For example:

{ 
   int myValue;
   myValue = 5; //here we assign value (set)
   Console.WriteLine(myValue); // here we retrieve value
}

So here we first declare value. In next line we assign value (does it work the same way as setting the property). Also, when retrieving value, does it work the same way as get in properties.

Next question:

If we have TextBox control, which has Text property. Lets say, name of text box control is myTextBox.

myTextBox.Text = "Michael"; // here we set value
string result = myTextBox.Text; // here we retrieve (get) value

Does this works same as { get; set; } method in fields-properties?

Answer 1

You can look at the IL if you want. Here's a simple sample using linqpad:

void Main()
{
    int i ;
    i=5 ;
    i.Dump();

    i_p = 6;
    i.Dump();

}

// Define other methods and classes here
public int i_p {get; set;}

and here's the IL for it:

IL_0000:  nop         
IL_0001:  ldc.i4.5    
IL_0002:  stloc.0     // i
IL_0003:  ldloc.0     // i
IL_0004:  call        LINQPad.Extensions.Dump
IL_0009:  pop         
IL_000A:  ldarg.0     
IL_000B:  ldc.i4.6    
IL_000C:  call        UserQuery.set_i_p
IL_0011:  nop         
IL_0012:  ldloc.0     // i
IL_0013:  call        LINQPad.Extensions.Dump
IL_0018:  pop         
IL_0019:  ret         

get_i_p:
IL_0000:  ldarg.0     
IL_0001:  ldfld       UserQuery.<i_p>k__BackingField
IL_0006:  stloc.0     
IL_0007:  br.s        IL_0009
IL_0009:  ldloc.0     
IL_000A:  ret         

set_i_p:
IL_0000:  ldarg.0     
IL_0001:  ldarg.1     
IL_0002:  stfld       UserQuery.<i_p>k__BackingField
IL_0007:  ret         

nothing too fancy happening there, if that is what you were asking.

The point of having properties is to avoid having public variables, and to enable you to encapsulate (read hide), your implementation.

So, using a property, you can in the setter alter it, apply validation logic, change other variables, etc, (you shouldn't, btw), or better yet, in the future, if you need to change the backing variable type, you can do it without breaking public interfaces.

Answer 2

If you set a variable the memory that corresponds to the variable will be filled with the value you assign to that variable. If you use {get; set;} you are using what is called autosetter/getter. The compiler will automatically insert a private value. For example if you have

public int myVariable {get; set;}

The compiler will make this:

private int _myVariale;

public int myVariable{
    get {return _myVariale;}
    set {_myVariale = value;}
}

So the concept of properties is something that build on top of variables. You can see the C# properties with its get and set syntax also as API sugar. In other programming languages you will implement functions like int GetMyVariable() and void SetMyVariable(int value) to implement properties.