08-01. Saving data

As I write the boilerplate, let me explain the background to this programme.

We're going to learn how to store data more permanently to secondary storage, such as a drive.

We'll need to use the I O library to do that.

When we use variables, constants, arrays and lists, the data is held temporarily in the main memory.

That's the cache and the ram.

If we close our programme, we lose the data and have to input it again.

It's more useful to store data in text files so you can load it again in the future.

There are lots of different standards for structured text files, such as XML and JSON, but to keep things simple, we'll store our data in what's known as a serial text file.

More complex data can also be stored and retrieved from databases, but that's something we'll learn in the future.

In the main programme, we want to get the name of a user that we have stored in a file.

So we'll identify a new variable called user, and that becomes the result of a subprogram we'll write in a moment called load.

That will require the file name.

So as an argument, datafile.txt.

so, just to be clear here, load is not a command, it's a subprogram we need to write.

Oops, I've written the same line of code twice.

This is a mistake.

I'll leave it in to show you that it won't make any difference.

And these sorts of errors could go unnoticed, lurking in the background, doubling the drive read and write cycles, reducing the lifespan of the drive.

Maybe the compiler will pick this up as redundant code and remove it.

Who knows?

We'd have to analyse the execution of the programme to know.

Let's just finish the main programme by outputting some text this programme was written by, and then the user variable, which we'll get from the data file.

Okay, so now let's write the subprogram that will read the data from our datafile.txt file and return it back to the main programme.

Static string load and we want a parameter, filename.

We need a variable representing the open file in C.

We do this with what is known as a stream reader.

So stream reader file becomes a new stream reader using the filename as an argument.

The variable file is also known as a pipe.

It's effectively a communication link between the programme and somewhere on our drive where the file is stored.

How that all works we'll leave to the operating system.

The string user, variable then becomes what we read from the file.

So file readline Note how we can use readline to read from both the keyboard and and the file.

The data in our, user variable will contain a hidden character at the end that we can't see when we look at the file.

But it would tell the computer it was the end of a line of data in the file.

This is known as an end of line marker.

There may also be an end of file marker too.

We need to get rid of these and Trim does this for us.

Important to close and open file as quickly as you can.

Although modern operating systems are good at preventing file corruptions, it is possible that if our programme or computer crashes with an open file, things can go wrong in the data in the file.

So it's considered good practise to do the minimum number of commands while the file is open.

That's why we don't leave closing the file to the end of the subprogram.

Finally, we want to return the user variable back to the main programme for this programme.

That's it.

We could give it a run now and it would do what we want.

Read the text from the datafire.txt file and output it to the screen.

However, while we're here, I'll show you how to save data from a programme too.

As always, for problem decomposition and reusable components, we'll use a subprogram for this static void save.

And we'll take our user variable, although this could be any variable and the file name as parameters.

This time we need a stream writer to write to a file.

So Streamwriter, file becomes a new stream writer using, the file name.

Note that data can only go in one direction at a time, either from the drive or to the drive.

Although you can have as many pipes as you want open, so you could have one pipe for reading while another one is writing.

We now write the user variable to the file using the writeline command we're already familiar with.

You just can't read and write to the same file at the same time?

Well, not using this, approach anyway.

Finally, we close the file.

Now we have two handy, subprograms for reading and writing a variable to a file.

If the file exists but is empty, you'll get an empty string from it.

If the file does not exist, the programme will crash at the moment as it can't find the file.

We can fix that in future programmes.

Let's give it a quick run and cheque that the load subprogram works.

It won't do anything with the save subprogram because we didn't call that?