Javen-Studio 咖啡小屋

http://javenstudio.org - C++ Java 分布式 搜索引擎
Naven's Research Laboratory - Thinking of Life, Imagination of Future
  C++博客 :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理 ::
  24 随笔 :: 57 文章 :: 170 评论 :: 4 Trackbacks
The Enterprise Library Core
Enterprise Library 4.1 - October 2008
The Enterprise Library Core

Many tasks that the Enterprise Library application blocks perform are common across more than one application block and are also useful in application code outside of Enterprise Library. Examples are routines that serialize data or access configuration information. To promote usability, these routines reside in a common assembly named the Enterprise Library Core.

In addition, all the application blocks are designed to have a limited number of dependencies so that they can be used individually as well as with other application blocks. All application blocks except the Unity Application Block depend on the Enterprise Library Core, which is a logical grouping made up of the following subsystems:

For information about the dependencies between application blocks and the Enterprise Library Core, see Application Block Dependencies.

The Enterprise Library includes an assembly named Common that contains useful elements that are shared among multiple application blocks. Any application that uses an Enterprise Library application block (with the exception of the Unity Application Block) must reference this assembly. By supplying a set of commonly used functions to all the application blocks, the Common assembly reduces the dependency of one application block on another.

The following are some criteria used to factor elements into the Common assembly:

  • Elements could not depend on other application blocks. However, they could depend on other elements that are already in the Common assembly.
  • Elements could not depend on any persistent state.
  • Elements could not depend on any third-party technology.
  • Elements could not imply a particular application model. They could be used equally well in any application model. For example, the elements should function as well in a smart client as in a Web service.

Most of the application blocks contain instrumentation. The types of instrumentation are the following:

  • Performance counters
  • Event log events
  • WMI (Windows Management Instrumentation) events

The instrumentation classes are a part of the Enterprise Library Core and are located in the Common assembly. You can reuse this code in your own applications.

By default, instrumentation is disabled, but you can use the Enterprise Library configuration tools to enable each type of instrumentation. If you have administrative rights, you can use the Installutil.exe program to install the instrumentation.

Most other dependencies are encapsulated in individual providers. For example, the Exception Handling Application Block can use the Logging Application Block to publish exception information, but this is not a requirement. You can choose to publish exception information to other sources, such as the event log, or you can extend the Exception Handling Application Block by supplying your own logging provider.

Configuration uses the System.Configuration namespace, which makes it easier to use application blocks either with configuration files or without them. Factories (and the Unity Application Block) create application block objects from the data contained in configuration files. It is possible to use alternatives to XML configuration files as configuration sources. For example, you can use a SQL Server database. You can also create objects without using configuration files; you can do this by using constructors with primitive data types.

To support extensibility in Enterprise Library, configuration includes helper classes in addition to those classes found in the System.Configuration namespace. These helper classes support polymorphic collections, generic collections, and configuration sources. These enhancements require configuration to be based on the Dependency Injection pattern instead of the Provider pattern, as is the case with the System.Configuration namespace.

The configuration tools allow you to change an application block's configuration without directly editing the XML configuration files. You can use the design-time components that the configuration tools use with applications and application blocks that you create to give your users a similar experience to the Enterprise Library Configuration Console and Configuration Editor.

Enterprise Library 4.1 - October 2008
Design-Time Configuration

All application blocks include both run-time support and design-time support for configuration settings. The run-time support includes classes that represent the configuration settings. The Configuration Application Block uses these class definitions when it loads configuration settings. It reads the configuration settings from storage and returns objects that contain the configuration data to the application block.

The design-time configuration support includes classes that allow you to change the configuration settings by using the Enterprise Library configuration tools. These classes provide a visual representation of the different configuration settings (such as the image that appears next to the configuration setting), the actions that can be performed based on the current configuration state, and the ability to validate the configuration settings.

Figure 1 illustrates the relationship between the run-time configuration support and the design-time configuration support.

Dd139921.ff6d55fe-b410-4679-a508-125d66269b08(en-us,MSDN.10).png

Figure 1
Design-time configuration support and run-time configuration support

The design-time classes depend on the configuration run-time classes because they obtain the current configuration settings from the configuration run-time objects. When you change these settings and save the changes, the design-time objects update the run-time objects, which are then saved in storage. However, the run-time classes have no dependency on the design-time classes. Each application packages the design-time support in separate assemblies from the run-time implementation. These assemblies are not required for running an application that uses the application blocks. However, they are required when you use the Configuration Console to change the configuration of an application block.


posted on 2008-12-26 17:23 Javen-Studio 阅读(630) 评论(0)  编辑 收藏 引用

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理