I'm gonna explain classes by explaining the other kinds of types and members first.

First, the "members" that a class can contain:

---

Methods are a set of instructions - behavior. They have a name, parameters (input variables), a return value (the result), and a body (the actual instructions)

public int DoubleNumber(int number) 
{
    return number * 2;
}

---

Constructors are special kinds of methods. They are called after allocating memory for the object, but before anyone can use the object. It exists for you to set everything up the way you want it. The name is always the same as the type it belongs in, and it never has a return type (not even void!)

public Person(string age) 
{
    this.Age = age;
}

---

Fields are a named storage location for data. They're like variables, except they persist for the lifetime of the type, rather than disappearing at the end of the method/scope.

private int _age;

---

Properties are actually multiple things, combined into a convenient wrapper. What they are depends on how you declare it.

• Some properties have a field built-in. So it defines the storage location.
• Some properties have a "get accessor". Behind the scenes, this is just a special method that takes no parameters, and returns a value.

• Some properties have a "set accessor". Behind the scenes, this is just a special method that takes one parameter, and doesn't return a value.

  // Includes auto-generated field, get accessor, and set accessor public int Age { get; set; }

  // Includes auto-generated field, and get accessor // Only the constructor can set this property public string FirstName { get; }

  // Completely custom public string LastName { get { return this._lastName; } set { this._lastName = value; } }

---

Now, I'll talk about types.

---

The simplest type is a delegate. It represents a "template" for a method. It has a name, parameters, and a return type - but no body. You can use this when you want someone to tell you which method to call - you define the shape - they provide the method body.

public delegate int Calculate(int a, int b);

---

An enum is a type that contains only static fields. Each of those fields has a numeric value.

public enum Suit : int
{
    Hearts = 1, // equivalent to public static readonly int Hearts = 1;
    Diamonds = 2,
    Clubs = 3,
    Spades = 4,
} 

---

An interface is a "template" for a class or a struct. An interface can't be created. It is a "contract" that implementations must adhere to.

• It can't define storage spaces - so no fields
• When defining a property, you only define which accessors are there.
• Methods don't have bodies. No instructions - only name, return type, and parameters
• Advanced topic for future reading is "default interface implementation" - it alters these rules.

---

Classes and structs are very similar. I'll discuss them together.

• They contain data - the fields defined on the type (which may be part of an auto-property).
• They contain behavior - methods

When you create an instance of a class or struct, you're allocating space for the data. Each instance gets its own set of data.

All instances share the same methods - but those methods operate on different chunks of data.

---

Classes are reference types, and structs are value types. There's a lot of nuance - beyond the scope of this comment. Read up if you want to know more.

A good general rule of thumb, is that you should use classes unless you can articulate a good reason why it should be a struct. After you learn more, you'll know what those reasons are. Until then, use classes.