Implementing Policy Injection in ASP.NET Applications
2011-11-10 23:05
323 查看
http://www.codeguru.com/csharp/.net/article.php/c17807
Introduction
Policy Injection Block was introduced in Enterprise Library 3.0 and makes use of aspect oriented programming concepts to add, remove, and modify common cross cutting concerns in your ASP.NET applications such as logging, validation, caching, exception handling,
authorization, etc, without the need of recompiling the application's code. This article takes a quick tour of the policy injection block and aspect oriented programming concepts and discusses how the former can be implemented in ASP.NET applications to manage
cross cutting concerns efficiently.
Pre-requisites
To use Policy Injection Block with ASP.NET 4.0, you should have the following installed in your system:
Microsoft Visual Studio 2010 RC or higher
Microsoft Enterprise Library 3.0 or higher
You can download a copy of Microsoft Enterprise Library from this link: http://entlib.codeplex.com/
Aspect Oriented Programming - What's that all about?
What is aspect oriented programming?
AOP is a programming technique that you can use to implement cross cutting concerns in your application through the usage of policies to change the behavior of business objects and classes in your application.
Such policies can be used to define and manage these cross cutting concerns declaratively. Note that aspect oriented programming is a new programming paradigm--not actually a replacement of object oriented programming. An aspect is simply a functionality,
a feature or a cross cutting concern in an application. In essence, aspect oriented programming is a programming paradigm that compliments object oriented programming by allowing you to modify the static object model to design and implement a system that can
be adaptable so as to accommodate future changes.
(Note: An aspect is the implementation of a crosscutting concern. AOP:
aspect-oriented programming )
The Wikipedia states: "aspect-oriented programming (AOP) is a programming paradigm which isolates secondary or supporting functions from the main program's business logic. It aims to increase modularity by allowing the separation of cross-cutting concerns,
forming a basis for aspect-oriented software development." Reference: http://en.wikipedia.org/wiki/Aspect-oriented_programming.
The policy injection application block from Microsoft is one such AOP framework. Some other popular AOP frameworks include: Spring.NET and Castle Dynamic Proxy.
What are Core and Cross Cutting Concerns?
Before we proceed with our discussion on the policy injection block, let's have a quick tour of a few basic concepts. What are concerns? A concern is basically a feature or a task implemented in an application.
Tasks that are specific to the application are known as core concerns. You may think of tasks specific to an application like retrieving data from the database, performing some calculations or executing certain business rules as examples of core concerns
of an application. On the contrary, the tasks that are common in the same application or across applications are commonly known as cross-cutting concerns. Typical examples of cross cutting
concerns include: validation, logging, authorization, exception handling, transaction management and caching.
MSDN states: "concerns that implement the features of an object within the application, such as the business logic, are core concerns. Crosscutting concerns are the necessary tasks, features, or processes that are common across different objects--for example,
logging, authorization, validation, and instrumentation. The purpose of the policy injection application block is to separate the core concerns and crosscutting concerns." Reference:
http://msdn.microsoft.com/en-us/library/ff650508.aspx
The Policy Injection Block - What is it and Why is it Needed?
The policy injection block from Microsoft is a flexible, extensible and easy to use framework that helps you to create policies to manage cross cutting concerns in your application effectively. In essence, the policy injection block facilitates simplifying
and unifying the cross cutting concerns in your application and create policies to effectively manage them.
Why do we need the policy injection block anyway? Applications have a mix of core and cross cutting concerns. An application's business logic is an example of a core concern. Note that an application's business logic is contextual and hence cannot be reused
most of the time. Cross cutting concerns in an application are reusable components that can be used across other layers of the same application or other applications. A clear isolation and good management of the
core and cross cutting concerns of an application helps avoid duplicated and unmanageable code.
The policy injection block enables you to implement AOP functionality in your applications by intercepting method calls and then invoking handlers before and after those methods based on pre-defined configuration information. You can use the policy injection
block to:
Create handlers for each of the cross cutting concerns that your application will use
Define the conditions where each cross cutting concern would apply
Define and manage behaviour of each of the cross cutting concerns through configuration
The policy injection block includes a collection of the following:
Handlers
Attributes
Matching Rules
The Matching Rules are used to indicate the methods that need to be intercepted and the handlers are used to specify what should happen before or after a method interception occurs.
The policy injection block includes the following set of built-in matching rules that can be used to select the classes to which a handler pipeline would be associated:
AssemblyMatchingRule
CustomAttributeMatchingRule
MemberNameMatchingRule
MethodSignatureMatchingRule
NamespaceMatchingRule
ParameterTypeMatchingRule
PropertyMatchingRule
ReturnTypeMatchingRule
TagAttributeMatchingRule
TypeMatchingRule
Each policy can have one or more handlers. You have the following set of built-in handlers that you can use to the handler pipeline:
Authorization Handler
Caching Handler
Exception Handling Handler
Logging Handler
Performance Counters Handler
Validation Handler
The Policy configuration information can be stored in your application's configuration in the format shown in the code snippet below:
<policyInjection>
<policies>
<add name="Policy1">
<matchingRules>
<add name="MatchingRuleA" ... />
<add name="MatchingRuleB" ... />
</matchingRules>
<handlers>
<add name="HandlerA" ... />
<add name="HandlerB" ... />
</handlers>
</add>
<add name="Policy2">
<matchingRules>
<add name="MatchingRuleC" ... />
<add name="MatchingRuleD" ... />
</matchingRules>
<handlers>
<add name="HandlerC" ... />
<add name="HandlerD" ... />
</handlers>
</add>
</policies>
</policyInjection>
Using the Policy Injection Block
To use the policy injection block in your applications, follow these steps:
Open the Microsoft Visual Studio 2010 IDE
Create an ASP.NET Application with some basic code
Identify the objects in the application that need to be intercepted
Add the necessary references to the policy injection block and its dependent assemblies
Add the policy injection block settings in the app.config file
Create a policy to be used to use the policy injection block to apply the cross cutting concerns in the application
Create matching rules within the policies you defined
Now specify the handlers to be executed for the rules that match
The configuration details would be structured as shown in the code snippet below:
<policies>
<add name="Logging">
<matchingRules>
//Add the rules here
</matchingRules>
<handlers>
<add
//Add the handlers here
</add>
</handlers>
</add>
</policies>
Add the handlers to the handler pipeline
Lastly invoke Policy Injection in your code to manage the cross cutting concerns
Consider the following interface ICustomer that declares a method GetCustomerName.
public interface ICustomer
{
String GetCustomerName(string customerCode);
}
Now suppose when the GetCustomerName(String) method is called, we would intercept the call and log the information. To do this, we need to use TagMatching rule. This implies that we would need to add a tag to the GetCustomerName(String) method. The updates
ICustomer interface would now look like as shown below:
public interface ICustomer
{
[Tag("LogMethod")]
String GetCustomerName(String customerCode);
}
public class Customer : ICustomer
{
public String GetCustomerName(string customerCode)
{
//Code to return customer name based on customer code
}
}
The next step is to define a policy in the application's configuration file so that the call to the method having the [Tag("LogMethod")] is intercepted and the information logged using the Logging Application Block. Here's how the policy injection configuration
would now look like:
<policyInjection>
<policies>
<add name="Logging">
<matchingRules>
<add type="Microsoft.Practices.
EnterpriseLibrary.PolicyInjection.MatchingRules.
TagAttributeMatchingRule,
Microsoft.Practices.EnterpriseLibrary.PolicyInjection,
Version=2.9.9.2, Culture=neutral,
PublicKeyToken=b03f5f7f11d50a3a"
name="Tag Matching Rule"
match="LogMethod" ignoreCase="true" />
</matchingRules>
<handlers>
<add name="Logging Handler"
type="Microsoft.Practices.EnterpriseLibrary.
PolicyInjection.CallHandlers.LogCallHandler,
Microsoft.Practices.
EnterpriseLibrary.PolicyInjection.CallHandlers,
Version=2.9.9.2, Culture=neutral,
PublicKeyToken=b03f5f7f11d50a3a"
logBehavior="Before"
beforeMessage="Before" includeParameterValues="true"
includeCallTime="true" includeCallStack="false"
severity="Information">
<categories>
<add name="General" />
</categories>
</add>
</handlers>
</add>
</policies>
</policyInjection>
The following code snippet illustrates how the policy injection block can be used to instantiate the customer class and invoke its method:
ICustomer customer =
PolicyInjection.Create<Customer, ICustomer>();
customer.GetCustomerName("C001");
The call to this method would then be logged appropriately as defined in the logging provider of the logging application block.
Summary
The policy injection block allows you to declaratively define and manage the cross cutting concerns in your application. It allows you to specify the cross cutting concerns in an application in terms of policies. You can use the policy injection block to log
method invocations, cache results from a method, analyze the performance of a method, handle and log exceptions, validate method parameters, etc. This article provided the readers a head start to the concepts of Aspect Oriented Programming and policy injection
block and strategies to implement them in your ASP.NET applications. Happy reading!
Introduction
Policy Injection Block was introduced in Enterprise Library 3.0 and makes use of aspect oriented programming concepts to add, remove, and modify common cross cutting concerns in your ASP.NET applications such as logging, validation, caching, exception handling,
authorization, etc, without the need of recompiling the application's code. This article takes a quick tour of the policy injection block and aspect oriented programming concepts and discusses how the former can be implemented in ASP.NET applications to manage
cross cutting concerns efficiently.
Pre-requisites
To use Policy Injection Block with ASP.NET 4.0, you should have the following installed in your system:
Microsoft Visual Studio 2010 RC or higher
Microsoft Enterprise Library 3.0 or higher
You can download a copy of Microsoft Enterprise Library from this link: http://entlib.codeplex.com/
Aspect Oriented Programming - What's that all about?
What is aspect oriented programming?
AOP is a programming technique that you can use to implement cross cutting concerns in your application through the usage of policies to change the behavior of business objects and classes in your application.
Such policies can be used to define and manage these cross cutting concerns declaratively. Note that aspect oriented programming is a new programming paradigm--not actually a replacement of object oriented programming. An aspect is simply a functionality,
a feature or a cross cutting concern in an application. In essence, aspect oriented programming is a programming paradigm that compliments object oriented programming by allowing you to modify the static object model to design and implement a system that can
be adaptable so as to accommodate future changes.
(Note: An aspect is the implementation of a crosscutting concern. AOP:
aspect-oriented programming )
The Wikipedia states: "aspect-oriented programming (AOP) is a programming paradigm which isolates secondary or supporting functions from the main program's business logic. It aims to increase modularity by allowing the separation of cross-cutting concerns,
forming a basis for aspect-oriented software development." Reference: http://en.wikipedia.org/wiki/Aspect-oriented_programming.
The policy injection application block from Microsoft is one such AOP framework. Some other popular AOP frameworks include: Spring.NET and Castle Dynamic Proxy.
What are Core and Cross Cutting Concerns?
Before we proceed with our discussion on the policy injection block, let's have a quick tour of a few basic concepts. What are concerns? A concern is basically a feature or a task implemented in an application.
Tasks that are specific to the application are known as core concerns. You may think of tasks specific to an application like retrieving data from the database, performing some calculations or executing certain business rules as examples of core concerns
of an application. On the contrary, the tasks that are common in the same application or across applications are commonly known as cross-cutting concerns. Typical examples of cross cutting
concerns include: validation, logging, authorization, exception handling, transaction management and caching.
MSDN states: "concerns that implement the features of an object within the application, such as the business logic, are core concerns. Crosscutting concerns are the necessary tasks, features, or processes that are common across different objects--for example,
logging, authorization, validation, and instrumentation. The purpose of the policy injection application block is to separate the core concerns and crosscutting concerns." Reference:
http://msdn.microsoft.com/en-us/library/ff650508.aspx
The Policy Injection Block - What is it and Why is it Needed?
The policy injection block from Microsoft is a flexible, extensible and easy to use framework that helps you to create policies to manage cross cutting concerns in your application effectively. In essence, the policy injection block facilitates simplifying
and unifying the cross cutting concerns in your application and create policies to effectively manage them.
Why do we need the policy injection block anyway? Applications have a mix of core and cross cutting concerns. An application's business logic is an example of a core concern. Note that an application's business logic is contextual and hence cannot be reused
most of the time. Cross cutting concerns in an application are reusable components that can be used across other layers of the same application or other applications. A clear isolation and good management of the
core and cross cutting concerns of an application helps avoid duplicated and unmanageable code.
The policy injection block enables you to implement AOP functionality in your applications by intercepting method calls and then invoking handlers before and after those methods based on pre-defined configuration information. You can use the policy injection
block to:
Create handlers for each of the cross cutting concerns that your application will use
Define the conditions where each cross cutting concern would apply
Define and manage behaviour of each of the cross cutting concerns through configuration
The policy injection block includes a collection of the following:
Handlers
Attributes
Matching Rules
The Matching Rules are used to indicate the methods that need to be intercepted and the handlers are used to specify what should happen before or after a method interception occurs.
The policy injection block includes the following set of built-in matching rules that can be used to select the classes to which a handler pipeline would be associated:
AssemblyMatchingRule
CustomAttributeMatchingRule
MemberNameMatchingRule
MethodSignatureMatchingRule
NamespaceMatchingRule
ParameterTypeMatchingRule
PropertyMatchingRule
ReturnTypeMatchingRule
TagAttributeMatchingRule
TypeMatchingRule
Each policy can have one or more handlers. You have the following set of built-in handlers that you can use to the handler pipeline:
Authorization Handler
Caching Handler
Exception Handling Handler
Logging Handler
Performance Counters Handler
Validation Handler
The Policy configuration information can be stored in your application's configuration in the format shown in the code snippet below:
<policyInjection>
<policies>
<add name="Policy1">
<matchingRules>
<add name="MatchingRuleA" ... />
<add name="MatchingRuleB" ... />
</matchingRules>
<handlers>
<add name="HandlerA" ... />
<add name="HandlerB" ... />
</handlers>
</add>
<add name="Policy2">
<matchingRules>
<add name="MatchingRuleC" ... />
<add name="MatchingRuleD" ... />
</matchingRules>
<handlers>
<add name="HandlerC" ... />
<add name="HandlerD" ... />
</handlers>
</add>
</policies>
</policyInjection>
Using the Policy Injection Block
To use the policy injection block in your applications, follow these steps:
Open the Microsoft Visual Studio 2010 IDE
Create an ASP.NET Application with some basic code
Identify the objects in the application that need to be intercepted
Add the necessary references to the policy injection block and its dependent assemblies
Add the policy injection block settings in the app.config file
Create a policy to be used to use the policy injection block to apply the cross cutting concerns in the application
Create matching rules within the policies you defined
Now specify the handlers to be executed for the rules that match
The configuration details would be structured as shown in the code snippet below:
<policies>
<add name="Logging">
<matchingRules>
//Add the rules here
</matchingRules>
<handlers>
<add
//Add the handlers here
</add>
</handlers>
</add>
</policies>
Add the handlers to the handler pipeline
Lastly invoke Policy Injection in your code to manage the cross cutting concerns
Consider the following interface ICustomer that declares a method GetCustomerName.
public interface ICustomer
{
String GetCustomerName(string customerCode);
}
Now suppose when the GetCustomerName(String) method is called, we would intercept the call and log the information. To do this, we need to use TagMatching rule. This implies that we would need to add a tag to the GetCustomerName(String) method. The updates
ICustomer interface would now look like as shown below:
public interface ICustomer
{
[Tag("LogMethod")]
String GetCustomerName(String customerCode);
}
public class Customer : ICustomer
{
public String GetCustomerName(string customerCode)
{
//Code to return customer name based on customer code
}
}
The next step is to define a policy in the application's configuration file so that the call to the method having the [Tag("LogMethod")] is intercepted and the information logged using the Logging Application Block. Here's how the policy injection configuration
would now look like:
<policyInjection>
<policies>
<add name="Logging">
<matchingRules>
<add type="Microsoft.Practices.
EnterpriseLibrary.PolicyInjection.MatchingRules.
TagAttributeMatchingRule,
Microsoft.Practices.EnterpriseLibrary.PolicyInjection,
Version=2.9.9.2, Culture=neutral,
PublicKeyToken=b03f5f7f11d50a3a"
name="Tag Matching Rule"
match="LogMethod" ignoreCase="true" />
</matchingRules>
<handlers>
<add name="Logging Handler"
type="Microsoft.Practices.EnterpriseLibrary.
PolicyInjection.CallHandlers.LogCallHandler,
Microsoft.Practices.
EnterpriseLibrary.PolicyInjection.CallHandlers,
Version=2.9.9.2, Culture=neutral,
PublicKeyToken=b03f5f7f11d50a3a"
logBehavior="Before"
beforeMessage="Before" includeParameterValues="true"
includeCallTime="true" includeCallStack="false"
severity="Information">
<categories>
<add name="General" />
</categories>
</add>
</handlers>
</add>
</policies>
</policyInjection>
The following code snippet illustrates how the policy injection block can be used to instantiate the customer class and invoke its method:
ICustomer customer =
PolicyInjection.Create<Customer, ICustomer>();
customer.GetCustomerName("C001");
The call to this method would then be logged appropriately as defined in the logging provider of the logging application block.
Summary
The policy injection block allows you to declaratively define and manage the cross cutting concerns in your application. It allows you to specify the cross cutting concerns in an application in terms of policies. You can use the policy injection block to log
method invocations, cache results from a method, analyze the performance of a method, handle and log exceptions, validate method parameters, etc. This article provided the readers a head start to the concepts of Aspect Oriented Programming and policy injection
block and strategies to implement them in your ASP.NET applications. Happy reading!
相关文章推荐
- Implementing HTTPS Everywhere in ASP.Net MVC application.
- Breaking Changes for ASP.NET 2.0 applications running in Integrated mode on IIS 7.0
- Debug JavaScript/VBScript in ASP.NET Applications
- [GOOD Article] How to disable web.config Inheritance for Child Applications in Subfolders in ASP.NET?
- Understanding Pagination in ASP.NET 1.x Mobile Applications
- Implementing a favourite icon (favicon) in ASP.NET
- Single sign-on across multiple applications in ASP.NET(Asp.Net跨应用单点登录[转自CodeProject])
- Implementing the Repository and Unit of Work Patterns in an ASP.NET MVC Application (9 of 10)
- Running ASP.NET Applications in Debian and Ubuntu using XSP and Mono
- Implementing HTTP Handlers in ASP.NET
- Dependency Injection in ASP.NET MVC
- Scott doesn't use datasets in ASP .NET Applications
- Dependency Injection in ASP.NET Web API 2 (在web api2 中使用依赖注入)
- Unhandled exceptions cause ASP.NET-based applications to unexpectedly quit in the .NET Framework 2.0
- Action Filtering in ASP.NET MVC Applications
- Encrypting Configuration Information in ASP.NET 2.0 Applications
- Implementing Basic Authentication in ASP.NET 2.0
- Tuning Up ADO.NET Connection Pooling in ASP.NET Applications
- Best pactices in developing ASP.NET applications
- Running ASP.NET 5 applications in Linux Containers with Docker