Is it possible to get Bitmap variable name?

You can use a Dictionary[^] for that task.

To add your Bitmaps:

Dictionary<string,Bitmap> bitmapDictionary = new Dictionary<string,Bitmap>();
bitmapDictionary.Add("a11.png", a11);
bitmapDictionary.Add("a12.png", a12);
...etc...

Iterate over the KeyValuePairs:

foreach (KeyValuePair<string,Bitmap> kvp in bitmapDictionary)
{
     if ( COMPARISON with my new BITMAP picture )
     {
         listBox1.Items.Add( " FOUND " + kvp.Key);
 
         break;
     }
}

The problem is deeper. It is really about the naming in application of the Don't Repeat Yourself principle (http://en.wikipedia.org/wiki/Do_not_repeat_yourself[^]). Your trying to apply two sets of names in one-to-one corresponding mapping: one set of names is file names, another one is the set of the variable names.

Whatever you do with this will always be of limited success. There should be at least one place where you build the mapping (using a dictionary, for example) which would be a painful point from the standpoint of maintainability. The problem is that you really don't need a separate name for each object.

The right solution should start not with object identification but with the place where you want to use the name semantically. The names not carrying any semantics should be avoided. As this idea is not conducted for this application, an adequate solutions can be different.

Here is some illustration of the idea. Let's assume you have several bitmaps in the directory and name if 00.png, 01.png, 02.png… Let's do the following:

string dataDirectory = //...

//...

string[] fileNames = System.IO.Directory.GetFiles(dataDirectory);
System.Drawing.Bitmap[] bitmaps = new System.Drawing.Bitmap[fileNames.Length];
for (int index = 0; index < fileNames.Length; ++index)
   bitmaps[index] = new System.Drawing.Bitmap(fileNames[index]);

//...

System.Drawing.Bitmap someBitmap = bitmaps[04]; //from 04.png

In this example, the "name" of the bitmap is always its index corresponding to a file. This is just an illustration of the idea. In programming, the names of any objects containing numeric value are never needed.

—SA

As RickShaub said dictionary is a good choice, you can retrieve the bitmap using the key

IDictionary<string,bitmap> imagelist=new Dictionary<string,bitmap>();

Then add your bitmaps like imagelist.Add("Bitmap1",bitmap1); imagelist.Add("Bitmap2",bitmap2); and retrieve like Bitmap bitmap=imagelist["Bitmap1"];.

All fine, but remember bitmaps must need to disposed after use.

An another issue if you call dispose the bitmap after added to the list the bitmap got disposed, but the reference of it still live in the list. it won't give negative if you check null and when access it you will get a fuzzy exceptions.

For example

Bitmap bmp1 = new Bitmap(100, 100);
 IDictionary<string, Bitmap> list = new Dictionary<string, Bitmap>();
 list.Add("bitmap1",bmp1);
 bmp1.Dispose();
 Bitmap bmp2 = list["bitmap1"];
 if (bmp2 != null)
 {
     MessageBox.Show(bmp2.Width.ToString());
 }

Here the bmp2 is not null, but it is not holding the unmanaged object as well. bmp2.Width will throw exception in this case "parameter invalid" which is really a confusing exception. Just aware of it.

If the bitmaps are too heavy for the memory, keeping all those in a list would be undesirable.

I would recommend keeping those bitmap data in an array and convert to bitmap, use it, and dispose whenever necessary (if this is not going to be an iterative cycle). This is not a performance optimization, but to avoid memory leaks.

Just my view. Listen to other experts as well.