• русский (Россия)
    • English (United States)
    • العربية (مصر)
    • Deutsch (Deutschland)
    • Español (España, alfabetización internacional)
    • français (France)
    • हिंदी (भारत)
    • italiano (Italia)
    • 日本語 (日本)
    • 한국어 (대한민국)
    • Nederlands (Nederland)
    • polski (Polska)
    • ไทย (ไทย)
    • Türkçe (Türkiye)
    • Tiếng Việt (Việt Nam)
    • 中文(中华人民共和国)
    • 中文(香港特別行政區)
  • Вход
  • Зарегистрироваться

DotNetAge

Скрыть боковую панель

DotNetAge plugable infrastructure - Dependency injection


    • Подаваемым на основании:
    • Infrastructure
  • 0


Before you start
This document is introduction to the DotNetAge development core concept from high level - Dependency injection. This document describes what MVC service locators are extended by DotNetAge and how DotNetAge using DI to implement a plug-able architecture for MVC.

If you are already read the following articles maybe help to understand this document:


Overview



DotNetAge 2.1 is a revolutionary release, it is largely abandoned in the past from the infrastructure. DotNetAge use the Microsoft Unity 2.0 to extend the ASP.NET MVC3 service locators to build a plugable architecture. Developers can use DI anywhere in DotNetAge!

Why dependency injection?



The purposes of using dependency injection pattern are:
  1. Reduce coupling between modules
  2. High scalability-Services and modules are all plug-able in DotNetAge.
  3. Effectively manage the life-cycle of objects and enhance performance
  4. Easy to write test.

What DotNetAge do for MVC with DI



DotNetAge implement a service container for Mvc, DI is available in all service locations in Mvc 3 including Controllers,Filters,Actions.

To learn more about Mvc3 service locations please refer : "ASP.NET MVC 3 Service Location"

Which DotNetAge modules and services support DI?



The answer is : All of them!
Modules and services of DotNetAge are base on DI pattern such as Repositories(IRepository,IUnitOfWork), Open search engine, Notification service, Syndication, Exporting , Installation service and ect.As long as you are developed using DotNetAge, DI will be ubiquitous

How to use DI in DotNetAge



In DotNetAge your Mvc application will support constructor injection, property injection, and method call injection.

Notes: For more about unity configuration please refer:The Unity Configuration Schema

Inject to Controllers




This example shows how to inject the IPubService to the ArticleController and call the NewPost method in Action.

Step1: Inject and use the interface





public partial class ArticleController : Controller
{
private IPubService srv;

//Inject the IPubService interface
public ArticleController(IPubService service)
{
srv = service;
}

public ActionResult Create(Article article)
{
if (ModelState.IsValid)
{
...
//Invoke srv.NewArticle method
srv.NewPost(article, isAdmin);
return Redirect(new ArticleWrapper(article).PermaLink);
}

return View(article);
}
}


  • Controller no need to know how to instantiate the IPubService. The IPubService instance is created and injected by DotNetAge in run time.
  • In this way developer can very easy to Mock a service to Controller in testing code.


[TestMethod]
public void Should_Create_Article()
{
var service = new Mock();
service.Setup(srv=>srv.NewPost(It.IsAny
(),true)).Returns(new Article());

var httpContext=Faker.FakeHttpContext();

var controller=new ArticleController(service.Object);
controller.ControllerContext = new ControllerContext(new RequestContext(httpContext, new RouteData()), controller);

var result = controller.Create(new Article());

//Do some verify
...
}


Step2:Register IPubService to unity.config



Open unity.config to register type mappings and object instances.


<unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
...
<alias alias="IPubService" type="DNA.Mvc.Publishing.IPubService,DNA.Mvc.Publishing.Services" />
<alias alias="PubService" type="DNA.Mvc.Publishing.PubService,DNA.Mvc.Publishing.Services" />
<assembly name="DNA.Mvc.Publishing.Services" />
<container>
<register type="IPubService" mapTo="PubService">
<lifetime type="PerWebRequest" />
<constructor>
<param name="pubContext" type="IPubContext" />
<param name="dbContext" type="IDataContext" />
constructor>
register>
container>
unity>


In unity.config we:
  1. Register the alias names for IPubService and PubService.
  2. Add an assembly for locate.
  3. Map IPubService interface to PubSerivce class.
  4. Specified the PubService constructor parameters.
  5. Specified the PubService using the PreWebRequest lifetime manager.

PreWebRequest lifetime manager - Specified the typed object returns from Unity container has the same life cycle as a http request.

References

Inject to Filters



As we know a filter can implement one of more of the following interfaces: IActionFilter, IResultFilter, IExceptionFilter, and IAuthorizationFilter. DotNetAge extend the filter providers to support DI for MVC3. So all filters in DotNetAge is inject-able.

One thing to note is the filters can not support constructor injection.

Example: In this example we define a new Filter and inject the IDataConetxt (The interface use to access the DotNetAge core objects) , we use DependencyAttribute to specify which property should be injected.


using Microsoft.Practices.Unity;

public class MyFilter:ActionFilterAttribute
{

[Dependency]
public IDataContext DataContext{get;set;}

public override void OnActionExecuting(ActionExecutingContext filterContext)
{
//Get the web object from database
var web=DataContext.Webs.GetByName("home");

//Do something here
...
}
}


Reference: Registering Injected Parameter and Property Values

IDataContext interface is use access the DotNetAge core objects it was already registered in unity.config.

The following code is the IDataContext registered elements in unity.config:


<unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
<alias alias="IDataContext" type="DNA.Mvc.IDataContext,DNA.Mvc.Data" />
<alias alias="DataContext" type="DNA.Mvc.Data.DataContext,DNA.Mvc.UI" />
<container>
<register type="IDataContext" mapTo="DataContext">
<lifetime type="PerWebRequest" />
register>
container>
unity>



DependencyResolver



In design time developers also can use the System.Web.Mvc.DependencyResolver to resolve an instance for the interface. The other way is use the WebSiteContext.GetService() and WebSiteContext.GetServices().

For example:

public interface IMyInterface
{
//Define this interface
}

public class MyClass:IMyInterface
{
//Implement the interface.
}


public class MyController:Controller
{
public Action DoSomething()
{
//Resolve the IMyInterface instance.
var myclass=DependencyResolver.Current.GetService();
...
// Or
var myclass=WebSiteContext.GetService();
}
}


The registered interfaces



There are many interface registered in unity.config by DotNetAge. Developers can resolve the instances of this interfaces directly.

The following table list all registered public interfaces:

Interface Description
IDataContext DotNetAge core object access interface. Provides the repositories to handle Webs,WebPages,Widgets,WidgetDescriptors,WidgetTemplates,PermissionSets,Permissions,OpenIDs,Themes,Solutions, PrivateMessages POCO objects.
IPubContext Publishing objects access interface,Provide repositories for Category, Article and Comment.
IForumContext Community objects access interface. Provide repositories for Forums, Threads and Posts.
IGlobalFilter Register a global DI filter.
IAppInitializer The interface use to execute the initialize task on app start.
IWebResourceService Defines the methods to manipulate the managed web resources.
INotificationService Defines the methods to subscribe,unsubscribe and send messages to subscribers.
ISubscriptionRepository Defines the repository methods to access subscription objects.
ISubscriptionSender Defines the send method to various kinds of subscription source.
IFormsAuthentication Defines forms authentication service methods.
IMembershipService Defines membership service methods.
ILogRepository Defines the repository methods for access log objects.
IWebStatRepository Defines the repository methods for analyze log data.
IPubService Defines the publishing service methods.
ISpammerRepository Defines the repository methods to access the spammer objects.
Exporter Defines a base exporter class to packing the data to package.
EventObserver Defines the observer base class for handling DotNetAge events.
InstallerBase Defines the installer base class to deploy the data/files to DotNetAge.
SiteMapGeneratorBase Defines methods to generate the sitemap data and add to global sitemap file.
OpenSearchProvider Defines the search provider base class,inherit this class could extend more search source.
RssItemsGeneratorBase rss data generator base class.
AtomEntriesGeneratorBase atom generator base class.


 


    Average:5
  • Читает
    (1262)
  • (0)
  • Постоянная ссылка
Следующий:Introduction to EventMonitoring architecture
Доля в:

Комментарии (0)


  • rss
  • atom

Существует никаких комментариев, установленных в данной статье.
Valid XHTML 1.0!