Thread: changing protected memory

But to perform any changes to protected memory it would have to inherit from IDisposable too, something that is not possible in C++ or I don't know how, because ISampleGrabber is unmanaged class and C++ forbids inheritance from both managed and unmanaged classes/interfaces. Changing all classes on ISampleGrabber side to managed is out of question.

IDisposable is just one of a few major flaws in the design of C# and only serves to act as a destructor. In C# you cannot directly call a finalizer from any code which means you can never force an object to do a task when it is destroyed. You can get around this by implementing IDisposable with one catch. Other objects and .NET do not know if an object is disposable or not and object.dispose() is not the same thing. So in order to effectively use IDisposable you essentially must query the object to see if it is an IDisposable and act accordingly if it is. Really ignorant design if you ask me.

In C++ you would simply provide a destructor to do the cleanup and it is a much simpler more defined process. Every time an object is destroyed you are guaranteed that the destructor for that object (even if you don't write one) will be called.

If you wish to mix managed and unmanaged code then you need to use managed C++. If you create a ref class it can be seen and used by C#. The managed C++ then can wrap an unmanaged pointer inside of a managed interface which essentially amounts to a simple call through or proxy pattern. You can also call from C++ to C# using the reverse of this mechanism but there are a few more caveats in that you cannot have any managed objects inside of a unmanaged class which is to be used by C++. However one can avoid this by using interfaces. Then it is the underlying impl that actually does the heavy lifting. This allows for uniform conformance to an interface on both sides while also allowing seamless integration of managed and unmanaged code. The most important thing to remember when doing this type of programming is to use .NET data types in the interfaces. You will need to write conversion functions if you wish to convert std::string to System::String and vice versa. You also cannot use any STL containers inside of a ref class that is to be used by C#. You can, however, use generics in managed C++ which also appear as generics to C#. The managed C++ interface would then convert this generic into a C++ template and make the call to the C++.

Managed C++ is really the best and worst of both worlds in that it can both talk to and use managed and unmanaged code. As such it makes it a great way to mix C# and C++ in the same project. There are many books about this and tons of online articles on how to do this properly. It is definitely worth your time and effort to research it. This type of programming and skill set is definitely in demand and will be in the future as other systems start to utilize the robustness of .NET but still need the raw speed of C/C++ for mission critical tasks. I work with this type of stuff each day and although it seems daunting at first once you get the hang of it - it becomes a very powerful tool.

I still don't understand why this code in c# works but similar doesn't in c++:

original c#:

Code:

int ISampleGrabberCB.BufferCB( double SampleTime, IntPtr pBuffer, int BufferLen )
        {
            Graphics g;
            String s;
            float sLeft;
            float sTop;
            SizeF d;
			
            g = Graphics.FromImage(bitmapOverlay);
            g.Clear(System.Drawing.Color.Transparent);
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; 

            // Prepare to put the specified string on the image
            g.DrawRectangle(System.Drawing.Pens.Blue, 0, 0, m_videoWidth - 1, m_videoHeight - 1);
            g.DrawRectangle(System.Drawing.Pens.Blue, 1, 1, m_videoWidth - 3, m_videoHeight - 3);

            d = g.MeasureString(m_String, fontOverlay);

            sLeft = (m_videoWidth - d.Width) / 2;
            sTop = (m_videoHeight - d.Height ) / 2;

            g.DrawString(m_String, fontOverlay, System.Drawing.Brushes.Red, 
                sLeft, sTop, System.Drawing.StringFormat.GenericTypographic);

            // Add a frame number in the bottom right
            s = "Frame " + m_Count.ToString();
            d = g.MeasureString(s, transparentFont);
            sLeft = (m_videoWidth - d.Width) - 10;
            sTop = (m_videoHeight - d.Height ) - 10;

            g.DrawString(s, transparentFont, transparentBrush, sLeft, sTop, 
                System.Drawing.StringFormat.GenericTypographic);
            g.Dispose();

            // need to flip the bitmap so it's the same orientation as the
            // video buffer
            bitmapOverlay.RotateFlip(RotateFlipType.RotateNoneFlipY);
			
            // create and copy the video's buffer image to a bitmap
            Bitmap v;
            v = new Bitmap(m_videoWidth, m_videoHeight, m_stride,
                PixelFormat.Format32bppArgb, pBuffer);
            g = Graphics.FromImage(v);
            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

            // draw the overlay bitmap over the video's bitmap
            g.DrawImage(bitmapOverlay, 0, 0, bitmapOverlay.Width, bitmapOverlay.Height);

            // dispose of the various objects
            g.Dispose();
            v.Dispose();

            // Increment frame number.  Done this way, frame are zero indexed.
            m_Count++;

            return 0;
        }

my C++:

Code:

HRESULT STDMETHODCALLTYPE Camera::BufferCB( double SampleTime, BYTE *pBuffer, long BufferLen )
        {
            Graphics^ g;
			Bitmap^ bitmapOverlay = gcnew Bitmap(640, 480,
				  PixelFormat::Format24bppRgb);
			g = g->FromImage(bitmapOverlay);
			g->Clear(System::Drawing::Color::Transparent);
			g->SmoothingMode = System::Drawing::Drawing2D::SmoothingMode::AntiAlias;
			g->DrawRectangle(System::Drawing::Pens::Blue, 20, 20, 100, 100);

			delete g;

			bitmapOverlay->RotateFlip(RotateFlipType::RotateNoneFlipY);

			Bitmap^ v;
            BensBitmaps bensbmp;
			// this is buffer form camera should not be different that whatever is returned by BufferCB I guess
            test.pSampleGrabber->GetCurrentBuffer(&(test.cbBuffer), (long*)test.pBuffer);
            bensbmp.BHmakeBitmap3(test.MediaType,test.pBuffer,NULL);
           
			v = bensbmp.bmpN;
            g = g->FromImage(v);
            g->SmoothingMode = System::Drawing::Drawing2D::SmoothingMode::AntiAlias;
            g->DrawImage(bitmapOverlay, 0 , 0, bitmapOverlay->Width, bitmapOverlay->Height); //<----- access violation 

			delete g;
			delete v;


            return 0;
        }

Anytime I try to do something with bitmap from buffer I get access violation. Not mentioning that BufferCB in c++ returns BYTE *pBuffer which I found impossible to translate to IntPtr (needed for creation of bitmap) so instead Im using :

Code:

   BensBitmaps bensbmp;
   test.pSampleGrabber->GetCurrentBuffer(&(test.cbBuffer), (long*)test.pBuffer);
   bensbmp.BHmakeBitmap3(test.MediaType,test.pBuffer,NULL);

while using BufferCB only as indicator that buffer is ready.

Am I right that reason why I can't access/change buffer is in my class not being managed

original c#:
internal class Capture : ISampleGrabberCB, IDisposable

my c++:
public class Camera : ISampleGrabberCB

or am I just doing something wrong?

@Spoilsport: she was answering another question from earlier who did not understand her response. I didn't know what it meant either until she explained it just before your response...once she did I thought it was quite clever, truth be told...

Easy now...