Background

For the basic of how to create an AJAX enabled WCF service, please refer to MSDN: http://msdn.microsoft.com/en-us/library/bb924552.aspx.

For the basic of JSONP, please refer to: http://en.wikipedia.org/wiki/JSON#JSONP.

This article introduce how to make AJAX enabled WCF service support cross-domain request.

In the WCF & WF samples provided by Microsoft, there is already a “custom binding extension” implementation for JSONP support. But there is some limitation, the biggest limitation is it could not support both JSON & JSONP protocol for one AJAX enabled WCF service URL, and it requires each endpoint you want to support JSONP protocol be configured with the specific custom JSONP binding extension which increased configuration complexity & cost.

Here I introduce a more general “custom Http Module” implementation for cross-domain calling AJAX enabled WCF services.

At the beginning, firstly, please realize WCF does not support custom Http Modules by default, which means, by default, a WCF service request, even a webHttpBinding AJAX enabled WCF service request, doesn’t go through any custom Http Modules. To enable it, you need to set the aspNetCompatibilityEnabled property of serviceHostingEnvironment element to true like below:

And to enable a WCF service support custom Http Module, you also need to mark the AspNetCompatibilityRequirementsAttribute on the service contract like below:

JSONPModule

Since with the aspNetCompatibilityEnabled property set to true, an Http WCF service request goes through custom Http Modules, it is possible to write a custom Http Module to automatically convert any JSON response to JSONP response. And actually, since it will be so general, it could not only give JSONP support to WCF, but also give JSONP support to any existing JSON response services, such as Web services and Http handler services. The JSONPModule class below is part of NIntegrate framework (BSD license), but it has no dependency. So you could use it freely and independently.

JSONPModule.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;

namespace NIntegrate.Web
{
    public class JSONPModule : IHttpModule
    {
        private const string JSON_CONTENT_TYPE = "application/json";
        private const string JS_CONTENT_TYPE = "text/javascript";

        #region IHttpModule Members

        public void Dispose()
        {
        }

        public void Init(HttpApplication app)
        {
            app.ReleaseRequestState += OnReleaseRequestState;
        }

        #endregion

        public void OnReleaseRequestState(object sender, EventArgs e)
        {
            HttpApplication app = (HttpApplication)sender;
            HttpResponse response = app.Response;
            if (response.ContentType.ToLowerInvariant().Contains(JSON_CONTENT_TYPE)
                && !string.IsNullOrEmpty(app.Request.Params["jsoncallback"]))
            {
                response.ContentType = JS_CONTENT_TYPE;
                response.Filter = new JsonResponseFilter(response.Filter);
            }
        }
    }

    public class JsonResponseFilter : Stream
    {
        private readonly Stream _responseStream;
        private long _position;

        private bool _isContinueBuffer;

        public JsonResponseFilter(Stream responseStream)
        {
            _responseStream = responseStream;
        }

        public override bool CanRead { get { return true; } }

        public override bool CanSeek { get { return true; } }

        public override bool CanWrite { get { return true; } }

        public override long Length { get { return 0; } }

        public override long Position { get { return _position; } set { _position = value; } }

        public override void Write(byte[] buffer, int offset, int count)
        {
            string strBuffer = Encoding.UTF8.GetString(buffer, offset, count);
            strBuffer = AppendJsonpCallback(strBuffer, HttpContext.Current.Request);
            byte[] data = Encoding.UTF8.GetBytes(strBuffer);
            _responseStream.Write(data, 0, data.Length);
        }

        private string AppendJsonpCallback(string strBuffer, HttpRequest request)
        {
            string prefix = string.Empty;
            string suffix = string.Empty;

            if (!_isContinueBuffer)
            {
                strBuffer = RemovePrefixComments(strBuffer);

                if (strBuffer.StartsWith("{"))
                    prefix = request.Params["jsoncallback"] + "(";
            }
            if (strBuffer.EndsWith("}"))
            {
                suffix = ");";
            }
            _isContinueBuffer = true;
            return prefix + strBuffer + suffix;
        }

        private string RemovePrefixComments(string strBuffer)
        {
            var str = strBuffer.TrimStart();
            while (str.StartsWith("/*"))
            {
                var pos = str.IndexOf("*/", 2);
                if (pos <= 0)
                    break;
                str = str.Substring(pos + 2);
                str = str.TrimStart();
            }
            return str;
        }

        public override void Close()
        {
            _responseStream.Close();
        }

        public override void Flush()
        {
            _responseStream.Flush();
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            return _responseStream.Seek(offset, origin);
        }

        public override void SetLength(long length)
        {
            _responseStream.SetLength(length);
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            return _responseStream.Read(buffer, offset, count);
        }
    }
}

Sample

The sample in this chapter is a unit test of NIntegrate for the JSONPModule. Imagine we have an AJAX enabled WCF service – TestAjaxClientService.svc, which could be called by jQuery like below:

With the JSONPModule configured like below:

We can cross-domain call the TestAjaxClientService.svc like:

评论: 2　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

In this article, let’s practice applying LRU caching in an enterprise application for different business cases.

Background

Firstly, let’s assume we have a User table in database and there may be millions of rows in this table. LRU caching is only meaningful if the total data to be cached is huge, which means it is impossible to put all the data in memory at same time. For example, if the rows in User table are only thousands, we could consider cache everything, but if it is millions, it becomes unsuitable to cache everything, right?

Our target is to LRU cache the total huge user data in our enterprise application for different business cases.

Practice

Case 1 Users are accessed by ID only, it is a single server application(APP1) and the only way to change the user data is through this application.

In this case, since “the only way to change the user data is through this application”, items cached could always be kept active in the cache, but each time a user is modified, and the item is in the cache, it should be set expired.

So the most suitable implementation for this case is to use in an in-process LRU hash table in APP1 for caching users. The LruDictionary class is a thread safe LRU hash table implementation provided by NIntegrate.

Case 2 Based on Case 1, additionally, user data may be read by another applications(APP2) deployed on a different server, but the access from APP2 is not very often.

In this case, since “the access from APP2 is not very often”, we could consider simply expose the LruDictionary instance for caching users in Case 1 as a WCF service which is still be deployed in APP1. This service should contain necessary operation methods for get/set the user cache.

Case 3 Based on Case 1, additionally, user data may be read by another applications(APP2) deployed on a different farm consisted of 3 servers, and the access from APP2 is much more often than from APP1 itself.

In this case, since “the access from APP2 is much more often”, still keep the LRU hash table implementation in APP1 becomes not reasonable. Because the load pressure from APP2 may kill the APP1 server.

So we should consider introduce some distributed hash table implementation such as memcached.

Case 4 Users are accessed by ID only, it is a single server application(APP1), but user data in the table could be modified by out-of-our-control applications.

Case 1-3 all could ensure “the only way to change the user data is through APP1”, that is a required condition for keeping cached users always be updated and consistent with data in database. But in this case, since “user data in the table could be modified by out-of-our-control applications”, it becomes impossible to keep “cached users always be updated and consistent with data in database”.

So if your business still require this, you have to choose not to do any caching for user data. Or, if data inconsistent for short time could be tolerated, you could consider using a LRU hash table supporting “item expire time”, which could automatically expire items when the expire time elapsed. The LruItemCache class is a thread safe LRU hash table implementation provided by NIntegrate which supports “item expire time” and more other features.

Case 5 Based on Case 1, additionally, users depend on its parent department. If a department is modified, all its child users in cache should be removed.

In this case, compared to case 1, we need a LRU hash table supporting “dependency based item expiration”. The LruDependingDictionary class is an extended version of LruDictionary provided in NIntegrate, which supports “dependency based item expiration”, the LruItemCache class provided by NIntegrate could also has this ability.

Case 6 Same to Case 5 except that users are accessed not only by ID, but also by unique user name, or user email address.

In this case, compared to case 5, because the hash table hashes items by the key value, for one hash table, if we choose ID as key, user name, user email could not be the key, which means the cache using ID as key could not benefit user name or user email based user data access.

To support this case, if you use 3 hash tables, each one use ID, user name or user email as key, the problem is there may be duplicated data cached in memory. A better solution is use a LRU hash table supporting indexing, which means for each user, there is still only one copy cached in memory, but cached items could be accessed through different indexes (indexed by different keys). The LruItemCache class provided by NIntegrate just implements this, it is not only a thread safe LRU hash table, but also supports “item expire time”, “dependency based item expiration” and multiple indexes for cached items.

评论: 9　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

Background

Caching is an very important topic in enterprise-level multi-tier application, especially for web application. A general rule for applying caching is you should consider do necessary caching at each tier of your application if possible. The other basic rule for applying caching is the closer the cache is near the user, the cheaper the cost to implement it is. For example, to implement browser side caching is much cheaper than at server side.

For a B/S application, from client to server side, possible tiers to implement caching include:

• Browser: local sandbox cache, memory cache
• Network Router: CDN
• Web Server: HTTP output cache, memory cache, distributed cache
• Application Server: memory cache, distributed cache
• Database Server: memory cache, file system cache

The Cache-Control HTTP Headers‎ standardizes the cache policy from browser, to network router and to Web server. Different Web browsers implement their internal caching according to the standard Web protocols.

CDN helps us cache and distribute content through Network routers between browsers and Web servers automatically.

Modern database systems could manage the caching of database server well enough by themselves.

So the only places need additional implementation for caching are in our application code, for a B/S application it may include:

• Browser side code (scripts, Flash/Silverlight, Java Applet/MS ActiveX/Smart Client, etc)
• Application code
• Database query code

I don’t want to talk much about caching in browser side code and database query code, because browser side caching more means how many memory you want the browser to occupy at client machine and there are no “thread synchronization” problems to be considered; and database side caching has its own guideline according to the database query language standards and different database system implementation.

So what left, worth to be discussed more is the caching in main application code. For a .NET C# application, this should mean the C# code to be compiled into executables to be deployed onto different tier servers. To be simple for discussion, let’s make our discussion below focus on .NET C# application only.

Caching in Application Code

1. Output Cache

The word “output cache” seems be invented by Microsoft together with ASP.NET. But its principle is simple. It caches the entire HTTP response message by a key which consists of a specified set of fields in a HTTP request. Since with output cache, a HTTP request could get the response message without further execution if the key exists in the output cache active key list, the performance of the Web server could be improved a lot. Especially, from II6, page level output cache could be dealt at IIS instead of at the ASP.NET ISAPI, there for, the performance is even much better than before.

So, as a general rule, for any request, if the response is possible to be reused to some extent, you should consider use output cache. But before use it, according to the “the closer the cheaper” rule, you should consider apply caching at “closer” places than Web server first. For example, practically, if possible, pay for CDN to extend the benefit of output cache out of your Web server to 3rd party CDN servers.

2. ASP.NET Cache Class and EntLib Caching Application Block

Behind the output cache, is the caching for application data. ASP.NET provides the Caching class, and similarly, the EntLib provides the caching application block. Each of the Cache class implements not only a thread safe hash table, but also common cache expiration policies. But so far, there are still not build-in cache replacement algorithms, such as FIFO & LRU, which are required by most real enterprise application. That’s why I  implements a set of cache classes with LRU algorithms in NIntegrate. And either of the Cache classes is still in-process caching only, which means, in a load-balanced farm, the application data cached in Cache instances may exists duplicated in each of the server in the farm.

3. Caching Service & Distributed Hash Table

If you want to shared cached data among processes and even among servers, you need shared caching service in separate process or distributed hash table.

A caching service is a service wrapping a hash table executing in a separate process, but store shared data among different processes on the same server. For example, I could implement it as a namedpipe binding based WCF service, exposing methods for operating an internal hash table, which stores shared application data of 3 ASP.NET application deployed on the same Web server.

Furthermore, a distributed hash table is more like a caching service be deployed on a separate server or even farm, which stores shared application data of different applications deployed on different servers and farms. The biggest benefit of distributed hash table is the cached data is not duplicated in different server, so you could expire cached data centrally. But you should realize that the performance of a distributed hash table is worse than a caching service deployed on the same server of an application, and of course far worse than in-process caching. But in practice, because in most cases, the performance bottle neck of enterprise applications is database server, and compare to querying database, the performance of distributed hash table is still much faster and  it could be scale-out easier than database, so distributed hash table could still benefit a lot on performance and is a indispensable part of enterprise applications.

评论: 1　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

E-Appointments is a Microsoft ASAP (Aspiring Software Architects Program) Case Study Implementation using the latest .NET 3.0 Technologies and proven Microsoft patterns and practices like Software Factories and Enterprise Library.

In this article, I’m going to enhance this application using NIntegrate, to demonstrate how to enhance WCF configuration management and how to make a WCF based distributed application support dynamic query easier and more maintainable in real enterprise distributed application. 

For details, please visit: http://www.cnblogs.com/teddyma/articles/1669960.html

评论: 2　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

Project Site:

http://nintegrate.com

Download:

Download from SVN

Download from Google Code

Download from CodePlex

评论: 2　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

NIntegrate is open source .NET enterprise SOA framework. It provides several reusable SOA components to solve specific enterprise SOA problems. Different from some other one-in-one SOA solution, NIntegrate is designed to be easily integrated with your company’s application frameworks.

Problems NIntegrate solves:

Read the article for details:

.NET Enterprise SOA – NIntegrate Practice

http://www.cnblogs.com/teddyma/articles/1651126.html

评论: 18　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

Background

Lots of people declares they are using WCF in their “enterprise” distributed software development together with other SOA technologies, and even calls their software architecture WCF based. If you are one of them, could you please answer the questions below; or, if you plan to be one of them, ask yourself the questions below:

• How many WCF services are their in your enterprise architecture?
• How many sub-systems and databases?
• How many servers deploying or consuming WCF services?
• How many load-balanced server farms and application tiers related to WCF?
• How many deployment server environments (DEV, QA, Staging, Production, etc)?
• Are your servers and farms in different domains, with different connectivity and different network bandwidth?
• What are your auto-build, test and release processes for WCF services?
• How do you deal with the WCF service configuration difference for different deployment server environments?
• How often are your WCF service configuration changed?
• How do you maintain your WCF service configuration changes?
• Where are your WCF service configuration saved?

The goal to ask the questions above is to lead you thinking & agree:

• The management of WCF services in enterprise distributed software development is not an easy stuff.
• To put WCF service configuration in your application configuration files is a nightmare for enterprise distributed software development.
• For enterprise distributed software development involving WCF service, an “enterprise framework” integrating consistent centralized WCF service configuration management is highly necessary.

Let me give a definition for “enterprise framework” discussed in this text: a set of shared software development components, and related configuration persistence and development & management process for all the distributed application development in enterprise.

Give you an example of “enterprise framework” in my company, even before using WCF, we already have a set of shared software components (VJ++/VB/DotNet COM DLLs for Non-DotNet applications; and DotNet DLLs for all DotNet applications), and a centralized database based configuration store for all the application app settings, connection strings, Web Service URLs and dependency injected object factory. We also have related development, maintain and release process for both the software components and the data in the configuration store.

Since you agree (I assumes) about the “the goal to ask the questions” above, when beginning to widely use WCF in our enterprise application development, you could imagine, we try to integrate WCF service configuration into our enterprise framework.

Articles I posted before already shows the possibility to centralize and programmatically configure all WCF service configuration. The rest of this text will introduce the summary of how we integrate WCF service configuration into our enterprise framework, and show you how to easily integrate WCF service configuration into other frameworks on the top of NIntegrate – an open source DotNet integration framework.

How We Integrate WCF Configuration into Our Enterprise Framework

I don’t want to expose any confidential information of my company, the purpose of this chapter is only to show you the benefits we get from the solution and give you more confidence to adopt a similar solution.

• Since we put all the configuration for applications in centralized database even before using WCF, the most suitable place to save all WCF configuration is the same database. And because our existing configuration are grouped by servers, load-balanced server farms and different applications, when extending the database to support WCF configuration, we easily get the ability to reuse WCF configuration at application, server or even farm scope for contracts, addresses, bindings, behaviors, security, etc.
• Since we put all the configuration in database instead of application configuration files, our applications could have very light application configuration files, and even no application files. This makes the auto-build & deployment of our application on different deployment server environment be super easy - no code change required for release packages on different server environments.
• To read configuration from database for publishing & consuming WCF services, we created some shared components (DotNet components only) to our development framework library, including custom ServiceHost Factory for hosting services and custom ChannelFactory for consuming services. For non-DotNet applications, they could also consume WCF services through Web Service binding or through DotNet COM wrappers (for windows apps only).
• The shared components not only read & cache WCF configuration from database, but also automatically refresh the cache in memory through background threads according to specified refresh policy, so it is easy to change WCF configuration at runtime, ex., disable/enable services or endpoints, change bindings, addresses or other settings, apply consistent health monitor, performance trace, error handling & logging, etc, through custom behaviors or other extension APIs of WCF.

Integrate WCF Configuration into a Dummy Enterprise Framework on the Top of NIntegrate

To demonstrate how to integrate WCF configuration into an enterprise framework, I’ll introduce a dummy enterprise framework in this chapter.

The attached picture is the class diagram of dummy enterprise framework integrated with NIntegrate:

Before integrated with NIntegrate, all the classes and methods containing the word ‘Wcf’ does not exist. The Dummy framework provides abilities to create class instances dependency injected, and get application variables & connection strings centrally, which are very common functions an enterprise framework may provide.

To use the DummyFramework, easily call DummyFrameworkConfigurationManager.GetConfiguration() to get an instance of DummyFrameworkConfiguration, and use it to construct a DummyFramework instance. Then you can call methods on DummyFramework.

On the top of NIntegrate, we could easily give the WCF configuration & custom persistence ability to the dummy framework.

To consume a WCF service, call the CreateWcfChannel<T>() method on DummyFramework, inside which reads WCF client endpoint configuration from DummyFrameworkConfiguration, which internally could load the configuration from anywhere rather than only in application configuration file (The returning instance is WcfClientEndpoint class, which is a serializable WCF DataContract defined in NIntegrate). The CreateWcfChannel<T>() method calls WcfChannelFactoryFactory.CreateChannelFactory<TChannel>() method, which is defined in NIntegrate, creates the ChannelFactory, cache it and returns an instance of WcfChannelWrapper class (also defined in NIntegrate), which implements the best practice for disposing a WCF channel instance.

Sample code as below:

    var df = new DummyFramework(DummyFrameworkConfiguationManager.GetConfiguration());
    using (var wrapper = df.CreateWcfChannel<IDummyService>())
    {
        Response.Write(wrapper.Channel.SayHello());
    }

To publish a WcfService, create the DummyWcfServiceHostFactory class, and set the Factory property of a .svc file as below:

<%@ ServiceHost Service="DummyEnterpriseService.Implementation.DummyService"
    Factory="DummyEnterpriseFramework.DummyWcfServiceHostFactory" %>

The DummyWcfServiceHostFactory class inherits the WcfServiceHostFactory class defined in NIntegrate, and overrides the LoadServiceConfiguration() method to load configuration from anywhere expected (The returning instance is WcfService class, which is a serializable Wcf DataContract defined in NIntegrate).

Attached the source code of the sample DummyEnterpriseFrameworkIntegration:

DummyEnterpriseFrameworkIntegration.zip

Original by Teddy's Knowledge Base, All rights reserved.

First Publish: http://www.cnblogs.com/teddyma/archive/2009/08/28/1556076.html

//The end

评论: 15　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

评论: 5　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

有意者请点击下面的链接给我留言：

http://www.cnblogs.com/teddyma/contact.aspx?id=1

评论: 6　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

AdoNet vs LinqToSql vs NIntegrateQuery查询性能测试.

先上测试结果:

AdoNetTest: 267ms
AdoNetCachedCommandTest: 182ms
LinqToSqlTest: 3191ms
LinqToSqlCompiledQueryTest: 386ms
NIntegrateQueryTest: 266ms

下载

下载测试数据库：AdventureWorksLT2008

下载测试代码：NIntegrateQueryPerformanceComparison.zip

代码导航

AdoNetTest.cs
 1    class AdoNetTest : ITest
 2    {
 3        private static readonly string _connString = ConfigurationManager.ConnectionStrings[Constants.ConnectingStringName].ConnectionString;
 4
 5        private void DoExecute(int repeatTime)
 6        {
 7            for (var i = 1; i <= repeatTime; ++i)
 8            {
 9                using (var conn = new SqlConnection(_connString))
10                {
11                    if (conn.State != System.Data.ConnectionState.Open)
12                        conn.Open();
13                    var cmd = new SqlCommand(
14                        "SELECT TOP 1 ProductID,Name FROM SalesLT.Product WHERE ProductID = @ProductID", conn)
15                                  {CommandType = System.Data.CommandType.Text};
16                    cmd.Parameters.Add(new SqlParameter("@ProductID", i));
17                    using (var reader = cmd.ExecuteReader())
18                    {
19                        if (reader.Read())
20                        {
21                            var product = new Product
22                                              {
23                                                  ProductID = ((int) reader["ProductID"]),
24                                                  Name = ((string) reader["Name"])
25                                              };
26                        }
27                    }
28                }
29            }
30        }
31
32        ITest Members#region ITest Members
33
34        public void Prepare()
35        {
36            DoExecute(1);
37        }
38
39        public void Execute()
40        {
41            DoExecute(Constants.RepeatTime);
42        }
43
44        #endregion
45    }
46

AdoNetCachedCommandTest.cs
 1    class AdoNetCachedCommandTest : ITest
 2    {
 3        private static readonly string _connString = ConfigurationManager.ConnectionStrings[Constants.ConnectingStringName].ConnectionString;
 4        private static SqlCommand _cachedCommand;
 5        private static SqlCommand GetCachedCommand()
 6        {
 7            if (_cachedCommand == null)
 8            {
 9                _cachedCommand = new SqlCommand(
10                    "SELECT TOP 1 ProductID,Name FROM SalesLT.Product WHERE ProductID = @ProductID")
11                                     {CommandType = System.Data.CommandType.Text};
12                _cachedCommand.Parameters.Add(new SqlParameter("@ProductID", 0));
13            }
14
15            return _cachedCommand.Clone();
16        }
17
18        private void DoExecute(int repeatTime)
19        {
20            for (var i = 1; i <= repeatTime; ++i)
21            {
22                using (var conn = new SqlConnection(_connString))
23                {
24                    if (conn.State != System.Data.ConnectionState.Open)
25                        conn.Open();
26                    var cmd = GetCachedCommand();
27                    cmd.Parameters[0].Value = i;
28                    cmd.Connection = conn;
29
30                    using (var reader = cmd.ExecuteReader())
31                    {
32                        if (reader.Read())
33                        {
34                            var product = new Product
35                                              {
36                                                  ProductID = ((int) reader["ProductID"]),
37                                                  Name = ((string) reader["Name"])
38                                              };
39                        }
40                    }
41                }
42            }
43        }
44
45        ITest Members#region ITest Members
46
47        public void Prepare()
48        {
49            DoExecute(1);
50        }
51
52        public void Execute()
53        {
54            DoExecute(Constants.RepeatTime);
55        }
56
57        #endregion
58    }
59

LinqToSqlTest.cs
 1    class LinqToSqlTest : ITest
 2    {
 3        private static readonly string _connString = ConfigurationManager.ConnectionStrings[Constants.ConnectingStringName].ConnectionString;
 4
 5        private void DoExecute(int repeatTime)
 6        {
 7            for (var i = 1; i <= repeatTime; ++i)
 8            {
 9                using (var conn = new SqlConnection(_connString))
10                {
11                    if (conn.State != System.Data.ConnectionState.Open)
12                        conn.Open();
13
14                    var ctx = new AdventureWorksDataContext(conn);
15                    var product = ctx.Products.SingleOrDefault(p => p.ProductID == i);
16                }
17            }
18        }
19
20        ITest Members#region ITest Members
21
22        public void Prepare()
23        {
24            DoExecute(1);
25        }
26
27        public void Execute()
28        {
29            DoExecute(Constants.RepeatTime);
30        }
31
32        #endregion
33    }
34

LinqToSqlCompiledQueryTest.cs
 1    class LinqToSqlCompiledQueryTest : ITest
 2    {
 3        private static readonly string _connString = ConfigurationManager.ConnectionStrings[Constants.ConnectingStringName].ConnectionString;
 4
 5        private void DoExecute(int repeatTime)
 6        {
 7            var query = CompiledQuery.Compile((AdventureWorksDataContext ctx, int index) 
 8                => ctx.Products.SingleOrDefault(p => p.ProductID == index));
 9
10            for (var i = 1; i <= repeatTime; ++i)
11            {
12                using (var conn = new SqlConnection(_connString))
13                {
14                    if (conn.State != System.Data.ConnectionState.Open)
15                        conn.Open();
16
17                    var ctx = new AdventureWorksDataContext(conn);
18                    var product = query(ctx, i);
19                }
20            }
21        }
22
23        ITest Members#region ITest Members
24
25        public void Prepare()
26        {
27            DoExecute(1);
28        }
29
30        public void Execute()
31        {
32            DoExecute(Constants.RepeatTime);
33        }
34
35        #endregion
36    }
37

NIntegrateQueryTest.cs
 1    class NIntegrateQueryTest : ITest
 2    {
 3        private static readonly string _connString = ConfigurationManager.ConnectionStrings[Constants.ConnectingStringName].ConnectionString;
 4
 5        private void DoExecute(int repeatTime)
 6        {
 7            for (var i = 1; i <= repeatTime; ++i)
 8            {
 9                var criteria = new ProductCriteria();
10                var cmd = new QueryCommandFactory(criteria.And(criteria.ProductID == i))
11                    .GetQueryCommand();
12                cmd.Parameters.Add(new SqlParameter("@ProductID", i));
13                cmd.Connection.Open();
14                using (var reader = cmd.ExecuteReader())
15                {
16                    if (reader.Read())
17                    {
18                        var product = new Product
19                                          {
20                                              ProductID = ((int) reader["ProductID"]),
21                                              Name = ((string) reader["Name"])
22                                          };
23                    }
24                    cmd.Connection.Close();
25                }
26            }
27        }
28
29        ITest Members#region ITest Members
30
31        public void Prepare()
32        {
33            DoExecute(1);
34        }
35
36        public void Execute()
37        {
38            DoExecute(Constants.RepeatTime);
39        }
40
41        #endregion
42    }
43

测试结果分析

1. 在不使用CompiledQuery的情况下，LinqToSql的性能比AdoNet差一个数量级，用百分比的话就是慢超过1000%；
2. 在缓存Command的情况下，AdoNet的查询性能可以提高约30%；
3. 在使用CompiledQuery的情况下，LinqToSql的查询性能比缓存Command的AdoNet下慢50%；
4. NIntegrqateQuery的查询性能和不带缓存的AdoNet查询性能相当，比LinqToSqlCompiledQuery快约40%;

* 如对测试结果有任何异议，欢迎根跟贴友好讨论。

什么是NIntegrateQuery？

1. NIntegrateQuery是Teddy最新开发的开源组件NIntegrate的一部分。
2. NIntegrate是一个企业级系统集成开发框架。它的核心设计思想是，提供一个基于数据库集中化管理WCF服务配置信息和应用程序配置信息的方案，从而使得基于WCF的企业级SOA系统集成真正成为可能。
3. NIntegrateQuery是一个类似Linq的强类型数据库查询语言。它的设计目标并不是ORM，也当然不是重新发明一个类似LinqToSql的轮子。它的设计目标是一个安全（完全防范SQL注入攻击）、高性能（参见测试结果），所有查询对象可以跨WCF、跨COM传递，并且支持动态查询条件、分页、排序的数据库查询语言。因为这个设计目标，它目前不支持，作为NIntegrate的一个组件，将来也没有计划支持类似LinqToSql提供的join、group by这样的查询。如果您要做这样的查询，标准的做法是先建一个View，再对View进行查询。
4. 对于比较频繁的查询操作，虽然NIntegrateQuery本身的查询性能是非常好的，但是，如果可能，还是建议尽可能使用存储过程。
5. 对于所有的写操作，虽然NIntegrateQuery提供了一个基于DataAdapter.Update的简单实现，但是，出于性能考虑，原则上，建议使用存储过程，当然，您也可以选择同时使用包括LinqToSql在内的任意其他ORM组件。

NIntegrateQuery支持的其它功能还包括：

1. 混合支持多数据库、不同类型数据库的查询（正式版本将至少支持：SQL Server, Oracle, DB2和MySql）。
2. 对不同的数据库，支持可扩展的，甚至是仅特定数据库支持的方法或语法。
3. NIntegrate中包括了基于NIntegrateQuery的通用WCF查询服务的定义和默认实现，以及基于NIntegrateQuery和通用WCF查询服务的ASP.NET DataSource控件，方便进行数据绑定。

后记

这篇文章写完第一遍发布之前点预览时Firefox崩溃了，结果所有内容在Live Writer里老老实实重写了一遍，我哭~~~。为了避免同样的悲剧，我强烈建议您，千万不要在没有在其他地方备份前，在Firefox里点击FreeTextBox这个Rich Editor的“Preview”按钮。我是32bit Window Server 2008 + Firefox 3.0。切忌、切忌~~

//我是结尾符

评论: 13　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· 网游3大美女高管仅剩刘伟(2010-03-19 23:59)
· 查理·米勒宣称将一口气公布20个Mac OS X漏洞(2010-03-19 23:55)
· Google投资的海底光缆建设完毕(2010-03-19 23:53)
· 微软2009年所获专利达苹果10倍(2010-03-19 23:50)
· 门户网站竞相掀起微博圈地运动(2010-03-19 22:26)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库