Making your library COM visible requires that you register the DLL in the GAC and registering something in the GAC should only be done when multiple applications need to access the same version of the same library. Even then, most software houses will deploy each app with it’s own copy of the DLL instead of using the GAC.

Nevertheless, C# (and most of other languages) support Reflection. Basically using reflection, programs can “observe and modify its own structure and behavior” (wiki). .NET has System.Reflection namespace with all needed methods. Purpose of this post is to find a way how to load DLL’s dynamically – without worrying about registering, re-registering, unregistering them in running system/production servers.

DLL’s are library assemblies, which “contain code in CIL, which is usually generated from .NET languages, and then compiled into machine language at runtime by the CLR just-in-time compiler.” (from). For all not familiar with assemblies, assembly “is a reusable, versionable, and self-describing building block of a common language runtime application.” (from). Consider this code:

using System;
using System.Reflection;
 
namespace Php
{
    public class Reflection
    {
        public Object get(string assembly, string className)
        {
            Assembly asm = Assembly.LoadFrom(assembly);
 
            return asm.CreateInstance(className, true);
        }
    }
}

This is very basic class, which can be used to do such things as:

Php.Reflection obj = new Php.Reflection ();
Object my = obj.get("my.dll", "namespace.class");

You may have thought that this class is absolutely useless, because you can simply use System.Reflection.Assembly without wrapping it into separate class. However, I was writing this code with an intention to use it as COM object in PHP and because PHP can’t access static COM class methods (which I find very disappointing) I needed to create this class. Now in PHP you can write:

$obj = new Com ("Php.Reflection");
$math = $obj->get("math_class.dll", "phpclass3.first");

This method, in my opinion, is much much more better than registering every single class with global assembly cache. It’s more practical and maintainable to have all required libraries in the same project directory, and not somewhere in Windows core. However, benchmarks are still coming so stay tuned.

* For everyone interested in Winphp contest, and people building PHP apps in Windows, I recommend reading www.eurowinphp.com blog, which aggregates all participants blogs. For example, Timmy Kokke, another WinPHP participant, recently wrote another great tutorial how to make your .NET classes accessible in PHP. Also, you can follow my on Twitter at twitter.com/juokaz.

I have been using Zend Framework for some time now, and found that only possible way to use XmlRpc Server package is to delete all functions signatures checking. My production server has Zend Optimizer installed and it just breaks Reflection functionality.

For tests I created simple reflection example:

/**
 *  My Class
 */
class test { }
 
$oClassReflect = new ReflectionClass("Test");
print $oClassReflect->getDocComment();

First time script outputs:

/**
 *  My Class
 */

Next times there is no output at all – all comments are gone (in Optimizer’s cache). I still can get methods of class (source code is not gone), but I cannot use comments to mark params/return types and later use them to validate I/O.

I don’t know yet if it’s a problem with my production server, but Zend manuals are not very clear and I can’t find any information about comments stripping issue. Has anyone had similar problems?