Spring.NET is one of the popular open source frameworks ported from Java platform. It offers a lot of functionality, and in this article, I will discuss about Dependency Injection and how it is supported in Spring.NET.
Dependency Injection is a technique that decouples the consumer from the actual implementation during design/compile time and binds them at run time.
At a lower level of implementation, in a typical application, there will be a class that implements a logic, and it will be consumed by another class. The reason why we have two classes will drag us to discussions like modularization of code, reusability, maintainability etc.
When we consume a class instance (let's say,
ClassB) from another class instance (
ClassA) at compile time, then any changes to
ClassB will affect
ClassA. For every change, we need to recompile, redeploy the whole stuff, and other related issues. In this case, there is a static or compile time binding between
Dependency Injection is one of the techniques that relieves us from the pain of static binding and decouples
ClassB. The end result, a decoupled or loosely coupled system.
There are lot of materials available to understand DI in detail. Martin Flower has an excellent article that explains the concepts, with examples.
DI using Spring.NET
Spring.NET offers DI as an out of the box solution. In this article, I will dig deep and explain how we can leverage the benefits offered by Spring.NET.
I created an application that has the typical three layers - Presentation, Business Logic Layer (BLL), Data Access Layer (DAL). The UI layer implements the MVP pattern, in which I created views (WinForms), Presenter classes, and
DataTable as Models.
The UI calls the Presenter, which interacts with BLL; BLL interacts with DAL and retrieves data from the Northwind database.
The following diagram shows the layers of the application:
Limitations of a tightly coupled system
In a tightly coupled system, the UI is dependant on BLL, and the BLL is dependant on the DAL. If we change something in the DAL, then all the layers need to be recompiled and redeployed.
Advantages of a loosely coupled system
Instead, if we develop in a loosely coupled manner, then the compile time dependency can be avoided. The instances can be chained at runtime. This gives the following advantages:
- Decouples the layers
- Ability to link the layers at runtime
- Ability to link a different implementation at runtime for QA/testing purposes
- Ability to develop the layers independently, and integrate at a later point
Steps to implement DI using Spring.NET
Having discussed about the advantages, it's now time to see how we can go about implementing the technique. Following are the broad steps that need to be followed to implement DI using Spring.NET.
Define your interfaces that will be exposed by the layers.
Provide concrete implementation for the interfaces defined by your layer.
Configure the objects in the Spring.NET configuration.
Initialize the Spring.NET configuration at runtime using the Spring.NET API.
Use the Spring factory to create the instance for you.
Consume the instance created by the Spring factory in the calling layer.
Implementation at ground level
Having seen the steps at 10,000 feet, it's now time to see how things are implemented at ground level.
I have created a layered application with three projects. Each layer defines the interface and the implementation.
Defining the interface
The Data Access Layer defines the interface, which the BLL will refer to. This interface defines methods that will retrieve data from a table.
public interface IDAL
DataTable GetById(string ID);
Provide concrete implementation
GetById() methods are shown as below:
public class CustomerDAL : IDAL
public DataTable GetAll()
public DataTable GetById(string ID)
Spring object configuration
So far so good. Now, it's time for us to understand the Spring configuration. First, you declare the Spring configuration section, then define the object/object node with type and assembly information. The object node's
name attribute must be unique, and it uniquely identifies the object. The
type specifies the full type of the object. The
singleton attribute specifies whether to create a single instance and serve for multiple requests (singleton implementation), or a new instance always.
The following snapshot gives the configuration of the application:
Initialize Spring configuration
Add a reference to the Spring.Core assembly. Include a reference to the
Initialize the configuration using the
ContextRegistry.GetContext() method. This will validate the configuration, check for the existence of objects, and return an
Get the instance using Spring
IApplicationContext instance returned by the
ContextRegistry.GetContext() method to get the instance.
IApplicationContext applicationContext = ContextRegistry.GetContext();
IBLL _customerBLL = applicationContext["customerBLL"];
Work with the instance
Once the object is instantiated, you can go ahead and perform the operations that you wish to. In our case, Customer DAL's
GetAll() method is called from the Customer BLL instance.
After working through Spring.NET DI, one obvious question is how it can be helpful in a real time scenario. Following are some of cases where DI can be used in a real time basis:
- The dependant layer can be changed at runtime based on the environment. For example: one can provide a test implementation for the test/QA environment and the actual implementation for the production environment
- The incremental bug fixes can be done offline and linked at integration/testing phase
- Parallel development of layers by different teams and can be linked at integration phase
About the sample application
The sample application has two forms - Customer and Employee. Both retrieve all data or data based on an ID. They follow a similar pattern.
When the form gets loaded, the presenters are initialized using Spring.NET's DI technique to the appropriate presenter. The Customer form gets linked to
CustomerPresenter; similarly, the Employee form gets linked to the
EmployeePresenter instance. The presenter gets linked to the appropriate BLL layer. The BLL layer gets linked to the appropriate DAL instance.
All these happen using Spring.NET's DI technique.
Dependency Injection is a key technique which helps in building loosely coupled systems. Spring.NET offers it as an out of the box solution, and it is the base principle for the rest of the components within Spring.NET.
Happy reading! Happy coding!