WCF服务中的一个通用类

WCF的异步服务编程，必须创建一个IAsyncResult的自定义实现：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

class UniversalAsyncResult : IAsyncResult, IDisposable
{
    // 存储回调和状态

    AsyncCallback callback;
    object state;

    // For the implementation of IAsyncResult.AsyncCallback

    volatile ManualResetEvent waithandle;

    // 线程同步对象

    object guard = new object();

    // 完成标志，设置为true就表示完成

    volatile bool complete;

    public UniversalAsyncResult(AsyncCallback callback, object state)
    {
        this.callback = callback;
        this.state = state;
    }

    public void Complete()
    {
        // flag as complete

        complete = true;

        // signal the event object

        if (waithandle != null)
        {
            waithandle.Set();
        }

        // Fire callback to signal the call is complete

        if (callback != null)
        {
            callback(this);
        }
    }

    #region IAsyncResult Members
    public object AsyncState
    {
        get { return state; }
    }

    // Use double check locking for efficient lazy allocation of the event object

    public WaitHandle AsyncWaitHandle
    {
        get
        {
            if (waithandle == null)
            {
                lock (guard)
                {
                    if (waithandle == null)
                    {
                        waithandle = new ManualResetEvent(false);

                        if (complete)
                        {
                            waithandle.Set();
                        }
                    }
                }
            }
            return waithandle;
        }
    }

    public bool CompletedSynchronously
    {
        get { return false; }
    }

    public bool IsCompleted
    {
        get { return complete; }
    }
    #endregion

    #region IDisposable Members

    public void Dispose()
    {
        if (waithandle != null)
        {
            waithandle.Close();
        }
    }
    #endregion
}

应用==========>

 

服务端：

using System;
using System.Collections.Generic;
using System.Text;
using System.ServiceModel;
using System.Data.SqlClient;
using System.Data;
using System.Threading;

namespace Service
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServiceHost host = new ServiceHost(typeof(Service)))
            {
                host.Open();

                Console.WriteLine("Async Service Ready ...");
                Console.ReadLine();
            }
        }
    }

    [ServiceContract]
    interface IGetData
    {
        // This pair of methods are bound together as WCF is aware of the async pattern

        [OperationContract(AsyncPattern=true)]
        IAsyncResult BeginGetData(AsyncCallback cb, object state);
        string[] EndGetData(IAsyncResult iar);
    }

    class Service : IGetData
    {
        SqlCommand cmd;
        SqlConnection conn;
        DataAsyncResult dar;

        // This connection string sets up the connection for asynchronous process which is supported by SQL2005

        static readonly string CONN_STR = @"Server=.\sqlexpress; database=slowdb; integrated security=SSPI; Asynchronous Processing=true";

        // This is the async pattern begin method that is passed a callback from the WCF infrastructure

        public IAsyncResult BeginGetData(AsyncCallback cb, object state)
        {
            // Create own async result type call object to let WCF know when the call has completed and so

            // when it can call the EndGetData method

            dar = new DataAsyncResult(cb, state);

            // Create the connection annd command

            conn = new SqlConnection(CONN_STR);
            cmd = conn.CreateCommand();
            cmd.CommandText = "SlowSproc";
            cmd.CommandType = CommandType.StoredProcedure;

            conn.Open();

            // Process the query asynchronously

            // this will take place using IO completion ports

            // so a thread is not being used while the query is running

            cmd.BeginExecuteReader(Callback, null);

            // return the call object to the WCF infrastructure

            return dar;
        }

        // End method cleans up and sends back the results

        public string[] EndGetData(IAsyncResult iar)
        {
            dar.Dispose();
            return data.ToArray();
        }

        // Called when the async query completes

        void Callback( IAsyncResult iar )
        {
            List<string> results = new List<string>();

            // process the list of results

            using (SqlDataReader reader = cmd.EndExecuteReader(iar))
            {

                while( reader.Read() )
                {
                    results.Add((string)reader["val"]);
                }
            }

            // cache the results

            data = results;

            // clean up the connection which is no longer required

            conn.Dispose();

            // Tell the call object that the call is now complete

            dar.Complete();
        }

        List<string> data;
    }

 客户端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Client.ServiceReference;

namespace Client
{
    class Program
    {
        static void Main(string[] args)
        {
            GetDataClient proxy = new GetDataClient();

            string[] res = proxy.GetData();

            foreach (var item in res)
            {
                Console.WriteLine(item);
            }
        }
    }
}