I am going NUTS here!  I just changed the code so the thread does not
actually die, simply goes into a WaitHandle.WaitAny until there are
more images to downsize and the handles STILL are going up and not
coming down!!!!!!!!!!!!!!!!

I have looked in MSDN and don't see anything about having to do any
clean up on WaitHandle.  Am I missing something?  Come on, this has to
be something brain dead simple, I know how to code and debug, from
everything I can tell, I am crossing all the T's and dotting all the
i's in my clean up code.

Willy, in your very first post of this thread, you said: "My guess is
that they are no thread handles, but event handles."  It HAS to be
event handles, the problem is I cannot find any information on
cleaning up event handles in managed code.  Can you elaborate on the
concept of leaking event handles?

Cartoper

Here is my complete WebUpdate class:

/// <summary>
/// Updates the web site images
/// </summary>
public class WebUpdate : IDisposable
{
   private static readonly log4net.ILog log =
log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);

   private readonly string rootDir;
   private readonly string webRoot;

   private IDictionary<string, IFileProcessor> filesToProcess = new
SortedDictionary<string, IFileProcessor> ();
   private Thread webUpdateThread = null;
   private ReaderWriterLock filesToProcessRWL = new
ReaderWriterLock();
   private AutoResetEvent goEvent = new AutoResetEvent(false);
   private AutoResetEvent stopEvent = new AutoResetEvent(false);
   private AutoResetEvent killEvent = new AutoResetEvent(false);
   private volatile bool isUpdating = false;

   private ImageFolder thumbnailFld = null;
   private ImageFolder imageFld = null;

   public event ProcessStepHandler FilesUpdateProgress;
   public event ProcessCompleteHandler FileUpdateComplete;

   internal WebUpdate(string rootDir, string webRoot)
   {
       this.rootDir = rootDir;
       this.webRoot = webRoot;
   }

   public void Dispose()
   {
       if (this.ThreadingStopped == false)
       {
           this.killEvent.Set();
           this.webUpdateThread.Join();
       }
       goEvent.Close();
       stopEvent.Close();
       killEvent.Close();
   }

   /// <summary>
   /// This is true when the thread is actively updating the web site
   /// </summary>
   public bool IsUpdating
   {
       get { return isUpdating; }
   }

   /// <summary>
   ///
   /// </summary>
   /// <param name="filesToProcess"></param>
   internal void SetFilesToProcess(IDictionary<string,
IFileProcessor> filesToProcess)
   {
       this.filesToProcessRWL.AcquireWriterLock(-1);
       try
       {
           foreach(KeyValuePair<string, IFileProcessor> kvp in
filesToProcess)
           {
               this.filesToProcess[kvp.Key] = kvp.Value;
           }
       }
       finally
       {
           this.filesToProcessRWL.ReleaseWriterLock();
       }
   }

   /// <summary>
   /// The total number of images to process
   /// </summary>
   public int TotalCount
   {
       get {
           this.filesToProcessRWL.AcquireReaderLock(-1);
           try
           {
               return this.filesToProcess.Count;
           }
           finally
           {
               this.filesToProcessRWL.ReleaseReaderLock();
           }
       }
   }

   /// <summary>
   /// Deletes a folder from the web server system
   /// </summary>
   static public void DeleteWebFolder(string webRoot, string
relativePath)
   {
       string fullpath = webRoot + relativePath;
       DirectoryInfo di = new DirectoryInfo(fullpath);

       if (di.Exists)
       {
           di.Delete(true);
       }
   }

   /// <summary>
   /// Starts the background thread that will update the images.
   /// </summary>
   /// <param name="thumbnail">This size of the thumbnail image</
param>
   /// <param name="image">The size of the large preview image</
param>
   public void Start(int thumbnail, int image)
   {
       if (this.IsUpdating == false)
       {
           log.InfoFormat("Start({0}, {1})", thumbnail, image);

           this.thumbnailFld = new ImageFolder("tn", thumbnail);
           this.imageFld = new ImageFolder("imgs", image);

           if (this.webUpdateThread == null)
           {
               // Debug.WriteLine(String.Format("1 handle count
before new ThreadStart(): {0}", General.HandleNThreadCount));
               this.webUpdateThread = new Thread(new
ThreadStart(ProcessFileList));
               this.webUpdateThread.Start();
               // Debug.WriteLine(String.Format("2 handle count after
this.webUpdateThread.Start(): {0}", General.HandleNThreadCount));
           }
           else
           {
               Debug.Assert(ThreadingStopped == false);
               this.stopEvent.Reset();
               this.goEvent.Set();
           }
       }
   }

   /// <summary>
   ///
   /// </summary>
   public void Stop()
   {
       Debug.Assert(ThreadingStopped == false);
       if (this.IsUpdating)
       {
           this.stopEvent.Set();
       }
   }

   /// <summary>
   /// true if the background thread is *NOT* running
   /// </summary>
   private bool ThreadingStopped
   {
       get
       {
           return this.webUpdateThread == null ||
               (this.webUpdateThread.ThreadState &
System.Threading.ThreadState.Stopped) ==
System.Threading.ThreadState.Stopped;
       }
   }

   /// <summary>
   /// The background thread
   /// </summary>
   private void ProcessFileList()
   {
       while (true)
       {
           isUpdating = true;
           List<IFileProcessDataError> errorList = new
List<IFileProcessDataError>();
           long totalTicks = 0;
           int cnt = 0;

           log.Info("ProcessFileList() started");
           while(this.filesToProcess.Count > 0)
           {
               string filepath = string.Empty;
               IFileProcessor fileProcessor = null;

               this.filesToProcessRWL.AcquireWriterLock(-1);
               try
               {
                   IEnumerator<KeyValuePair<string, IFileProcessor>>
enumerator = this.filesToProcess.GetEnumerator();

                   enumerator.Reset();
                   enumerator.MoveNext();

                   KeyValuePair<string, IFileProcessor> kvp =
enumerator.Current;

                   this.filesToProcess.Remove(kvp);

                   filepath = kvp.Key;
                   fileProcessor = kvp.Value;
               }
               finally
               {
                   this.filesToProcessRWL.ReleaseWriterLock();
               }

               DateTime start = DateTime.Now;

               FileInfo fi = new FileInfo(filepath);

               string srcFolder = fi.FullName.Substring(0,
fi.FullName.Length - fi.Name.Length - 1);
               string dstFolder = this.webRoot +
fi.Directory.FullName.Substring(this.rootDir.Length);

               // log.DebugFormat("{0} --> file: [{1}] src := [{2}]
dest := [{3}]", General.GetClassNameWONS(fileProcessor), fi.Name,
srcFolder, dstFolder);

               FileProcessData fpd = new FileProcessData(srcFolder,
dstFolder, fi.Name);
               try
               {
                   fileProcessor.Process(fpd, this.ImageFolderList);
               }
               catch (Exception ex)
               {
                   log.FatalFormat("Process Image Exception: {0} -->
{1}\n srcFolder => {2}\n dstFolder => {3} \n filename => {4}",
General.GetClassNameWONS(ex), ex.Message, srcFolder, dstFolder,
fpd.Filename);
                   errorList.Add(new FileProcessDataError(fpd,
fileProcessor, ex));
               }

               TimeSpan processTime = DateTime.Now - start;

               totalTicks += processTime.Ticks;

               long averageTicks = totalTicks / ++cnt;

               TimeSpan averageTime = new TimeSpan(averageTicks);

               FireFilesUpdateProgress(this.TotalCount, averageTime);
               if (this.stopEvent.WaitOne(1, false))
               {
                   break;
               }
           }

           isUpdating = false;

           if (FileUpdateComplete != null)
           {
               FileUpdateComplete(this, new
CrunchImageErrorEventArgs(cnt, errorList));
           }

           WaitHandle[] waitHandles = new WaitHandle[2];

           waitHandles[0] = this.killEvent;
           waitHandles[1] = this.goEvent;

           if (WaitHandle.WaitAny(waitHandles) == 0)
               return;
       }
       //log.Info("ProcessFileList() ended.");
   }

   /// <summary>
   /// The collection of folders in which to copy the images to
   /// </summary>
   /// <remarks>
   /// It is very important that the order of these folders go from
largest image size to smallest.
   /// </remarks>
   private IEnumerable<ImageFolder> ImageFolderList
   {
       get
       {
           yield return this.imageFld;
           yield return this.thumbnailFld;
       }
   }

   /// <summary>
   ///
   /// </summary>
   /// <param name="count"></param>
   private void FireFilesUpdateProgress(int count, TimeSpan
processTime)
   {
       if (FilesUpdateProgress != null)
       {
           FilesUpdateProgress(this, new CruchImageEventArgs(count,
processTime));
       }
   }
}

On Mar 19, 11:01 am, "Willy Denoyette [MVP]"
<willy.denoye...@telenet.be> wrote:

If I knew what handles where leaking, I could fix it!  I am trying to
figure out how to find the handles.

Ok, I am quite at home in C/C++, where might I go for some tips/tricks
on tracking down handle leaks in native code?

PE can list all handles created by your process, just select View Handles in
the toolbar and select your Process, the lower pane will list all OS handles
currently owned.
The native debugging tools (Windbg, nsdb etc.. are the right tools to go
hunting for handle leaks, if you run your code under widbg,

The project type in VS2005 is "Windows Application" and "Class
LIbrary"

Like I said before, the code in question is down sizing image files.
It loops through a SortedDictionary of images.  It is opening them
with a FileStream, loading them into an Image Object, creating a
Graphics object to downsize them, along with assorted other GDI+
calls.

As I have already stated, I spend quite a bit of time yesterday check
and debuging all that code.  The Handles count before entering the
loop that downsized images is 100% identical to the number of Handles
once it is finished looping through all the images that need to be
downsized.

C#.Net v2.0.50727

I wish.

You keep assuming these handles are leaked, well I'm not.
Keep in mind that Handles are native objects, some may only get released
after the GC/Finalizer has run. So, while it's possible to see this count
going up with every thread cycle (start/stop) , it doesn't mean that at some
point in time, these handles won't get collected. And, as I said before, the
CLR also creates "event" and other kind of OS objects, the CLR is the owner
and only the CLR is controlling the life cycle of these objects.
And that's what you are probably having issues with.
For each managed Thread object you create, the CLR creates 5 objects:
- 1 "OS thread" object and
- 4 "Manual Reset event" objects.
These objects are not necessarily deleted when the GC/Finalizer runs, they
are not under control of the GC, they are managed by the CLR, the CLR will
delete them when he sees fit.

Just create a small program which starts a "do nothing thread" and watch the
handle count going up for each thread you start, until the CLR decides it's
enough and starts releasing it's internally owned handles (CLR/Framework
version dependent). At that point you will see the Handle count going down.

Also, keep in mind that PE is only a tool that takes snapshots of a running
external process, that means that the handle count does not necessarily
represent the actual count. In order to watch the real count, you have to
freeze the process by running your code under a debugger. This means that PE
is not a debugging tool.
In order to watch handles life time, you need to start your program under a
native debugger like nsdb or windbg (See Debugging Tools For Windows).
Issuing the !handle debugger command will show you the list of handles owned
by the process.

Willy.