C#

for (int i=0; i < 5; i++)
{
  MenuItem menu = new MenuItem("Menu " + i.ToString());
  menu.Click += new EventHandler(MenuItem_Click);
  contextMenu1.MenuItems.Add(menu);
}
// ...
private void MenuItem_Click(object sender, EventArgs e)
{
  MenuItem menu = sender as MenuItem;
  if (menu != null) MessageBox.Show(menu.Text + " was clicked.");
}

// in the Form class, MyForm.cs
OtherClass theOtherClass = new OtherClass(this);

// in the other class
public class OtherClass
{
   MyForm myFormInstance = null;
   
   public OtherClass(MyForm frmInst)
   {
      this.myFormInstance = frmInst;

      this.myFormInstance.DoSomething();
   }
}

public class MyForm : Form
{
   public static MyForm TheFormInstance = null;

   public MyForm()
   {
      TheFormInstance = this;
   }
}

// in some other class (note that MyForm is the actual name of the class, not a class instance)
MyForm.TheFormInstance.DoSomething();

// This is the main DLL file.

#include "stdafx.h"

#include "csusb.dll" //simple error handler
#include "ezusbsys.h" //comes with the cypress board
#include "usb100.h" //found in windows DDK; contains USB definitions for constants & structures.


using namespace System;
using namespace System::Text;
using namespace System::Runtime::InteropServices;

namespace EzUsb
{
	[StructLayout(LayoutKind::Explicit, Size=18, CharSet=CharSet::Auto)]
	public __gc class UsbDeviceDescriptor 
	{
	public:
		[FieldOffset(0)] System::Byte bLength;
		[FieldOffset(1)] System::Byte bDescriptorType;
		[FieldOffset(2)] System::UInt16 bcdUSB;
		[FieldOffset(4)] System::Byte bDeviceClass;
		[FieldOffset(5)] System::Byte bDeviceSubClass;
		[FieldOffset(6)] System::Byte bDeviceProtocol;
		[FieldOffset(7)] System::Byte bMaxPacketSize0;
		[FieldOffset(8)] System::UInt16 idVendor;
		[FieldOffset(10)] System::UInt16 idProduct;
		[FieldOffset(12)] System::UInt16 bcdDevice;
		[FieldOffset(14)] System::Byte iManufacturer;
		[FieldOffset(15)] System::Byte iProduct;
		[FieldOffset(16)] System::Byte iSerialNumber;
		[FieldOffset(17)] System::Byte bNumConfigurations;
	};

	public __gc class Usb
	{
	private:
		HANDLE _hEzUsb;

		void ReportError( String* msg )
		{
			if( OnErrorMessage )
			{
				OnErrorMessage( this, new ErrorEventArgs( msg ) );
			}
		}

		void CheckWin32Error()
		{
			int errCode = GetLastError(); 
			if( errCode != 0 )
			{
				char msg[256];
				FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, errCode, 0, 
					msg, 256, NULL );
				ReportError( msg );
			}
		}

	public:
		static const int MaxBlkSize = 64;

		__delegate void ErrorMessage( Object* sender, ErrorEventArgs* e );
		__event ErrorMessage* OnErrorMessage;

		Usb()
		{
			_hEzUsb = INVALID_HANDLE_VALUE;
		}

		~Usb()
		{
			if( _hEzUsb != INVALID_HANDLE_VALUE )
			{
				CloseHandle( _hEzUsb );
			}
		}

		bool Open( String* driverName )
		{
			char* lpFileName = new char[driverName->Length + 10];
			sprintf( lpFileName, "\\\\.\\%s", driverName );
			_hEzUsb = CreateFile( lpFileName,
									GENERIC_WRITE,
									FILE_SHARE_WRITE,
									NULL,
									OPEN_EXISTING,
									0,
									NULL);
			if( _hEzUsb == INVALID_HANDLE_VALUE )
			{
				CheckWin32Error();
			}
			delete lpFileName;

			return( _hEzUsb != INVALID_HANDLE_VALUE );
		}

		void Close()
		{
			CloseHandle( _hEzUsb );
		}

		Usb::UsbDeviceDescriptor* GetDeviceDescriptor()
		{
			BOOLEAN success;
			ULONG nBytes;
			PUSB_DEVICE_DESCRIPTOR pDeviceDiscriptor = new USB_DEVICE_DESCRIPTOR();

			if( _hEzUsb == INVALID_HANDLE_VALUE )
			{
				ReportError( "Driver not open." );
			}
			else
			{
				success = DeviceIoControl( _hEzUsb,
						IOCTL_Ezusb_GET_DEVICE_DESCRIPTOR,
						NULL,
						0,
						pDeviceDiscriptor,
						sizeof(USB_DEVICE_DESCRIPTOR),
						&nBytes,
						NULL );
				if( success == FALSE )
				{
					CheckWin32Error();
				}
			}

			UsbDeviceDescriptor* DeviceDiscriptor = new UsbDeviceDescriptor();
			DeviceDiscriptor = (UsbDeviceDescriptor*)Marshal::PtrToStructure(
					pDeviceDiscriptor, DeviceDiscriptor->GetType() );

			delete pDeviceDiscriptor;

			return( DeviceDiscriptor );
		}

		System::Byte BulkRead( int pipe ) []
		{
			if( _hEzUsb == INVALID_HANDLE_VALUE )
			{
				ReportError( "Driver not open." );
				return( 0 );
			}

			char lpOutBuffer[MaxBlkSize];

			BULK_TRANSFER_CONTROL btc;
			btc.pipeNum = pipe;
			BOOL success;
			int nBytes;

			success = DeviceIoControl( _hEzUsb,
						IOCTL_EZUSB_BULK_READ, 
						&btc,
						sizeof (BULK_TRANSFER_CONTROL),
						lpOutBuffer,
						MaxBlkSize,
						(unsigned long *)&nBytes,
						NULL);
			if( success == FALSE )
			{
				CheckWin32Error();
				return( 0 );
			}

			System::Byte buffer  __gc[] = new System::Byte[nBytes];
			IntPtr ptr( lpOutBuffer );
			Marshal::Copy( ptr, buffer, 0, nBytes );

			return( buffer );
		}

		int BulkWrite( System::Byte buffer __gc[], int pipe )
		{
			if( _hEzUsb == INVALID_HANDLE_VALUE )
			{
				ReportError( "Driver not open." );
				return( 0 );
			}

			char* lpOutBuffer = new char[buffer->Length];
			Marshal::Copy( buffer, 0, lpOutBuffer, buffer->Length );

			BULK_TRANSFER_CONTROL btc;
			BOOLEAN success;
			int nBytes;

			btc.pipeNum = pipe;

			success = DeviceIoControl( _hEzUsb,
						IOCTL_EZUSB_BULK_WRITE, 
						&btc,
						sizeof (BULK_TRANSFER_CONTROL),
						lpOutBuffer,
						buffer->Length,
						(unsigned long *)&nBytes,
						NULL);
			if( !success )
			{
				CheckWin32Error();
			}

			delete lpOutBuffer;

			return( nBytes );
		}
	};
}