C# WCF RESTFul配置

服务端

服务端配置文件App.config

<configuration>
  <appSettings>
    <add key="aspnet:UseTaskFriendlySynchronizationContext" value="true"/>
  </appSettings>
  <system.web>
    <compilation debug="true"/>
  </system.web>
  <!-- 部署服务库项目时，必须将配置文件的内容添加到 
  主机的 app.config 文件中。System.Configuration 不支持库的配置文件。-->
  <system.serviceModel>
    <services>
      <service name="SCADA.Transfer.WCF.SCADATransAPI">
        <!--必须使用webHttpBinding，而且要定义此endpoint的behaviorConfiguration(见后)-->
        <endpoint address="" binding="webHttpBinding" bindingConfiguration="webHttp_Binding" contract="SCADA.Transfer.WCF.ISCADATransAPI" behaviorConfiguration="restBehavior"/>
        <host>
          <baseAddresses>
            <add baseAddress="http://127.0.0.1:8181/interface"/>
          </baseAddresses>
        </host>
      </service>
    </services>
        <bindings>
      <webHttpBinding>
        <!--其实要修改所有的服务，不管是服务端还是客户端，Binding那边增加一个没有设置名字的默认配置就OK了-->
        <binding name="webHttp_Binding" closeTimeout="00:10:00" receiveTimeout="00:20:00" sendTimeout="00:20:00" maxBufferSize="2147483647" maxReceivedMessageSize="2147483647">
        </binding>
      </webHttpBinding>
    </bindings>      
    <behaviors>
      <!--定义endpoint的behavior，webHttp节点表示启用web方式访问，这对REST是非常关键的-->
      <endpointBehaviors>
        <behavior name="restBehavior">
          <webHttp/>
        </behavior>
      </endpointBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

IDataProvider接口文件

namespace WCFService
{
    [ServiceContract]
    public interface IDataProvider
    {
        /// <summary>
        /// 请求接口
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        [OperationContract]
        [WebInvoke(UriTemplate = "/Request", Method = "POST", BodyStyle = WebMessageBodyStyle.Bare)]
        Stream Request(Stream buffer);   // stream是重点
    }
}

DataProvider接口继承类文件

namespace WCFService
{

    /// <summary>
    /// 服务器状态
    /// 服务器当前模式 - 多线程
    /// 服务器调用对象模式 - 每次调用创建一个，用完回收
    /// </summary>
     [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple, InstanceContextMode = InstanceContextMode.PerCall)]
    public class DataProvider : IDataProvider
    {

        /// <summary>
        /// 事件函数
        /// </summary>
        /// <param name="buffer">请求的buffer</param>
        /// <param name="lockobj">同步锁对象，有同步操作可使用</param>
        /// <returns>返回的buffer</returns>
        public delegate Stream ProcessDataRequested(Stream buffer, object lockobj);

        /// <summary>
        /// 数据请求事件
        /// </summary>
        public static event ProcessDataRequested DataRequested;

        /// <summary>
        /// 同步锁对象
        /// </summary>
        public static readonly object m_lockobj = new object();

        /// <summary>
        /// 数据请求接口
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public Stream Request(Stream buffer)
        {
            Stream retvalue = null;

            try
            {
                if (null != DataRequested)
                {
                    Delegate[] delegateArray = DataRequested.GetInvocationList();
                    if (delegateArray.Length == 1)
                    {
                        ProcessDataRequested method = (ProcessDataRequested)delegateArray[0];
                        retvalue = method(buffer, m_lockobj);
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }
            finally
            {
            }

            return retvalue;
        }

        /// <summary>
        /// 请求事件参数
        /// </summary>
        public class RequestArgs : EventArgs
        {

            /// <summary>
            /// 数据流
            /// </summary>
            public Stream m_stream { get; set; }

        }

    }
}

标准接口库文件 standDlls

namespace standDlls
{
    class TestA
    {
        public Stream TestDataRequested(Stream buffer, object obj)
        {
            lock (obj)
            {
                Console.WriteLine("123");
            }
            return buffer;
        }
    }

    class Program
    {
        public static Stream TestDataRequested(Stream buffer, object obj)
        {
            lock (obj)
            {
                Console.WriteLine("123");
            }
            return buffer;
        }

        static void Main(string[] args)
        {
            TestA tempa = new TestA();
            //DataProvider a = new DataProvider();
            //a.DataRequested += tempa.TestDataRequested;

            DataProvider.DataRequested += TestDataRequested;
            DataProvider.DataRequested +=new DataProvider.ProcessDataRequested(DataProvider_DataRequested);
            //DataProvider.DataRequested += new DataProvider.ProcessDataRequested(DataProvider_DataRequested);

            ServiceHost host = new ServiceHost(typeof(DataProvider));
            host.Open();

            //using (ServiceHost host = new ServiceHost(typeof(DataProvider)))
            //{
            //    host.Open();
            //    host.Faulted += new EventHandler(host_Faulted);
            //    host.Opened += new EventHandler(host_Opened);
            //}

            Console.ReadKey();
        }

        static Stream DataProvider_DataRequested(Stream buffer, object lockobj)
        {
            lock (lockobj)
            {
                Console.WriteLine("321");
            }
            return buffer;
        }

        static void host_Opened(object sender, EventArgs e)
        {
            Console.WriteLine(e.ToString());
        }

        static void host_Faulted(object sender, EventArgs e)
        {
            Console.WriteLine(e.ToString());
        }
    }
}

客户端请求

WebClient client = new WebClient();
client.Proxy = null;
client.Encoding = Encoding.UTF8;
string sResult = client.UploadString(serverUrl, "POST", requestText);