In this video, we'll be using the C# interactive window,

which is a REPL feature inside Visual Studio.

To open it up, we'll go to View > Other Windows > C# Interactive.

Inside this window, we can execute C# code like we can in a workspaces console.

I mentioned earlier that our stream reader deals with encoding.

Let's take a look at our text file.

It contains a string called Hello, world!

So what is a string?

Well, a string is made up of one or more characters.

That brings us to the char type.

The char is a type that represents a single character.

The way we assign a value to a char type in C# is similar to a string, but

instead of using double quotes, we use single quotes.

So here's how we'd create a char variable.

char capitalH equals,

single quote, H, and semicolon.

capitalH.

Let's go find the documentation on the char type.

C# char.

Here's something.

This page is for the keyword.

We can click on System.Char to get to the actual type.

So check this out.

It's actually a struct and not a class.

A struct is a lot like a class, but it has some limitations.

We'll get into a little more about structs later on.

It says, Represents a character as a UTF-16 code unit.

So what does it mean by UTF-16 code unit?

UTF-16 is a Unicode character encoding format.

Without going into too much detail, It's good to keep in mind that

every piece of text, even every character, has some kind of encoding behind it.

This is because computers only know how to deal with numbers, and

they need some way to translate the numbers into characters.

Encoding formats are kind of like the Rosetta Stone for computers.

Unicode formats have many characters in their sets, and each character has a code,

sometimes called a control code or a codepoint.

This is so we can accommodate languages that have way more characters than

the standard English alphabet.

Let's look up the Unicode character for the lower letter h.

Do unicode letter h.

All right, here's the capital letter H.

Let's see if we can get to it from there.

Lowercase, U+0068.

We can use this value to create a char variable.

We'll do char lowerH equals, single quote, and then a backslash,

u, and then I'll paste in that code we copied from the web page.

The backslash is indicating an escape sequence like in our directory string,

and the 0068 is a hexadecimal value that represents our lower letter h.

Each character in C# is encoded as two bytes in the default encoding of UTF-16.

lowerH.

Let's try getting the underlying bytes of our lower letter h.

byte[] unicodeBytes.

First we'll need to specify an encoding.

So UnicodeEncoding and

Unicode.GetBytes.

And it wants a character array, so I'll pass it new character array.

And we'll fill it with the lowerH.

Okay, let's see what it's got.

And there's our two bytes.

Now we can convert them back into a string.

string unicodeString equals

UnicodeEncoding.Unicode.GetString, and

we'll pass it the unicodeBytes.

And Unicode string has our letter h.

And notice it's a string because, it's got double quotes.

So what is the byte type exactly?

In C#, a byte is an integral type, an unsigned eight-bit integer.

Integral types represent whole numbers and have a minimum and a maximum value.

Unsigned means that it can only contain positive values.

An unsigned eight-bit integer can store values from 0 to 255.

Conversely, when you see that a type is signed, it means that it can have a range

of values from a negative number to a positive number.

A signed byte in C#, declared as sbyte, is also eight-bit, but

it can have a minimum value of a negative 128 and a maximum value of 127.

Let's create one.

sbyte signedByte = -128.

If we tried to assign it a constant value that's out of range, like 200,

the compiler wouldn't let us.

Let's try it.

sbyte signedByte = 200.

We'll get into other signed and unsigned integral types later in this course.

How about a character that's not usually on a keyboard, like the degree symbol,

the unit symbol for a temperature?

Let's go look it up.

Unicode degree symbol.

Here it is.

00B0.

Gonna copy that with Ctrl+C.

Get back to our code.

So here I'll say char degree equals, single quote,

backslash, u, and I'll paste in our code from the Unicode page.

Okay, now let's see what it looks like when the console prints it out.

Console.WriteLine.

We'll type a sentence, The current temperature

is 74.6, then we'll insert our degree symbol.

Whoops, I got an equal sign in here,

needs to be a plus, Fahrenheit.

The current temperature is 74.6 degrees Fahrenheit.

In the .NET framework, when strings are created in memory,

their default encoding is UTF-16.

You'll also see UTF-8, which is usually the encoding for text files.

In IO, we can specify different encodings if we need to.

But you usually don't have to worry about it unless you're dealing with

communicating with other systems that may need a different encoding.

Check out the notes if you want to read more about different encodings in .NET.