C# Discussion Boards - CodeProject

6-Jan-09 1:00

Hi,

I am facing with a performance issue in one of my windowsapplication.

I need to create a dialog window for excluding subfolders and files in a particular folder (passed as input).
The Exclude dialog must allow the user to select folders and files which he wants to exclude from counting.

Currently I am using a tree view and list view (both with checkboxes) for this purpose.

<br />
Implementation:<br />
1.	I bind the tree view with all subfolders on the load time.<br />
2.	The list view shows the files and folders of each selected node in the tree.<br />
3.	When a node or list item checked or unchecked, all its sub-items has to get checked or unchecked.<br />
<br />
Issue faced:<br />
1.	In case of a large folder (with large no. of Subfolders and files), it takes long time for loading the tree (to bind all these sub-folders and files to tree)<br />
2.	If I go for an implementation of binding only two levels to the tree node each time (on load and on node click), issue occurs when I uncheck a node or list item. Only the sub items up to 2 level gets unchecked.<br />
3.	Check- Uncheck for large subfolders too takes long time.<br />
<br />

Can anyone help me out with a solution for this? Even a design change or change in the current implementation can be suggested.

Thanks in Advance
Praji

Wendelius6-Jan-09 1:19

6-Jan-09 1:19

KP_Prajilal wrote:
In case of a large folder (with large no. of Subfolders and files), it takes long time for loading the tree (to bind all these sub-folders and files to tree)

You could fill the node when it's opened. Just fill the root and perhaps some child levels in the beginning

KP_Prajilal wrote:
If I go for an implementation of binding only two levels to the tree node each time (on load and on node click), issue occurs when I uncheck a node or list item. Only the sub items up to 2 level gets unchecked

You can either fill the child nodes for the selected node upon selecting but you can also change the logic so that if the child nodes aren't filled, the outer node selection automatically implies to all subfolders even if they are not in the tree. So when working on user's choices (what ever you do with them) you don't expect to find every folder in the tree.

The need to optimize rises from a bad design.My articles[^]

DJ2457-Jan-09 18:19

7-Jan-09 18:19

I want to bind all the sub folders and file of a root folder when selecting it.
Could u please give me a sample code?

Wendelius7-Jan-09 19:40

7-Jan-09 19:40

The idea was that you don't take all the folders to the tree, only the nodes are selected. You can use BeforeExpand[^] event and in that event you fill the folders right under that node (if not already filled).

When you perform the operation (whatever it is) you check if the node is present and based on the selection you do the operation. You can use recursion in the operation just check if node is selected and if it is, recurse child nodes if there are any. if there aren't recurse, the folders under that folder and do the operation if the node was selected.

The need to optimize rises from a bad design.My articles[^]

DJ2457-Jan-09 20:55

7-Jan-09 20:55

I tried it and got better performance while binding the folders. But when Check/Uncheck a root folder performance is too low(for Check/Uncheck the sub folders). How can i solve this?

Thanks in Advance
Praji

Wendelius7-Jan-09 21:04

7-Jan-09 21:04

DJ245 wrote:
But when Check/Uncheck a root folder performance is too low(for Check/Uncheck the sub folders). How can i solve this?

Without seeing the code you've made, it's quite impossible to say why it's slow. When the root node is checked, do you for example recursively traverse all of the subnodes and check them also? That would explain why it's slow. Also if that's the case, it depends how you have done it. Can you post the code that is used when checking a node?

The need to optimize rises from a bad design.My articles[^]

DJ2457-Jan-09 21:21

7-Jan-09 21:21

Code used :

#region CheckUncheckChildNodes
   /// <summary>
   /// This method is used to check/uncheck the subsequent child nodes on checking a node.
   /// </summary>
   private void CheckUncheckChildNodes(TreeNode node)
   {
       childCheck = true;
       //if the selected node is checked
       if (node.Checked == true)
       {
           //check if the selected node already present in removedFileList,
           //if not add the node to initalFileList (which has the list of selected files and folders)
           bool isExists = false;
           for (int index = 0; index < removedFileList.Count; index++)
           {
               string name = removedFileList[index].ToString().Replace("\\\\", "\\");
               if (name == node.FullPath)
               {
                   isExists = true;
                   break;
               }
           }
           if (isExists)
               removedFileList.Remove(node.FullPath);

           //check all the filtered files in the selected node
           CheckUncheckFilteredFiles(node, node.Checked);

           //check all the sub-nodes of the selected node
           foreach (TreeNode childNode in node.Nodes)
           {
               childNode.Checked = true;
               CheckUncheckChildNodes(childNode);
           }
       }
       //if the selected node is not checked
       else
       {
           //check if the selected node already present in initalFileList,
           //if present, remove the node from initalFileList (which has the list of selected files and folders)

           bool isExists = false;
           for (int index = 0; index < removedFileList.Count; index++)
           {
               string name = removedFileList[index].ToString().Replace("\\\\", "\\");
               if (name == node.FullPath)
               {
                   isExists = true;
                   break;
               }
           }
           if (!isExists)
               removedFileList.Add(node.FullPath);

           //uncheck all the filtered files in the selected node
           CheckUncheckFilteredFiles(node, node.Checked);
           //uncheck all the sub-nodes of the selected node
           foreach (TreeNode childNode in node.Nodes)
           {
               childNode.Checked = false;
               CheckUncheckChildNodes(childNode);
           }
       }
   }
   #endregion



   #region CheckUncheckFilteredFiles
   /// <summary>
   /// This method add the files to the tree after filtering any unsupported files for the selected parser.
   /// </summary>
   private void CheckUncheckFilteredFiles(TreeNode tnSubNode, bool checkedState)
   {
       //set the image for the treeview
       trvSource.ImageList = sysIcons.SmallIconsImageList;

       bool isDirectory = false;

       //get the directory info of the selected node
       DirectoryInfo diRoot;
       diRoot = new DirectoryInfo(tnSubNode.FullPath);
       string allFiles = string.Empty;

       //get the file info of the selected nodes
       FileInfo info = new FileInfo(tnSubNode.FullPath);
       //get the extension of the file
       string ext = info.Extension;

       //checking if the selected node is a file or folder
       if (tnSubNode.FullPath != string.Empty)
       {
           if (File.Exists(tnSubNode.FullPath) || Directory.Exists(tnSubNode.FullPath))
           {
               FileAttributes attrb = File.GetAttributes(tnSubNode.FullPath);
               //detect whether its a directory or file
               if ((attrb & FileAttributes.Directory) == FileAttributes.Directory)
               {
                   isDirectory = true; // for directories
               }
               else
               {
                   isDirectory = false; // for file
               }
           }
       }
       //show the sub files only when a directory selected.
       if (isDirectory)
       {
           DirectoryInfo[] dirs = diRoot.GetDirectories();
           FileInfo[] fils = diRoot.GetFiles();

           //arraylist to add the files of the selected node
           ArrayList directoryFiles = new ArrayList();
           //arraylist to add the files of the selected node that are not supported by the selected node
           ArrayList excludedDestFiles = new ArrayList();
           //get all the files in the selected folder
           for (int index = 0; index < fils.Length; index++)
           {
               directoryFiles.Add(tnSubNode.FullPath.ToString() + @"\" + fils[index].ToString());
           }

           ArrayList allFilesInDirectory = directoryFiles;

           //get files that are not supported by the selected parser
           excludedDestFiles = GetExcludedFiles(ref allFilesInDirectory);

           //add all the supported files to the tree
           foreach (FileInfo fil in fils)
           {
               TreeNode subNode = new TreeNode(fil.Name);
               subNode.ImageIndex = sysIcons.GetIconIndex(fil.FullName);
               subNode.SelectedImageIndex = sysIcons.GetIconIndex(fil.FullName);
               //if parser selected, filter the supported files
               if (isParserSelected)
               {
                   for (int fileIndex = 0; fileIndex < allFilesInDirectory.Count; fileIndex++)
                   {
                       allFiles = allFilesInDirectory[fileIndex].ToString().Replace("\\\\", "\\");

                       if (allFiles == fil.FullName)
                       {
                           //when check-unchecking a node, remove/add the files in the node to the removedFileList
                           if (!treeClick)
                           {
                               //check if the particular file exist in removedFileList
                               bool isExist = false;
                               for (int index = 0; index < removedFileList.Count; index++)
                               {
                                   if (removedFileList[index].ToString() == fil.FullName)
                                   {
                                       isExist = true;
                                       break;
                                   }
                               }
                               //already present in removedFileList
                               if (!isExist)
                               {
                                   if (!checkedState)
                                       removedFileList.Add(fil.FullName);

                               }
                               else
                               {
                                   if (checkedState)
                                       removedFileList.Remove(fil.FullName);
                               }
                           }
                       }
                   }
               }
           }
       }
   }
   #endregion

Wendelius7-Jan-09 21:40

7-Jan-09 21:40

Lets start with the CheckUncheckChildNodes method.

You have an array removedFileList. Instead of using an array and always looping through it, use for example HashTable. Something like this when you add new files to the list (or whatever code you use when you add to the array):

private System.Collections.HashTable removedFileList = new System.Collections.HashTable();
...
// when adding to HashTable:
removedFileList.Add(node.FullPath, "");

Now when you have the CheckUncheckChildNodes method, you could modify your code to this:

...
                //check if the selected node already present in removedFileList,
                //if not add the node to initalFileList (which has the list of selected files and folders)
                if (removedFileList.ContainsKey(node.FullPath))
                    removedFileList.Remove(node.FullPath);
                //check all the filtered files in the selected node
                CheckUncheckFilteredFiles(node, node.Checked);
...

The same applies to the else section if the selected node is not checked.

That would speed up the execution and use less code. The same idea can be used in CheckUncheckFilteredFiles

The need to optimize rises from a bad design.My articles[^]

DJ2457-Jan-09 23:15

7-Jan-09 23:15

Changed my code . But no improvement. Performance is same as previous.

Wendelius8-Jan-09 2:20

8-Jan-09 2:20

One question is that do you still have all the files and directories initially in the tree view. I'm asking this because both listview and treeview can handle few thousand rows. After that the performance degrades radically.

The next step is that is the CheckUncheckChildNodes method slow or the CheckUncheckFilteredFiles method? I would guess that it's CheckUncheckFilteredFiles. You can try this by commenting out the call to CheckUncheckFilteredFiles from CheckUncheckFilteredFiles.

I figured out that you're listing both files and folders in the same treeview but you exclude some files based on their extension or is it vice versa, if the user has selected a parser, do you show only files with certain extension? If you show only certain extensions, use serchpattern on GetFiles

Then you also show an icon based on the file. However did I understand correctly that you have a separate icon for every file??

subNode.ImageIndex = sysIcons.GetIconIndex(fil.FullName)

Also I don't seem to find that you are clearing subnodes anywhere so if the directory is read twice, won't you have duplicate rows on the tree?

One way to enhance the performance is to use a tree for folders only and a list view for files, same as Windows Explorer. By separating them you wouldn't have so many items in the tree.

Also, what's the whole idea. You have a form where you have a combobox? for parser selection. After selecting the parser, user can select what files are parsed? All the files that are selected are parsed and if a node is parsed then every file in that node and it's subnodes are parsed? Was that even close?

The need to optimize rises from a bad design.My articles[^]

DJ2458-Jan-09 18:18