Section 18.2. Creating a Real-World Application
18.2. Creating a Real-World ApplicationTo see how Windows Forms can be used to create a more realistic Windows application, you'll build a utility named FileCopier that copies all files from a group of directories selected by the user to a single target directory or device, such as a floppy or backup hard drive on the company network. Although you won't implement every possible feature, this example will provide a good introduction to what it is like to build meaningful Windows applications. For the purposes of this example and to keep the code simple, you'll focus on the user interface and the steps needed to wire up its various controls. The final application UI is shown in Figure 18-8. The user interface for FileCopier consists of the following controls:
Figure 18-8. The FileCopier user interface The goal is to allow the user to check files (or entire directories) in the left tree view (source). If the user clicks the Copy button, the files checked on the left side will be copied to the Target Directories specified on the right-side control. If the user clicks Delete, the checked files will be deleted.
18.2.1. Creating the Basic UI FormThe first task is to open a new project named FileCopier. The IDE puts you into the designer, in which you can drag widgets onto the form. You can expand the form to the size you want. Drag, drop, and set the Name properties of labels ( lblSource , lblTarget , lblStatus ), buttons ( btnClear , btnCopy , btnDelete , btnCancel ), a checkbox ( chkOverwrite ), a text box ( txtTargetDir ), and tree view controls ( tvwSource , tvwTargetDir ) from the Toolbox onto your form. Then set the Text properties of the widgets until it looks more or less like the one shown in Figure 18-9. Figure 18-9. Creating the form in the designer You want checkboxes next to the directories and files in the source selection window, but not in the target (where only one directory will be chosen ). Set the CheckBoxes property on the left treeView control, tvwSource , to TRue , and set the property on the right treeView control, tvwTargetDir , to false. To do so, click each control in turn and adjust the values in the Properties window. Once this is done, double-click the Cancel button to create its click event handler, like this: protected void btnCancel_Click (object sender, System.EventArgs e) { Application.Exit( ); } You can handle many different events for the various controls. An easy way to do so is by clicking the Events button in the Properties window. From there, you can create new handlers, just by filling in a new event handler method name or picking one of the existing event handlers. Visual Studio registers the event handler and opens the editor for the code, where it creates the header and puts the cursor in an empty method body. So much for the easy part. Visual Studio generates code to set up the form and initializes all the controls, but it doesn't fill the treeView controls. That you must do by hand. 18.2.2. Populating the TreeView ControlsThe two treeView controls work identically, except that the left control, tvwSource , lists the directories and files, whereas the right control, tvwTargetDir , lists only directories. The CheckBoxes property on tvwSource is set to true , and on tvwTargetDir , it is set to false . Also, although tvwSource will allow multiselect , which is the default for treeView controls, you will enforce single selection for tvwTargetDir . You'll factor the common code for both TReeView controls into a shared method FillDirectoryTree . You'll pass in the treeview control with a boolean (also called a flag ) indicating whether to get the files that are currently present (you'll see how this works in a bit). You'll call this method from the Form's constructor, once for each of the two controls. Click on the Form1.cs tab at the top of the main window in Visual Studio to switch to the code for the form. Locate the constructor for the form ( public Form1( ) ), and add these two method calls: FillDirectoryTree(tvwSource, true); FillDirectoryTree(tvwTargetDir, false); The FillDirectoryTree implementation names the treeView parameter tvw . This will represent the source TReeView and the destination treeView in turn. You'll need some classes from System.IO , so add a using System.IO statement at the top of Form1.cs . Next, add the method declaration to Form1.cs : private void FillDirectoryTree(TreeView tvw, bool isSource) Right now, the code for Form1.cs should look like this: using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System.Windows.Forms; using System.IO; namespace FileCopier { public partial class Form1 : Form { public Form1( ) { InitializeComponent( ); FillDirectoryTree(tvwSource, true); FillDirectoryTree(tvwTargerDir, false); } private void lblSource_Click(object sender, EventArgs e) { } private void btnCancel_Click(object sender, EventArgs e) { Application.Exit( ); } private void FillDirectoryTree(TreeView tvw, bool isSource) { } } } 18.2.2.1. TreeNode objectsYou're now going to fill in the code for the FillDirectoryTree( ) method you just created. The treeView control has a property, Nodes , which gets a TReeNodeCollection object. The treeNodeCollection is a collection of treeNode objects, each of which represents a node in the tree. Start by emptying that collection. tvw.Nodes.Clear( );
You are ready to fill the treeView 's Nodes collection by recursing through the directories of all the drives. First, you need to get all the logical drives on the local system. To do so, call a static method of the Environment object, GetLogicalDrives( ) . The Environment class provides information about and access to the current platform environment. You can use the Environment object to get the machine name, OS version, system directory, and so forth, from the computer on which you are running your program. string[] strDrives = Environment.GetLogicalDrives( ); GetLogicalDrives( ) returns an array of strings, each of which represents the root directory of one of the logical drives. You will iterate over that collection, adding nodes to the treeView control as you go. foreach (string rootDirectoryName in strDrives) { You process each drive within the foreach loop. The very first thing you need to determine is whether the drive is available (that is, it is not a floppy drive with no floppy in it). My hack for that is to get the list of top-level directories from the drive by calling GeTDirectories( ) on a DirectoryInfo object I created for the root directory: DirectoryInfo dir = new DirectoryInfo(rootDirectoryName); dir.GetDirectories( ); The DirectoryInfo class exposes instance methods for creating, moving, and enumerating through directories, their files, and their subdirectories. The GeTDirectories( ) method returns a list of directories, but actually, this code throws the list away. You are calling it here only to generate an exception if the drive is not ready. Wrap the call in a TRy block and take no action in the catch block. The effect is that if an exception is thrown, the drive is skipped . Once you know that the drive is ready, create a treeNode to hold the root directory of the drive and add that node to the TReeView control: TreeNode ndRoot = new TreeNode(rootDirectoryName); tvw.Nodes.Add(ndRoot); To get the + signs right in the TReeView , you must find at least two levels of directories (so that the TReeView knows which directories have subdirectories and can write the + sign next to them). You don't want to recurse through all the subdirectories, however, because that would be too slow. The job of the GetSubDirectoryNodes( ) method is to recurse two levels deep, passing in the root node, the name of the root directory, a flag indicating whether you want files, and the current level (you always start at level 1): if ( isSource ) { GetSubDirectoryNodes(ndRoot, ndRoot.Text, true,1 ); } else { GetSubDirectoryNodes(ndRoot, ndRoot.Text, false,1 ); }
After the catch block, you throw in the following line: Application.DoEvents( ); This instructs the application to yield processing long enough to update the user interface. This keeps the user informed and happy, and avoids the problem of it looking like your program has hung while performing a long procedure. You are now finished with FillDirectoryTree( ) . See Example 18-1 later in this chapter for a complete listing of this method. 18.2.2.2. Recursing through the subdirectoriesNext, you need to create the method that gets the subdirectory nodes. Create that in a new method following the one you just finished. GetSubDirectoryNodes( ) begins by once again calling Getdirectories( ) , this time stashing away the resulting array of DirectoryInfo objects: private void GetSubDireoctoryNodes( TreeNode parentNode, string fullName, bool getFileNames, int level) { DirectoryInfo dir = new DirectoryInfo(fullName); DirectoryInfo[] dirSubs = dir.GetDirectories( ); Notice that the node passed in is named parentNode . The current level of nodes will be considered children to the node passed in. This is how you map the directory structure to the hierarchy of the tree view. Iterate over each subdirectory, skipping any that are marked Hidden : foreach (DirectoryInfo dirSub in dirSubs) { if ( (dirSub.Attributes & FileAttributes.Hidden) != 0 ) { continue; } FileAttributes is an enum ; other possible values include Archive , Compressed , Directory , Encrypted , Normal , ReadOnly , and a few others, but they are rarely used. The property dirSub.Attributes is the bit pattern of the current attributes of the directory. If you logically AND that value with the bit pattern FileAttributes.Hidden , a bit is set if the file has the hidden attribute; otherwise , all the bits are cleared. You can check for any hidden bit by testing whether the resulting int is something other than 0. Next, create a treeNode with the directory name and add it to the Nodes collection of the node passed in to the method ( parentNode ): TreeNode subNode = new TreeNode(dirSub.Name); parentNode.Nodes.Add(subNode); Check the current level (passed in by the calling method) against a constant defined for the class. By convention, member constants and variables are declared at the top of the class declaration: partial class frmFileCopier : Form { private const int MaxLevel = 2; The constant makes sure you recurse only two levels deep. The following snippet is back in the foreach loop within GetSubDirectoryNodes : if ( level < MaxLevel ) { GetSubDirectoryNodes(subNode, dirSub.FullName, getFileNames, level+1 ); }
The call to the treeNode constructor uses the Name property of the DirectoryInfo object, while the call to GetSubDirectoryNodes( ) uses the FullName property. If your directory is C:\Windows\Media\Sounds , the FullName property returns the full path, while the Name property returns just Sounds . Pass in only the name to the node because that is what you want displayed in the tree view. Pass in the full name with the path to the GetSubDirectoryNodes( ) method so that the method can locate all the subdirectories on the disk. This answers the question asked earlier as to why you need to pass in the root node's name the first time you call this method. What is passed in isn't the name of the node; it is the full path to the directory represented by the node! 18.2.2.3. Getting the files in the directoryOnce you've recursed through the subdirectories, it is time to get the files for the directory if the getFileNames flag is true . To do so, call the GetFiles( ) method on the DirectoryInfo object. An array of FileInfo objects is returned: if (getFileNames) { // Get any files for this node. FileInfo[] files = dir.GetFiles( ); The FileInfo class provides instance methods for manipulating files. You can now iterate over this collection, accessing the Name property of the FileInfo object and passing that name to the constructor of a treeNode , which you then add to the parent node's Nodes collection (thus creating a child node). There is no recursion this time because files don't have subdirectories: foreach (FileInfo file in files) { TreeNode fileNode = new TreeNode(file.Name); parentNode.Nodes.Add(fileNode); } That's all it takes to fill the two tree views. See Example 18-1 for a complete listing of this method. If you found any of this confusing, I highly recommend building Example 18-1 and stepping through the code in the Visual Studio 2005 debugger. Pay particular attention to the recursion, watching as the TreeView build its nodes. 18.2.3. Handling TreeView EventsYou must handle a number of events in this example. First, the user might click Cancel, Copy, Clear, or Delete. Second, the user might fire events in either TreeView. We'll consider the TreeView events first, as they are the more interesting, and potentially the more challenging. 18.2.3.1. Clicking the source TreeViewThere are two treeView objects, each with its own event handler. Consider the source treeView object first. The user checks the files and directories he wants to copy from. Each time the user clicks the checkbox indicating a file or directory, a number of events are raised. The event you must handle is AfterCheck . To do so, implement a custom event handler method you will create and name tvwSource_AfterCheck( ) .The implementation of AfterCheck( ) delegates the work to a recursable method named SetCheck( ) that you'll also write. The SetCheck( ) method will recursively set the check mark for all the contained folders. To add the AfterCheck( ) event, select the tvwSource control, click the Events icon in the Properties window, and then double-click AfterCheck. This will add the event, wire it up, and place you in the code editor where you can add the body of the method: private void tvwSource_AfterCheck ( object sender, System.Windows.Forms.TreeViewEventArgs e) { SetCheck(e.Node,e.Node.Checked); } The event handler passes in the sender object and an object of type treeViewEventArgs . It turns out that you can get the node from this treeViewEventArgs object ( e ). You then call SetCheck( ) , passing in the node and the state of whether the node has been checked. Each node has a Nodes property, which gets a TReeNodeCollection containing all the subnodes. SetCheck( ) recurses through the current node's Nodes collection, setting each subnode's check mark to match that of the node that was checked. In other words, when you check a directory, all its files and subdirectories are checked, recursively, all the way down. For each treeNode in the Nodes collection, check to see if it is a leaf. A node is a leaf if its own Nodes collection has a count of 0. If it is a leaf, set its check property to whatever was passed in as a parameter. If it is not a leaf, recurse: private void SetCheck( TreeNode node, bool check ) { foreach ( TreeNode n in node.Nodes ) { n.Checked = check; // check the node if ( n.Nodes.Count != 0 ) { SetCheck( n, check ); } } } This propagates the check mark (or clears the check mark) down through the entire structure. In this way, the user can indicate that he wants to select all the files in all the subdirectories by clicking a single directory. 18.2.3.2. Expanding a directoryEach time you click a + sign next to a directory in the source (or in the target), you want to expand that directory. To do so, you'll need an event handler for the BeforeExpand event. Because the event handlers will be identical for both the source and the target tree views, you'll create a shared event handler (assigning the same event handler to both). Go back to the Design view, select the tvwSource control, double-click the BeforeExpand event, and add this code: private void tvwExpand(object sender, TreeViewCancelEventArgs e) { TreeView tvw = ( TreeView ) sender; bool getFiles = tvw == tvwSource; TreeNode currentNode = e.Node; string fullName = currentNode.FullPath; currentNode.Nodes.Clear( ); GetSubDirectoryNodes( currentNode, fullName, getFiles, 1 ); } Your second task is to determine whether you want to get the files in the directory you are opening, and you do only if the name of the treeView that triggered the event is tvwSource . You determine which node's + sign was checked by getting the Node property from the TReeViewCancelEventArgs that is passed in by the event: TreeNode currentNode = e.Node; Once you have the current node, you get its full pathname (which you will need as a parameter to GetSubDirectoryNodes ) and then you must clear its collection of subnodes, because you are going to refill that collection by calling in to GetSubDirectoryNodes : currentNode.Nodes.Clear( ); Why do you clear the subnodes and then refill them? Because this time you will go another level deep so that the subnodes know if they in turn have subnodes, and thus will know if they should draw a + sign next to their subdirectories. Be sure to select the target TReeView and add the same code to its BeforeExpand event. 18.2.3.3. Clicking the target TreeViewThe second event handler for the target TReeView (in addition to BeforeExpand ) is somewhat trickier. The event itself is AfterSelect . (Remember that the target treeView doesn't have checkboxes.) This time, you want to take the one directory chosen and put its full path into the text box at the upper-left corner of the form. To do so, you must work your way up through the nodes, finding the name of each parent directory and building the full path: private void tvwTargetDir_AfterSelect ( object sender, System.Windows.Forms.TreeViewEventArgs e) { string theFullPath = GetParentString(e.Node); We'll look at GetParentString( ) in just a moment. Once you have the full path, you must lop off the backslash (if any) on the end, and then you can fill the text box: if (theFullPath.EndsWith("\")) { theFullPath = theFullPath.Substring(0,theFullPath.Length - 1); } txtTargetDir.Text = theFullPath; The GetParentString( ) method takes a node and returns a string with the full path. To do so, it recurses upward through the path, adding the backslash after any node that is not a leaf: private string GetParentString( TreeNode node ) { if ( node.Parent == null ) { return node.Text; } else { return GetParentString( node.Parent ) + node.Text + ( node.Nodes.Count == 0 ? String.Empty : "\" ); } } You learned about the conditional operator ( ? ) in Chapter 4. The logic is, "Test whether node.Nodes.Count is 0; if so, return the value before the colon (in this case, an empty string). Otherwise, return the value after the colon (in this case, a backslash)." The recursion stops when there is no parent; that is, when you hit the root directory. 18.2.3.4. Handling the Clear button eventGiven the SetCheck( ) method developed earlier, handling the Clear button's Click event is trivial: private void btnClear_Click( object sender, System.EventArgs e ) { foreach ( TreeNode node in tvwSource.Nodes ) { SetCheck( node, false ); } } Just call the SetCheck( ) method on the root nodes and tell them to recursively uncheck all their contained nodes. 18.2.4. Implementing the Copy Button EventNow that you can check the files and pick the target directory, you're ready to handle the Copy click event. The very first thing you need to do is to get a list of which files were selected. What you want is an array of FileInfo objects, but you have no idea how many objects will be in the list. This is a perfect job for a generic List. Delegate responsibility for filling the list to a method called GetFileList( ) : private void btnCopy_Click( object sender, System.EventArgs e ) { List<FileInfo> fileList = GetFileList( ); Let's pick that method apart before returning to the event handler. Start by instantiating a new List object to hold the strings representing the names of all the files selected: private List<FileInfo> GetFileList( ) { List<string> fileNames = new List<string>( ); To get the selected filenames, you can walk through the source treeView control: foreach ( TreeNode theNode in tvwSource.Nodes ) { GetCheckedFiles( theNode, fileNames ); } To see how this works, step into the GetCheckedFiles( ) method. This method is pretty simple: it examines the node it was handed. If that node has no children ( node. Nodes.Count == 0 ), it is a leaf. If that leaf is checked, get the full path (by calling GetParentString( ) on the node) and add it to the ArrayList passed in as a parameter: private void GetCheckedFiles( TreeNode node,List<string> fileNames ) { // if this is a leaf... if ( node.Nodes.Count == 0 ) { // if the node was checked... if ( node.Checked ) { // get the full path and add it to the arrayList string fullPath = GetParentString( node ); fileNames.Add( fullPath ); } } If the node is not a leaf, recurse down the tree, finding the child nodes: else { foreach (TreeNode n in node.Nodes) { GetCheckedFiles(n,fileNames); } } } This returns the List filled with all the filenames. Back in GetFileList( ) , you use this List of filenames to create a second List , this time to hold the actual FileInfo objects: List<FileInfo> fileList = new List<FileInfo>( ); Notice the use of typesafe List objects to ensure that the compiler flags any objects added to the collection that aren't of type FileInfo . Back in GetFileList( ) , you can now iterate through the filenames in fileList , picking out each name and instantiating a FileInfo object with it. You can detect if it is a file or a directory by calling the Exists property, which will return false if the File object you created is actually a directory. If it is a File , you can add it to the new ArrayList : foreach ( string fileName in fileNames ) { FileInfo file = new FileInfo( fileName ); if ( file.Exists ) { // both the key and the value are the file // would it be easier to have an empty value? fileList.Add( file ); } } 18.2.4.1. Sorting the list of selected filesYou want to work your way through the list of selected files in large to small order so that you can pack the target disk as tightly as possible. You must therefore sort the List . You can call its Sort( ) method, but how will it know how to sort FileInfo objects? To solve this, you must pass in an IComparer<T> interface. We'll create a class called FileComparer that will implement this generic interface for FileInfo objects: public class FileComparer : IComparer<FileInfo> { This class has only one method, Compare( ) , which takes two FileInfo objects as arguments: public int Compare(FileInfo file1, FileInfo file2); The normal approach is to return 1 if the first object ( file1 ) is larger than the second ( file2 ), to return -1 if the opposite is true, and to return 0 if they are equal. In this case, however, you want the list sorted from big to small, so you should reverse the return values.
To test the length of the FileInfo object, you must cast the Object parameters to FileInfo objects (which is safe because you know this method will never receive anything else): public int Compare(FileInfo file1, FileInfo file2) { if ( file1.Length > file2.Length ) { return -1; } if ( file1.Length < file2.Length ) { return 1; } return 0; } Returning to GetFileList( ) , you were about to instantiate the IComparer reference and pass it to the Sort( ) method of fileList : IComparer<FileInfo> comparer = ( IComparer<FileInfo> ) new FileComparer( ); fileList.Sort( comparer ); That done, you can return fileList to the calling method: return fileList; The calling method was btnCopy_Click . Remember, you went off to GetFileList( ) in the first line of the event handler! protected void btnCopy_Click (object sender, System.EventArgs e) { List<FileInfo> fileList = GetFileList( ); At this point, you've returned with a sorted list of File objects, each representing a file selected in the source treeView . You can now iterate through the list, copying the files and updating the UI: foreach ( FileInfo file in fileList ) { try { lblStatus.Text = "Copying " + txtTargetDir.Text + "\" + file.Name + "..."; Application.DoEvents( ); // copy the file to its destination location file.CopyTo( txtTargetDir.Text + "\" + file.Name, chkOverwrite.Checked ); } catch ( Exception ex ) { MessageBox.Show( ex.Message ); } } lblStatus.Text = "Done."; As you go, write the progress to the lblStatus label and call Application.DoEvents( ) to give the UI an opportunity to redraw . Then call CopyTo( ) on the file, passing in the target directory obtained from the text field, and a Boolean flag indicating whether the file should be overwritten if it already exists. The copy is wrapped in a try block because you can anticipate any number of things going wrong when copying files. For now, handle all exceptions by popping up a dialog box with the error; you might want to take corrective action in a commercial application. That's it; you've implemented file copying! 18.2.5. Handling the Delete Button EventThe code to handle the Delete event is even more simple. The very first thing you do is ask the user if she is sure she wants to delete the files: private void btnDelete_Click( object sender, System.EventArgs e ) { // ask them if they are sure System.Windows.Forms.DialogResult result = MessageBox.Show( "Are you quite sure?", // msg "Delete Files", // caption MessageBoxButtons.OKCancel, // buttons MessageBoxIcon.Exclamation, // icons MessageBoxDefaultButton.Button2 ); // default button You can use the MessageBox static Show( ) method, passing in the message you want to display, the title "Delete Files" as a string, and flags, as follows : MessageBox.OKCancel asks for two buttons: OK and Cancel . MessageBox.IconExclamation indicates that you want to display an exclamation mark icon. MessageBox.DefaultButton.Button2 sets the second button ( Cancel ) as the default choice. When the user chooses OK or Cancel, the result is passed back as a System.Windows. Forms.DialogResult enumerated value. You can test this value to see if the user selected OK: if ( result == System.Windows.Forms.DialogResult.OK ) { If so, you can get the list of fileName s and iterate through it, deleting each as you go: List<FileInfo> fileNames = GetFileList( ); foreach ( FileInfo file in fileNames ) { try { // update the label to show progress lblStatus.Text = "Deleting " + txtTargetDir.Text + "\" + file.Name + "..."; Application.DoEvents( ); // Danger Will Robinson! file.Delete( ); } catch ( Exception ex ) { // you may want to do more than // just show the message MessageBox.Show( ex.Message ); } } lblStatus.Text = "Done."; Application.DoEvents( ); This code is identical to the copy code, except that the method that is called on the file is Delete( ) . Example 18-1 provides the commented source code for this example. Example 18-1. FileCopier source code
|
EAN: 2147483647
Pages: 250