Enterprise Library for .NET Framework 2.0:Core Architecture
Enterprise Library for .NET Framework 2.0
Major new release of Enterprise Library
Designed for Microsoft® .NET Framework 2.0
• Leverages key new capabilities provided by the platform
• Certain features from Enterprise Library v1.x have been deprecated in favor of the platform
Scenarios and features largely unchanged
• Public application programming interfaces (APIs) not identical, but changes are minor
• …but many improvements are hiding under the covers!
Key Changes from Enterprise Library 1.x
Configuration now built on System.Configuration
• Configuration Application Block no longer exists
• Easier to use blocks with or without configuration files
Instrumentation configurable and disabled by default
Much improved Logging Application Block
• Flexibility and performance
Simpler and more powerful Data Access Application Block
• Use with OLE-DB, Open Database Connectivity (ODBC) or any managed provider
Most of the Security Application Block has been removed
• Deprecated in favor of .NET Membership and Profile features
CachingCaching
SecuritySecurity
Data Data AccessAccess LoggingLogging
ExceptionExceptionHandlingHandling
Enterprise Library for .NET Framework 2.0
Plug-inConfigConfig
Helpers Helpers & Design& Design
Instrumen-Instrumen-tationtation
ObjectObjectBuilderBuilder
CryptographyCryptography
Core
Block DependencyOptional ProviderDependency
CachingCaching
SecuritySecurity
Data Data AccessAccess LoggingLogging
ExceptionExceptionHandlingHandling
Enterprise Library for .NET Framework 2.0
Plug-inConfigConfig
Helpers Helpers & Design& Design
Instrumen-Instrumen-tationtation
ObjectObjectBuilderBuilder
CryptographyCryptography
Core
Block DependencyOptional ProviderDependency
Core Architecture
Configuration runtime
Configuration design and tooling
Instrumentation
Factories and object builder
Configuration in Enterprise Library
All Enterprise Library blocks are configurable
• Controls how the blocks work in your application
• Specifies which plug-ins you are using
Previous versions of Enterprise Library included a Configuration Application Block
• Supported reading/writing complex configuration objects from pluggable storage
• Used by all Enterprise Library blocks, and can be used by customer code
In Enterprise Library for .NET Framework 2.0, the requirements are the same but the solution is different
System.Configuration in .NET 2.0
Much more powerful than the Microsoft® .NET Framework 1.x classes
• Supports reading and writing rich graphs of objects
• Automatic serialization and deserialization between configuration classes and XML using ConfigurationSection and ConfigurationElement
Some Enterprise Library 1.x features are not directly supported
• Storing configuration somewhere other than XML Files
• Monitoring external changes to configuration
Configuration Runtime
Enterprise Library for .NET Framework 2.0 uses System.Configuration, but provides additional helper classes to provide more functionality
• All blocks provide ConfigurationSections which are stored in app.config / web.config by default
• All System.Configuration features such as encryption and using external files are supported
Configuration Runtime helper classes are in the Common assembly
• Used by all Enterprise Library application blocks
• Can be used by your apps, but you generally won’t need to
Configuration Sources
Application BlocksApplication Blocksor Custom Codeor Custom Code
IConfigurationSourceIConfigurationSource
SystemConfigurationSystemConfigurationSourceSource
FileConfigurationFileConfigurationSourceSource
SqlConfigurationSqlConfigurationSourceSource
app.config/ web.config
foo.config
app.config/ web.config
DefaultConfigurationSource
= …
System.ConfigurationSystem.Configuration
File WatcherFile Watcher
Configuration Sources
Abstract interface that supports loading/saving configuration and monitoring for changes
Two implementations included in the core
• SystemConfigurationSource defers to System.Configuration to read from default configuration file (plus adds file watchers)
• FileConfigurationSource defers to System.Configuration but reads from arbitrary files
SqlConfigurationSource included as a sample
• Requires that sections derive from SerializableConfigurationSection
Choosing a Configuration Source
Several ways of choosing a configuration source when using Enterprise Library
If you access blocks using static façades or factories (Examples: DatabaseFactory, Logger), you will always use the application’s default ConfigurationSource:
• If you define a ConfigurationSources section in your default.config file, you can specify which type of source should be used
• If you don’t have this section, SystemConfigurationSource is used
If you use the instance factories (Examples:DatabaseProviderFactory, LogWriterFactory) you can specify a configuration source of your choosing
• Instantiated directly or using ConfigurationSourceFactory
Configuration Source Examples
// Use default source specified in the app.config / web.config file
Database db1 = DatabaseFactory.CreateDatabase(“Sales”);
// Use the specified source – you don’t need an app.config / web.config file
FileConfigurationSource fileSource = new FileConfigurationSource(“tom.config”);
DatabaseProviderFactory factory = new DatabaseProviderFactory(fileSource);
Database db2 = factory.Create(“Sales”);
<enterpriseLibrary.ConfigurationSource selectedSource="fileSource"> <sources> <add name="fileSource" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.FileConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common" filePath="test.config"/>
<add name="systemSource" type="Microsoft.Practices.EnterpriseLibrary.Common.Configuration.SystemConfigurationSource, Microsoft.Practices.EnterpriseLibrary.Common"/>
</sources> </enterpriseLibrary.ConfigurationSource>
Change Notifications
IConfigurationSource supports monitoring configuration data for changes
• AddSectionHandler(string sectionName, ConfigurationChangedEventHandler handler)
• RemoveSectionHandler(string sectionName, ConfigurationChangedEventHandler handler)
Any code can register for changes and respond accordingly
In Enterprise Library, only the Logging Application Block currently registers to receive change notification events
Configuration Design and Tooling
Configuration tool eliminates the need to edit the blocks’ XML configuration files
• Quickly add default configuration for a block
• Strongly-typed properties and providers
• Validate configuration before you save
No major changes to configuration tool user experience from previous versions of Enterprise Library
Configuration design-time subsystem can be used in your own applications and blocks to provide a similar experience for your users
Configuration Design-Time
Improved API
• Simple base configuration design manager
• Better node registration and command registration
• 3 to 4 simple classes to register your custom provider
• No more OnSited
One configuration design manager per section
Dependent configuration design managers
Easy to interop with any .NET configuration
Instrumentation
All Enterprise Library blocks include instrumentation to assist in development, testing and operations
• Event Log events
• Performance Counters
• Microsoft® Windows® Management Instrumentation (WMI) events
All instrumentation is disabled by default, but each type can be individually enabled using the configuration tool
Instrumentation code contained in common assembly can be reused in your apps
Enabling Instrumentation
Run the installer classes to create the instrumentation artifacts:
• Run installservices.bat (using an admin account), or
• Run installutil.exe over each Enterprise Library assembly (using an admin account), or
• Create your own installers/MSI that do this
Configure instrumentation for your app using the tool
Instrumentation Architecture
Event-driven architecture
InstrumentationInstrumentationProviderProviderClass(es)Class(es)
InstrumentationInstrumentationListenerListenerClass(es)Class(es)
InstrumentationInstrumentationConfigurationConfiguration
SettingsSettings
WMIWMI
PerfPerfCountersCounters
EventEventLogLog
EventEvent
ObjectBuilderObjectBuilder
Wires upWires up
Application or BlockApplication or Blockcallscalls
Instrumentation Attributes
Instrumentation is wired up using attributes:
• [InstrumentationListener]
Defined on a type within the block or application
Specifies which listener will deal with instrumentation events
• [InstrumentationProvider]
Defined on an event within the block or application
Specifies the name of the event being fired
• [InstrumentationConsumer]
Defined on a method within the instrumentation listener
The method contains the instrumentation logic, and the name must match the one used in an [InstrumentationProvider] declaration
Instrumentation Example
public class public class Database : Database : IInstrumentationEventProviderIInstrumentationEventProvider { { DbConnection OpenConnection() { DbConnection OpenConnection() { // Do stuff// Do stuff instrumentationProvider.FireConnectionOpenedEvent();instrumentationProvider.FireConnectionOpenedEvent(); }} public object GetInstrumentationEventProvider() {public object GetInstrumentationEventProvider() { return instrumentationProvider; }return instrumentationProvider; }}}
[InstrumentationListener([InstrumentationListener( typeof(DataInsttypeof(DataInstrumentationListener), rumentationListener), typeof(DataInstrumentationListenerBinder)typeof(DataInstrumentationListenerBinder))])] public class public class DataInstrumentationProviderDataInstrumentationProvider { {
[InstrumentationProvider("ConnectionOpene[InstrumentationProvider("ConnectionOpened")]d")] public event public event EEventHandler<EventArgs> ventHandler<EventArgs> connectionOpened;connectionOpened;
public void FireConnectionOpenedEvent() public void FireConnectionOpenedEvent() {{ connectionOpened(this, new connectionOpened(this, new EventArgs());EventArgs());}}
internal class internal class DataInstrumentationListenerDataInstrumentationListener : : InstrumentationListenerInstrumentationListener { {
public public DataInstrumentationListener(string DataInstrumentationListener(string instanceName, bool perfCountersEnabled,instanceName, bool perfCountersEnabled,bool eventLogEnabled, bool wmiEnabled) :bool eventLogEnabled, bool wmiEnabled) : base(perf…, event…, wmi…) {}base(perf…, event…, wmi…) {}
[InstrumentationConsumer( “ConnectionOpe[InstrumentationConsumer( “ConnectionOpened")]ned")]public void ConnectionOpened(object public void ConnectionOpened(object sender, EventArgs e) {sender, EventArgs e) {if (PerformanceCountersEnabled)if (PerformanceCountersEnabled) connectionOpenedCounter.Increment();connectionOpenedCounter.Increment();}}
Instrumentation Installation Attributes
Running installutil over an instrumented class should install all required event log sources, WMI schemas and performance counters
Enterprise Library provides a ReflectionInstaller which uses reflection to find these, with the help of some attributes
[HasInstallableResources]
• Indicates that there is instrumentation to install
[PerformanceCountersDefinition]
• Defines the counters used by the block or app
[EventLogDefinition]
• Defines the event log sources used by the block or app
Factories and Object Builder
Objects inside application blocks need to be constructed and configured
There are different ways you can construct objects depending on what you want to do
• Use a default configuration source
• Use a custom configuration source
• Don’t use any configuration at all
• Inject instrumentation
Although each block is different, all rely on similar types of factories for construction
Object Builder
New subsystem shared between EntLib and Composite UI Application Block
Responsible for building objects inside the application blocks
• Invoking the necessary custom factory using data from configuration
• Configuring instrumentation for the blocks
Can be leveraged from your own apps, but understanding ObjectBuilder is not required to use Enterprise Library
CoreCoreApplication BlockApplication Block
Factories
Static FactoryStatic Factoryor façadeor façade
Instance Instance Provider FactoryProvider Factory
Enterprise LibraryEnterprise Library FactoryFactory
CustomCustom FactoryFactory
Block ObjectsBlock Objects
Object BuilderObject Builder
StrategiesStrategies
UserUserCodeCode
ConfigurationConfigurationSourceSource
Using Static Facades and Factories
Easiest way to use the blocks
Configuration is retrieved from the default configuration source
Instrumentation is wired up (but may be disabled)
Results in a call to an instance factory behind the scenes
Examples:
• Dim db As Database = DatabaseFactory.CreateDatabase(“Sales”)
• Logger.Write(“My message”, “My Category”)
Using Instance Provider Factories
You get slightly more control on how objects are created
You can choose your own configuration source
Instrumentation is wired up (but may be disabled)
Examples:
• Dim factory As New DatabaseProviderFactory(configSource)Dim db As Database = factory.Create(“Sales”)
• Dim factory As New LogWriterFactory(configSource)Dim writer As LogWriter = factory.Create()
Creating Objects Directly
New up the object and any dependent objects yourself
Configuration sources are not used
Object Builder is not involved
Instrumentation will not be automatically wired up (but you can add it yourself)
Example:
• Dim db As SqlDatabase = New SqlDatabase("server=(local)\SQLEXPRESS;database=EntLibQuickStarts;Integrated Security=true")
Resources
Download Enterprise Library and related resources from:
• http://msdn.microsoft.com/practices
Join the Enterprise Library Community at:
• http://practices.gotdotnet.com/projects/entlib
Read blogs from the Enterprise Library team at:
• http://msdn.microsoft.com/practices/Comm/EntLibBlogs/
Top Related