Let's play around with the console a little bit.

We'll delete what we did before and we'll print out hello world.

I know, I know,

you've probably done this at least ten times already but bear with me.

Console.WriteLine and "Hello, world!".

So what is the console class exactly?

We've been using it this whole time in other courses, but

what is actually going on when we tell it to read or write?

Well, we can gather that read is the input part of our IO and

write is the output, right?

Let's take a look at the documentation on the Console class by hitting F1.

Represents the standard input, output, and error streams for console applications.

So not only do we have an input and output stream, we've also got an error stream.

Let's go back to our code and open up our data.text file.

But we'll take Hello, world from our String here and cut it with Ctrl+X.

Paste it here with Ctrl+V.

Okay, now we can change the input stream of our console with a method on

the console class called SetIn.

But we need a stream first.

We need an input stream from our text file.

There's a handy class we can use called Stream reader, Stream reader.

Let's check out its documentation by hitting F1, implements a text

reader that reads characters from a byte stream in a particular encoding.

We'll talk about what it means by encoding in a bit but

let's take a look at the constructors.

That's a lot of constructors.

We're looking for one that takes a file name.

Well, here's a string, initializes a new instance of the stream reader class for

the specified file name.

We can try and use that.

First we need to get the filename.

We can use the file info class to get a single file and

make sure it exists before we try to read it.

We'll instantiate a new file info objects.

So, file = new FileInfo and it looks like it takes a file name in the constructor,

says the fully qualified name of the new file or the relative file name.

Do not end path with the directory separator character.

Got it.

We'll create a new variable to hold the file name, var filename,

we'll use the Path.Combine method, Path.Combine,

we'll give it directory.FullName and

the name of our file, which is data.txt and semi-colon.

It's a good idea to use Path.Combine when you wanna filename

because it will add the backslashes for you if they're missing.

We can pass the fileName into the FileInfo constructor, and to be safe,

we should check and make sure the file exists before trying to access it.

Let's see if there's a property on file that we can use.

file.Exists.

It returns a boolean, so we can write an IF statement,

if file.Exists, and open close curly brace.

Now we can use our StreamReader class.

var reader = new StreamReader, and

we'll pass it the file.FullName,

then we can use the SetIn method of the console class.

Console.SetIn, and we'll pass it the reader.

We'll delete this down here, too.

Now that our console input stream is set to our data.txt file,

we'll write the contents of the file to the console.

Console.WriteLine and

Console.ReadLine.

And semi-colon.

There's one final thing that we should do before we try to run this.

There is a method called close that we should call

once we're done with the stream reader.

What this does is mostly self-explanatory, it closes the stream and

it also releases the resources that are being used to read the stream.

When we deal with streams and files, we're using unmanaged memory.

In .NET, objects aren't cleaned up immediately when they're no longer needed.

It's more efficient to only clean up those objects when the computer is in need of

the memory, so it will wait as long as possible before cleaning up these objects.

It's very difficult to predict when this might happen.

The part of .NET responsible for

cleaning up these objects is called the garbage collector.

Files are unmanaged, meaning that they're not managed by the garbage collector.

We have to tell the garbage collector that it can take out our trash, and

we do that by calling the close method.

This will also let other programs on the computer use the file.

One way to know if something is unmanaged is to check to see if it implements

the interface IDisposable.

Let's click on StreamReader and go to definition.

It inherits from text reader, let's go to definition,

aha, there it is, IDisposable,

though an easier way to tell is to just check intellisense to see if it exists.

Reader.Close.

So now we just need to call it.

But what would happen if an exception is thrown after our StreamReader is created,

but before our call to close it?

Close would never be called and we'd never an open file with no way to close it.

In order to ensure that Close is called, even in the event of an exception,

we need to wrap this code in a try finally.

Try, And finally

The finally block guarantees that any code inside of it will get executed,

even if there's an exception in our try block.

You can use it with or without a catch block.

But instead of having to call the close method,

there's an even better way to do this.

We can declare and instantiate the disposable object with a using statement

surrounding a block of code.

So up here, using and then at the end,

Close paren and then our block of code and we can move our

try block in there and we can delete all of this.

>> When the program gets to the final curly brace of the using block,

the dispose method of the stream reader object will be called.

The dispose method will then call the close method, and the file will be closed.

So here when we call Console.ReadLine,

instead of reading from the prompt, it's gonna read from our text file.

Let's run it to see what happens.

Ctrl+F5 and there's our Hello, world.

So what happens when we try to read from the stream after our using blog?

Let's try it out.

Console.ReadLine.

And again we'll run with Ctrl+F5.

No.

We get an ObjectDisposedException: Cannot read from a closed TextReader.

The stream was closed by our using statement.