Nopcommerce Architecture Analysis (reprint)

Original

First, the beginning of Nopcommerce architecture analysis

Nopcommerce is a relatively mature business application framework in. NET open source projects and a model in e-commerce systems. So I want to learn more about the design and implementation of the way.

Second, Nopcommerce structure analysis of the reference

Reference:dependencyresolver

Http://www.cnblogs.com/RobbinHan/archive/2011/11/30/2269537.html

Simple use of Dependency injection framework AUTOFAC

Http://www.cnblogs.com/liping13599168/archive/2011/07/16/2108209.html

The core of the modelbinder--asp.net MVC model binding

Http://www.cnblogs.com/artech/archive/2012/05/21/model-binder-provision.html

How ASP. NET MVC works?

Http://www.cnblogs.com/artech/archive/2012/04/10/how-mvc-works.html

View View new engine Razor

Http://www.cnblogs.com/sonykings/archive/2013/05/23/3095539.html

ASP. NET MVC 3: @model new keywords in razorhttp://blog.csdn.net/Sandy945/article/details/6046285

Third, one of the Nopcommerce architecture analysis----dependent class generation container

Nopcommerce for the purpose of loosely coupled framework design, the IOC framework is used: AUTOFAC. According to some tests, AUTOFAC is an IOC tool with good performance.

1, in the IOC, the components first need to register in the IOC, there are registered through the configuration file, like Spring.net, but also through the characteristics of registration, like StructureMap, but also through the agent to register, like AUTOFAC. But the IOC pays attention to one principle, namely interface and realization separation. All IOC is life a specific class implements an interface. Then, when used, the system obtains the implementation class of the interface from the IOC and creates the object.

2. Nopcommerce How to use AUTOFAC to achieve a loosely coupled frame design. In fact, its plug-in mechanism is also through the AUTOFAC to achieve.

The IOC package and flexible use mechanisms are mainly encapsulated in the Nop.Core.Infrastructure. In Autofac, objects are also called components. The component life cycle is divided into: singleton, temporal, and life cycle domains, defined as follows:

[HTML]View Plaincopy

1. Namespace Nop.Core.Infrastructure.DependencyManagement
2. {
3. public enum Componentlifestyle
4. {
5. Singleton = 0,
6. Transient = 1,
7. Lifetimescope = 2
8. }
9. }

AUTOFAC has containers, and provides methods for registering interfaces and their types, and also provides methods to find the types of registrations and automatically create objects.

3. Type Finder

In order to support plug-in features, as well as support some auto-registration features. The system provides a type finder. Itypefinder and implementation classes provide this functionality. The Type Finder lets you find classes in this program domain, or you can find classes in all dynamic-link libraries in the entire bin directory, and register them in a type reversal container. The Itypefinder and implementation classes are as follows:

4. Type Registration

Container Management classes: Containermanager, managing containers generated through AUTOFAC;

Container configurator: Containerconfigurer: Configures a dependency reversal container that establishes the relationship between the type-dependent registration of the entire framework and the type lookup class.

In the system there is a dependency on the class engine context: Enginecontext, which can be generated from the configuration file engine, which is responsible for returning objects from the container based on the type interface.

The system default engine Nopengine, if not configured with a valid engine, the default engine, the generated engine is saved in a singleton container.

Their relationship is as follows:

The system initializes the engine context in the method Application_Start of the class mvcapplication. and by calling Enginecontext.initialize (false) to implement all the inversion-dependent registration functions;

5. Container Registration Class

The system registers the interface as: Idependencyregistrar, the system registers this interface through the Containerconfigurer and implements the class, And the class that implements the interface Idependencyregistrar through the Itypefinder class search assembly. The code is as follows:

[CSharp]View Plaincopy

2. Namespace Nop.Core.Infrastructure.DependencyManagement
4. {
6. // <summary>
8. // configures the inversion of control container with services used by NOP.
10. // </summary>
12. public class Containerconfigurer
14. {
16. public virtual void Configure (Iengine engine, Containermanager Containermanager, Eventbroker broker, Nopconfig configuration)
18. {
20. //other Dependencies
22. Containermanager.addcomponentinstance<nopconfig> (Configuration, "Nop.configuration");
24. Containermanager.addcomponentinstance<iengine> (engine, "Nop.engine");
26. Containermanager.addcomponentinstance<containerconfigurer> (This, "Nop.containerconfigurer");
30. //type Finder
32. Containermanager.addcomponent<itypefinder, webapptypefinder> ("Nop.typefinder");
36. //register Dependencies provided by other assemblies
38. var typeFinder = containermanager.resolve<itypefinder> ();
40. Containermanager.updatecontainer (x =
42. {
44. var drtypes = typefinder.findclassesoftype<idependencyregistrar> ();
46. var drinstances = new list<idependencyregistrar> ();
48. foreach (Var drtype in drtypes)
50. Drinstances.add ((Idependencyregistrar) activator.createinstance (Drtype));
52. //sort
54. Drinstances = Drinstances.asqueryable (). (t = t.order). ToList ();
56. foreach (Var dependencyregistrar in drinstances)
58. Dependencyregistrar.register (x, TypeFinder);
60. });
64. //event Broker
66. Containermanager.addcomponentinstance (broker);
68. }
70. }
72. }

The contents of the interface Idependencyregistrar are as follows:

[CSharp]View Plaincopy

2. Namespace Nop.Core.Infrastructure.DependencyManagement
4. {
6. public interface Idependencyregistrar
8. {
10. // <summary>
12. /// This method registers the dependency relationship through Containerbuilder.
14. // </summary>
16. /// <param name= "Builder" > Container manager Class </param>
18. /// <param name= "TypeFinder" > Type Finder interface </param>
20. void Register (Containerbuilder builder, Itypefinder TypeFinder);
22. // <summary>
24. // Registration sort serial number
26. // </summary>
28. int Order { get;}
30. }
32. }

6. Single class container

The Singleton Class series holds the Singleton object in the system with the same life cycle as the program, or it is called a singleton class container.

This includes an entity class, a collection class, and a singleton container for a dictionary class.

Singleton<t>,singletonlist<t>,singletondictionary<tkey, tvalue>. Enginecontext is to manage the engine through the Singleton<t> class.

7, the MVC service provides the class.

Type dependent: Nopdependencyresolver, which inherits the interface under MVC: Idependencyresolver, and registers it in the Application_Start method, so that it is called at system startup.

[CSharp]View Plaincopy

1. Set Dependency resolver
2. var dependencyresolver = new Nopdependencyresolver ();
3. Dependencyresolver.setresolver (Dependencyresolver);

8. Other

Event interception class: Eventbroker: Filters the requests sent to the system to prevent the system from crashing due to temporary errors or exceptions.

Perform tasks at system startup: Istartuptask, the task performed at startup is primarily the initialization and loading of the database.

Nopcommerce Architecture Analysis (reprint)