Third Shelf

Wow, it has been crazy for a while, but I finally got it together :). So, on with our little aspect oriented framework.

The first building block in our aspect proxy framework is the Dynamic Type Factory. As you might have guessed, this is the component that we will use to define a dynamic assembly that will hold our in-memory assembly with the dynamically created types. In other words, we have an assembly that is created in-memory as a container for the proxy classes that we will create and instantiate.

A couple of static variables and constants are needed for the DynamicTypeFactory class which are:

private const string ASSEMBLY_NAME = "AspectProxies";

private static ModuleBuilder _ModuleBuilder;
private static AssemblyBuilder _AssemblyBuilder;

private static string _FileName =
  string.Format("{0}.dll", ASSEMBLY_NAME);

private static AssemblyName _AssemblyName =
  new AssemblyName(ASSEMBLY_NAME);

First of all, we need to give the assembly some sort of name and I thought “AspectProxies” to be a good fit. We then declare an AssemblyBuilder which we will use only to define a dynamic module. We then declare a ModuleBuilder which we will use to define our dynamic types with. We set a FileName variable which we will expose via a property so that others can know what the assembly file is called when it saved to disk. Lastly we declare an AssemlyName variable that we will provide to the AssemblyBuilder.

For simplicity we will only have one dynamic assembly in the current AppDomain. Hence, the DynamicTypeFactory class will have a static constructor that creates a new dynamic assembly and module, like so:

static DynamicTypeFactory()
{
  _AssemblyBuilder = Thread.GetDomain().DefineDynamicAssembly(
    _AssemblyName, AssemblyBuilderAccess.RunAndSave);

  _ModuleBuilder = _AssemblyBuilder.DefineDynamicModule(
    ASSEMBLY_NAME, _FileName);
}

We then create a property to expose our filename, like so:

public static string FileName
{
  get { return _FileName; }
}

Next, we define the most commonly used method in this class, that we will call to define our dynamic types with:

public static TypeBuilder Create<T>(T instance, string identifier)
{
  if (!typeof(T).IsInterface)
    throw new ArgumentException("Type T must be an interface.");

  if (instance == null)
    throw new ArgumentNullException("instance"));

  if (string.IsNullOrEmpty(identifier))
    identifier = Guid.NewGuid().ToString("N");

  return _ModuleBuilder.DefineType(
    string.Format("{0}_Proxy", identifier),
    TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Sealed,
    typeof(object),
    Resolver.GetInterfaces(instance.GetType()));
}

In this method we firstly check whether the type of T is indeed an interface, since we only want to create proxy types for interfaces. We also check that the instance that we were provided with is not null. The reason we need to check this is that we are going to find all of the interfaces that the instance implements, since the interface might not necessarily inherit from the same interfaces.

Obviously, every type that we define must have a unique name and this is where the identifier comes in. Sometimes we would want a name that we can recognize such as the type the proxy is for and maybe some of the interfaces. Using reflector to examine our types can become rather painful to examine if we have a thousand types and no way to identify them. Just for safety we check if we an identifier, if not then we will just assign it a GUID value. This identifier is later on post-pended with “_Proxy”.

The next bit actually defines the type in the dynamic module. We supply a couple of attributes that says that our type must be a public sealed class which derives from object. The next parameter resolves or gets all of the interfaces on our instance and supplies them for the type definition. Now we defined a type in the meta data but still need to give this type a body.

When debugging, it is useful to have the ability to save the proxy type to the disk. For that we need to have a method like so:

public static void Save()
{
  _AssemblyBuilder.Save(_FileName);
}

Now that we are able to define types dynamically we will next look at how to create the body of for this proxy type.