NanoContainer Core

NanoContainer Booter

NanoContainer Deployer

NanoContainer AOP

NanoContainer Persistence

NanoContainer Remoting

NanoContainer Web

Overview of NanoContainer.NET Attribute

RegisterWithContainerAttribute - This is a class level attribute used by concrete classes that need to be registered with the container. The properties of this class are:

• object key: which represents the key the component should be registered against
• ComponentAdapterType componentAdapterType: An enum that defines the type of component adapter (choices consist of Caching, NonCaching and Custom). Caching is the default.
• DependencyInjectionType dependencyInjectionType: An enum that defines the DI construct to follow (Constructor or Setter are the choices) as expected Constructor is the default type.
• Type componentAdapter: represents the concrete Type to use as the component adapter. This allows a concrete class to define a custom component adapter to use for itself.

PicoParameterAttribute - This is an abstract class level Attribute used to define Parameter which are needed for constructing some objects. Multiple Attributes of this type are allowed.

• int Index: is needed to define in what order the parameter should be applied.
• object Value: the usage of this field is specific to the implementation.

ConstantParameterAttribute: extends the PicoParameterAttribute abstract class and as it's name implies is used to define a constant to use as a parameter

• object Value represent the value of the Constant (i.e. a string: "hello"; a number: 10; etc...)

ComponentParameterAttribute: extends the PicoParameterAttribute abstract class and is used to reference a specific component registered under a particular key value.

• object Value represent the key value of the Component being referenced. This is useful when one or more of a specific type (i.e. string) is registered to the container, the ComponentParameter allows you specify which component the container should use.

RegisterWithContainerAttribute usage examples...

[RegisterWithContainer]
public class Foo : IFoo
{
  private IBar bar;
  public Foo(IBar bar)
  {
    this.bar = bar;
  }
}

[RegisterWithContainer(DependencyInjection=DependencyInjectionType.Setter)]
public class Foo : IFoo
{
  private IBar bar;

  public IBar Bar
  {
    set {this.bar = value; }
  }
}

[RegisterWithContainer(ComponentAdapterType.NonCaching)]
public class Foo : IFoo
{
  private IBar bar;
  public Foo(IBar bar)
  {
    this.bar = bar;
  }
}

[RegisterWithContainer(ComponentAdapterType.NonCaching,
     DependencyInjection=DependencyInjectionType.Setter)]
public class Foo : IFoo
{
  private IBar bar;

  public IBar Bar
  {
    set {this.bar = value; }
  }
}

[RegisterWithContainer(ComponentAdapterType.Custom,
      ComponentAdapter=typeof(CustomComponentAdapter))]
public class Foo : IFoo
{
  private IBar bar;
  public Foo(IBar bar)
  {
    this.bar = bar;
  }
}

// example of the Custom ComponentAdapter...
public class CustomComponentAdapter: CachingComponentAdapter
{
  public CustomComponentAdapter(Type type) : base(new ConstructorInjectionComponentAdapter(type))
  {
  }
}

Okay so now it should be clear how to use the custom NanoContainer.NET attributes. But what probably is not clear is how do we get the dynamically constructed PicoContainer from these classes tagged with these Attributes. The next example should look similar, it is almost identical to how we process a Script. The difference is that we need to reference the Assembly we want to search for usages of the RegisterWithContainerAttribute and the fact we are instantiating a AttributeBasedContainerBuilder.

// Define the assemlies we want to load from
StringCollection assemblies = new StringCollection();
assemblies.Add("../FooBar.dll");
			
// Notice we are using a different type of ContainerBuilderFacade (for supporting Attributes)
ContainerBuilderFacade cbf = new AttributeBasedContainerBuilderFacade();
IMutablePicoContainer container = cbf.Build(assemblies);

More info on Nano.NET Attributes can be found here.