Capturing the Screen Image Using C#

Environment: C#, .NetFramework, Windows9x, Windows2000, WindowsXP

I am working on a desktop-sharing type application in C#. The first problem that I encountered was that there was not much in C# to capture the desktop image. After a bit of research, I came to know that I shall have to use the Win32 APIs to provide this functionality to my application. I made the following three classes to perform this job:

Class Description
PlatformInvokeGDI32 All the GDI32.dll APIs being used in this application are placed in this class.
PlatformInvokeUSER32 All the User32.dll APIs have been placed in this class.
CaptureScreen In this class I have provided a simple static function, GetDesktoImage, that captures the screen image using the APIs given in PlatformInvokeGDI32 and PlatformInvokeUSER32 and returns it as a bitmap.

You can very easily place these classes in your C# application. Just copy and paste the following code into your C# project without changing anything at all. If you want to use the accompanying source files, either you will add the CaptureScreen namespace in your project or just change the CaptureScreen namespace in these classes with your project namespace; that’s all.

Here Is the Beautiful Source Code

/// This class shall keep the GDI32 APIs used in our program.

public class PlatformInvokeGDI32
#region Class Variables
public const int SRCCOPY = 13369376;
#region Class Functions
public static extern IntPtr DeleteDC(IntPtr hDc);

public static extern IntPtr DeleteObject(IntPtr hDc);

public static extern bool BitBlt(IntPtr hdcDest,int xDest,
int yDest,int wDest,
int hDest,IntPtr hdcSource,
int xSrc,int ySrc,int RasterOp);

[DllImport (“gdi32.dll”,EntryPoint=”CreateCompatibleBitmap”)]
public static extern IntPtr CreateCompatibleBitmap
(IntPtr hdc,int nWidth, int nHeight);

[DllImport (“gdi32.dll”,EntryPoint=”CreateCompatibleDC”)]
public static extern IntPtr CreateCompatibleDC(IntPtr hdc);

[DllImport (“gdi32.dll”,EntryPoint=”SelectObject”)]
public static extern IntPtr SelectObject(IntPtr hdc,IntPtr bmp);

#region Public Constructor

/// This class shall keep the User32 APIs used in our program.

public class PlatformInvokeUSER32
#region Class Variables
public const int SM_CXSCREEN=0;
public const int SM_CYSCREEN=1;

#region Class Functions
[DllImport(“user32.dll”, EntryPoint=”GetDesktopWindow”)]
public static extern IntPtr GetDesktopWindow();

public static extern IntPtr GetDC(IntPtr ptr);

public static extern int GetSystemMetrics(int abc);

public static extern IntPtr GetWindowDC(Int32 ptr);

public static extern IntPtr ReleaseDC(IntPtr hWnd,IntPtr hDc);


/// This class shall keep all the functionality for capturing
/// the desktop.

public class CaptureScreen
#region Public Class Functions
public static Bitmap GetDesktopImage()
//In size variable we shall keep the size of the screen.
SIZE size;

//Variable to keep the handle to bitmap.
IntPtr hBitmap;

//Here we get the handle to the desktop device context.
IntPtr hDC = PlatformInvokeUSER32.GetDC

//Here we make a compatible device context in memory for screen
//device context.

IntPtr hMemDC = PlatformInvokeGDI32.CreateCompatibleDC(hDC);

//We pass SM_CXSCREEN constant to GetSystemMetrics to get the
//X coordinates of the screen. = PlatformInvokeUSER32.GetSystemMetrics

//We pass SM_CYSCREEN constant to GetSystemMetrics to get the
//Y coordinates of the screen. = PlatformInvokeUSER32.GetSystemMetrics

//We create a compatible bitmap of the screen size and using
//the screen device context.

hBitmap = PlatformInvokeGDI32.CreateCompatibleBitmap

//As hBitmap is IntPtr, we cannot check it against null.
//For this purpose, IntPtr.Zero is used.

if (hBitmap!=IntPtr.Zero)
//Here we select the compatible bitmap in the memeory device
//context and keep the refrence to the old bitmap.

IntPtr hOld = (IntPtr) PlatformInvokeGDI32.SelectObject
(hMemDC, hBitmap);
//We copy the Bitmap to the memory device context.
PlatformInvokeGDI32.BitBlt(hMemDC, 0, 0,,, hDC,
0, 0,PlatformInvokeGDI32.SRCCOPY);
//We select the old bitmap back to the memory device context.
PlatformInvokeGDI32.SelectObject(hMemDC, hOld);
//We delete the memory device context.
//We release the screen device context.
GetDesktopWindow(), hDC);
//Image is created by Image bitmap handle and stored in
//local variable.

Bitmap bmp = System.Drawing.Image.FromHbitmap(hBitmap);
//Release the memory to avoid memory leaks.
//This statement runs the garbage collector manually.
//Return the bitmap
return bmp;
//If hBitmap is null, retun null.
return null;

//This structure shall be used to keep the size of the screen.
public struct SIZE
public int cx;
public int cy;

There is also a demo application with this code that shows the use of these classes. It’s a very simple Windows application in which there is a simple form with a menu and a picture box control. The Capture Screen menu item of the menu is used to capture the screen and assign to the image property of the picturebox control.

I hope you like this code. I have commented each line of this code to make it self-explanatory. If there is still something confusing to you, please let me know. Good Luck!


Download demo project – 12 Kb

Download source – 3 Kb

More by Author

Must Read