Introduction
WinSearchFile is a program that I developed and I usually use it to search files on my PC.
Sometimes the search engine integrated with Explorer doesn't work fine, especially when I try to find text contained into files, so I decided to build my own search program.
There are a lot of search programs available to install on your PC but this one, without indexing your data, is simple and fast enough to help you in your search.
Inside the application
WinSearchFile layout is simple and quite similar to the Explorer integrated search. It is possible to write a pattern search (wildcards admitted) and/or a text to search into file contents (you can also decide for a case sensitive search).
In the "look in" area, you have all the disks of your computer (network connection included). To obtain this list, I use the DiskCollection class developed by dmihailescu in his Get Logical Drives Information article.
/// <SUMMARY>
/// Add items for all floppy,
/// CD and hard drives.
/// </SUMMARY>
private void LoadDisksComboBox()
{
disksListBox.Items.Clear();
// Try to use DiskCollection
// retrieving drive information
DiskCollection diskColl = new DiskCollection();
if ( diskColl.Load() )
{
foreach(DiskCollection.LogicalDriveInfo diskinfo in diskColl)
{
disksListBox.Items.Add(diskinfo.Name.ToString() +
": "+ diskinfo.Description );
}
}
else
{
// otherwise build a drive list checking
// if a root directory exists
for (char Ch = 'A'; Ch <= 'Z'; Ch++)
{
string Dir = Ch + @":\";
if (Directory.Exists(Dir))
{
disksListBox.Items.Add( Ch+ @":" );
}
}
}
}
Application shows alerts when you check a not-ready disk.
In the WinSearchFile application, I use threads to make the same search simultaneously on different targets; I use a thread for each target drive.
/// <SUMMARY>
/// Start search
/// </SUMMARY>
/// <PARAM name="sender"></PARAM>
/// <PARAM name="e"></PARAM>
private void btnSearch_Click(object sender, System.EventArgs e)
{
// empty thread list
for (int i = thrdList.ItemCount()-1; i>=0; i--)
{
thrdList.RemoveItem(i);
}
// clear the file founded list
listFileFounded.Items.Clear();
ContainingFolder = "";
// get the search pattern
// or use a default
SearchPattern = txtSearchPattern.Text.Trim();
if (SearchPattern.Length == 0)
{
SearchPattern = "*.*";
}
// get the text to search for
SearchForText = txtSearchText.Text.Trim();
// clear the Dirs arraylist
Dirs.Clear();
// check if each selected drive exists
foreach (int Index in disksListBox.CheckedIndices)
{
// chek if drive is ready
String Dir = disksListBox.Items[Index].ToString().Substring(0,2);
Dir += @"\";
if (CheckExists(Dir))
{
Dirs.Add(Dir);
}
}
// I use 1 thread for each dir to scan
foreach (String Dir in Dirs)
{
Thread oT;
string thrdName = "Thread" + ((int)(thrdList.ItemCount()+1)).ToString();
FileSearch fs = new FileSearch(Dir, SearchPattern,
SearchForText, CaseSensitive, this, thrdName);
oT = new Thread(new ThreadStart(fs.SearchDir));
oT.Name = thrdName;
SearchThread st = new SearchThread();
st.searchdir = Dir;
st.name = oT.Name;
st.thrd = oT;
st.state = SearchThreadState.ready;
thrdList.AddItem(st);
oT.Start();
}
}
Data about searching threads is stored in a list, and during the search process, you can see how many threads are running/ready/cancelled.
Threads use the FileSearch class to do their work. To update controls or data structures on main threads, use delegate functions. I defined a delegate function for the AddListBoxItem method:
/// <SUMMARY>
/// Delegate for AddListBoxItem
/// </SUMMARY>
public delegate void AddListBoxItemDelegate(String Text);
/// <SUMMARY>
/// Add a new item to the file founded list
/// </SUMMARY>
/// <PARAM name="Text"></PARAM>
public void AddListBoxItem(String Text)
{
// I use Monitor to synchronize access
// to the file founded list
Monitor.Enter(listFileFounded);
listFileFounded.Items.Add(Text);
Monitor.Exit(listFileFounded);
}
and one to update the thread state:
/// <SUMMARY>
/// Delegate for UpdateThreadStatus function
/// </SUMMARY>
public delegate void UpdateThreadStatusDelegate(String thrdName,
SearchThreadState sts);
/// <SUMMARY>
/// Store the new state of a thread
/// </SUMMARY>
/// <PARAM name="thrdName"></PARAM>
/// <PARAM name="sts"></PARAM>
public void UpdateThreadStatus(String thrdName, SearchThreadState sts)
{
SearchThread st = thrdList.Item(thrdName);
st.state = sts;
}
On clicking the "Stop search" button, all the running threads are cancelled using the Abort method.
/// <SUMMARY>
/// Stop searching
/// </SUMMARY>
/// <PARAM name="sender"></PARAM>
/// <PARAM name="e"></PARAM>
private void btnStop_Click(object sender, System.EventArgs e)
{
// some threads are running
if (InProgress)
{
// Abort each searching thread in running status
// and change its status to cancelled
for (int i= 0; i < thrdList.ItemCount(); i++)
{
if (((SearchThread)thrdList.Item(i)).state ==
SearchThreadState.running)
{
((SearchThread)thrdList.Item(i)).state =
SearchThreadState.cancelled;
Thread tt;
try
{
tt = ((SearchThread)thrdList.Item(i)).thrd;
tt.Abort();
}
catch
{
}
}
}
}
}
On double clicking on a result listbox item, WinSearchFile will open the corresponding containing folder.
To quick launch WinSearchFile, you can create a shortcut to it on your desktop and assign to this one a shortcut key.
Conclusion
I hope you enjoy this article.
New WinSearchFile version
The new WinSearchFile 2.0, built using Visual Studio 2005 and C# 2.0, contains the following new features:
- Single Instance Application using code written by Eric Bergman-Terrell.
- Search inside PDF files.
- Regular expression searching.
- Searching using IFilter.
- Max directory visit depth.
- File
Creation TimeorLast ACcess TimeorLast Write Timesearching - directory list to search into.
Save resultsbutton.
Here is a new screenshot:
About IFilter
User can decide to use installed IFilter to extract plaintext from files. To implement this interface I used 2 class developed by Dan Letecky.
The following code shows where I try to use IFilter to get plaintext:
public static bool FileContainsText(String FileName,
String SearchForText, bool CaseSensitive,
bool UseRegularExpression, bool UseIFilter)
{
bool Result = (SearchForText.Length == 0);
if (!Result)
{
// try to use IFilter if you have checked
// UseIFilter checkbox
if (Parser.IsParseable(FileName) && UseIFilter)
{
string content = Parser.Parse(FileName);
// if content length > 0
// means that IFilter works and returns the file content
// otherwise IFilter hadn't read the file content
// i.e. IFilter seems no to be able to extract
// text contained in dll or exe file
if (content.Length > 0)
{
Result = containsPattern(SearchForText,
CaseSensitive, UseRegularExpression, content);
return Result;
}
}
// scan files to get plaintext
// with my routines
if (FileName.ToLower().EndsWith(".pdf"))
{
// search text in a pdf file
Result = SearchInPdf(FileName, SearchForText,
CaseSensitive, UseRegularExpression);
}
else
{
bool Error;
String TextContent = GetFileContent(FileName, out Error);
if (!Error)
{
Result = containsPattern(SearchForText,
CaseSensitive, UseRegularExpression, TextContent);
}
}
}
return Result;
}
The following screenshot shows the about box where it's possible to get the list of installed IFilter. To get this list I used a class developed by vbAccelerator.com.
