Question

I’ve been having a lot of annoying problems with accessing bitmaps lately and I’m starting to think I need to re-evaluate the design of my application.

At present, I have one object that creates two others. One of these others provides a series of bitmaps (e.g. from a webcam) and the other provides a series of coordinate pairs (e.g. from a mouse or touchpad). The parent object has listeners for the events that the children objects generate. The events are have custom arguments which carry the new information (bitmap or coordinates) as a payload. For instance:

public class NewImageEventArgs : EventArgs
{
    public NewImageEventArgs(Bitmap image)
    {
        Image = image;
    }
    public Bitmap Image { get; private set; }
}

The listener methods in the parent object copy the payload to the object-level representation. When either listener (bitmap or coordinates) is triggered, they subsequently call a shared method, which uses both the bitmap and the coordinates to do some calculation.

private void PointerModule_NewPosition(object sender, NewPositionEventArgs e)
{
    this.p = e.Position;
    this.Invalidated();
}

It seems to me that my recurring problems with OutOfMemory and InvalidOperation (“Object is currently in use elsewhere”) exceptions stem from the fact that each new event may be on a different thread. When a bitmap is being used on one thread, exceptions are raised when another thread tries to simultaneously access it.

Do I need to fundamentally change the shape of my program? Are there any precautions I can take to eliminate this type of problem?

Answer 1

EDIT:
I reread your question and I might have responded to a slightly different question than you’ve asked. However I fought the same problems with “Object is used elsewhere” exceptions and the lesson I learned is summarized in the link in the bottom. Neither bitmap.Clone() nor new Bitmap(source) creates deep image copy. This is causing the exceptions.

In my application I use pattern :

public class ImageProvider()
{
public event EventHandler LiveImageUpdated;
private object _currentImageLock = new object();

private Bitmap _currentImage;
public Bitmap CurrentImage
{ 
    get    
      {
       lock (_currentImageLock)
         {
            return DeepImageCopy(_currentImage)
         }
       }
     private set
     {
       lock(_currentImageLock)
       {
            _currentImage = value
       }
        if (LiveImageUpdated != null)
        {
          foreach (Delegate del in LiveImageUpdated.GetInvocationList())
          {
              EventHandler handler = (EventHandler)del;
              handler.BeginInvoke(this, EventArgs.Empty, null, null);
           }
        }
     }
}

}

And I asked this question :
How to create a Bitmap deep copy

Application works without a problem. So basically I skipped the part with pushing new image as an argument and listeners are asking for deep copy of the image and they are not sharing images. Performancewise it works without a problem.