1 - Welcome to the Library: Introduction to the Microsoft Enterprise Library

On this page:

Download:

Meet the Librarian | What You Get with Enterprise Library | Things You Can Do with Enterprise Library | Why You Should Use Enterprise Library | Some Fundamentals of Enterprise Library | Choosing Which Blocks to Install | Installing Enterprise Library | Assemblies and References - GAC or Bin, Signed or Unsigned?, Importing Namespaces | Configuring Enterprise Library | Diving in with an Example | Configuration Classes | Instantiating and Using Enterprise Library Objects | Enterprise Library Objects and Factories | Creating Instances of Enterprise Library Types | The Example Applications | Summary | More Information

Meet the Librarian

Before we begin our exploration of Microsoft Enterprise Library and the wondrous range of capabilities and opportunities it encompasses, you need to meet the Librarian. In the early days we called him Tom, sometimes we called him Chris, and for the past six years we call him Grigori. He—in collaboration with an advisory board of experts from the industry and other internal Microsoft product groups, and a considerable number of other community contributors—is the producer and guardian of the Microsoft Enterprise Library.

Since its inception as a disparate collection of individual application blocks, the Librarian has guided, prodded, inspired, and encouraged his team to transform it into a comprehensive, powerful, easy-to-use, and proven library of code that can help to minimize design and maintenance pain, maximize development productivity, and reduce costs. And now in version 6, it contains even more built-in goodness that should make your job easier. It's even possible that, with the time and effort you will save, Enterprise Library can reduce your golf handicap, help you master the ski slopes, let you spend more time with your kids, or just make you a better person. However, note that the author, the publisher, and their employees cannot be held responsible if you just end up watching more TV or discovering you actually have a life.

Carlos says:
	If you’ve used Enterprise Library before, you’ll find version 6 is easy to get started with. There are some changes, some features have been deprecated, and new features have been added, but it continues to address the common cross-cutting concerns that developers face building line-of-business applications both on-premises and in the cloud.

What You Get with Enterprise Library

Enterprise Library is made up of a series of application blocks, each aimed at managing specific crosscutting concerns. In case this concept is unfamiliar, crosscutting concerns are those annoying tasks that you need to accomplish in several places in your application. When trying to manage crosscutting concerns there is often the risk that you will implement slightly different solutions for each task at each location in your application, or that you will just forget them altogether. Writing entries to a system log file or Windows Event Log, and validating user input are typical crosscutting concerns. While there are several approaches to managing them, the Enterprise Library application blocks make it a whole lot easier by providing generic and configurable functionality that you can centralize and manage.

Note

What are application blocks? The definition we use is "pluggable and reusable software components designed to assist developers with common enterprise development challenges." Application blocks help address the kinds of problems developers commonly face from one line-of-business project to the next. Their design encapsulates the Microsoft recommended practices for Microsoft .NET Framework-based applications, and developers can add them to .NET-based applications and configure them quickly and easily.

As well as the application blocks, Enterprise Library contains an optional configuration tool, plus a set of core functions that manage tasks applicable to all of the blocks. Some of these functions—routines for handling configuration and serialization, for example—are exposed and available for you to use in your own applications.

And, on the grounds that you need to learn how to use any new tool that is more complicated than a hammer or screwdriver, Enterprise Library includes a range of sample applications, Quickstarts, descriptions of key scenarios for each block, hands-on labs, and comprehensive reference documentation. You even get all of the source code and the unit tests that the team created when building each block (the team follows a test-driven design approach by writing tests before writing code). So you can understand how it works, see how the team followed good practices to create it, and then modify it if you want it to do something different. Figure 1 shows the big picture for Enterprise Library.

Figure 1 - Enterprise Library—the big picture

Things You Can Do with Enterprise Library

If you look at the documentation, you'll see that Enterprise Library today actually contains eight application blocks. However, there are actually only six blocks that "do stuff"—these are referred to as functional blocks. The other two are concerned with "wiring up stuff" (the wiring blocks). What this really means is that there are six blocks that target specific crosscutting concerns such as logging, data access, and validation. The other two, the Unity Dependency Injection mechanism and the Policy Injection Application Block, are designed to help you implement more loosely coupled, testable, and maintainable systems. There’s also some shared core pieces used in all the blocks. This is shown in Figure 2.

Beth says:
	With this release of Enterprise Library, there are fewer dependencies between the blocks. You can choose to use just the blocks that are relevant to your application.

Figure 2 - The parts of Enterprise Library

In this book we'll be concentrating on the six functional blocks. If you want to know more about how you can use Unity and the Policy Injection Application Block, check out the Dependency Injection with Unity guide. It describes the capabilities of Unity as a dependency injection mechanism and the use of policy injection in more detail.

Jana says:
	You can use Unity to add dependency injection to your applications and to use interception techniques to address additional cross-cutting concerns specific to your applications.

The following list describes the crosscutting scenarios you'll learn about in this book:

• Data Access. The Data Access Application Block simplifies many common data access tasks such as reading data for display, passing data through application layers, and submitting changed data back to the database system. It includes support for both stored procedures and in-line SQL, can expose the data as a sequence of objects for client-side querying, and provides access to the most frequently used features of ADO.NET in simple-to-use classes.
• Exception Handling. The Exception Handling Application Block lets you quickly and easily design and implement a consistent strategy for managing exceptions that occur in various architectural layers of your application. It can log exception information, hide sensitive information by replacing the original exception with another exception, and maintain contextual information for an exception by wrapping the original exception inside another exception.
• Transient Fault Handling. The Transient Fault Handling Application Block makes your application more robust by providing the logic for handling transient faults. It does this in two ways. First, the block includes logic to identify transient faults for a number of common cloud-based services in the form of detection strategies. Second, the application block enables you to define your retry strategies so that you can follow a consistent approach to handling transient faults in your applications. The block also helps you to perform retries if you are dealing with asynchronous, task-based code.
• Logging. The Logging Application Block simplifies the implementation of common logging functions such as writing information to the Windows Event Log, an e-mail message, a database, Windows Message Queuing, a text file, or a custom location.
• Semantic Logging. The Semantic Logging Application Block enables you to use the EventSouce class to write strongly typed log messages from your application. This enables you to write log messages with a consistent structure and format and to collect and process log messages out-of-process.
• Validation. The Validation Application Block provides a range of features for implementing structured and easy-to-maintain validation mechanisms using attributes and rule sets, and integrating with most types of application interface technologies.

Note

If you have used previous versions of Enterprise Library and are wondering what happened to the Caching Application Block, Security Application Block and Cryptography Application Block as well as some other functionality, the answer is that these have been deprecated. Many scenarios supported by these blocks are now better supported by the .NET platform. Our deprecation philosophy is outlined in this post by the Librarian. The V6 project was focused on ensuring Enterprise Library’s close alignment to the current platform (.NET framework 4.5) with a goal of reducing Enterprise Library’s footprint by leveraging platform capabilities and improvements. For more details, see the Migration Guide.

Why You Should Use Enterprise Library

As you can see from the previous section, Enterprise Library provides a comprehensive set of features that can help you to manage your crosscutting concerns though a reusable set of components and core functionality. Of course, like many developers, you may suffer from the well-known NIH (not invented here) syndrome. But, seriously, isn’t it about time that every developer on your team stopped writing his or her own logging framework or other “plumbing”? It's a commonly accepted fact that the use of standard and proven code libraries and components can save development time, minimize costs, reduce the use of precious test resources, and decrease the overall maintenance effort. In the words of the Librarian, "These days you cannot afford not to reuse."

Note

You can download the Nucleus Research 2009 Report on Microsoft patterns & practices, which reviews the key components, benefits, and includes direct feedback from software architects and developers who have adopted patterns & practices deliverables in their projects and products from https://www.microsoft.com/en-us/download/confirmation.aspx?id=11522 .

And it's not as though Enterprise Library is some new kid on the block that might morph into something completely different next month. Enterprise Library as a concept has been around for many years, and has passed through six full releases of the library as well as intermediate incremental releases.

Enterprise Library continues to evolve along with the capabilities of the .NET Framework. As the .NET Framework has changed over time, some features that were part of Enterprise Library were subsumed into the core, while Enterprise Library changed to take advantage of the new features available in both the .NET Framework and the underlying system. Examples include new programming language capabilities, and the use of asynchronous techniques, and the Task Parallel Library. You can also use Enterprise Library in your Microsoft Azure cloud-based applications as well as in your on-premises applications. Yet, even in version 6, the vast majority of the code is entirely backwards compatible with applications written to use Enterprise Library 2.0.

Carlos says:
	Upgrading to a new version of Enterprise Library may require some changes to your applications, but the guidance that accompanies Enterprise Library will help you to identify and make the necessary changes.

You can also use Enterprise Library as learning material—not only to implement design patterns in your application, but also to learn how the development team applies patterns when writing code. Enterprise Library embodies many design patterns, and demonstrates good architectural and coding techniques. The source code for the entire library together with unit tests is provided, so you can explore the implementations and reuse the techniques in your own applications.

Markus says:
	The Enterprise Library source code and tests are great learning resources, not just for Enterprise Library but for .NET development as well.

And, finally, it is free! Or rather, it is distributed under the Microsoft Public License (MS-PL) that grants you a royalty-free license to build derivative works, and distribute them free—or even sell them. You must retain the attribution headers in the source files, but you can modify the code and include your own custom extensions. Do you really need any other reasons to try Enterprise Library?

Note

You'll notice that, even though we didn't print "Don't Panic!" in large friendly letters on the cover, this book does take a little time to settle down into a more typical style of documentation, and start providing practical examples. However, you can be sure that—from here on in—you'll find a whole range of guidance and examples that will help you master Enterprise Library quickly and easily. There are resources to help if you're getting started with Enterprise Library, and there's help for existing users as well (such as the breaking changes and migration information for previous versions) available on Codeplex. You can also visit the Preview section of the site to see what the Enterprise Library team is working on as you read this guide.

Some Fundamentals of Enterprise Library

Before we dive into our tour of the application blocks and features of Enterprise Library, you need to grasp some fundamentals. In this chapter, the Librarian will help you explore topics such as how to install and deploy the library, and how to perform initial configuration. After that, you'll be free to skip to any of the other chapters and learn more about the ways that each block helps you to simplify your code and manage your crosscutting concerns. For more information about the topics covered in this chapter, see the Enterprise Library Reference Documentation.

Choosing Which Blocks to Install

Enterprise Library is a "pick and mix" candy store, where you choose just the features you want to use and simply disregard the rest. Once you have chosen which Enterprise Library blocks to use in your application, you need to add the appropriate assemblies to your project: for the Enterprise Library blocks, you can use the NuGet package manager in Visual Studio to handle this for you.

Markus says:
	NuGet makes it very easy to get started. Installing a specific application block package downloads all the required assemblies and adds all the required references in one easy step.

A NuGet package typically contains one or more assemblies, links to other NuGet packages that the current one depends on, and some configuration settings for your project. In some cases, NuGet packages also include additional project resources such as XML schema files or readme files.

From the perspective of Enterprise Library, the great advantage of NuGet is that it automatically adds everything that you need to use a block (including any dependencies) to your project in one, easy step. If you’ve not used NuGet before, you can find out more at "Welcome to NuGet Docs."

When NuGet installs a package, it places all the assemblies that make up a package and its dependencies in a folder within your solution. Therefore NuGet doesn’t install or change anything on your machine, it just modifies the project. Because the correct version of all of the Enterprise Library assemblies that your project uses are now part of the project, you’ll find that it’s much easier to deploy your application with all the correct dependencies.

In some cases, an Enterprise Library block consists of more than one NuGet package. This happens when you don’t necessarily need all of the features offered by a block. For example, you could install just the EnterpriseLibrary.ExceptionHandling NuGet package. However, if you want to log certain types of exception, you can also install the EnterpriseLibrary.ExceptionHandling.Logging NuGet package. Not surprisingly, if you begin by trying to install the EnterpriseLibrary.ExceptionHandling.Logging package, NuGet will automatically install both the EnterpriseLibrary.ExceptionHandling and EnterpriseLibrary.Logging packages that it depends on.

The configuration tool will automatically add the required block configuration to your application configuration file with the default configuration when required. For example, when you add a Logging handler to an Exception Handling block policy, the configuration tool will add the Logging block to the configuration with the default settings.

Installing Enterprise Library

There is no Enterprise Library installation; you add the blocks you need to any Visual Studio project by using the NuGet package manager. You can find all the Enterprise Library blocks in the Manage NuGet Packages dialog in Visual Studio by searching online for EnterpriseLibrary. You can also use the Package Manager Console in Visual Studio if you prefer to work on the command line.

Note

NuGet enables you to add packages to projects and solutions. If you add a package to a solution, you can then use NuGet to add references to the package to individual projects within the solution.

If you want to examine the source code, and perhaps even modify it to suit your own requirements, you can download the EnterpriseLibrary 6-source.exe (a self-extractable zip file). You can also download the binaries, Reference Implementation, and QuickStarts from the Microsoft Download Center.

Markus says:
	In NuGet, all new Enterprise Library packages are tagged with the ‘entlib6’ keyword. This makes it easy to search for the latest packages.

The zip file also contains a folder called scripts that includes batch files to install database files and other features. There are also batch files that you can use to compile the entire library source code, and to copy all the assemblies to the bin folder within the source code folders, if you want to rebuild the library from the source code.

Assemblies and References

It's not uncommon, when people first look at Enterprise Library, to see a look of mild alarm spread across their faces. Yes, there are quite a few assemblies, but remember:

• You only need to use those directly connected with your own scenario.
• Several are required for only very special situations.
• The runtime assemblies you will use in your applications are mostly less than 100 KB in size; and the largest of all is only around 500 KB.
• In most applications, the total size of all the assemblies you will use will be between 1 and 2 MB.
• NuGet will make sure that you have all the required assemblies for the blocks that you are using.

GAC or Bin, Signed or Unsigned?

All of the assemblies are provided as precompiled signed versions that NuGet places in a folder within your project. This helps to ensure that your project references the correct version of the assemblies you are using. However, you can install the assemblies into the global assembly cache (GAC) if you wish.

Carlos says:
	NuGet can install a package to either a Visual Studio solution or project. NuGet never makes any changes outside of a solution. For example, NuGet never installs assemblies into the GAC.

NuGet adds references in your project to the compiled assemblies it downloaded, these assemblies are automatically copied to the bin folder when you build your solution. This approach gives you simple portability and easy installation.

Alternatively, you can install the source code for Enterprise Library and use the scripts provided to compile unsigned versions of the assemblies. This is useful if you decide to modify the source code to suit your own specific requirements. You can strong name and sign the assemblies using your own credentials if required.

For more information about side-by-side operation and other deployment issues, see the Enterprise Library Reference Documentation.

Importing Namespaces

After you reference the appropriate assemblies in your projects, you will probably want to add using statements to your project files to simplify your code and avoid specifying types using the full namespace names.

You will also need to import the namespaces for the specific application blocks you are using. Most of the Enterprise Library assemblies contain several namespaces to organize the contents. For example, the Semantic Logging Application Block includes the following namespaces.

• Microsoft.Practices.EnterpriseLibrary.SemanticLogging
• Microsoft.Practices.EnterpriseLibrary.SemanticLogging.Database
• Microsoft.Practices.EnterpriseLibrary.SemanticLogging.Etw
• Microsoft.Practices.EnterpriseLibrary.SemanticLogging.Etw.WindowsService
• Microsoft.Practices.EnterpriseLibrary.SemanticLogging.WindowsAzure

Configuring Enterprise Library

Enterprise Library offers users several options for configuring the various blocks. Typically, you use an extremely flexible programmatic approach to configure the blocks: this is the approach used in the examples in this guide. If you have used a previous release of Enterprise Library, you will have used either a declarative approach based on XML configuration files and the Configuration Tool, or the fluent configuration API. For more information about these legacy approaches, you should read the reference documentation and the Developer’s Guide for Enterprise Library 5.0.

Beth says:
	In previous version of Enterprise Library, the preferred configuration approach was declarative, using the Configuration Tool to edit the configuration files.

Diving in with an Example

To demonstrate the configuration features of Enterprise Library, we provide a sample application that you can download and run on your own computer. You can run the executable directly from the bin\Debug folder, or you can open the solution named Configuration in Microsoft Visual Studio to see the code and run it under Visual Studio.

Note

Depending on the version of the operating system you are using, you may need to execute the application under the context of an account with administrative privileges. If you are running the sample from within Visual Studio, start Visual Studio by right-clicking the entry in your Start menu and selecting Run as administrator.

One point to note about the sample application is that it creates a folder named Temp in the root of your C: drive if one does not already exist, and writes the text log files there so that you can easily find and view them.

Configuration Classes

For most blocks, you can simply create the objects you need. However, the Logging Application Block includes a special configuration LoggingConfiguration class. Typically, you instantiate any necessary supporting objects before you create the configuration class, and then initialize the application block object by passing it the configuration object. The following code illustrates how to create a LoggingConfiguration object and then initialize a LogWriter object. The LogWriter class is part of the Logging Application Block.

// Create filters
PriorityFilter priorityFilter = new PriorityFilter(...);
LogEnabledFilter logEnabledFilter = new LogEnabledFilter(...);
CategoryFilter categoryFilter = new CategoryFilter(...);
 
// Create trace listeners
FlatFileTraceListener flatFileTraceListener =
  new FlatFileTraceListener(...);
 
// Build Configuration
LoggingConfiguration config = new LoggingConfiguration();
config.Filters.Add(priorityFilter);
config.Filters.Add(logEnabledFilter);
config.Filters.Add(categoryFilter);
config.AddLogSource("General", SourceLevels.All, true, flatFileTraceListener);

// Configure the LogWriter instance
LogWriter defaultWriter = new LogWriter(config);

The code shown in this example is adapted slightly to make it easier to read from the code in the method BuildProgrammaticConfig in the sample application.

For other blocks, you can simply instantiate the required objects and start using them. For example, in the Validation Application Block, you can create validators directly in code as shown in the following example.

Validator[] valArray = new Validator[] { 
new NotNullValidator(true, "Value can be NULL."),
new StringLengthValidator(
           5, RangeBoundaryType.Inclusive,
           5, RangeBoundaryType.Inclusive, 
  "Value must be between {3} ({4}) and {5} ({6}) chars.")
};

Validator orValidator = new OrCompositeValidator(
  "Value can be NULL or a string of 5 characters.", valArray);

// This will not cause a validation error.
orValidator.Validate(null, valResults);  

// This will cause a validation error.
orValidator.Validate("MoreThan5Chars", valResults);

Instantiating and Using Enterprise Library Objects

After you have referenced the assemblies you need, imported the required namespaces, and configured your application, you can start to think about creating instances of the Enterprise Library objects you want to use in your applications. As you will see in each of the following chapters, the Enterprise Library application blocks are optimized for use as loosely coupled components in almost any type of application. Typically, if you are using declarative configuration, you will use a factory provided by the block to create and configure the objects that you need in your application.

Enterprise Library Objects and Factories

Each of the application blocks in Enterprise Library contains one or more core objects that you typically use to access the functionality of that block. An example is the Exception Handling Application Block, which provides a class named ExceptionManager that exposes the methods you use to pass exceptions to the block for handling. The following table lists the commonly used objects for each block.

Functional Application Block	Non-static Instance or Factory	Static instances or Factories
Data Access	Database GenericDatabase SqlDatabase SqlCeDatabase OracleDatabase DatabaseProviderFactory	DatabaseFactory
Exception Handling	ExceptionManager	ExceptionPolicyFactory ExceptionPolicy
Transient Fault Handling	RetryManager RetryPolicyFactory
Logging	LogWriter LogEntry TraceManager LogWriterFactory	Logger
Semantic Logging	ObservableEventListener ConsoleSink FlatFileSink RollingFlatFileSink SqlDatabaseSink WindowsAzureTableSink
Validation	ValidationFactory ConfigurationValidatorFactory AttributeValidatorFactory ValidationAttributeValidatorFactory	ValidatorFactory

Note

This table includes the task-specific objects in some blocks that you can create directly in your code in the traditional way using the new operator. For example, you can create individual validators from the Validation Application Block, or log entries from the Logging Application Block. We show how to do this in the examples for each application block chapter.

To use the features of an application block, all you need to do is create an instance of the appropriate object, facade, or factory listed in the table above and then call its methods. The behavior of the block is controlled by the configuration you specified, and often you can carry out tasks such as exception handling and logging with just a single line of code. Even tasks such as accessing data or validating instances of your custom types require only a few lines of simple code. So, let's look at how you create instances of the Enterprise Library objects you want to use.

Creating Instances of Enterprise Library Types

In this release of Enterprise Library, the recommended approach to creating instances of Enterprise Library objects is to use the programmatic approach and instantiate the objects directly. You may decide to store some configuration information externally (such as in a custom configuration section or in the Azure service settings) and use this information when you create the Enterprise Library objects programmatically. In this way, you can expose just those settings that you want to make available, rather than all the settings, which is the case when you use declarative configuration. Each block is self-contained and does not have dependencies on other blocks for basic operations. Typically, creating an instance is a simple operation that takes only a few lines of code.

Beth says:

You could use Unity, or another dependency injection container, to manage your Enterprise Library objects and their dependencies with the corresponding lifecycles. Unlike in the previous release, it is now your responsibility to register and resolve the types you plan to use. Unity 3 now supports the registration by convention to make it easier to do so. See the Dependency Injection with Unity guide for more info.

The chapters that cover the individual blocks provide the details of how to create the objects relevant to that block. For now, you’ll see an example from the Data Access Application Block that illustrates the core principles. Typically, you start by creating a factory object and then use that factory to construct an instance of the required type.

The following code sample first creates a DatabaseProviderFactory instance and then use two different methods to create Database objects.

DatabaseProviderFactory factory = new DatabaseProviderFactory();
 
Database defaultDB = factory.CreateDefault();
 
Database namedDB = factory.Create("ExampleDatabase");

The DatabaseProviderFactory class provides several overloaded constructors that enable you to specify from where the factory should obtain the configuration data that it needs. In the case of the Data Access Application Block, the key configuration data is the connection strings for the databases you are using in your application.

The Example Applications

To help you understand how you can use Enterprise Library and each of the seven application blocks covered in this guide, we provide a series of simple example applications that you can run and examine. Each is a console-based application and, in most cases, all of the relevant code that uses Enterprise Library is found within a series of routines in the Program.cs file. This makes it easy to see how the different blocks work, and what you can achieve with each one.

The examples use the simplest approach for creating the Enterprise Library objects they require (in most cases using a factory class or instantiating the required objects directly), most define the configuration information programmatically but for reference some also contain equivalent declarative configuration in their configuration files. Each of the options in the examples exercises specific features of the relevant block and displays the results. You can open the solutions for these examples in Visual Studio, or just run the executable file in the bin\debug folder and view the source files in a text editor if you prefer.

To obtain the example applications, go to https://go.microsoft.com/fwlink/p/?LinkID=304210.

Summary

This brief introduction to Enterprise Library will help you to get started if you are not familiar with its capabilities and the basics of using it in applications. This chapter described what Enterprise Library is, where you can get it, and how it can make it much easier to manage your crosscutting concerns. This book concentrates on the application blocks in Enterprise Library that "do stuff" (as opposed to those that "wire up stuff"). The blocks we concentrate on in this book include the Data Access, Exception Handling, Transient Fault Handling, Semantic Logging, Logging, and Validation Application Blocks.

The aim of this chapter was also to help you get started with Enterprise Library by explaining how you deploy and reference the assemblies it contains, how you configure your applications to use Enterprise Library, how you instantiate Enterprise Library objects, and the example applications we provide. Some of the more advanced features and configuration options were omitted so that you may concentrate on the fundamental requirements. However, the Enterprise Library contains substantial reference documentation, samples, a reference implementation, and other resources that will guide you as you explore these more advanced features.

More Information

All links in this book are accessible from the book's online bibliography on MSDN at https://aka.ms/el6biblio.

If you want to know more about how you can use Unity and the Policy Injection Application Block, check out the Dependency Injection with Unity guide. This guide is also available on MSDN: Developer's Guide to Dependency Injection Using Unity.

Many scenarios supported by these blocks are now better supported by the .NET platform. Our deprecation philosophy is outlined in this post by the Librarian. The V6 project was focused on ensuring Enterprise Library’s close alignment to the current platform (.NET framework 4.5) with a goal of reducing Enterprise Library’s footprint by leveraging platform capabilities and improvements. For more details, see the Migration Guide.

You can download the Nucleus Research 2009 Report on Microsoft patterns & practices, which reviews the key components, benefits, and includes direct feedback from software architects and developers who have adopted patterns & practices deliverables in their projects and products from https://www.microsoft.com/en-us/download/confirmation.aspx?id=11522 .

For more information about the topics covered in this chapter, see the Enterprise Library Reference Documentation.

From the perspective of Enterprise Library, the great advantage of NuGet is that it automatically adds everything that you need to use a block (including any dependencies) to your project in one, easy step. If you’ve not used NuGet before, you can find out more at "Welcome to NuGet Docs."

For more information about side-by-side operation and other deployment issues, see the Enterprise Library Reference Documentation.

For more information about these legacy approaches, you should read the reference documentation and the Developer’s Guide for Enterprise Library 5.0.

Unity 3 now supports the registration by convention to make it easier to do so. See the Dependency Injection with Unity guide for more info.

General Links:

• There are resources to help if you're getting started with Enterprise Library, and there's help for existing users as well (such as the breaking changes and migration information for previous versions) available on the Enterprise Library Community Site at https://www.codeplex.com/entlib/.
• For more details about the Enterprise Library Application Blocks, see the Enterprise Library Reference Documentation and the Enterprise Library 6 Class Library.
• You can download and work through the Hands-On Labs for Enterprise Library, which are available at https://aka.ms/el6hols.
• You can download the Enterprise Library binaries, source code, Reference Implementation, or QuickStarts from the Microsoft Download Center at https://go.microsoft.com/fwlink/p/?LinkID=290898.
• To help you understand how you can use Enterprise Library application blocks, we provide a series of simple example applications that you can run and examine. To obtain the example applications, go to https://go.microsoft.com/fwlink/p/?LinkID=304210.

Next Topic | Previous Topic | Home | Community