Crows Programming

SDL & OpenGL Game with C++ – Part II

crow — Tue, 08 Dec 2009 05:39:32 +0000

Parts in the Series

Rendering a Quad with OpenGL and SDL

Ok, so if we are going to program a video game then we need to draw something with OpenGL.

That being said, last time we left off with a basic framework for creating a game with SDL. If you haven’t read it then you should check out part 1 here because we’ll be building off of that. This time around the goal is simply to get something rendering on the screen with OpenGL. So with that in mind here is the road map for what I wanted to accomplish:

Render a single quad
Render a textured quad

As you can see I am going to keep it simple for now. I’ll throw in the ability to swap textures at runtime as well just to keep it interesting.

The game so far will look a little something like this:

Drawing a Square With SDL

First on the list is to render a single quad. But, before you do anything make sure you add the OpenGL libraries to your project. You can accomplish that by going into the linker section of the project settings and adding opengl32.lib and glu32.lib to the additional dependencies section, just as we did for the SDL libraries in Part I.

I am just going to start out showing you the new main function and then we will go through it step by step. So here ya go!

int main( int argc, char **argv)
{
        // graphics properties
	const int width = 640;        // width of the game window 
	const int height = 480;       // height of the game window
	const float fov = 45.0f;      // field of view (degrees)
	const float nearClip = 1.0f;  // near clip plane (don't set to zero)
	const float farClip = 100.0f; // far clip plane
 
	// initialize SDL
	if( SDL_Init( SDL_INIT_VIDEO ) == -1 )
	{
              fprintf(stderr, "Failed to initialize SDL. [%s]\n", SDL_GetError());
              exit(1);
	}
 
	// set desired OpenGL attributes prior to selecting a video mode
	SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );  // use 16 bits for depth buffer
	SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // enable double buffering
 
	// create an OpenGL surface/window
	SDL_Surface *screen = SDL_SetVideoMode(width, height, 32, SDL_OPENGL);
        if( screen == NULL )
        {
              fprintf(stderr, "Failed to set video mode. [%s]\n", SDL_GetError());
              exit(1);
        }
 
	// initialize OpenGL
	if( SetupOpenGL( width, height, fov, nearClip, farClip) == -1 )
	{
		fprintf( stderr, "Failed to setup OpenGL.\n" );
		exit(1);
	}
 
	// main game loop
	bool done = false;
 
	while( !done )
	{
		RenderScene();
 
		if( ProcessInput() )
			done = true;
	}
 
	SDL_Quit();
 
	return 0;
}

The variable declarations on lines 4-8 just control the graphical properties of the application. They’re pretty self-explanatory. You can change the width or height and so on.

Next up you’ll see that the code to initialize the video mode (lines 17-27) has been changed. SDL gives us certain attributes that can modify the behavior of OpenGL, but these changes only take place after a call to SDL_SetVideoMode. In this case we’re telling SDL that we would like OpenGL to use a 16-bit depth buffer and to use double buffering when rendering (actively draws to an off screen surface, not the screen). Note that technically we should check the value of these attributes after the SDL_SetVideoMode call to ensure that they were set successfully. You could (and technically should) do this with the correct calls to SDL_GL_GetAttribute. You’ll also notice that the flags parameter for SDL_SetVideoMode now uses SDL_OPENGL instead of SDL_SWSURFACE since we are specifying that we want to use OpenGL for drawing.

Following the setting of the video mode I make a call to SetupOpenGL which is going to configure OpenGL for the application. I’ll detail this function shortly. The last major change to the code is the addition of RenderScene in the main loop. This is the function that will actually draw the game on the screen. Everthing should seem pretty straight forward.

Configuring OpenGL

So now I am going to show you SetupOpenGL. The entire purpose of this function is simply to setup things with respect to OpenGL that we won’t be changing again or that need a known initial state. It’s pretty simple stuff.

int SetupOpenGL( int width, int height, float fov, float nearClip, float farClip )
{
	glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
 
	float ar = (GLfloat)width / height; // display aspect ratio
 
	// setup projection matrix
	glMatrixMode(GL_PROJECTION);						
	glLoadIdentity();						
	gluPerspective(fov, ar, nearClip, farClip);
 
	// setup model view matrix
	glMatrixMode(GL_MODELVIEW);			
	glLoadIdentity();
 
	// setup depth buffer
	glClearDepth(1.0f);						
	glEnable(GL_DEPTH_TEST);						
	glDepthFunc(GL_LEQUAL);	
 
	// misc. GL settings
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	glShadeModel(GL_SMOOTH);
 
	glViewport( 0, 0, width, height );
 
	return 0;
}

Here I do some basic setup work:

Setup the projection matrix with gluPerspective
Set the view matrix to identity
Setup the depth buffer
Setup some various GL settings such as the shade model
And finally setup the viewport

If that looks like gably gook to you then you should check out the the OpenGL Red Book. The 3D transformation pipeline, matrix math, etc is a vast subject and beyond the scope of this post.

Render Scene

Next let’s look at the render scene function.

void RenderScene( void )
{
	// render everything for the current frame
 
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();
 
	// move off center so the quad is visible
	glTranslatef(-1.0f, 0.0f, -5.0f);
 
	// draw quad as red
	glColor3f( 1.0f, 0.0, 0.0 );
 
	// render the quad
	glBegin(GL_QUADS);						
		glVertex3f(-1.0f, 1.0f, 0.0f);				
		glVertex3f( 1.0f, 1.0f, 0.0f);				
		glVertex3f( 1.0f,-1.0f, 0.0f);				
		glVertex3f(-1.0f,-1.0f, 0.0f);			
	glEnd();
 
	// update display
	SDL_GL_SwapBuffers();
}

So this function will be called every frame to draw the entire screen or “scene”. In this example, it’s simply drawing a red quad on the screen. What’s happening should be clear. First the framebuffer is cleared to get rid of the last scene. Then the identity matrix is loaded into the view matrix so that we are in the center of our world. After that the “camera” is positioned slightly to the left and back a little so the quad is nice and visible. Also, remember OpenGL uses a right handed system so to move the camera back we move along the negative z-axis. Moving on, the active color is then set to red and the quad is drawn vertex by vertex inside the glBegin/glEnd calls. Note that we are not culling back faces so we don’t worry about vertex winding order. Finally a call to SDL_GL_SwapBuffers is made so that the output can be seen. You should see a nice pretty red square.

ProcessInput

The ProcessInput function is responsible for reacting to input events like key presses. Basically it’s the same code from the last example moved into its own little function. It returns true to indicate that the user has indicated he would like to exit the game. Here is the code:

bool ProcessInput( void )
{
	// runs the input processing loop
	// returns true if any input has requested the application to exit
 
	SDL_Event evt;
	bool exitFlag = false;
 
	// check for events generated from SDL
	while( SDL_PollEvent( &evt ) )
	{
		switch( evt.type )
		{
		case SDL_QUIT:
			exitFlag = true;
			break;
 
		case SDL_KEYUP:
			if( evt.key.keysym.sym == SDLK_ESCAPE )
				exitFlag = true;
			break;
 
		default:
			break;
		}
	}
 
	return exitFlag;
}

Complete Code Listing

Ok, that was great fun. Now, behold the entire code listing!

#include 
 
#include 
#include 
 
#include 
#include 
 
// function prototypes
int SetupOpenGL( int width, int height, float fov, float nearClip, float farClip );
void RenderScene( void );
bool ProcessInput( void );
 
int main( int argc, char **argv)
{
	// graphics properties
	const int width = 640;        // width of the game window 
	const int height = 480;       // height of the game window
	const float fov = 45.0f;      // field of view (degrees)
	const float nearClip = 1.0f;  // near clip plane (don't set to zero)
	const float farClip = 100.0f; // far clip plane
 
	// initialize SDL
	if( SDL_Init( SDL_INIT_VIDEO ) == -1 )
	{
		fprintf(stderr, "Failed to initialize SDL. [%s]\n", SDL_GetError());
		exit(1);
	}
 
	// set desired OpenGL attributes prior to selecting a video mode
	SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );  // use 16 bits for depth buffer
	SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // enable double buffering
 
	// create an OpenGL surface/window
	SDL_Surface *screen = SDL_SetVideoMode(width, height, 32, SDL_OPENGL);
        if( screen == NULL )
        {
		fprintf(stderr, "Failed to set video mode. [%s]\n", SDL_GetError());
		exit(1);
        }
 
	// initialize OpenGL
	if( SetupOpenGL( width, height, fov, nearClip, farClip) == -1 )
	{
		fprintf( stderr, "Failed to setup OpenGL.\n" );
		exit(1);
	}
 
	// main game loop
	bool done = false;
 
	while( !done )
	{
		RenderScene();
 
		if( ProcessInput() )
			done = true;
	}
 
	SDL_Quit();
 
	return 0;
}
 
int SetupOpenGL( int width, int height, float fov, float nearClip, float farClip )
{
	glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
 
	float ar = (GLfloat)width / height; // display aspect ratio
 
	// setup projection matrix
	glMatrixMode(GL_PROJECTION);						
	glLoadIdentity();						
	gluPerspective(fov, ar, nearClip, farClip);
 
	// setup model view matrix
	glMatrixMode(GL_MODELVIEW);			
	glLoadIdentity();
 
	// setup depth buffer
	glClearDepth(1.0f);						
	glEnable(GL_DEPTH_TEST);						
	glDepthFunc(GL_LEQUAL);	
 
	// misc. GL settings
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	glShadeModel(GL_SMOOTH);
 
	glViewport( 0, 0, width, height );
 
	return 0;
}
 
void RenderScene( void )
{
	// render everything for the current frame
 
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();
 
	// move off center so the quad is visible
	glTranslatef(-1.0f, 0.0f, -5.0f);
 
	// draw quad as red
	glColor3f( 1.0f, 0.0, 0.0 );
 
	// render the quad
	glBegin(GL_QUADS);						
		glVertex3f(-1.0f, 1.0f, 0.0f);				
		glVertex3f( 1.0f, 1.0f, 0.0f);				
		glVertex3f( 1.0f,-1.0f, 0.0f);				
		glVertex3f(-1.0f,-1.0f, 0.0f);			
	glEnd();
 
	// update display
	SDL_GL_SwapBuffers();
}
 
bool ProcessInput( void )
{
	// runs the input processing loop
	// returns true if any input has requested the application to exit
 
	SDL_Event evt;
	bool exitFlag = false;
 
	// check for events generated from SDL
	while( SDL_PollEvent( &evt ) )
	{
		switch( evt.type )
		{
		case SDL_QUIT:
			exitFlag = true;
			break;
 
		case SDL_KEYUP:
			if( evt.key.keysym.sym == SDLK_ESCAPE )
				exitFlag = true;
			break;
 
		default:
			break;
		}
	}
 
	return exitFlag;
}

Wrap Up

Well, now we can at least draw something on the screen. I wanted to do textures on this post but it is already getting pretty lengthy. So, next time we will texture map the quad and work another step closer to having some kind of game programmed.

Have fun!

SDL & OpenGL Game with C++ – Part I

crow — Mon, 23 Nov 2009 07:22:01 +0000

Parts in the Series

Part II – Drawing a Quad

Getting Started

I think I’ve spent too many late nights playing multiplayer Modern Warfare 2 and now I feel the need to build a small game of some kind. Game programming is fun, and although I’ve never done it professionally, I have dabbled with it as a hobby for many years. I’ll be documenting my progress here over time via a number of different postings. Maybe some of you will find it useful as a reference or small SDL tutorial or game programming tutorial. That being said, time to get to work!

I have no idea what type of game to build yet so the first thing to do is just get the basic framework setup. I’ll be using C++ for this game project. I thought about using C# and XNA but I need to dust off my C++. For the graphics system I decided to use OpenGL. This is mostly because I am familiar with it and didn’t want the extra overhead of boilerplate setup stuff associated with DirectX. I just want to get something going quickly. For the rest of the stuff needed (audio, input, etc) I am going to use SDL. SDL is a great tool to get things up and running fast and it easily interfaces with OpenGL. I am also thinking about putting in some UI stuff using CEGUI (Crazy Eddie’s GUI System).

SDL Setup Prerequisites

Before we get started you’ll want to make sure you have the SDL development libraries (I am using version 1.2.14). You can find them on the SDL website: http://www.libsdl.org. The ones I used specifically are:

Runtime – http://www.libsdl.org/release/SDL-1.2.14-win32.zip
Library (Visual Studio 2008) – http://www.libsdl.org/release/SDL-devel-1.2.14-VC8.zip

Creating the Project

Ok enough talk, let’s get started. You’ll need to create a new project and correctly configure it to use the SDL library. Fire up Visual Studio and create a new C/C++ console project. In the project wizard, uncheck the “Using Precompiled Header” option and check the “empty project” option. Now, add a new file and call it main.cpp.

In the Solution Explorer, right click your project and select properties. Open the C/C++ settings and select the general property page. Under the item “additional include directories” enter the path to the SDL SDK header files (i.e. C:\YourSDLDir\SDL-1.2.14\include).

Now, drop down to the Code Generation page and under “Runtime Library” select “Multi-threaded DLL”. If you try to link with the debug build of the runtime you’ll see a nice error message like this one:

warning LNK4098: defaultlib ‘msvcrt.lib’ conflicts with use of other libs; use /NODEFAULTLIB:library

This is because the SDL runtime is not a debug build. I couldn’t find a debug build on the SDL website so I guess if you want one you have to build it from source.

That takes care of the C/C++ settings so now let’s do the linker settings. Under the linker settings select the general page. Under additional library directories enter the path to the lib directory for your SDL SDK (i.e. C:\YourSDLDIR\SDL-1.2.14\lib). On the input page 2 files need to be listed as additional dependencies.

SDL.lib
SDLmain.lib

Also, make sure you grab SDL.dll from the SDK and put it in your debug folder along side the executable you build.

And that’s it! Go ahead and compile your application to make sure you set everything up correctly.

Basic SDL Usage

Next we will fill out main.cpp to get a basic SDL skeleton application running. Start out by including the SDL header file.

#include

Now add the main function:

int main( int argc, char **argv)
{
     return 0;
}

Now, an interesting thing to note here is that’s not really your normal main function. It’s not even the main entry point into your application. SDL redefines main using a #define to SDL_main. This also means that you cannot change the function signature as you normally could for a main function. SDL_main just does some basic housekeeping/setup stuff on behalf of SDL.

SDL Initialization

Next up we need to initialize the SDL system. This is accomplished via SDL_Init. Go ahead and add the following to your main function.

if( SDL_Init( SDL_INIT_VIDEO ) == -1 )
{
   fprintf(stderr, "Failed to initialize SDL. [%s]\n", SDL_GetError());
   exit(1);
}

This will initialize SDL and the video subsystem. If it fails, it will print an error message to the standard error stream. Since we have a console app, this information will be printed directly to the console. Note the usage of SDL_GetError. This is a great tool to help determine why an SDL function call failed. It simply returns a pointer to a null-terminated string containing a description of the last failure.

The next thing to do is setup a video mode. This will give us a window and a drawing surface so we can actually render game content to the screen. Add the following code after the SDL_Init block.

SDL_Surface *screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);
if( screen == NULL )
{
   fprintf(stderr, "Failed to set video mode. [%s]\n", SDL_GetError());
   exit(1);
}

This will get us a window and a surface to draw on that’s 640×480 with 32 bits per pixel. The video surface will be created in system memory as opposed to say video memory thanks to the SDL_SWSURFACE flag. That’s ok for now. Also note that you could create the application in fullscreen mode by specifying SDL_FULLSCREEN for the last parameter.

Now we’re going to add the main game loop. Game loops can get pretty complicated but we will keep it simple here. For now we only need to check user input. So let’s add the following code now.

Game Loop & Event Processing

SDL_Event evt;
bool done = false;
 
while( !done )
{
        while( SDL_PollEvent( &evt ) )
	{
		switch( evt.type )
		{
		case SDL_QUIT:
		  done = true;
		  break;
 
		case SDL_KEYUP:
		  if( evt.key.keysym.sym == SDLK_ESCAPE )
		       done = true;
		  break;
            default:
                  break;
		}
	}
}

Ok, so what’s going on here is that for every trip through the game loop we are emptying the SDL event queue and processing the events. SDL stores all kinds of events for us such as key presses, mouse movement, and joystick input. In this case, we want to know if the user wants to quit the application (SDL_QUIT) or if the user presses the escape key (SDL_KEYUP). In both cases we simply set done to true to signal the main loop to bail. SDL_Event is a union with all kinds of interesting structures in it. You should have a look at it in the SDL documentation.

The last thing that needs to happen is to shutdown the application. We can accomplish that with a simple call to SDL_Quit.

So, without further ado, here is the complete skeletal SDL game code that simply creates a 640×480 window and waits for the user to press escape or close the window.

Full Code Listing

#include 
 
int main( int argc, char **argv)
{
	SDL_Event evt;
	bool done = false;
 
	// initialize SDL
	if( SDL_Init( SDL_INIT_VIDEO ) == -1 )
	{
            fprintf(stderr, "Failed to initialize SDL. [%s]\n", SDL_GetError());
            exit(1);
	}
 
	// create a software surface/window
	SDL_Surface *screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);
        if( screen == NULL )
        {
            fprintf(stderr, "Failed to set video mode. [%s]\n", SDL_GetError());
            exit(1);
        }
 
	// main game loop
	while( !done )
	{
		// check for events generated from SDL
		while( SDL_PollEvent( &evt ) )
		{
			switch( evt.type )
			{
			case SDL_QUIT:
				done = true;
				break;
 
			case SDL_KEYUP:
				if( evt.key.keysym.sym == SDLK_ESCAPE )
					done = true;
				break;
 
			default:
				break;
			}
		}
	}
 
	SDL_Quit();
 
	return 0;
}

Fun Stuff to Try

So, here’s some fun stuff to try to understand a little more about making things happen in SDL.
Try adding this snippet of code to see how to fill or clear the screen (SDL surface) with a different color. Before the main game loop add this:

Uint32 color1 = SDL_MapRGB(screen->format, 0x00, 0x00, 0xFF);
Uint32 color2 = SDL_MapRGB(screen->format, 0x00, 0xFF, 0x00);
Uint32 currentColor = color1;

And, your SDL_KEYUP processing code in your main loop should look like this:

case SDL_KEYUP:
   if( evt.key.keysym.sym == SDLK_ESCAPE )
      done = true;
   else if( evt.key.keysym.sym == SDLK_SPACE )
   {
      currentColor = ( currentColor == color1 ) ? color2 : color1;
      SDL_FillRect( screen, NULL, currentColor);
      SDL_UpdateRect(screen, 0, 0, 0, 0);
   }
   break;

Now, every time your press the space key the screen color will alternate between green and blue.

Another thing you can do is when processing the key stroke is display the character pressed in the console window. You can do that like this:

case SDL_KEYDOWN:
   printf( "KEYDOWN: %c\n", evt.key.keysym.unicode);
   break;

But you have to remember to enable Unicode support within SDL. Do that with a call to SDL_EnableUNICODE(1) in the initialization code prior to the main game loop.

What Next?

Well that’s it for now. You now have a basic game setup using SDL. It also shows some basic ways to manipulate the screen and process SDL events. Next time I am going to start integrating OpenGL and get something fun on the screen.

If you have any questions or comments let me know. See ya next time!!!

Runtime Scripting in .Net

crow — Thu, 01 Oct 2009 04:49:40 +0000

The ability to ship source code with your product that can be compiled or interpreted at runtime is a very valuable asset. Video games do this all the time with things like AI allowing the end-user to easily mod the game. In compiled languages like C++, this technique is highly advantageous as it allows you to avoid the costly compile-link cycle for every small change to a source file. This is also helpful in an environment where creating a new build, generating the installer, and deploying it is overkill or difficult to achieve. In this article we will examine how you can achieve this from .Net programs consuming a C# or VB.Net script. I’ll refer to this as “scripting”, even though an unambiguous definition of a “script” is somewhat difficult to nail down.

Using a C# or VB script from a .Net language is actually very simple. The basic idea is to read in a source file, which could come from the network or disk, and compile it into a temporary assembly on file or IL in memory. Then you can instantiate types from the script file and use them just as easily as any other types already defined. Normally the hard part in this process is locating and invoking the proper compiler. Luckily, we can compile IL code using a CodeDomProvider like CSharpCodeProvider. And, since these types are part of the .Net framework we know they are available on the end-user PC! Life is great eh?

Ok, so first make sure you have referenced the following namespaces:

    using System.CodeDom.Compiler;
    using Microsoft.CSharp;
    using Microsoft.VisualBasic;

Next you need to setup the compiler parameters. These are simply the options given to the compiler such as whether to create the resulting assembly in memory or if debug information should be included in the generated code. You can do this with the CompilerParameters type. Here is an example for creating an in memory assembly with debug information:

 CompilerParameters cparams = new CompilerParameters();
 
 cparams.GenerateInMemory = false;
 cparams.IncludeDebugInformation = true;
 cparams.CompilerOptions += " /debug:pdbonly";
 
 cparams.TreatWarningsAsErrors = false;
 cparams.GenerateExecutable = false;

You would also want to add any references that your code needs using CompilerParameters. ReferencedAssemblies. So, after you have the compiler options set you need to actually invoke the C# or Visual Basic compiler. You do this by creating a CodeDomCompiler of the appropriate type:

VBCodeProvider – for Visual Basic
CSharpCodeProvider – for C Sharp

Then you can use the provider to compile an assembly like so:

CodeDomProvider provider = CSharpCodeProvider();
CompilerResults result = provider.CompileAssemblyFromFile(cparams, script);

Where cparams are your compiler parameters and result is well, your results. Within results you will find out if the compilation was successful or generated warnings. It will also give you access to the resulting assembly. You can check for errors using results.Errors.HasErrors and reference the assembly with results.CompiledAssembly.

Now that you have a compiled assembly in memory, there is one last issue to address. How do you instantiate types from the assembly? The easiest way to attack the problem is to create an interface that your application can access and derive a type from that interface in your script. I’ve created a full example below (explained in code comments) to illustrate the technique I am talking about.

C# Example

Main application – Script.cs

using System;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
using Microsoft.VisualBasic;
using System.Reflection;
using System.IO;
 
namespace ScriptingExample
{
    public class Script
    {
        public LoadedType LoadScript<LoadedType>(string script, string referenceString) where LoadedType:class
        {
            // this will load/compile the script source file, "script", and return a type of LoadedType
            // it is assumed that a type of "LoadedType" is defined in the script
            // the referenceString is a comma delimited string identifying all references needed by the script
            // e.g. "System.dll,System.Windows.Forms.dll"
            // either the VB or C# compiler will be invoked, based upon the file extenstion .vb or .cs
 
            // try and compile the script
            CompilerParameters cparams = CreateCompilerParameters(referenceString);
            CompilerResults results = CompileScript(script, cparams);
 
            // check for errors
            if (results.Errors.HasErrors)
            {
                string e = "";
                foreach (CompilerError error in results.Errors)
                    e += (error.ErrorText + Environment.NewLine);
 
                throw new Exception("ERROR IN SCRIPT: " + Environment.NewLine + e);
            }
 
            // find the "exported" type to load
            LoadedType scriptObject = FindScriptObject<LoadedType>(results.CompiledAssembly);
 
            if (scriptObject == null)
                throw new Exception("CAN'T LOAD SCRIPT, TARGET TYPE NOT IMPLEMENTED IN SCRIPT.");
            else
                return scriptObject;
        }
 
        private CompilerResults CompileScript(string script, CompilerParameters cparams)
        {
            // compiles the script using the specified parameters
            // either the VB or C# compiler will be invoked, based upon the file extenstion .vb or .cs
            CodeDomProvider provider = GetCompiler(script);
            CompilerResults result = provider.CompileAssemblyFromFile(cparams, script);
 
            return result;
        }
 
        CodeDomProvider GetCompiler(string script)
        {
            // returns the correct compiler to use based on the file extension of the script
            string extension = Path.GetExtension(script);
 
            if (extension == ".vb")
                return new VBCodeProvider();
            else if (extension == ".cs")
                return new CSharpCodeProvider();
            else
                throw new Exception("UNKNOWN SCRIPT TYPE");
        }
 
        private LoadedType FindScriptObject<LoadedType>(Assembly assembly) where LoadedType : class
        {
            // attempts to locate the type "LoadedType" within the assembly that was created from the "script"
            foreach (Type t in assembly.GetTypes())
                if (typeof(LoadedType).IsAssignableFrom(t))
                    return Activator.CreateInstance(t) as LoadedType;
 
            return default(LoadedType);
        }
 
        private CompilerParameters CreateCompilerParameters(string referenceString)
        {
            // creates compiler parameters to generate an in memory assembly, with debug
            // symbols if this is a debug build
            // the referenceString is a comma delimited string identifying all references needed by the script
            CompilerParameters cparams = new CompilerParameters();
 
            cparams.GenerateInMemory = true;
 
            #if DEBUG
                // create debug symbols if this is a debug build
                cparams.IncludeDebugInformation = true;
                cparams.CompilerOptions += " /debug:pdbonly";
            #endif
 
            cparams.TreatWarningsAsErrors = false;
            cparams.GenerateExecutable = false; 
 
            // seperate reference string
            string[] references = referenceString.Split(',');
 
            foreach (string reference in references)
                cparams.ReferencedAssemblies.Add(reference);
 
            return cparams;
        }
    }
}

App Showing How to Use Script.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
 
namespace ScriptingExample
{
    // we have to define an interface so we know how to "talk" to
    // the script, that is, there must be a type that we *know* the
    // script implements so we can call methods on it
    public interface MyScript
    {
        void Execute();
    }
 
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void Form1_Load(object sender, EventArgs e)
        {
            // just populate the combo box with all "scripts" located in the directory "Scripts"
            foreach (string file in Directory.GetFiles("Scripts"))
                comboBox1.Items.Add(file);
 
            if (comboBox1.Items.Count > 0)
                comboBox1.SelectedIndex = 0;
            else
            {
                button1.Enabled = false;
                comboBox1.Enabled = false;
            }
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            // load the script, which contains a type that implements MyScript
            // and call the execute method on it
            Script s = new Script();
 
            // these are the references the script will need, we must reference this executable
            // because the script needs to see the MyScript data type
            // this is just a sample, in a real application such types would be defined in an assembly dll
            // that is shared between the app consuming the script and the script itself
            string references = "System.dll,System.Windows.Forms.dll," + Directory.GetCurrentDirectory() + "\\ScriptingExample.exe";
 
            MyScript script = s.LoadScript<MyScript>(comboBox1.SelectedItem as string, references);
 
            script.Execute();
        }
    }
}

A VB and C# Script

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
 
namespace ScriptingExample.Scripts
{
    public class CSharpScript : MyScript
    {
        public void Execute()
        {
            MessageBox.Show("I AM A C# SCRIPT");
        }
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.Windows.Forms
 
Namespace ScriptingExample.Scripts
    Public Class VBScript
        Implements MyScript
        Public Sub Execute() Implements MyScript.Execute
            MessageBox.Show("I AM A VB SCRIPT!!")
        End Sub
    End Class
End Namespace

Conclusion

And that’s it! A very simple technique that can be used in many interesting ways. I’ve included a link to a Visual Studio project containing an implementation using the above information. The project can be found here As always, let me know if you have any questions or ideas!

See ya next time!

Using Ini Files In C#

crow — Thu, 16 Jul 2009 23:26:32 +0000

An Initialization, or Ini file, is a common text based file format commonly used on the Windows platform. Today its mostly been succeeded in favor of XML files for application configuration and persisting user data. Never the less, these files still exist and are in use by many applications. In this post, we will explore how to work with Ini files via C#.

The structure of an Ini file is very simple and straight forward. You have three primary types of information: sections, parameters, and values. They look like this:

[SectionA]
Parameter1=value1
Parameter2=value2

[SectionB]
Parameter1=value1

Below we will create a class to read this data from a file. Keep in mind as you look at this C# Ini file implementation that this is just one way to do it. You could for example, create a much more concise solution using regular expressions, etc.

Parsing the Data

The first thing we should do if figure out how to get the data from the Ini file. We could read in all the text and manually parse the file; however there is an easier approach. The Win32 API contains a function called GetPrivateProfileString that we can use specifically for this task. We can use it to directly obtain the sections, parameters, and values. For a more detailed description of the GetPrivateProfileString function, check out this link on MSDN.

To use GetPrivateProfileString in C#, we need only reference it using the DLLImport attribute with the correct function signature.

        [DllImport("Kernel32.dll", EntryPoint = "GetPrivateProfileStringW", SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern int GetPrivateProfileString(string lpAppName,
                                                         string lpKeyName,
                                                         string lpDefault,
                                                         [In, Out] char[] lpReturnString,
                                                         int nSize,
                                                         string lpFilename);

Reading from an Ini File

First, to make our job a little easier we will wrap the call to GetPrivateProfileString with our own method so that we can handle all of the details. Here is the wrapper:

        private string[] GetPrivateProfileString(string appName, string keyName, string defaultName, string inifile)
        {
            // the file inifile should exist as it's validated in the class constructor, however GetPrivateProfileString does not lock the file hence it could be locked or deleted by
            // another process between calls to this method
 
            // used to tell if we successfully read all requested data from the file 
            // from MSDN:
            //  If neither lpAppName nor lpKeyName is NULL and the supplied destination buffer is too small to hold the requested string, the string is truncated and followed by a null character, and the return value is equal to nSize minus one.
            //  If either lpAppName or lpKeyName is NULL and the supplied destination buffer is too small to hold all the strings, the last string is truncated and followed by two null characters. In this case, the return value is equal to nSize minus two.
            int sizeReadOffset = (appName != null && keyName != null) ? 1 : 2;
 
            // try and read the entire amount of data from the ini file
            int sizeRead = Kernel32.GetPrivateProfileString(appName, keyName, defaultName, _readBuffer, _readBufferSize, inifile);
 
            // if unable to read all of the data because the buffer is to small, increase the size and try again, but only allow memory to increase up to _readBufferMaxSize
            while ((sizeRead >= _readBufferSize - sizeReadOffset) && (_readBufferSize < _readBufferMaxSize))
            {
                _readBufferSize += 512;
                _readBuffer = new char[_readBufferSize];
 
                sizeRead = Kernel32.GetPrivateProfileString(appName, keyName, defaultName, _readBuffer, _readBufferSize, inifile);
            }
 
            // if memory consumption exceeded _readBufferMaxSize then we have a problem
            if (_readBufferSize >= _readBufferMaxSize)
                throw new FileLoadException("ErrorBadIniLoad");
 
            // the buffer returned from GetPrivateProfileString will be null terminated C-strings followed by a double null at the end - so split the strings on the nulls
            char[] sep = new char[1];
            sep[0] = '\0';
 
            string s = new string(_readBuffer, 0, sizeRead);
 
            string[] result = s.Split(sep, StringSplitOptions.RemoveEmptyEntries);
 
            return result;
        }

Here, the MSDN terminology refers to what I call a section as an appName and what I refer to as a paramter as a keyName.

This method has a lot going on but is very easy to use. To get an array of strings containing all of the section names you simply say:

string[] raw = GetPrivateProfileString(null, null, null, filename);

And, to get an array of all parameter names for a particular section you would say:

string[] raw = GetPrivateProfileString(sectionName, null, null, inifileName);

And finally, to get a parameter value you could say:

string[] raw = GetPrivateProfileString(sectionName, parameterName, null, inifile);

And the value is stored in the first element of the returned array.

Putting it All Together

So now we can put together a simple class encapsulating the above functionality. You can use this class as follows:

Given an Ini file:

[SectionA]
Parameter1=value1
Parameter2=value2

[SectionB]
Parameter1=value1

You could,

            INIFile file =  new INIFile(Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar + "MyInifile.ini");
 
            string a1 = file["SectionA","Parameter1"]; // returns "value1"
            string a2 = file["SectionA","Parameter2"]; // returns "value2"
 
            string b1 = file["SectionB", "Parameter1"]; // returns "value1"

Have fun playing with it. You could easily add the ability to write new sections and parameters as well. If you make some changes, find some bugs, or just plain find it useful let me know. I am always interested.

Here is the complete code listing for the class. You can download it here or just copy and paste it.

    /// 
    /// Contains native Win32 API methods found in Kernel32. 
    /// 
    public static class Kernel32
    {
        /// 
        /// Retrieves a string from the specified section in an initialization file.
        /// 
        /// The name of the section containing the key name. If this parameter is NULL, the GetPrivateProfileString function copies all section names in the file to the supplied buffer.
        /// The name of the key whose associated string is to be retrieved. If this parameter is NULL, all key names in the section specified by the lpAppName parameter are copied to the buffer specified by the lpReturnedString parameter.
        /// A default string. If the lpKeyName key cannot be found in the initialization file, GetPrivateProfileString copies the default string to the lpReturnedString buffer. If this parameter is NULL, the default is an empty string, "".
        ///                         Avoid specifying a default string with trailing blank characters. The function inserts a null character in the lpReturnedString buffer to strip any trailing blanks.
        /// A pointer to the buffer that receives the retrieved string.
        /// The size of the buffer pointed to by the lpReturnedString parameter, in characters.
        /// The name of the initialization file. If this parameter does not contain a full path to the file, the system searches for the file in the Windows directory.
        /// The return value is the number of characters copied to the buffer, not including the terminating null character.
        [DllImport("Kernel32.dll", EntryPoint = "GetPrivateProfileStringW", SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]
        public static extern int GetPrivateProfileString(string lpAppName,
                                                         string lpKeyName,
                                                         string lpDefault,
                                                         [In, Out] char[] lpReturnString,
                                                         int nSize,
                                                         string lpFilename);
 
    }
 
 
    /// 
    /// Represents the common INI file format consisting of parameter-value pairs grouped by sections.
    /// 
    public class INIFile
    {
        #region Nested Types
        public enum CaseSensitiviy
        {
            CaseInsensitive,
            CaseSensitive
        }
        #endregion
 
        #region Properties
        /// 
        /// Provides the string value of parameter belonging to the specified section. The section and parameter must exist.
        /// 
        /// The name of the section the parameter belongs to.
        /// The name of the parameter containing the value.
        /// Thrown if either the section or parameter name do not exist.
        /// The value of the parameter.
        public string this[string sectionName, string parameterName]
        {
            get
            {
                if (_sections.ContainsKey(sectionName))
                {
                    if (_sections[sectionName].ContainsKey(parameterName))
                        return _sections[sectionName][parameterName];
                    else
                        throw new ArgumentException("ErrorBadIniFile");
                }
                else
                    throw new ArgumentException("ErrorBadIniFile");
            }
        }
 
        /// 
        /// Specifies what case sensitivity mode is being used when looking up section and parameter names.
        /// 
        public CaseSensitiviy CaseSensitivity
        {
            get { return _caseSensitivity; }
        }
        #endregion
 
        #region Events
        #endregion
 
        #region Constructors
        /// 
        /// Loads the specified INI file. By default, all searches for section and parameter names will be case sensitive.
        /// 
        /// The file name and path to the INI file. If this parameter does not contain a full path to the file, the method will search the Windows directory.
        /// Thrown if filename could not be found and doesn't exist in the Window directory.
        public INIFile(string filename) :
            this(filename, CaseSensitiviy.CaseSensitive)
        {
 
        }
 
        /// 
        /// Loads the specified INI file.
        /// 
        /// The file name and path to the INI file. If this parameter does not contain a full path to the file, the method will search the Windows directory.
        /// Specifies if letter case should be accounted for when looking up section and parameter names.
        /// Thrown if filename could not be found and doesn't exist in the Window directory.
        public INIFile(string filename, CaseSensitiviy sensitivity)
        {
            // make sure the file exists, directly, or in the Windows directory
            if (!File.Exists(filename))
                if (!File.Exists(Path.Combine(Environment.ExpandEnvironmentVariables("%WinDir%"), filename)))
                    throw new FileNotFoundException();
 
            // save local state
            _caseSensitivity = sensitivity;
            _readBufferSize = _readBufferDefaultSize;
            _readBuffer = new char[_readBufferSize];
 
            // read all section names
            string[] raw = GetPrivateProfileString(null, null, null, filename);
 
            // the data is stored in a dictionary, we must tell it if case sensitivity is important
            if (_caseSensitivity == CaseSensitiviy.CaseInsensitive)
                _sections = new Dictionary<string, IDictionary<string, string>>(StringComparer.CurrentCultureIgnoreCase);
            else
                _sections = new Dictionary<string, IDictionary<string, string>>();
 
            // now, read in all parameters and values for each section name we located
            foreach (string s in raw)
                ReadSection(filename, s, _sections);
        }
        #endregion
 
        #region Public Methods
        /// 
        /// Checks to see if a given section exists in the Ini file.
        /// 
        /// The section name to check for.
        /// True if the section exists, false if not.
        public bool DoesSectionExist(string sectionName)
        {
            return _sections.ContainsKey(sectionName);
        }
 
        /// 
        /// Checks to see if a given parameter exists for a section.
        /// 
        /// The name of the section containing the parameter.
        /// The name of the parameter to check for.
        /// True if the parameter exists, false if not.
        public bool DoesParameterExist(string sectionName, string parameterName)
        {
            if (DoesSectionExist(sectionName))
                return _sections[sectionName].ContainsKey(parameterName);
            else
                return false;
        }
        #endregion
 
        #region Private Methods
        /// 
        /// Reads all parameters and values for a given section within the Ini file.
        /// 
        /// The ini file to read from.
        /// The name of the section to read.
        /// A dictionary containing an entry for the section that will be populated with the resulting parameters/values.
        private void ReadSection(string inifile, string sectionName, IDictionary<string, IDictionary<string, string>> storage)
        {
            // create the parameter/value dictionary for the section entry
            // it is assumed that the callers logic created/validated storage[sectionName] -- we will not check again here
            if (_caseSensitivity == CaseSensitiviy.CaseInsensitive)
                storage[sectionName] = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);
            else
                storage[sectionName] = new Dictionary<string, string>();
 
            string[] raw = GetPrivateProfileString(sectionName, null, null, inifile);
 
            // now read in the values for the parameters that we found
            foreach (string s in raw)
                ReadParameter(inifile, sectionName, s, storage[sectionName]);
        }
 
        /// 
        /// Reads the value of a parameter in a given section within the Ini file.
        /// 
        /// The ini file to read from.
        /// The name of the section containing the parameter.
        /// The name of the parameter to read.
        /// The dictionary that the parameter value will be written to.
        /// Thrown if more than 1 value is associated with a single parameter.
        private void ReadParameter(string inifile, string sectionName, string parameterName, IDictionary<string, string> storage)
        {
            // get the param value
            string[] raw = GetPrivateProfileString(sectionName, parameterName, null, inifile);
 
            // store the resulting value, if more than 1 value comes back for the parameter throw an exception, not sure how to parse that scenario
            // if no values come back just use an empty string by default
            if (raw.Length > 1)
                throw new ArgumentException("ErrorBadIniFile");
            else if (raw.Length == 0)
                storage[parameterName] = "";
            else
                storage[parameterName] = raw[0];
        }
 
        /// 
        /// Wrapper around the Win32 function GetPrivateProfileString to make it nicer and more robust.
        /// 
        /// The name of the section containing the key name. If this parameter is null, all section names will be returned.
        /// The name of the key whose associated string is to be retrieved. If this parameter is null, all key names in the section will be returned.
        /// A default string. If the keyName key cannot be found in the initialization file, GetPrivateProfileString copies the default string to the 
        ///                           returned value. If this parameter is null, the default is an empty string, "".
        /// The path and file name of the INI file. If this parameter does not contain a full path to the file, the system searches for the file in the Windows directory.
        /// An array of string containing either section names, parameter names, or values corresponding to appName and keyName.
        /// 
        private string[] GetPrivateProfileString(string appName, string keyName, string defaultName, string inifile)
        {
            // the file inifile should exist as it's validated in the class constructor, however GetPrivateProfileString does not lock the file hence it could be locked or deleted by
            // another process between calls to this method
 
            // used to tell if we successfully read all requested data from the file 
            // from MSDN:
            //  If neither lpAppName nor lpKeyName is NULL and the supplied destination buffer is too small to hold the requested string, the string is truncated and followed by a null character, and the return value is equal to nSize minus one.
            //  If either lpAppName or lpKeyName is NULL and the supplied destination buffer is too small to hold all the strings, the last string is truncated and followed by two null characters. In this case, the return value is equal to nSize minus two.
            int sizeReadOffset = (appName != null && keyName != null) ? 1 : 2;
 
            // try and read the entire amount of data from the ini file
            int sizeRead = Kernel32.GetPrivateProfileString(appName, keyName, defaultName, _readBuffer, _readBufferSize, inifile);
 
            // if unable to read all of the data because the buffer is to small, increase the size and try again, but only allow memory to increase up to _readBufferMaxSize
            while ((sizeRead >= _readBufferSize - sizeReadOffset) && (_readBufferSize < _readBufferMaxSize))
            {
                _readBufferSize += 512;
                _readBuffer = new char[_readBufferSize];
 
                sizeRead = Kernel32.GetPrivateProfileString(appName, keyName, defaultName, _readBuffer, _readBufferSize, inifile);
            }
 
            // if memory consumption exceeded _readBufferMaxSize then we have a problem
            if (_readBufferSize >= _readBufferMaxSize)
                throw new FileLoadException("ErrorBadIniLoad");
 
            // the buffer returned from GetPrivateProfileString will be null terminated C-strings followed by a double null at the end - so split the strings on the nulls
            char[] sep = new char[1];
            sep[0] = '\0';
 
            string s = new string(_readBuffer, 0, sizeRead);
 
            string[] result = s.Split(sep, StringSplitOptions.RemoveEmptyEntries);
 
            return result;
        }
        #endregion
 
        #region Fields
        /// 
        /// Stores the sections from the Ini file. The section name is the key. The value is another dictionary containing the parameter values, keyed on the parameter name.
        /// 
        private IDictionary<string, IDictionary<string, string>> _sections;
 
        /// 
        /// Determines if case is ignored or not when referencing section and parameter names.
        /// 
        private CaseSensitiviy _caseSensitivity;
 
        /// 
        /// Holds the information from the last read of the ini file. The buffer is overwritten with sections, parameters, or values on each call to GetPrivateProfileString.
        /// 
        private char[] _readBuffer;
 
        /// 
        /// The size, in bytes, of _readBuffer.
        /// 
        private int _readBufferSize;
 
        /// 
        /// The starting size of _readBuffer, in bytes.
        /// 
        private const int _readBufferDefaultSize = 1024;
 
        /// 
        /// The maximum size _readBuffer is allowed to grow to in order to hold all information obtained from GetPrivateProfileString.
        /// 
        private const int _readBufferMaxSize = 4096;
        #endregion
    }

I’m Back

crow — Thu, 16 Jul 2009 02:58:14 +0000

Hey guys, sorry I’ve been away for a bit. I’ll try and respond to your questions, especially those over on the C# dynamic web service page.

I’ll be adding a whole lot of new content as well. If anyone has any suggestions on a topic feel free to leave them for me.

See Ya!!

Accessing the System Task Bar in C#

crow — Sun, 10 May 2009 06:56:18 +0000

In this post I’ll show you how to access the system taskbar and obtain information like its location, size, etc. You may find yourself needing to do something like this if you had a “popup” window for instance that is always supposed to “pop up” from the system tray. This is a common feature in many of today’s applications; however the task bar may be docked somewhere other than the bottom of the screen or maybe even on a different monitor in a multi-monitor setup.

The Taskbar is an APPBAR

First, the task bar is considered an appbar (or desktop application toolbar) albeit with some special restrictions. Being an appbar we can talk to it with the Win32 API function SHAppBarMessage. SHAppBarMessage allows us to send a message to the system to get or set information about a registered appbar. The necessary C# definitions to access the function are as follows:

[StructLayout(LayoutKind.Sequential)]
private struct RECT
{
public int left;
      public int top;
      public int right;
      public int bottom;
}
 
[StructLayout(LayoutKind.Sequential)]
private struct APPBARDATA
{
public Int32 cbSize;
      public IntPtr hWnd;
      public Int32 uCallbackMessage;
      public ABEdge uEdge;
      public RECT rc;
      public IntPtr lParam;
}
 
private enum ABMsg
{
ABM_NEW = 0,
      ABM_REMOVE = 1,
      ABM_QUERYPOS = 2,
      ABM_SETPOS = 3,
      ABM_GETSTATE = 4,
      ABM_GETTASKBARPOS = 5,
      ABM_ACTIVATE = 6,
      ABM_GETAUTOHIDEBAR = 7,
      ABM_SETAUTOHIDEBAR = 8,
      ABM_WINDOWPOSCHANGED = 9,
      ABM_SETSTATE = 10
}
 
private enum ABEdge
{
ABE_LEFT = 0,
      ABE_TOP = 1,
      ABE_RIGHT = 2,
      ABE_BOTTOM = 3,
}
 
private enum ABState
{
ABS_MANUAL = 0,
      ABS_AUTOHIDE = 1,
      ABS_ALWAYSONTOP = 2,
      ABS_AUTOHIDEANDONTOP = 3
}
 
[DllImport("shell32.dll")]
private static extern IntPtr SHAppBarMessage(ABMsg dwMessage, [In, Out] ref APPBARDATA pData);

Using SHAppBarMessage

In order to use SHAppBarMessage we must first fill out the APPBAR struct with at least the cbSize and hWnd members. For hWnd we need to get the handle to the system taskbar window. It just so happens that you can use the FindWindow API function with a system class name of “Shell_TrayWnd” to get the required handle. Of course, to the best of my knowledge the class name “Shell_TrayWnd” is not a “documented” part of the Win32 system therefore it could change with any Windows release. However, I think it’s probably a safe bet to rely on it given the number of applications in the field that already do. Without further ado, some code to get the size of the task bar.

[DllImport("user32.dll")]
private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
 
APPBARDATA appBar = new APPBARDATA();
 
appBar.hWnd = FindWindow("Shell_TrayWnd", "");
appBar.cbSize = Marshal.SizeOf(appBar);
 
System.IntPtr ret = SHAppBarMessage(ABMsg.ABM_GETTASKBARPOS, ref appBar);
 
Size s = new Size(appBar.rc.right - appBar.rc.left, appBar.rc.bottom - appBar.rc.top);

Simple right?

Modifying the Taskbar

Remember earlier I said the system taskbar is not quite like a normal appbar? Well it’s special in that you can’t really change any of its properties like its size or position. This makes sense as you wouldn’t just want any program you install to play with the users taskbar; it’s sort of like an invasion of privacy. I’ve seen claims around the Internet that this can be pulled off in application code, which may be true prior to Vista; however I’ve tried all kinds of tricks based on SHAppBarMessage and can’t change the taskbar properties under Vista. Do you know how this can be done or if it’s even possible? I have found that you can change the task bar state. That is, you can toggle between “autohide” mode and “always on top” mode.

Example Taskbar Code

So, here is a little class I’ve put together to wrap the SHAppBarMessage functionality. I really haven’t paid attention to error handling or anything with it so if you use this you would need to address that.

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Drawing;
 
namespace TaskbarInfoExample
{
    /// 
    /// Provides methods for obtaining and modifying information for the system taskbar.
    /// 
    class TaskBar
    {
        #region Native API
        // The native API functions/enums/structs needed to access taskbar info
        // consult MSDN for more detailed information about them
        [StructLayout(LayoutKind.Sequential)]
        private struct RECT
        {
            public int left;
            public int top;
            public int right;
            public int bottom;
        }
 
        [StructLayout(LayoutKind.Sequential)]
        private struct APPBARDATA
        {
            public Int32 cbSize;
            public IntPtr hWnd;
            public Int32 uCallbackMessage;
            public ABEdge uEdge;
            public RECT rc;
            public IntPtr lParam;
        }
 
        private enum ABMsg
        {
            ABM_NEW = 0,
            ABM_REMOVE = 1,
            ABM_QUERYPOS = 2,
            ABM_SETPOS = 3,
            ABM_GETSTATE = 4,
            ABM_GETTASKBARPOS = 5,
            ABM_ACTIVATE = 6,
            ABM_GETAUTOHIDEBAR = 7,
            ABM_SETAUTOHIDEBAR = 8,
            ABM_WINDOWPOSCHANGED = 9,
            ABM_SETSTATE = 10
        }
 
        private enum ABEdge
        {
            ABE_LEFT = 0,
            ABE_TOP = 1,
            ABE_RIGHT = 2,
            ABE_BOTTOM = 3,
        }
 
        private enum ABState
        {
            ABS_MANUAL = 0,
            ABS_AUTOHIDE = 1,
            ABS_ALWAYSONTOP = 2,
            ABS_AUTOHIDEANDONTOP = 3
        }
 
        [DllImport("shell32.dll")]
        private static extern IntPtr SHAppBarMessage(ABMsg dwMessage, [In, Out] ref APPBARDATA pData);
 
        [DllImport("user32.dll")]
        private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
        #endregion
 
        /// 
        /// Represents the edge of the screen the task bar is docked to.
        /// 
        public enum TaskBarEdge
        {
            Left = ABEdge.ABE_LEFT,
            Top = ABEdge.ABE_TOP,
            Right = ABEdge.ABE_RIGHT,
            Bottom = ABEdge.ABE_BOTTOM
        }
 
        /// 
        /// The states the task bar can be in.
        /// 
        [Flags]
        public enum TaskBarState
        {
            /// 
            /// No autohide, not always top
            /// 
            None = ABState.ABS_MANUAL,
 
            /// 
            /// Hides task bar when mouse exits task bar region
            /// 
            AutoHide = ABState.ABS_AUTOHIDE,
 
            /// 
            /// Taskbar is always on top of other windows
            /// 
            AlwaysTop = ABState.ABS_ALWAYSONTOP
        }
 
        /// 
        /// Gets the location, in screen coordinates of the task bar.
        /// 
        /// The taskbar location.
        public static Point GetTaskBarLocation()
        {
            APPBARDATA appBar = GetTaskBarData();
 
            return new Point(appBar.rc.left, appBar.rc.top);
        }
 
        /// 
        /// Gets the size, in pixels of the task bar.
        /// 
        /// The taskbar size.
        public static Size GetTaskBarSize()
        {
            APPBARDATA appBar = GetTaskBarData();
 
            return new Size(appBar.rc.right - appBar.rc.left, appBar.rc.bottom - appBar.rc.top);
        }
 
        /// 
        /// Gets the edge of the screen that the task bar is docked to.
        /// 
        /// 
        public static TaskBarEdge GetTaskBarEdge()
        {
            APPBARDATA appBar = GetTaskBarData();
 
            return (TaskBarEdge)appBar.uEdge;
        }
 
        /// 
        /// Gets the current state of the taskbar.
        /// 
        /// 
        public static TaskBarState GetTaskBarState()
        {
            APPBARDATA appBar = CreateAppBarData();
 
            return (TaskBarState)SHAppBarMessage(ABMsg.ABM_GETSTATE, ref appBar);
        }
 
        /// 
        /// Sets the state of the task bar.
        /// 
        /// The new state.
        public static void SetTaskBarState(TaskBarState state)
        {
            APPBARDATA appBar = CreateAppBarData();
 
            appBar.lParam = (IntPtr)state;
 
            SHAppBarMessage(ABMsg.ABM_SETSTATE, ref appBar);
        }
 
        /// 
        /// Gets an APPBARDATA struct with valid location,size,and edge of the taskbar.
        /// 
        /// 
        private static APPBARDATA GetTaskBarData()
        {
            APPBARDATA appBar = CreateAppBarData();
 
            System.IntPtr ret = SHAppBarMessage(ABMsg.ABM_GETTASKBARPOS, ref appBar);
 
            return appBar;
        }
 
        /// 
        /// Creats an APPBARDATA struct with its hWnd member set to the task bar window.
        /// 
        /// 
        private static APPBARDATA CreateAppBarData()
        {
            APPBARDATA appBar = new APPBARDATA();
 
            appBar.hWnd = FindWindow("Shell_TrayWnd", "");
            appBar.cbSize = Marshal.SizeOf(appBar);
 
            return appBar;
        }
    }
}

That’s All!

That’s all I’ve got for now. I have included a little demo app you can download to demonstrate the class. You can find that here Basically it just allows you to modify the task bar state and shows you all of its properties.

Hope you found this useful and saved yourself some time!

Launching and Viewing Processes in C#

crow — Wed, 15 Apr 2009 05:23:19 +0000

You can launch a new process from a C# application by using the Process class located in the System.Diagnostics namespace. The Process class also allows you to obtain a collection of all running processes on the system.

How to Launch a New Process

Starting a process is really easy.

Process.Start( "Notepad.exe" );

And that’s it. If Notepad.exe exists on your system then it will start. Make sure that if you do not specify a complete path then the name you do present is available in your environment path. You can wait for the newly created process to terminate as well.

Process p = Process.Start( "Notepad.exe");
 
p.WaitForExit();

Keep in mind that WaitForExit will block the calling thread. If you don’t want that behavior considering launching the new process on a thread of its own. You can also use the ProcessStartInfo class to pass information to the Start method. This example launches the new process on a thread from the thread pool via an anonymous method. Remember to include System.Threading.

// launch the program / process on a new thread from the thread pool
ThreadPool.QueueUserWorkItem( (WaitCallback)delegate(object state)
{
    ProcessStartInfo psi = new ProcessStartInfo("Notepad.exe", "");
 
    Process p = Process.Start(psi);
 
    p.WaitForExit();
});

Passing Arguments to the New Process

You can also pass arguments to a new process. The next example will launch Notepad and tell it to open the file MyFile.txt.

ProcessStartInfo psi = new ProcessStartInfo("Notepad.exe", @"C:\My\Path\MyFile.txt");
 
Process p = Process.Start(psi);

Launching a Document and Setting the Verb

There are some other interesting things you can do with the Process class. For instance, instead of specifying a file name in Process.Start like we did above with Notepad.exe, we could specify a file or document. The method would then open that file with the registered default application for that type of file. You can also specify a verb that is associated with that file type. A verb represents an action that is associated with that file type. So, if I wanted to launch the default application for a .txt file and have that file printed I could do the following:

ProcessStartInfo psi = new ProcessStartInfo(@"C:\My\Path\MyFile.txt");
psi.Verb = "print";
 
Process p = Process.Start(psi);
 
p.WaitForExit();

Listing All Running Processes

The last thing I want to show you is how easy it is to view a list of all processes running on the system with C#. Assuming you have a ListBox name listbox1, the following code fragment would add an entry to the ListBox with the name of each process running on the system.

Process[] processes = Process.GetProcesses();
 
foreach( Process process in processes )
   listBox1.Items.Add( process.ProcessName );

Well, that’s it for today. Hope this information comes in handy for some of you!

How To Get Screen Shot Capture in C#

crow — Mon, 13 Apr 2009 06:36:10 +0000

It’s often necessary to programmatically get a screen shot of the desktop and save it to a file. This is pretty easy with C#; we can create a simple method that will save an image of whatever is on the screen or desktop.

Saving a Bitmap Image of the Screen

First make sure you include the System.Drawing.Imaging namespace. Now, all we really have to do is create a new bitmap and use the CopyFromScreen method of the bitmaps Graphics device.

/// 
/// Saves a screen capture in the specified image format to a file.
/// 
/// 
/// 
private void SaveScreenShot(string filename, ImageFormat format)
{
        Bitmap screenShot = CaptureScreenShot();
 
  	screenShot.Save(filename, format);
}
 
/// 
/// Saves a picture of the screen to a bitmap image.
/// 
/// The saved bitmap.
private Bitmap CaptureScreenShot()
{
 	// get the bounding area of the screen containing (0,0)
        // remember in a multidisplay environment you don't know which display holds this point
    	Rectangle bounds = Screen.GetBounds(Point.Empty);
 
    	// create the bitmap to copy the screen shot to
   	Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height);
 
    	// now copy the screen image to the graphics device from the bitmap
   	using (Graphics gr = Graphics.FromImage(bitmap))
   	{
       	   gr.CopyFromScreen(Point.Empty, Point.Empty, bounds.Size);
   	}
 
  	return bitmap;
}

And that’s really all there is to capturing a screen shot. You can save it to whatever file you would like and in any of the image formats supported by ImageFormat such as PNG or JPEG. Keep in mind if your working in a multidisplay environment you’ll want to be careful which display your targeting. Or perhaps you may want a huge image of all the desktop displays.

You can use the above code simply by calling the SaveScreenShot method with a file name and image format to save to:

//save screen shot in PNG image format
SaveScreenShot("MyScreenShot.png", ImageFormat.Png);

With a really small change you can modify the above code to save a screen shot of an arbitrary control instead of the entire desktop display.

Saving a Screen Capture of a Control

/// 
/// Saves a screen capture of the specified control to a file.
/// 
/// 
/// 
/// 
private void SaveControlShot(Control control, string filename, ImageFormat format)
{
   	Bitmap controlShot = CaptureControlShot(control);
 
   	controlShot.Save(filename, format);
}
 
/// 
/// Gets a bitmap image of the specified control.
/// 
/// 
/// 
private Bitmap CaptureControlShot(Control control)
{
        // get control bounding rectangle
     	Rectangle bounds = control.Bounds;
 
   	// create the new bitmap that holds the image of the control
     	Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height);
 
   	// copy controls image data to the bitmaps graphics device
    	using (Graphics gr = Graphics.FromImage(bitmap))
    	{
        	gr.CopyFromScreen(control.Location, Point.Empty, bounds.Size);
     	}
 
    	return bitmap;
}

And you can use this just as easily as the previous screen capture method:

// if "this" is a control, like a form
SaveControlShot(this, "MyControlShot.png", ImageFormat.Png);

And there you have it, an example of simple methods for saving a screen shot or an image of a control. I Hope you find this helpful.

Introduction to Multithreading in C#

crow — Thu, 09 Apr 2009 00:34:18 +0000

This article is a very basic introductory tutorial for using multiple threads in C#. I’ll explain what threads are, why you would want to use them, and how to use them. I’ll also show you several examples for creating threads, killing threads, etc.

What’s a Thread?

A computer program is generally very linear. That is, you have a sequence of instructions that get executed one after another in an orderly and predictable fashion. This scenario only affords you one path of execution. Threads allow you to execute multiple paths of code simultaneously. Now, simultaneously in this case does not necessarily mean physically at the same time. Both your operating system and processor must support this for that to be true. Threads are not particular to C#; most modern programming languages such as Visual Basic.Net support the concept of threads.

So Why Do I Need Multiple Threads?

Threading is handy because many programming tasks are asynchronous. That is, I can start the task and go on about my business and when that task is finished it can let me know and I can take action. An example of this would be downloading files from a remote location. I can start downloading three files and when the first is finished I can process it while the others continue to download.

There are numerous other reasons. Consider for instance a long task like sorting a million numbers. If I start that task on the thread that runs the GUI then I couldn’t update my user interface which means I couldn’t respond to user requests like button clicks.

Ok, lets move on to an example of creating a new thread via C#.

Creating a Thread with C#

Creating a thread is easy; we make use of the Thread object from the System.Threading namespace. When we create the thread we must pass it a ParameterizedThreadStart or ThreadStart delegate. This will be the method that gets invoked on the new thread – it’s the starting point. New threads begin life in a stopped state. To make it run we call the Thread.Start method.

Thread myThread = new Thread(MyThreadFunction);
myThread.Start();
 
private void MyThreadFunction()
{
   MessageBox.Show("HI");
}

Congratulations, you’ve created your first thread that runs in parallel with your main thread.

Passing an Argument to the New Thread

You can easily pass an argument to the thread like so:

Thread myThread = new Thread(MyThreadFunction);
myThread.Start("HELLO WORLD");
 
private void MyThreadFunction(object x)
{
   MessageBox.Show(x as string);
}

Keep in mind that this is not the best way to pass data to the thread. Since Thread.Start accepts only an object this is not very type safe. Image if we didn’t pass a string or the object didn’t have a ToString method. The best way to accomplish this would be to encapsulate your thread function in a class with data members you could set ahead of time.

Waiting for a Thread to Stop

Now that we have our thread up and running, we may at some point wish to wait for it to complete. This is accomplished with the Thread.Join method. Here is an example for Thread.Join:

myThread = new Thread(MyThreadFunction);
myThread.Start("HELLO WORLD");
 
myThread.Join();
 
MessageBox.Show("ALL DONE!");
 
//-elsewhere
private void MyThreadFunction(object x)
{
   MessageBox.Show(x as string);
}

When the first piece of code executes it will create a new thread that will begin running in MyThreadFunction. After calling myThread.join that thread will go to sleep and stop executing until MyThreadFunction returns. This will happen after you dismiss the message box. Finally, when MyThreadFunction exits and the thread is destroyed, the original thread will continue execution at the next statement and pop its message box.

One thing to watch out for is what happens if the thread function never returns meaning the thread never dies. In this situation you can specify a timeout value in Thread.Join. The method will block for a predetermined amount of time waiting for the thread to terminate. If the thread did not terminate then Thread.Join would return false.

Stopping a Thread

Stopping a thread is simple. You call Thread.Abort on the thread you wish to stop.

myThread.Abort();

This will cause a ThreadAbortException to be raised on the thread you are trying to stop. Now this usually stops the thread. It’s possible that the thread can abort your abort and continue living. There are a few other circumstances that can prevent the thread from aborting.

Sharing Variables

When you have two or more threading running it’s possible that they could be executing at the same time. This can create problems when both threads are trying to read/write to the same variable. You have to synchronize thread access to shared variables. There are many synchronization primitives available to you in C# via the .Net Framework Library such as AutoResetEvent, Monitor, and Mutex. This is a big subject so I will defer it till another post.

Along those same lines here’s a tip: If you create secondary threads they cannot modify controls on your GUI. Only the thread that created a control can modify its properties. You will generate the dreaded illegal cross thread exception. I’ve already posted a brief work around for this problem

So that’s it for my C# threading tutorial. Now you know the basics of how to create a thread, how to kill a thread, how to wait for a thread, and some general threading principles. This is a big subject and I’ve hardly done it justice with this little bit of writing. If there are sufficient interests, I will elaborate on some more advance multithreading techniques that are applicable in all .Net languages – not just C#. I’ll leave you with a small incomplete pro and con list about using multiple threads.

Advantages of Multithreading

Improved performance – Multiple threads can execute concurrently.
Streamline application logic – Some tasks are easier to conceptualize this way
Improves responsiveness of an application – GUI still works under heavy load.

Disadvantages of Multithreading

Hard to write and debug – Nuff said!!
Performance impact from synchronizing access to shared variables
There is a limit to how many threads an operating system can handle efficiently
Context switching between threads can hurt performance

C# – Dynamically Invoke Web Service At Runtime

crow — Wed, 08 Apr 2009 06:42:42 +0000

Web services have become an integral part of the communications between software over a network. There are a lot of ugly details behind how they work but thankfully C# hide a lot of those gory details. What you need to know is that there is a web service description (WSDL) that describes the available services and the data types they use (via XML).

You can use the WSDL to create types in C# that can communicate with the web service. There are a couple of ways that you can do this. You can generate a proxy class using the WSDL utility in the .NET SDK and add it to your project. You can also download the WSDL file at runtime, create the proxy class, compile it into an assembly, and execute the methods on it. This allows you to dynamically invoke methods from a web service that aren’t known at build time and is the approach I will explore today.

Step 1 – Obtain a ServiceDescriptionImporter

We want to create a ServiceDescriptionImporter object that we can use to generate the web service proxy class. We have to pass to it the WSDL location which is an XML document.

XmlTextReader xmlreader = new XmlTextReader(“MyWebService” + "?wsdl");
 
ServiceDescription serviceDescription = ServiceDescription.Read(xmlreader);
 
// build an importer, that assumes the SOAP protocol, client binding, and generates properties
ServiceDescriptionImporter descriptionImporter = new ServiceDescriptionImporter();
descriptionImporter.ProtocolName = "Soap";
descriptionImporter.AddServiceDescription(serviceDescription, null, null);
descriptionImporter.Style = ServiceDescriptionImportStyle.Client;
descriptionImporter.CodeGenerationOptions = System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;

Step 2 – Compile an Assembly from the importer

Now that we have the ServiceDescriptionImporter we need to use it to compile a proxy assembly that we can use to communicate with the web service. The assembly will exist in the users’ temporary folder.

// a namespace and compile unit are needed by importer
CodeNamespace codeNamespace = new CodeNamespace();
CodeCompileUnit codeUnit = new CodeCompileUnit();
 
codeUnit.Namespaces.Add(codeNamespace);
 
ServiceDescriptionImportWarnings importWarnings = descriptionImporter.Import(codeNamespace, codeUnit);
 
if (importWarnings == 0) // no warnings
{
     // create a c# compiler
     CodeDomProvider compiler = CodeDomProvider.CreateProvider("CSharp");
 
     // include the assembly references needed to compile
     string[] references = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
 
     CompilerParameters parameters = new CompilerParameters(references);
 
     // compile into assembly
     CompilerResults results = compiler.CompileAssemblyFromDom(parameters, codeUnit);
 
     foreach (CompilerError oops in results.Errors)
     {
          // trap these errors and make them available to exception object
          throw new Exception("Compilation Error Creating Assembly");
     }
 
     // all done....
     return results.CompiledAssembly;
}
else
{
     // warnings issued from importers, something wrong with WSDL
     throw new Exception("Invalid WSDL");
}

Step 3 – Execute Methods from the Web Service

Finally we have an assembly built from the web service description and now we can invoke methods from it just like any other ordinary assembly we might use. To accomplish this we must use reflection to discover the correct method.

object obj = this.webServiceAssembly.CreateInstance(serviceName);
 
Type type = obj.GetType();
 
return (T)type.InvokeMember(methodName, BindingFlags.InvokeMethod, null, obj, args);

And there you have it, dynamic invocation of web service methods at runtime. Using this technique you can invoke methods from any arbitrary web service at runtime.

Here is a full example class for dynamically invoking a web service method in C#.

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Web.Services;
using System.Web.Services.Description;
using System.Web.Services.Discovery;
using System.Xml;
 
namespace DynamicWebExample
{
    class WebServiceInvoker
    {
        Dictionary<string, Type> availableTypes;
 
        /// 
        /// Text description of the available services within this web service.
        /// 
        public List<string> AvailableServices
        {
            get{ return this.services; }
        }
 
        /// 
        /// Creates the service invoker using the specified web service.
        /// 
        /// 
        public WebServiceInvoker(Uri webServiceUri)
        {
            this.services = new List<string>(); // available services
            this.availableTypes = new Dictionary<string, Type>(); // available types
 
            // create an assembly from the web service description
            this.webServiceAssembly = BuildAssemblyFromWSDL(webServiceUri);
 
            // see what service types are available
            Type[] types = this.webServiceAssembly.GetExportedTypes();
 
            // and save them
            foreach (Type type in types)
            {
                services.Add(type.FullName);
                availableTypes.Add(type.FullName, type);
            }
        }
 
        /// 
        /// Gets a list of all methods available for the specified service.
        /// 
        /// 
        /// 
        public List<string> EnumerateServiceMethods(string serviceName)
        {
            List<string> methods = new List<string>();
 
            if (!this.availableTypes.ContainsKey(serviceName))
                throw new Exception("Service Not Available");
            else
            {
                Type type = this.availableTypes[serviceName];
 
                // only find methods of this object type (the one we generated)
                // we don't want inherited members (this type inherited from SoapHttpClientProtocol)
                foreach (MethodInfo minfo in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly))
                    methods.Add(minfo.Name);
 
                return methods;
            }
        }
 
        /// 
        /// Invokes the specified method of the named service.
        /// 
        /// The expected return type.
        /// The name of the service to use.
        /// The name of the method to call.
        /// The arguments to the method.
        /// The return value from the web service method.
        public T InvokeMethod<T>( string serviceName, string methodName, params object[] args )
        {
            // create an instance of the specified service
            // and invoke the method
            object obj = this.webServiceAssembly.CreateInstance(serviceName);
 
            Type type = obj.GetType();
 
            return (T)type.InvokeMember(methodName, BindingFlags.InvokeMethod, null, obj, args);
        }
 
        /// 
        /// Builds the web service description importer, which allows us to generate a proxy class based on the 
        /// content of the WSDL described by the XmlTextReader.
        /// 
        /// The WSDL content, described by XML.
        /// A ServiceDescriptionImporter that can be used to create a proxy class.
        private ServiceDescriptionImporter BuildServiceDescriptionImporter( XmlTextReader xmlreader )
        {
            // make sure xml describes a valid wsdl
            if (!ServiceDescription.CanRead(xmlreader))
                throw new Exception("Invalid Web Service Description");
 
            // parse wsdl
            ServiceDescription serviceDescription = ServiceDescription.Read(xmlreader);
 
            // build an importer, that assumes the SOAP protocol, client binding, and generates properties
            ServiceDescriptionImporter descriptionImporter = new ServiceDescriptionImporter();
            descriptionImporter.ProtocolName = "Soap";
            descriptionImporter.AddServiceDescription(serviceDescription, null, null);
            descriptionImporter.Style = ServiceDescriptionImportStyle.Client;
            descriptionImporter.CodeGenerationOptions = System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;
 
            return descriptionImporter;
        }
 
        /// 
        /// Compiles an assembly from the proxy class provided by the ServiceDescriptionImporter.
        /// 
        /// 
        /// An assembly that can be used to execute the web service methods.
        private Assembly CompileAssembly(ServiceDescriptionImporter descriptionImporter)
        {
            // a namespace and compile unit are needed by importer
            CodeNamespace codeNamespace = new CodeNamespace();
            CodeCompileUnit codeUnit = new CodeCompileUnit();
 
            codeUnit.Namespaces.Add(codeNamespace);
 
            ServiceDescriptionImportWarnings importWarnings = descriptionImporter.Import(codeNamespace, codeUnit);
 
            if (importWarnings == 0) // no warnings
            {
                // create a c# compiler
                CodeDomProvider compiler = CodeDomProvider.CreateProvider("CSharp");
 
                // include the assembly references needed to compile
                string[] references = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
 
                CompilerParameters parameters = new CompilerParameters(references);
 
                // compile into assembly
                CompilerResults results = compiler.CompileAssemblyFromDom(parameters, codeUnit);
 
                foreach (CompilerError oops in results.Errors)
                {
                    // trap these errors and make them available to exception object
                    throw new Exception("Compilation Error Creating Assembly");
                }
 
                // all done....
                return results.CompiledAssembly;
            }
            else
            {
                // warnings issued from importers, something wrong with WSDL
                throw new Exception("Invalid WSDL");
            }
        }
 
        /// 
        /// Builds an assembly from a web service description.
        /// The assembly can be used to execute the web service methods.
        /// 
        /// Location of WSDL.
        /// A web service assembly.
        private Assembly BuildAssemblyFromWSDL(Uri webServiceUri)
        {
            if (String.IsNullOrEmpty(webServiceUri.ToString()))
                throw new Exception("Web Service Not Found");
 
            XmlTextReader xmlreader = new XmlTextReader(webServiceUri.ToString() + "?wsdl");
 
            ServiceDescriptionImporter descriptionImporter = BuildServiceDescriptionImporter(xmlreader);
 
            return CompileAssembly(descriptionImporter);
        }
 
        private Assembly webServiceAssembly;
        private List<string> services;
    }
}

This C# class can be easily used to invoke web service methods:

WebServiceInvoker invoker = new WebServiceInvoker(new Uri("http://localhost/services/test.php"));
 
string service = “MyService”;
string method = “MyMethod”;
 
string[] args = new string[] { “arg1”, “arg2” };
 
string result = invoker.InvokeMethod<string>(service, method, args);

I’ve put together an example application that you can download to evaluate the class. It allows you to invoke methods from a web service entered on the GUI and see the return value. You can download it here.

I hope you find this useful and if you have any questions or comments be sure to leave them here.