WCF入门讲解

一、简单WCF服务TCP和HTTP传输协议

二、实例管理

1、实例管理-单调服务

介绍：单调服务的一个实例创建于每个方法调用之前，调用完成后会立即销毁该服务实例。

2、实例管理-会话

介绍：一个配置了私有会话的服务通常无法支持多达几十个（或者上百个）独立的客户端，只因为创建专门的服务实例的代价太大。

3、实例管理-单例服务

介绍：一种极端的共享服务，单例服务会在创建宿主时创建，且它的生命周期是无限的，只有在关闭宿主时，单例服务才会被释放。

4、实例管理-限流

介绍：并发会话数，默认值为处理器计数（或内核）的100倍；并发调用最大数，默认值为 处理器计数（或内核 ）的16倍；并发实例的最大数量，默认等于最大并发调用的数目和最大并发会话数目（单个处理器116个会话）的和

 

三、操作

1、回调操作

介绍：客户端调用接口完成后，服务端通过回调方式调用客户端方法

 

四、事务

1、事务-ConcurrentMode.Single

介绍：一次只允许一个调用者进入，如果同时有多个并发调用，那么调用请求会进入一个队列里等待服务处理。

2、事务-ConcurrentMode.Multiple

介绍：不会为服务实例提供同步访问机制，不会队列化客户端请求，而是在消息到达时就立即发送出去。

 

附： 非同步访问事务

3、事务-ConcurrentMode.Reentrant

介绍：是对concurrentMode.Single模式的改进。

 

五、队列服务

1、简单使用

 

2、最终客户端Web.config文件

 

 

 

新建项目：WCFDemo

引入命名空间：

using System.ServiceModel;
using System.Runtime.Serialization;

添加接口：IUserContract（服务契约）

 

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

namespace WCFDemo
{
    [ServiceContract]
    public interface IUserContract
    {
        [OperationContract]
        bool Login(string userName, string pwd);
    }
}

 

 

添加类：UserContract 

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

namespace WCFDemo
{
    public class UserContract : IUserContract
    {
        public bool Login(string userName, string pwd)
        {
            if (userName == "x" && pwd == "x")
            {
                return true;
            }
            return false;
        }
    }
}

 

添加类：UserInfo（数据契约）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.Runtime.Serialization;

namespace WCFDemo
{
    [DataContract]
    public class UserInfo
    {
        [DataMember]
        public string UserName { get; set; }

        [DataMember]
        public string Pwd { get; set; }
    }
}

 

Program类：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Channels;

namespace WCFDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            ServiceHost host = new ServiceHost(typeof(UserContract));

            ServiceMetadataBehavior metadataBehavior;

            metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();

            var httpUri = new Uri("http://192.168.1.104:8002/WCFDemo/UserContract");

            var tcpUri = new Uri("net.tcp://192.168.1.104:8001/WCFDemo/UserContract");

            if (metadataBehavior == null)
            {
                metadataBehavior = new ServiceMetadataBehavior();
                metadataBehavior.HttpGetEnabled = true;
                metadataBehavior.HttpGetUrl = httpUri;
                host.Description.Behaviors.Add(metadataBehavior);

            }

            NetTcpBinding tcpBinding = new NetTcpBinding();

            WSHttpBinding wsBinding = new WSHttpBinding();

            //以管理员方式运行CMD输入：netsh http add urlacl url=http://+:8002/WCFDemo/UserContract/ user=Everyone
            host.AddServiceEndpoint(typeof(IUserContract), wsBinding, httpUri);

            tcpBinding.MaxBufferPoolSize = 52428800;
            tcpBinding.MaxBufferSize = 6553600;
            tcpBinding.MaxReceivedMessageSize = 6553600;
            tcpBinding.PortSharingEnabled = false;
            tcpBinding.Security.Mode = SecurityMode.None;//取消身份验证

            host.AddServiceEndpoint(typeof(IUserContract), tcpBinding, tcpUri);

            host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "net.tcp://192.168.1.104:8001/service/");//TCPBindding时，一定要有

            host.Open();

            Console.WriteLine("服务已启用");

            Console.ReadKey();
        }
    }
}

 

新建MVCWeb项目：WCFWeb

 

添加服务引用： net.tcp://192.168.1.104:8001/service/【注意】

 

代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace WCFWeb.Controllers
{
    public class HomeController : Controller
    {
        //
        // GET: /Home/

        public ActionResult Index()
        {
            ServiceReference1.UserContractClient client = new ServiceReference1.UserContractClient("NetTcpBinding_IUserContract");
            bool b = client.Login("x", "x");

            return View();
        }

    }
}

 

web.config文件：

  <system.serviceModel>
    <bindings>
      <netTcpBinding>
        <binding name="NetTcpBinding_IUserContract">
          <security mode="None" />
        </binding>
      </netTcpBinding>
      <wsHttpBinding>
        <binding name="WSHttpBinding_IUserContract" />
      </wsHttpBinding>
    </bindings>
    <client>
      <endpoint address="http://192.168.1.104:8002/WCFDemo/UserContract"
        binding="wsHttpBinding" bindingConfiguration="WSHttpBinding_IUserContract"
        contract="ServiceReference1.IUserContract" name="WSHttpBinding_IUserContract">
        <identity>
          <userPrincipalName value="AdministratorPC\john" />
        </identity>
      </endpoint>
      <endpoint address="net.tcp://192.168.1.104:8001/WCFDemo/UserContract"
        binding="netTcpBinding" bindingConfiguration="NetTcpBinding_IUserContract"
        contract="ServiceReference1.IUserContract" name="NetTcpBinding_IUserContract" />
    </client>
  </system.serviceModel>

 

使用WCFclient测试：

（VS2012自带WcfTestClient.exe测试工具,文件位置：C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\IDE）

 

 

单调服务

 

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

namespace WCFDemo
{
    [ServiceContract]
    public interface IMonotoneContract
    {
        [OperationContract]
         int Add();
    }
}

 

 

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

namespace WCFDemo
{

     //配置为单调
     [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
    public class MonotoneContract : IMonotoneContract, IDisposable
    {
        private int count = 0;
       
        public int Add()
        {
            count++;
            return count;
        }

        public void Dispose()
        {
            
        }
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Channels;

namespace WCFDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            ServiceHost host = new ServiceHost(typeof(MonotoneContract));

            ServiceMetadataBehavior metadataBehavior;

            metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();

            var httpUri = new Uri("http://192.168.1.104:8002/WCFDemo/MonotoneContract");

            var tcpUri = new Uri("net.tcp://192.168.1.104:8001/WCFDemo/MonotoneContract");

            if (metadataBehavior == null)
            {
                metadataBehavior = new ServiceMetadataBehavior();
                metadataBehavior.HttpGetEnabled = true;
                metadataBehavior.HttpGetUrl = httpUri;
                host.Description.Behaviors.Add(metadataBehavior);

            }

            NetTcpBinding tcpBinding = new NetTcpBinding();

            WSHttpBinding wsBinding = new WSHttpBinding();

            //以管理员方式运行CMD输入：netsh http add urlacl url=http://+:8002/WCFDemo/MonotoneContract/ user=Everyone
            host.AddServiceEndpoint(typeof(IMonotoneContract), wsBinding, httpUri);

            tcpBinding.MaxBufferPoolSize = 52428800;
            tcpBinding.MaxBufferSize = 6553600;
            tcpBinding.MaxReceivedMessageSize = 6553600;
            tcpBinding.PortSharingEnabled = false;
            tcpBinding.Security.Mode = SecurityMode.None;//取消身份验证

            host.AddServiceEndpoint(typeof(IMonotoneContract), tcpBinding, tcpUri);

            host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "net.tcp://192.168.1.104:8001/service/");//TCPBindding时，一定要有

            host.Open();

            Console.WriteLine("服务已启用");

            Console.ReadKey();
        }
    }
}

 

未配置单调服务测试：点击11次，显示效果如下

 

配置为单调服务： 点击11次，显示效果如下

 

操作-会话

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

namespace WCFDemo
{
     [ServiceContract(SessionMode=SessionMode.Required)]
    public interface IMonotoneContract
    {
        [OperationContract]
         int Add();
    }
}

 

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

namespace WCFDemo
{
   
     [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
    public class MonotoneContract : IMonotoneContract, IDisposable
    {

        private int count = 0;

        public int Add()
        {
            count++;
            return count;
        }

        public void Dispose()
        {

        }
    }
}

 

主程序Program同上

 

配置为会话： 点击11次，显示效果如下

操作-单例服务

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

namespace WCFDemo
{
     [ServiceContract(SessionMode=SessionMode.Required)]
    public interface IMonotoneContract
    {
        [OperationContract]
         int Add();
    }
}

 

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

namespace WCFDemo
{
    
     [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
    public class MonotoneContract : IMonotoneContract, IDisposable
    {

        private int count = 0;

        public int Add()
        {
            count++;
            return count;
        }

        public void Dispose()
        {

        }
    }
}

配置为会话：打开两个WCFTestClient,分别点击Invoke一次 ，显示效果如下

实例管理-限流

 

添加类：ServiceThrottleHelper

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;

namespace WCFDemo
{
    public static class ServiceThrottleHelper
    {
        public static void SetThrottle(this ServiceHost host, int maxCalls, int maxSessions, int maxInstances)
        {
            ServiceThrottlingBehavior serviceThrottle = new ServiceThrottlingBehavior();
            serviceThrottle.MaxConcurrentCalls = maxCalls;
            serviceThrottle.MaxConcurrentSessions = maxSessions;
            serviceThrottle.MaxConcurrentInstances = maxInstances;
            host.SetThrottle(serviceThrottle);
        }

        public static void SetThrottle(this ServiceHost host, ServiceThrottlingBehavior serviceThrottle, bool overrideConfig)
        {
            if (host.State == CommunicationState.Opened)
            {
                throw new InvalidOperationException("Host is already opended");
            }
            ServiceThrottlingBehavior throttle = host.Description.Behaviors.Find<ServiceThrottlingBehavior>();
            if (throttle == null)
            {
                host.Description.Behaviors.Add(serviceThrottle);
                return;
            }
            if (overrideConfig == false)
            {
                return;
            }
            host.Description.Behaviors.Remove(throttle);
            host.Description.Behaviors.Add(serviceThrottle);
        }

        public static void SetThrottle(this ServiceHost host, ServiceThrottlingBehavior serviceThrottle)
        {
            host.SetThrottle(serviceThrottle, false);
        }
    }
}

 

主程序：Program

 

host.SetThrottle(12, 34, 56);//限流（最大并发调用、最大并发会话数、最大并发实例）

 

操作-回调操作

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

namespace WCFDemo
{
    interface IMonotoneContractCallback
    {
         [OperationContract]
        void OnCallback();
    }
}

 

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

namespace WCFDemo
{
     [ServiceContract(CallbackContract = typeof(IMonotoneContractCallback))]
    public interface IMonotoneContract
    {
        [OperationContract]
        int Add();
    }
}

 

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

namespace WCFDemo
{
    //ConcurrencyMode = ConcurrencyMode.Reentrant 配置重入已支持回调
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Reentrant)]
    public class MonotoneContract : IMonotoneContract
    {
        static List<IMonotoneContractCallback> m_Callbacks = new List<IMonotoneContractCallback>();

        private int count = 0;

        public int Add()
        {
            count++;

           /*
            IMonotoneContractCallback callbacks = OperationContext.Current.GetCallbackChannel<IMonotoneContractCallback>();
            if (m_Callbacks.Contains(callbacks) == false)
            {
                m_Callbacks.Add(callbacks);
            }
            CallClients();
            */
            OperationContext.Current.GetCallbackChannel<IMonotoneContractCallback>().OnCallback();

            return count;
        }

        public static void CallClients()
        {
            Action<IMonotoneContractCallback> invoke = callback => callback.OnCallback();

            m_Callbacks.ForEach(invoke);

        }

       
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Channels;

namespace WCFDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            ServiceHost host = new ServiceHost(typeof(MonotoneContract));

            ServiceMetadataBehavior metadataBehavior;

            metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();

            var httpUri = new Uri("http://192.168.1.104:8002/WCFDemo/MonotoneContract");

            var tcpUri = new Uri("net.tcp://192.168.1.104:8001/WCFDemo/MonotoneContract");

            if (metadataBehavior == null)
            {
                metadataBehavior = new ServiceMetadataBehavior();
                metadataBehavior.HttpGetEnabled = true;
                metadataBehavior.HttpGetUrl = httpUri;
                host.Description.Behaviors.Add(metadataBehavior);

            }

            NetTcpBinding tcpBinding = new NetTcpBinding();

            WSHttpBinding wsBinding = new WSHttpBinding();

            //以管理员方式运行CMD输入：netsh http add urlacl url=http://+:8002/WCFDemo/MonotoneContract/ user=Everyone
            //host.AddServiceEndpoint(typeof(IMonotoneContract), wsBinding, httpUri);(不支付回调)

            tcpBinding.MaxBufferPoolSize = 52428800;
            tcpBinding.MaxBufferSize = 6553600;
            tcpBinding.MaxReceivedMessageSize = 6553600;
            tcpBinding.PortSharingEnabled = false;
            tcpBinding.Security.Mode = SecurityMode.None;//取消身份验证

            host.AddServiceEndpoint(typeof(IMonotoneContract), tcpBinding, tcpUri);

            host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "net.tcp://192.168.1.104:8001/service/");//TCPBindding时，一定要有

            host.SetThrottle(12, 34, 56);//限流

            host.Open();

            Console.WriteLine("服务已启用");

            Console.ReadKey();
        }
    }
}

 

客户端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace WCFWeb.Controllers
{
    public class HomeController : Controller
    {
        //
        // GET: /Home/

        public ActionResult Index()
        {
             MonotoneContractCallback monotoneContractCallback = new  MonotoneContractCallback();
            System.ServiceModel.InstanceContext context = new System.ServiceModel.InstanceContext(monotoneContractCallback);

            ServiceReference1.MonotoneContractClient client = new ServiceReference1.MonotoneContractClient(context, "NetTcpBinding_IMonotoneContract");
            var b = client.Add();

            return View();
        }

    }

    class  MonotoneContractCallback :  WCFWeb.ServiceReference1.IMonotoneContractCallback
    {
        public void OnCallback()
        {
            string a = "b";
        }
    }
}

 

运行效果：

事务-Transactions

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

namespace WCFDemo
{
    [ServiceContract]
    public interface IMonotoneContract
    {
        [OperationContract]
         [TransactionFlow(TransactionFlowOption.Allowed)]
        int Add();
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Text;
using System.Transactions;
using System.Data;
using System.Data.SqlClient;

namespace WCFDemo
{
    [Serializable]
     [ServiceBehavior(ReleaseServiceInstanceOnTransactionComplete = false, InstanceContextMode = InstanceContextMode.PerSession)]
    public class MonotoneContract : IMonotoneContract
    {
        private int count = 0;

         [OperationBehavior(TransactionAutoComplete = true, TransactionScopeRequired = true)]
        public int Add()
        {
            count++;

            using (System.Data.SqlClient.SqlConnection con = new System.Data.SqlClient.SqlConnection("Data Source=.;Initial Catalog=test2;Integrated Security=True"))
            {
                if (con.State != ConnectionState.Open)
                {
                    con.Open();
                }
                SqlCommand cmd = con.CreateCommand();
                cmd.CommandText = "insert into Table_1 values('" + Guid.NewGuid() + "','" + count + "');";
                cmd.ExecuteNonQuery();
            }

            return count;
        }
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Channels;

namespace WCFDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            ServiceHost host = new ServiceHost(typeof(MonotoneContract));

            ServiceMetadataBehavior metadataBehavior;

            metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();

            var httpUri = new Uri("http://192.168.1.104:8002/WCFDemo/MonotoneContract");

            var tcpUri = new Uri("net.tcp://192.168.1.104:8001/WCFDemo/MonotoneContract");

            if (metadataBehavior == null)
            {
                metadataBehavior = new ServiceMetadataBehavior();
                metadataBehavior.HttpGetEnabled = true;
                metadataBehavior.HttpGetUrl = httpUri;
                host.Description.Behaviors.Add(metadataBehavior);

            }

            NetTcpBinding tcpBinding = new NetTcpBinding();

            WSHttpBinding wsBinding = new WSHttpBinding();

            //以管理员方式运行CMD输入：netsh http add urlacl url=http://+:8002/WCFDemo/MonotoneContract/ user=Everyone
            host.AddServiceEndpoint(typeof(IMonotoneContract), wsBinding, httpUri);//(不支付回调)

            tcpBinding.MaxBufferPoolSize = 52428800;
            tcpBinding.MaxBufferSize = 6553600;
            tcpBinding.MaxReceivedMessageSize = 6553600;
            tcpBinding.PortSharingEnabled = false;
            tcpBinding.Security.Mode = SecurityMode.None;//取消身份验证

             tcpBinding.TransactionFlow = true;
            tcpBinding.TransactionProtocol = TransactionProtocol.WSAtomicTransactionOctober2004;

            host.AddServiceEndpoint(typeof(IMonotoneContract), tcpBinding, tcpUri);

            host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "net.tcp://192.168.1.104:8001/service/");//TCPBindding时，一定要有

 

            host.Open();

            Console.WriteLine("服务已启用");

            Console.ReadKey();
        }
    }
}

 

客户端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Transactions;
using System.Web;
using System.Web.Mvc;

namespace WCFWeb.Controllers
{
    public class HomeController : Controller
    {
        //
        // GET: /Home/

        public ActionResult Index()
        {

            ServiceReference1.MonotoneContractClient client = new ServiceReference1.MonotoneContractClient("NetTcpBinding_IMonotoneContract");
             using (TransactionScope scope = new TransactionScope())
            {
                var b = client.Add();
            }
            using (TransactionScope scope = new TransactionScope())
            {
                var b = client.Add();
            }
            using (TransactionScope scope = new TransactionScope())
            {
                var b = client.Add();
                scope.Complete();
            } 
            using (TransactionScope scope = new TransactionScope())
            {
                var b = client.Add();
                scope.Complete();

            }
          
            return View();
        }

    }

    
}

 

执行结果：(因为只提交了2次事务，因此只有2条记录)

 

服务并发模式-Single：   

 

[ServiceBehavior(ConcurrencyMode=ConcurrencyMode.Single)]
public class MonotoneContract : IMonotoneContract

 

服务并发模式-Multiple：

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

namespace WCFDemo
{
    [ServiceContract]
    public interface IMonotoneContract
    {
        [OperationContract]
        int Add();
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Text;
using System.Transactions;
using System.Data;
using System.Data.SqlClient;
using System.Runtime.CompilerServices;

namespace WCFDemo
{
    [Serializable]
     [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)]
    public class MonotoneContract : IMonotoneContract
    {
        private int count = 0;

        //锁住实例
         [MethodImpl(MethodImplOptions.Synchronized)]
        public int Add()
        {
            count++;

            return count;
        }
    }
}

 

 

非同步访问与事务

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

namespace WCFDemo
{
    [ServiceContract]
    public interface IMonotoneContract
    {
        [OperationContract]
        int Add();
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Text;
using System.Transactions;
using System.Data;
using System.Data.SqlClient;
using System.Runtime.CompilerServices;

namespace WCFDemo
{
    //事务性非同步服务必须明确将ReleaseServiceInstanceOnTransactionComplete设置为false
    [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple, ReleaseServiceInstanceOnTransactionComplete = false)]
    public class MonotoneContract : IMonotoneContract
    {
        private int count = 0;

        [OperationBehavior(TransactionScopeRequired = true)]
        public int Add()
        {
            count++;
           
            return count;
        }
    }
}

 

列列服务

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

namespace WCFDemo
{
    [ServiceContract]
    public interface IMonotoneContract
    {
        //使用消息队列，只能是单向的，不能有返回值
        [OperationContract(IsOneWay = true)]
        void Add();
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Text;
using System.Transactions;
using System.Data;
using System.Data.SqlClient;
using System.Runtime.CompilerServices;

namespace WCFDemo
{
    public class MonotoneContract : IMonotoneContract
    {
        private int count = 0;

        public void Add()
        {
            count++;

        }
      
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.ServiceModel.Channels;
using System.Messaging;

namespace WCFDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            ServiceHost host = new ServiceHost(typeof(MonotoneContract));

            ServiceMetadataBehavior metadataBehavior;

            metadataBehavior = host.Description.Behaviors.Find<ServiceMetadataBehavior>();

            var httpUri = new Uri("http://192.168.1.104:8002/WCFDemo/MonotoneContract");

            var tcpUri = new Uri("net.tcp://192.168.1.104:8001/WCFDemo/MonotoneContract");

             var msqUri = new Uri("net.msmq://192.168.1.104/private/MyServiceQueue");

            if (metadataBehavior == null)
            {
                metadataBehavior = new ServiceMetadataBehavior();
                metadataBehavior.HttpGetEnabled = true;
                metadataBehavior.HttpGetUrl = httpUri;
                host.Description.Behaviors.Add(metadataBehavior);

            }

            NetMsmqBinding msqBinding = new NetMsmqBinding();

            if (MessageQueue.Exists(@".\private$\MyServiceQueue") == false)
            {
                MessageQueue.Create(@".\private$\MyServiceQueue", true);
            }
            msqBinding.Security.Mode =NetMsmqSecurityMode.None ;

 

            NetTcpBinding tcpBinding = new NetTcpBinding();

            WSHttpBinding wsBinding = new WSHttpBinding();

            //以管理员方式运行CMD输入：netsh http add urlacl url=http://+:8002/WCFDemo/MonotoneContract/ user=Everyone
            host.AddServiceEndpoint(typeof(IMonotoneContract), wsBinding, httpUri);//(不支付回调)

            tcpBinding.MaxBufferPoolSize = 52428800;
            tcpBinding.MaxBufferSize = 6553600;
            tcpBinding.MaxReceivedMessageSize = 6553600;
            tcpBinding.PortSharingEnabled = false;
            tcpBinding.Security.Mode = SecurityMode.None;//取消身份验证

             host.AddServiceEndpoint(typeof(IMonotoneContract), msqBinding, msqUri);

            host.AddServiceEndpoint(typeof(IMonotoneContract), tcpBinding, tcpUri);

            host.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexTcpBinding(), "net.tcp://192.168.1.104:8001/service/");//TCPBindding时，一定要有

 

            host.Open();

            Console.WriteLine("服务已启用");

            Console.ReadKey();
        }
    }
}

 

客户端调用：

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Messaging;
using System.Transactions;
using System.Web;
using System.Web.Mvc;

namespace WCFWeb.Controllers
{
    public class HomeController : Controller
    {
        //
        // GET: /Home/

        public ActionResult Index()
        {

            ServiceReference1.MonotoneContractClient client = new ServiceReference1.MonotoneContractClient(" NetMsmqBinding_IMonotoneContract");
            if (MessageQueue.Exists(@".\private$\MyServiceQueue") == false)
            {
                MessageQueue.Create(@".\private$\MyServiceQueue", true);
            }
            client.Add();

            return View();
        }

    }

}

 

web.config:

 

<system.serviceModel>
    <bindings>
      <netMsmqBinding>
        <binding name="NetMsmqBinding_IMonotoneContract">
          <security mode="None" />
        </binding>
      </netMsmqBinding>
      <netTcpBinding>
        <binding name="NetTcpBinding_IMonotoneContract">
          <security mode="None" />
        </binding>
      </netTcpBinding>
      <wsHttpBinding>
        <binding name="WSHttpBinding_IMonotoneContract" />
      </wsHttpBinding>
    </bindings>
    <client>
      <endpoint address="http://192.168.1.104:8002/WCFDemo/MonotoneContract"
        binding="wsHttpBinding" bindingConfiguration="WSHttpBinding_IMonotoneContract"
        contract="ServiceReference1.IMonotoneContract" name="WSHttpBinding_IMonotoneContract">
        <identity>
          <userPrincipalName value="AdministratorPC\john" />
        </identity>
      </endpoint>
      <endpoint address="net.msmq://192.168.1.104/private/MyServiceQueue"
        binding="netMsmqBinding" bindingConfiguration="NetMsmqBinding_IMonotoneContract"
        contract="ServiceReference1.IMonotoneContract" name="NetMsmqBinding_IMonotoneContract" />
      <endpoint address="net.tcp://192.168.1.104:8001/WCFDemo/MonotoneContract"
        binding="netTcpBinding" bindingConfiguration="NetTcpBinding_IMonotoneContract"
        contract="ServiceReference1.IMonotoneContract" name="NetTcpBinding_IMonotoneContract" />
    </client>
  </system.serviceModel>