Resources

CLR?

Like Java, C# is not compiled straight to assembly / machine / native code - instead it is compiled to CIL (Common Intermediate Language) code, aka bytecode, which is portable across environments. The CLR (Common Language Runtime) is what handles converting / compiling this IL code into actual machine code for each device.

Similarly, Java compiles to Java Bytecode, which is loaded and executed on the Java Runtime Environment (JRE).

Built-in Types

What's with...

• The brackets above methods? [HttpGet], etc.
  • Those are Attributes, which are a way to inject metadata into the code which can be read during runtime
    • The process by which these attributes, or built-in metadata, is read during runtime is called reflection
• The braces at the end of members?
  • Check out the properties and accessors section
• The Type<...>, a type followed by angle brackets (aka less than and greater than) enclosing another type?
  • See generics

Properties and accessors

Members on a class in C# are generally called fields. A property is just a field (again, a class member), that has special logic for reads and/or writes to the field. The difference between many other approaches and C#'s here, is that C# lets you basically define the methods for get and set directly on the member, without requiring making it a private member, or declaring the methods separately.

The reasoning behind this and why the docs recommend using them is twofold:

1. If you a make a member field public, then the integrity of its value cannot always be ensured
2. A regular member cannot invoke logic before returning

• PS: This reason is the same reason why a lot of frameworks have something they called computed properties

With a property, you have two options for defining the get and set'ers.

Option A: Use a private member, aka a backing field as storage

This is a very common code pattern. You define a private member in your class, and then expose the methods to retrieve or set that field with custom getters / setters. Here's an example:

public class User
{
	private int _age;
	public int Age
	{
		get
		{
			return this._age;
		}
		set
		{
			if (value > 0){
				this._age = value;
			}
		}
	}
}

Within the context of C#, the private member is often called a backing field or the storage for the public methods.

You can make a property read-only by simply not defining a set method, or write-only by not defining a get method :)

Option B: Automatic properties

In C# v3.0+, you can use what they call auto-implemented properties; basically, if you want a property that gets and sets with no extra logic (getting it returns the value, setting it sets the value to what was passed), you can have the compiler automatically implement that boilerplate for you:

public class User {
	public int Age {get; set;}
}

The compiler does a few things upon seeing this:

• Creates a private member backing field
  • Note: This is auto-generated and you cannot access it directly (see 1, 2, 3)
• Hooks up the get and set logic

You might be wondering why not just use a field (public member) if get and set doesn't do anything special and is auto-generated. The answer has more to do with what other code is expecting. For example, data binding in C# expects properties, not fields, in order to work. There are other reasons as well - see this.

Another benefit here is that you can even have it generate a private setter; that will make it so you can only set the value of the variable from inside the class, not outside:

public class User {
	public int Age {get; private set;}
}

Generics

You will often see something in C# that looks like this:

User<Senior> myUser = new User<Senior>("John");

This is an example of the use of generics, where is a way for classes and/or methods to accept multiple types in the same parameter. In this case, the User class might look like this:

public class User<T> {
	public string getAgeRange(T userAgeBracket){
		// ...
	}
}

In this case, the User class accepts the "age bracket" of the user (child, adult, senior), which is another class/type, as a generic type property, T. When we instantiate the User class, we pass in the specific type for T, within the angle brackets, and the compiler replaces the instances of T with Senior.

More reading: MSDocs, TutorialsTeacher