Non Primitive Types

Non-primitive types include

• Classes

• Strings

• Structs

• Arrays

• Enums

• And more

Classes

Classes have fields and methods. They are used to create objects, which become instances of those classes.

To create a class, we write:

public class Person
{
  // Field
  public string Name;

  // Method
  public void Introduce()
  {
    Console.WriteLine("Hi, name is " + Name);
  }
}

Note: ``public` is an access modifier. It determines who can access the class or field or method.

Creating objects

Creating an object is sort of like declaring any variable: you provide a type and a variable name.

int number;
Person person = new Person();

The only difference is that you have to explicitly call new ClassName(). (You do this to tell C# to allocate memory for your object.)

Note: You can use var Person = new Person(); here too, and C# will make a best guess what data type the variable is.

The static modifier

A static modifier uses the static keyword to make a field or method accessible via the class itself (instead of the object instance).

public class Calculator
{
  public static int Add(a, b)
  {
    return a + b;
  }
}

int result = Calculator.Add(1, 2);

Note: When you use static, the field or method is not accessible in the object instance. At the same time, this means the field or method is not duplicated in memory for every object instance either; it's only found once in the class itself.

Structs

Structs are like classes except more lightweight (there a lot of subtle differences).

Pro tip: 99% of the time, you'll be creating classes, not structs. Use structs when you want something small and lightweight. This is especially useful if you're creating 1000s of objects of that type, as small and lightweight means less load for the computer.

Good candidates for structs:

public struct RgbColor
{
  public int Red;
  public int Green;
  public int Blue;
}

public struct Coordinate
{
  public float Latitude;
  public float Longitude;
}

Note: All primitive data types like int or bool are actually structs! To see this for yourself, just type int number; and hover over int. As a result, these 2 variable declarations are the same!

int number;
Int32 number;

Arrays

Arrays store a fixed-size collection of variables of the same type.

// This is an array that accepts 3 integers
int[] numbers = new int[3] { 1, 2, 3 };

// Alternatively, you can add the items after initialization
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;

Note: Once again, we use the new keyword to explicitly allocate memory for the array, as C# won't do that automatically for us.

Pro tip: When you create a new array, internally you are actually creating an instance of a class. That's why it looks like a class so much.

Incomplete arrays

Notice what happens when you use an array where not all items have been set in the array:

int[] numbers = new int[3];
numbers[0] = 1;

Console.WriteLine(numbers[0]); // prints 1
Console.WriteLine(numbers[1]); // prints 0
Console.WriteLine(numbers[2]); // prints 0

When items are not set in an array, the value falls back to the default for that data type. In this case, the default for int is 0.

Strings

Strings are just sequences of characters denoted by the double quotes: "hello world".

// String literal
string name = "Dan Fitz";
// String concatenation
string anotherName = firstName + " " + lastName;
// String format
string altName = string.Format("{0} {1}", firstName, lastName);
// String join (using an array)
var numbers = new int[3] { 1, 2, 3 };
string list = string.Join(",", numbers);
// Accessing string characters
string simpleName = "Mosh";
char firstChar = simpleName[0];

Strings are immutable. Once you create them, you can't change them.

string name = "Dan";
name[0] = "M"; // doesn't work

Verbatim strings prefix @, so you don't have to use escape characters in your string.

// String with escape characters
string path = "c:\\projects\\project1\\folder1";
// Verbatim string
string path = @"c:\projects\project1\folder";

Note: Behind the scenes, strings are actually classes. As a result, these 2 variable declarations are the same!

string firstName = "Dan";
String lastName = "Fitz";

Enums

Enums are data types that represent a set of name-value pairs or constants.

Pro tip: Enums are especially useful when you have a set of constants in your application, so it's cleaner to group them together.

// Instead of this...
const int RegularShipping = 1;
const int ExpressShipping = 2;

// Do this
public enum ShippingMethod
{
  Regular = 1,
  Express = 2;
}

Note: Think of the integers as ids for each constant in the enum.

Enums are useful for getting at values when you have one already available.

// Get an int from an enum using casting
var method = (int)ShippingMethod.Express; // returns 2

// Get an enum from an int using casting
var methodId = (ShippingMethod)2; // returns "Express" enum

// Parse a string into an enum
var shippingMethod = Enum.Parse(typeof(ShippingMethod), "Express"); // returns "Express" enum

Note: Enum.Parse is a way of converting a data type into a specified enum.

Reference vs. Value Types

As mentioned previously, it turns out that all primitive data types are structs because they're smaller; they take no more than 8 bytes of memory. And all non-primitive data types like arrays and strings are classes; they're treated differently during memory management.

Structs are value types because

• Memory is allocated on the stack

• Memory is allocated automatically

• When value is out of scope, it is removed from the stack

Classes are reference types because

• Memory is allocated on the heap (more sustainable data structure)

• Memory must be manually allocated using new

• When object is out of scope, it will remain in the heap for a little while; later, it will be garbage collected by the CLR

Copying vs. referencing

When you assign a variable containing a value type into a new variable, that value is copied in memory. As a result, those 2 variables are independent: changing one doesn't change the other.

var a = 10;
var b = a;
b++;

Console.WriteLine(a); // prints 10
Console.WriteLine(b); // prints 11

Behind the scenes, a is in the stack. Then we copy the contents of a into a new memory location in the stack that we call b.

In contrast, when you assign a variable containing a reference type into a new variable, that value is referenced in memory. In other words, both variables are pointing to the same location in memory: changing one changes the other (because they're the same thing).

var array1 = new int[3] { 1, 2, 3 };
var array2 = array1;
array2[0] = 0;

Console.WriteLine(array1[0]); // prints 0
Console.WriteLine(array2[0]); //prints 0

Behind the scenes, the variable array1 is stored in the stack containing a memory address that references a memory location in the heap containing the contents of the actual array. As a result, when you store the contents of array1 to array2, you're just copying the memory address.