In this part, I’ll be discussing about constructor
and property or setter
injection. I’ve created a new class – Product3: 1: public class Product3 : IProduct
2: {
3: public string Name { get; set; }
4: [Dependency]
5: public IDistributor Distributor { get; set; }
6: public ILogger Logger { get; set; }
7:
8: public Product3(ILogger logger)
9: {
10: Logger = logger;
11: Name = "Product 1";
12: }
13:
14: public string WriteProductDetails()
15: {
16: StringBuilder productDetails = new StringBuilder();
17: productDetails.AppendFormat("{0}<br/>", Name);
18: productDetails.AppendFormat("{0}<br/>", Logger.WriteLog());
19: productDetails.AppendFormat("{0}<br/>", Distributor.WriteDistributorDetails());
20: return productDetails.ToString();
21: }
22: }
This version has a property of type IDistributor
and takes a constructor parameter of type ILogger. The IDistributor property has a
Dependency attribute (Microsoft.Practices.Unity namespace) applied to it. IDistributor
and its implementation are shown below:
1: public interface IDistributor
2: {
3: string WriteDistributorDetails();
4: }
5:
6: public class Distributor : IDistributor
7: {
8: public List<string> DistributorNames = new List<string>();
9:
10: public Distributor()
11: {
12: DistributorNames.Add("Distributor1");
13: DistributorNames.Add("Distributor2");
14: DistributorNames.Add("Distributor3");
15: DistributorNames.Add("Distributor4");
16: }
17: public string WriteDistributorDetails()
18: {
19: StringBuilder distributors = new StringBuilder();
20: for (int i = 0; i < DistributorNames.Count; i++)
21: {
22: distributors.AppendFormat("{0}<br/>", DistributorNames[i]);
23: }
24: return distributors.ToString();
25: }
26: }
ILogger
and the FileLogger have the following definition:
1: public interface ILogger
2: {
3: string WriteLog();
4: }
5:
6: public class FileLogger : ILogger
7: {
8: public string WriteLog()
9: {
10: return string.Format("Type: {0}", GetType());
11: }
12: }
The Unity container creates an instance of the dependent class (the Distributor class) within the scope of the target object (an instance of Product3 class that will be called by doing a Resolve<IProduct>() in the calling code)
and assign this dependent object to the attributed property of the target object. To add to it, property
injection is a form of optional
injection of dependent objects.The dependent object instance is generated before the container returns the target object. Unlike constructor
injection, you must apply the appropriate attribute in the target class to initiate property
injection.
Let’s see how to change the config file to make this work. The first step is to add all the type aliases:
1: <typeAlias alias="Product3" type="ProductModel.Product3, ProductModel"/>
2: <typeAlias alias="ILogger" type="ProductModel.ILogger, ProductModel"/>
3: <typeAlias alias="FileLogger" type="ProductModel.FileLogger, ProductModel"/>
4: <typeAlias alias="IDistributor" type="ProductModel.IDistributor, ProductModel"/>
5: <typeAlias alias="Distributor" type="ProductModel.Distributor, ProductModel"/>
Now define mappings for these aliases:
1: <type type="ILogger" mapTo="FileLogger" />
2: <type type="IDistributor" mapTo="Distributor" />
Next step is to define the constructor
and property
injection in the config file:
1: <type type="IProduct" mapTo="Product3" name="ComplexProduct">
2: <typeConfig extensionType="Microsoft.Practices.Unity.Configuration.TypeInjectionElement, Microsoft.Practices.Unity.Configuration">
3: <constructor>
4: <param name="logger" parameterType="ILogger" />
5: </constructor>
6: <property name="Distributor" propertyType="IDistributor">
7: <dependency />
8: </property>
9: </typeConfig>
10: </type>
There you see a constructor element that tells there’s a property named ‘logger’ that is of type ILogger. By default, the type of ILogger gets resolved to type FileLogger. There’s also a property named ‘Distributor’ which is of type IDistributor
and which will get resolved to type Distributor.
On the calling side, I’ve added a new button, whose click event does the following:
1: protected void InjectionButton_Click(object sender, EventArgs e)
2: {
3: unityContainer.RegisterType<IProduct, Product3>();
4: IProduct product3 = unityContainer.Resolve<IProduct>();
5: productDetailsLabel.Text = product3.WriteProductDetails();
6: }
This renders the following output:
This completes the part for constructor
and property
injection. In the next blog, I’ll talk about Arrays
and Generics. Please see the code used here.
