Posts tagged with Unity

Some (self-indulgent) overview of G2's interface hierarchy is available.

The bare bones of Unity interceptions

The Enterprise Library 4.1 was released together with Unity 1.2 in which a whole interception mechanism was added as part of the aspect-oriented approach to coding and a merge of the policy injection ideas. This little note is just a stepping stone if you wish to play with the new interception namespace.

2 comments

Extensibility through Unity

Architecture

ObjectBuilder, Unity

This is the third part (see part I & part II) of my series on Unity & ObjectBuilder. The previous introductory material was only there to make the stuff described below more accessible and the framework described here is in fact a complete addition to the Unity toolset, it allows you:

to use Unity much like the Microsoft Extensibility Framework (MEF), i.e. use import/export attributes to combine instances
to use Unity to create action flows (workflows in fact but the term has an unintended technical conotation here)
to use Unity to inject at runtime other objects and sub-objects through a dotted attribute notation

Before giving you concrete code samples let me first highlight what I wanted to achieve and why I created this framework in the first place. During the development of GraphSquare (see this article and the architecture series) I needed a flexible mechanism to convert entities and to let the MVC model pass various stages of transformation to serialize things to a variety of export formats (binary, XML, WCF entities and so on). The idea can be best understood as a combination of ORM and serialization. Imagine that you have some domain entities which need to be converted to data entities through a series of actions like depicted in the picture below. Now, the 'transaction' here is a package which combines the start and end result and the 'workflow' is a series of 'actions' which can be chained and which reacts according to what the transaction state (content) is. Obviously, the transformation to an XML output requires a different set of actions than a binary one, yet there is some overlap.

Each action requires either the whole domain entity or some part of it and maybe even some information from the already created data entities. In addition, writing code to assign all this to each instance becomes a repetitive task. So, the idea quickly became involved and difficult to implement. Until I realized that Unity and ObjectBuilder together with their extensibility model were perfectly adapted to this kind of paradigm.

5 comments

Unity & ObjectBuilder (part II)

Architecture

ObjectBuilder, Unity

In the first part of this series I gave you an overview of Unity and OB. In this article I have picked out some concrete examples which cover the various (technical) ideas and OB techniques. While Unity & OB can be overwhelming at first in the amount of interface and classes you are presented with, I hope these articles demonstrate that if you keep a map of the main roads in your mind it's quite safe (and fun!) to walk around in uncharted OB areas.

4 comments

Unity & ObjectBuilder (part I)

Architecture

Extensibility, ObjectBuilder, Unity

This is a series of articles on Unity and ObjectBuilder (OB). Currently the OB is version 2 and Unity is version 1.1 (v1.2 is around the corner with the new interception mechanism). I have written these articles in the first place because I needed to understand myself the inner treasures of Unity & OB. During this research I discovered that there is very, very little info/documentation and few people have either the courage to go deep into these frameworks or lack the time to write down what they have understood. The exception to the rule is the (now somewhat obsolete) series of articles on the Software Mechanics blog, which seems to have had the same pains as me in trying to understand the OB. I'm not an expert and I don't pretend I understand all of it now (especially the threading stuff is intrinsically hard to fathom) but I hope these field notes will help others to extend Unity (write Unity extensions) and to use the OB with more confidence. The plan is the following. This first part will give an overview of Unity & OB. The second part goes into more details of how you can articulate OB to build stuff. The third part will deal with some concrete Unity extensions. The goal is to show you that creating (for example) something like the Microsoft Extensibility Framework (MEF) on top of Unity & OB is conceptually not difficult once you unsterstand the basic tenets.

4 comments