Understand why strings in C# are so unique

String, The Exception

Well done, you're a reference master now!

The concept of references, especially the nuances of the `string` type, can be difficult to understand when they aren't clearly visible in the code. Let the information sink in and play with some code to check your understanding. Once you get it, this concept will save you dozens of hours of debugging.

Here's what was covered in this lesson:

* The `String` or `string` type is a reference type
* Strings are _immutable_, which means they cannot be changed after they are created
*  Being immutable also means that a `string` reference will always point to the original object, so "modifying" one reference to a `string` will not affect other references to it
* With the equality operator (`==`), strings are checked for value, not referential, equality
* A `string` variable can be unassigned, `null`, or empty. Empty strings can be represented by `String.Empty` or `""` &mdash; they're equivalent


Review

We can prove that `String` is a class by looking up [the `String` class documentation](https://docs.microsoft.com/en-us/dotnet/api/system.string) and trying some of the methods and properties listed there.

This example uses `Length` and `Contains()`.

```cs
string s = "Hello World";
Console.WriteLine(s.Length);
Console.WriteLine(s.Contains("o"));
```

We've already seen one `static` property `Empty` and one `static` method, `IsNullOrEmpty()`:

```cs
string s = String.Empty;
bool isEmpty = String.IsNullOrEmpty(s);
```


 String as Class

Previous lessons have stated that all classes are reference types and all "primitive" values are value types.

```cs
// Reference type
Object o = new Object();
// Value type
bool b = true;
```

Do we consider `string` a reference type or a value type? 

Spoiler! Strings are technically reference types. But in action, it's a bit more complicated. Nearly every C# program uses some strings, so you'll need to know how it works. This lesson will explain the unique behavior of `string` references.

By the way: in C#, `String` and `string` are equivalent. This just gives us more options when we are coding. It's convenient for beginners because they usually see `string` introduced with other primitive value types like `int` and `bool`.


 Re-introduction to Strings

Like other reference types, `string` references can be _null_ or _unassigned_. They can also have a third value: _empty_.

```cs
// Unassigned
string s;
// Null
string s2 = null;
// Empty string
string s3 = "";
// Also empty string
string s4 = String.Empty;
// This prints true
Console.WriteLine(s3 == s4);
```

All of these signify a lack of text, but they each mean something slightly different:

* unassigned means that the programmer did not give the variable any value
* null means that the programmer intentionally made the variable refer to no object
* an empty string signifies a piece of text with zero characters. This is often used to represent a blank text field. It can be represented by `""` or `String.Empty`

The [Microsoft Programming Guide suggests](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/strings/#null-strings-and-empty-strings) using `String.Empty` or `""` instead of `null` to avoid `NullReferenceException` errors.

We can check for null OR empty strings using the static `String` method `IsNullOrEmpty()`. It's explained [in more detail in the documentation](https://docs.microsoft.com/en-us/dotnet/api/system.string.isnullorempty).


 Strings can be Null or Empty or Unassigned

`String`, or `string`, is a class that represents text. Technically its value is stored as a collection of `char` objects.

Since it is a class, it is a reference type. In some cases its behavior looks like a value type:

* A `string` reference will always point to the original object, so "modifying" one reference to a `string` will not affect other references
* Comparing strings with the equality operator (`==`) performs a value, not referential, comparison

Here are two examples of the first behavior (modifying one reference doesn't affect the others):
```cs
// Example 1
string dog = "chihuahua";
string tinyDog = dog;
dog = "dalmation";
Console.WriteLine(dog);
// Output: "dalmation"
Console.WriteLine(tinyDog);
// Output: "chihuahua"

// Example 2
string s1 = "Hello ";
string s2 = s1;
s1 += "World";
System.Console.WriteLine(s1);
// Output: "Hello World"
System.Console.WriteLine(s2);
// Output: "Hello"
```

They can be explained by the fact that strings are _immutable_: they cannot be changed after they are created. Anything that appears to modify a string actually returns a new `string` object.

Here's an example of the second behavior (value-like comparisons):
```cs
string s = "hello";
string t = "hello";
// b is true
bool b = (s == t);
```
Typically we want to compare strings by value, so this makes it easier to write in code and it also gives the C# compiler flexibility in how it implements the program (it doesn't have to worry about where the actual string value is stored).
