Learn the difference between reference and value types in C#

Reference Fundamentals

When we compare value types with `==`, the C# compiler performs a _value_ comparison. For example, this prints `true` because the value `6` is equal to the value `6`:
```cs
int int1 = 6;
int int2 = 6;
Console.WriteLine(int1 == int2);
// Output: true
```
`int1` and `int2` are the actual value `6`. When we compare the value `6` with `6`, they're the same!




When we compare reference types with `==`, the C# compiler performs a _referential_ comparison, which means it checks if two variables refer to the same memory location. For example, this prints `false` because `d1` and `d2` refer to two different locations in memory (even though they contain objects with the same values):
```cs
Dissertation d1 = new Dissertation(50);
Dissertation d2 = new Dissertation(50);
Console.WriteLine(d1 == d2);
// Output: false
``` 


We constructed two different `Dissertation` objects which happened to have the same values. Each reference (`d1` and `d2`) point to different objects, so they are not equal.


Reference vs. Value Comparison

Before going any further, let's remind ourselves that `Dissertation` implements `IFlippable`, which has the `CurrentPage` property and `Flip()` method. You'll need this info in a minute.


In our previous example both references to the `Dissertation` object were of type `Dissertation`:
```cs
Dissertation diss1 = new Dissertation();
Dissertation diss2 = diss1;
```
Whenever we use `diss1` and `diss2` we can handle the `Dissertation` object as if it were a `Dissertation` type. Since `Dissertation` also implements the `IFlippable` interface, we can reference it that way too:
```cs
Dissertation diss = new Dissertation(50);
IFlippable fdiss = diss;
```
Now `diss` and `fdiss` refer to the same object, but `fdiss` is an `IFlippable` reference, so it can ONLY use `IFlippable` functionality:
```cs
diss.Flip();
fdiss.Flip();
Console.WriteLine(diss.Define());
// This causes an error!
Console.WriteLine(fdiss.Define());
```
This last line causes an error because `Define()` is not a method in the `IFlippable` interface. The other lines do NOT cause errors because they use members that both `IFlippable` and `Dissertation` have.


This rule also applies to base classes too, so we can refer to a `Dissertation` object as `Book`. 
```cs
Dissertation diss = new Dissertation(50);
Book bdiss = diss;
Console.WriteLine(diss.Title);
Console.WriteLine(bdiss.Title);
diss.Define();
// This causes an error!
bdiss.Define();
```
`Title` is defined for `Book`, so no error is thrown there. `Define()`, however, is not defined for the `Book` class, so we can't use it with `Book` references.
 


References of Different Types

We just saw how useful it is to have the same interface for multiple data types. This is a common concept across many programming languages, and it's called _polymorphism_.


The concept really includes two related ideas. A programming language supports polymorphism if:
1. Objects of different types have a common interface (interface in the general meaning, not just a C# `interface`), and
2. The objects can maintain functionality unique to their data type


Let's prove to ourselves that this is true in C#. We'll use the example of `Stringify`: `Dissertation` and `Book` have different `Stringify()` methods but can both be referenced as `Book`s.


Here are snippets from each class:
```cs
class Dissertation : Book
{
  public override string Stringify()
  {
    return "This is a Dissertation object!";
  }
}


class Book
{
  public virtual string Stringify()
  {
    return "This is a Book object!";
  }
}
```


Given that information, what will the below program print?
```cs
Book bk = new Book();
Book bdiss = new Dissertation();
Console.WriteLine(bk.Stringify());
Console.WriteLine(bdiss.Stringify());
```
The answer is:
```
This is a Book object!
This is a Dissertation object!
```
Even though `bk` and `bdiss` are both `Book` type references, their behavior is different. `Dissertation` overrides the `Stringify()` method, so all `Dissertation` objects (regardless of reference type) will use that method. 
 
Therefore, C# support polymorphism!


You'll never have to write `polymorphism` in your code, but this vocabulary is essential to communicating with other developers!


So remember: _polymorphism_ is the ability in programming to present the same interface for differing data types.


Polymorphism

You made it! References aren't always easy, but learning how to use them unlocks a whole new set of superpowers in C#.

In this lesson you learned that:
* Classes and interfaces are _reference types_. A variable of this type holds a reference to the data, not the data itself. This is different from _value types_ like `int` and `bool`
* The equality operator (`==`) uses a _referential_ comparison for reference types and a _value_ comparison for value types
* Multiple references can be created for a single object
* A reference and its corresponding object do not have to be the same type. For example, we can refer to a subclass object by an inherited superclass or implemented interface reference
* The functionality available to an object reference is determined by the reference's type, not the object's type
* _Polymorphism_ is the ability in programming to present the same interface for differing data types
* Referencing an object by an inherited type or implemented interface is called _upcasting_. It can be done implicitly
* Referencing an object by a derived class is called _downcasting_, which must be made explicit by adding the type name in parentheses. It may cause an `InvalidCastException` error when the code is run
* To signify that a reference is "empty" or refers to no object, we set it equal to `null`
* If a reference is not set to any value it is _unassigned_ and cannot perform any operations



Review

So far we've referred to objects with a reference of their own type, an inherited type, or an implemented interface:
```cs
Dissertation diss = new Dissertation();
Book bdiss = diss;
IFlippable fdiss = diss;
```
The process is called _upcasting_. As we saw in the last exercise upcasting allows us to work with multiple types at once. It also lets us safely store an object without knowing its specific type.
You can think of upcasting as using a reference "up" the inheritance hierarchy:

![Dissertation inherits from Book and implements IFlippable](https://content.codecademy.com/courses/learn-c-sharp/references/book-diary-dissertation-diagram.svg)


What happens if you try to _downcast_, or reference an object by a subclass? You'll need to do this when you want to access the specific functionality of a subclass. 


For example what happens when we refer to a `Book` object as a `Dissertation` type?
 
```cs
Book bk = new Book();
Dissertation dbk = bk;
// Error!
```


The code produces this error:
```
error CS0266: Cannot implicitly convert type `Book` to `Dissertation`. An explicit conversion exists (are you missing a cast?)
```

Not every downcast is possible in C#. In this case, `Dissertation` has a `Define()` method that is incompatible with `Book`. This is the computer's way of telling you: there's a chance that this cast won't work!


To get around this error, we must explicitly downcast, like below. The desired type is written in parentheses:
```cs
Book bk = new Book();
Dissertation bdk = (Dissertation)bk;
```
This essentially tells the computer: "I know the risk I'm taking, and this might fail if I'm not careful."

In many cases, the downcast will still fail. Here, the `Dissertation` type reference `bdk` can’t reference a `Book` object, so when we explicitly downcast we see that it fails with a new error message:
```
System.InvalidCastException: Specified cast is not valid.
```
There are multiple ways to deal with downcasting, including the `as` and `is` operators. We won't get into those now, but you can learn about them in the Microsoft C# Programming Guide: [Casting and type conversions](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/types/casting-and-type-conversions) if you'd like. 
For now, focus on these things:
* _Upcasting_ is creating a superclass or interface reference from a subclass reference
* _Downcasting_ is creating a subclass reference from a superclass or interface reference.
* Upcasting can be done implicitly, while downcasting cannot


Casting

So far we've seen:
* A reference to an object
* Multiple references to an object


What about a reference that refers to no object? In C# a reference to no object is called either a _null reference_ or _unassigned_. We'll need to apply these concepts in C# whenever we want to show that a reference is "missing", create a reference variable without defining it, or initialize an empty array.
 
In the first use case, we'd like to create a reference that is "missing" or empty. We set it equal to the keyword `null`:


```cs
Diary dy = null;
```
 
In the second case, if we create a reference variable without a value, it is unassigned:


```cs
Diary dy;
// dy is unassigned
```
 
In the third case, if we create an empty array of reference types, each element is an unassigned reference:
 ```cs
Diary[] diaries = new Diary[5];
// diaries[1] is unassigned, diaries[2] is unassigned, etc.
```
 
Be careful when checking for `null` and unassigned references. We can only compare a `null` reference if it is explicitly labeled `null`:
```cs
Diary dy = null;
Console.WriteLine(dy == null);
// Output: true
```
 
For the other two cases, comparing an unassigned variable we'll get an error:
```cs
Object o;
Console.WriteLine (o == null);
// error CS0165: Use of unassigned local variable 'o'
```
 
This might seem annoying at first, but it's actually a good thing: the C# compiler prevents future issues down the road by raising an error the first time an unassigned variable is used.


Null and Unassigned References

What do you think will be printed by this code?

```cs
Dissertation diss1 = new Dissertation();
Dissertation diss2 = diss1;
diss1.CurrentPage = 0;
diss2.CurrentPage = 16;
Console.WriteLine(diss1.CurrentPage);
Console.WriteLine(diss2.CurrentPage);
```

Did you guess `0` and `16`? The answer is `16` and `16`!

To understand what's happening here, we need to understand _references_. They might not be obvious in this code, but learning how to use them unlocks a whole new set of superpowers in C#. This lesson explains:
* How references work in C#
* Why references are useful
* How to upcast a reference
* How to create a null reference


Introduction to References

We know that we can use inherited classes and implemented interfaces to reference an object:
```cs
Dissertation diss = new Dissertation(50);
IFlippable fdiss = diss;
```
This allows us to work with many similar types at the same time. Imagine if we didn't have this feature and we had to "flip" a group of `Diary` and `Dissertation` types:
```cs
Diary dy1 = new Diary(1);
Diary dy2 = new Diary(30);
Dissertation diss1 = new Dissertation(50);
Dissertation diss2 = new Dissertation(49);
dy1.Flip();
dy2.Flip();
diss1.Flip();
diss2.Flip();
```
Look at all that code! It would be faster and safer if we could store the references in an array and loop through it. But would it be an array of `Diary[]` or an array of `Dissertation[]` or something else?
Since both dissertations and diaries are flippable (they both implement the `IFlippable` interface), we can create references to them as `IFlippable`s:
```cs
IFlippable f1 = new Diary(1);
IFlippable f2 = new Diary(30);
IFlippable f3 = new Dissertation(50);
IFlippable f4 = new Dissertation(49);
```


Instead of dealing with individual variables, we can use an array of  `IFlippable` references:
```cs
IFlippable[] classroom = new IFlippable[] { new Diary(1), new Diary(30), new Dissertation(50), new Dissertation(49) };
```
 
Then to "flip" each element, we can write a `foreach` loop: 
```cs
foreach (IFlippable f in classroom) 
{
  f.Flip();
}
```
 We can only access the functionality defined in the interface. For example, we couldn't access `f.Title` because `Title` isn't a property defined in `IFlippable`.


Arrays of References

While reference-type variables refer to a place in memory, value-type variables hold the actual data.

Let's put that into practice with a little code.

References vs. Values II

To better grasp the idea of reference types, let's look at the other kind of type: _value types_. While reference-type variables refer to a place in memory, value-type variables hold the actual data.


`int` is a value type, so the variable `num` holds the value `6`:
```cs
int num = 6;
```


Reference types, on the other hand, refer to a location in memory. Every class is a reference type, so the variable `diss` refers to a location in memory that has the `Dissertation` object:

```cs
Dissertation diss = new Dissertation(50);
```

Every "primitive" data type is a value type, including:
* `int`
* `double`
* `bool`
* `char`


Revisiting our metaphor: a reference is like directions to a house, which "points" to a house. It isn't the actual house. A value type is the house itself!

You might have noticed that `string` is missing here. It works a bit differently, so it will be covered in a later lesson.

 


diss1 and diss2 contain references to the object in memory. num refers to a value.

References vs. Values

Classes are _reference types_. That means that when we create a new instance of a class and store it in a variable, the variable is a _reference_ to the object.

Let's see what's happening behind the scenes. When this code is run:

```cs
Dissertation diss1 = new Dissertation();
```

A new `Dissertation` instance is constructed and stored in the computer's memory. You can imagine a slot in your computer holding the instance's type, property values, etc. `diss1` is a reference to that location in memory.

![diss1 refers to memory location](https://content.codecademy.com/courses/learn-c-sharp/references/MemoryBlocks_3.svg)


`diss1` is not the actual object, it is a _reference_ to the object. Thus an object can have multiple references:

```cs
Dissertation diss1 = new Dissertation();
Dissertation diss2 = diss1;
```

![diss1 and diss2 refer to the same memory location](https://content.codecademy.com/courses/learn-c-sharp/references/MemoryBlocks_2.svg)

Now there are two references to the same location in memory: we can say that `diss1` and `diss2` refer to the same object. If changes are made to that object, then they will be reflected in both references to it:

```cs
Dissertation diss1 = new Dissertation();
Dissertation diss2 = diss1;
diss1.CurrentPage = 0;
diss2.CurrentPage = 16;
Console.WriteLine(diss1.CurrentPage);
Console.WriteLine(diss2.CurrentPage);
```
* The middle two lines of this code are setting the `CurrentPage` property of the same object (first setting it to `0`, then `16`)
* The last two lines will print the same value, `16`
 
You can imagine references like directions to a house: they tell you where to find the house, but they are not the house itself!


