Lab 6: Making a program persistent

Transcription

1 Lab 6: Making a program persistent In this lab, you will cover the following topics: Using the windows registry to make parts of the user interface sticky Using serialization to save application data in an binary format Automating the load and save process so that the program will always resume from where it left off In this lab, you will complete the Investments application developed over the previous labs, adding persistence mechanisms that will save user-interface and application data. 1. Returning to the Investments application/project We will extend the InvestmentUI application started in lab 4 and extended in lab 5. To re-open this application, EITHER: Run Visual Studio.NET and from the start page click on the Entry for InvestmentUI in the existing applications list OR: Run Visual Studio.NET and from the File menu select File Open Project, locate the Solution (.sln) file for your project and open this If you did not complete lab5, or would prefer to start with a fresh version of it, download the InvestmentUI.zip file from the Labs section of the website and extract the project folder to the folder where you keep your VB.NET projects. Then proceed as above. The project should open as the complete solution to lab Saving UI Information to the Windows Registry (optional) Note that program access to the computer registry is not always possible (e.g. if you are working in a lab where restrictions are in place to prevent malicious damage to a computer). Therefore, you may not be able to make this facility work properly. However, the exception handling used will inform you if such restrictions are in place and the program would work on a home PC if you subsequently transport it. We will save a few pieces of information to the registry and could save many more, but you should accept the limitation that only a small amount of data should ever be sent to this location in the interest of saving the host computer from becoming gummed up with a lot of inappropriate data. The information save will be: 1. The location of the main program window on the PC screen 2. The time and date the application was last used Writing data to the registry is done by using the SaveSetting() sub, which is used as follows: A.McMonnies, CIS Lab 6, Page 1 02/02/2004

2 SaveSetting(<ProgramName>, <SectionName>, <SettingName>, <SettingValue>) All of the parameters to this sub are required to be strings. The first three parameters will always be string (since they are names), but the fourth could be anything a number, date, time or Boolean. Therefore, we may need to translate any value sent to the registry to a String, usually by using the ToString() method of an existing data type. The code to send our selected values to the registry should be in a routine that will execute just before the application shuts down the Form.Closing() event handler for the main form (frminvestments) is ideal for this. Double-click on the background of the main application form to generate the outline for the Form_Load event handler. Leave this as it is for now we will add code to it in the next section. From the Method Name box at the top-right of the code window, pull down the list of event handler names and select the Closing() event (they are organised into alphabetical order. This will cause the outline for the frminvestments.closing() method to be created in the code window. Now add the four statements shown below to this event handler (note they have been formatted here to fit on the page each statement can instead be placed on a single line by just missing out the _ line continuation sequences: Private Sub frminvestments_closing(byval sender As Object, _ ByVal e As System.ComponentModel.CancelEventArgs) _ Handles MyBase.Closing Try SaveSetting(Application.ProductName, "FormPosition", _ "Left", Me.Left.ToString()) SaveSetting(Application.ProductName, "FormPosition", _ "Top", Me.Top.ToString()) SaveSetting(Application.ProductName, "LastUsed", _ "Date", DateString) SaveSetting(Application.ProductName, "LastUsed", _ "Time", TimeString) Catch ex As Exception MessageBox.Show( "Unable to save application settings. ", _ "InvestmentUI", MessageBoxButtons.OK, _ MessageBoxIcon.Exclamation) End Try This code will save the application settings to the registry. Note that if registry access has been denied, the exception handler will display a message to indicate that this has happened. Note also that numerical values (Me.Top and Me.Left) have been converted to strings using the ToString() method. The date and time values were retrieved from the operating system as strings (DateString, TimeString) so the conversion was not necessary. A.McMonnies, CIS Lab 6, Page 2 02/02/2004

3 3. Loading UI Information from the Windows Registry (optional) Retrieving information from the registry is a simple reversal of the above process. However, a little more care is required because the information to be loaded may not be in the registry (e.g. if the application has never been run before), and because the information retrieved will always be in String format and may need to be converted. To retrieve the data that is stored in the registry by the code in the previous step, proceed as follows: Go back to the frminvestments.load() method that an outline was created for in the previous step. Add the following statements: Private Sub frminvestments_load(byval sender As System.Object, _ ByVal e As System.EventArgs) Handles MyBase.Load Dim LastUsedDate As String Dim LastUsedTime As String Me.Left = CInt(GetSetting(Application.ProductName, _ "FormPosition", "Left", "100")) Me.Top = CInt(GetSetting(Application.ProductName, _ "FormPosition", "Top", "100")) LastUsedDate = GetSetting(Application.ProductName, _ "LastUsed", "Date", "Never") LastUsedTime = GetSetting(Application.ProductName, _ "LastUsed", "Time", "") MessageBox.Show(String.Format( _ "Program was last used on {0} at {1}", _ LastUsedDate, LastUsedTime)) Test the application s persistence. You should now find that if you run the program and movie its main form to a different position and shut it down, the next time you run it, it will display a message indicating the time and date of the last shut-down, and position the form exactly where it was at that time. 4. Adding the <Serialization()> attribute and serializing the data To save the object-model data, we need to mark the Investment class as serializable using a code attribute. Code attributes in.net are markers applied to a section of code (a Class, Sub, Function or Property) that tell the.net runtime more about it. They act as settings that describe the code in some way, and a number of standard attributes are already supported in.net code. More can be added, nut that is a matter beyond the purpose of this lab. Marking a class as Serializable() makes it possible for the.net runtime to send it to a stream (either a binary stream or a XML stream) for persistence or communications purposes. In the Solution Explorer, double-click on the Investment.vb class file. The file will open in a code window (if it is not already open). Modify the first line in the module (which is currently Public Class Investment) by adding the word Serializable in angle brackets as shown: <Serializable()> Public Class Investment Private Capital As Decimal Private PIR As Single A.McMonnies, CIS Lab 6, Page 3 02/02/2004

4 ...code continues... This small modification will enable.net to save objects of the Investment class to a stream. We can now add code to the application s main form to send the entire collection of Investment objects to a stream as follows: Return to the main form s code window (frminvestments) and add the following two code routines to the form class: Private Sub SerializeData() Dim filename As String ' First, set up a suitable file name in the application's folder... filename = Application.ExecutablePath ' filename currently has the application name at the end remove ' it and add a more suitable one... filename = filename.substring(0, filename.lastindexof("\")) & _ "\Investments.dat" ' A listbox is not serializable, so extract the list of Investments ' from it and put them into an ArrayList... Dim al As New ArrayList al.addrange(lstinvestments.items) ' Now create a serialization formatter... Dim str As New IO.FileStream(fileName, IO.FileMode.Create) Dim b As New _ Runtime.Serialization.Formatters.Binary.BinaryFormatter b.serialize(str, al) str.close() Private Sub DeSerializeData() Dim filename As String filename = Application.ExecutablePath filename = filename.substring(0, filename.lastindexof("\")) & _ "\Investments.dat" ' Now try to get the serialized data from the file... Dim str As New IO.FileStream(fileName, IO.FileMode.Open) Dim b As New _ Runtime.Serialization.Formatters.Binary.BinaryFormatter ' need to read it into an ArrayList (that was what we saved)... Dim al As New ArrayList al = CType(b.Deserialize(str), ArrayList) str.close() lstinvestments.items.addrange(al.toarray()) Note that serialization and de-serialization are handled by new objects a FileStream object is used to send the data to and retrieve the data from a file. A BinaryFormatter object is used to handle the conversion from object model (the items in a listbox) to a binary stream and back. When we send the items to the stream, the BinaryFormatter is aware of the type the list of items must be converted to (a stream of binary data). However, in the reverse direction, the binary that is retrieved will be simply regarded as some type of object (there is no ArrayListFormatter to format it automatically into an ArrayList), so we must make a type conversion (or a cast) to return the data into an ArrayList; the CType() function does this. A.McMonnies, CIS Lab 6, Page 4 02/02/2004

5 Note also that because the.net runtime system does not know how to send the contents of a ListBox to a stream, when we save the data we first move it into an ArrayList (using al.addrange()) and when we retrieve it, we read into an ArrayList and then add it to the ListBox (using lstinhvestments.items.addrange()). 5. Automating the Save and Load processes The two routines described in section 4 will handle the saving and retrieving of the object model data to and from a binary stream. The final step is to make sure that they are executed when the application is used serialize the data when the program is shut down, and retrieve it when it is started up. Add a call to DeSerializeData() at the end of the frminvestment.load() method to ensure that the data is retrieved when the application is started up. Note that it is possible that the data file does not exist, since this may be the first time the application has been run. Therefore, you will need to guard against an attempt to open a non-existent data file. The easiest solution will be to insert the call to DeSerializeData() into the Try block of a Try..Catch..End Try exception handler, displaying a suitable message in a message box if an exception occurs. Add a call to SerializeData( ) at the end of the frminvestment.close() method to ensure that the data is saved at the same time as the form settings. It is a parameterless Sub, so simply add the name to the end of the.close() method. There will be no need to guard against problems here the program will always be able to create a new data file. Having completed this lab, you should be able to Make use of the registry read and write methods ( GetSetting() and SaveSetting() ) to store small amounts of application data to the Windows Registry Handle the conversions between application data and Strings, which are the required data format for the registry Make a class serializable by adding the <Serializable()> attribute Send object model data to and retrieve it from a binary stream. A.McMonnies, CIS Lab 6, Page 5 02/02/2004