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.
