WCF服务通信测试

知识需要反复咀嚼，常读常新，简单的WCF通信测试：basicHttpBinding(基本通信)\netTcpBinding(双工通信)\netMsmqBinding(消息队列)，简单的测试Demo。
简单说一下代码结构，后续整理一下具体的实现逻辑，为什么这么处理。

1.WCFTest.DataContracts类库代码(基础数据契约类库)
<1>.OrderItem.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using System.Runtime.Serialization;

using System.Threading.Tasks;


namespace WCFTest.DataContracts

{

    [DataContract]

    public class OrderItem

    {

        [DataMember]

        public Guid ProductID;


[DataMember]

        public string ProductName;


[DataMember]

        public decimal UnitPrice;


[DataMember]

        public int Quantity;

    }

}

<2>.Order.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using System.Runtime.Serialization;

using System.Threading.Tasks;


namespace WCFTest.DataContracts

{

    [DataContract]

    [KnownType(typeof(OrderItem))]

    public class Order

    {

        [DataMember]

        public Guid OrderNo;


[DataMember]

        public DateTime OrderDate;


[DataMember]

        public Guid SupplierID;


[DataMember]

        public string SupplierName;


[DataMember]

        public List<OrderItem> OrderItems=new List<OrderItem> ();

        //如果不这样的构建方式，使用请使用get;set;,并且Order构造函数实例化(new)这个集合


/// <summary>

        /// 订单信息描述

        /// </summary>

        /// <returns></returns>

        public override string ToString()

        {

            StringBuilder strBuilder = new StringBuilder();


strBuilder.AppendLine("General Information:\n\t");

            strBuilder.AppendLine(string.Format("Order No:{0}", OrderNo));

            strBuilder.AppendLine(string.Format("Order Date:{0}", OrderDate.ToShortDateString()));

            strBuilder.AppendLine(string.Format("SupplierID:{0}", SupplierID));

            strBuilder.AppendLine(string.Format("SupplierName:{0}", SupplierName));


strBuilder.AppendLine("\nProducts:");

            foreach (OrderItem order in OrderItems)

            {

                strBuilder.AppendLine(string.Format("ProductID:{0}", order.ProductID));

                strBuilder.AppendLine(string.Format("ProductName:{0}", order.ProductName));

                strBuilder.AppendLine(string.Format("UnitPrice:{0}", order.UnitPrice));

                strBuilder.AppendLine(string.Format("Quantity:{0}", order.Quantity));

            }

            return strBuilder.ToString();

        }

    }

}

2.WCFTest.Contracts类库代码(服务端和客户端通信契约接口)
<1>.ICalculator.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using System.Threading.Tasks;


namespace WCFTest.Contracts

{


[ServiceContract]

    public interface ICalculator

    {

        [OperationContract]

        double Add(double numA, double numB);


[OperationContract]

        double Sub(double numA, double numB);


[OperationContract]

        double Multiply(double numA, double numB);


[OperationContract]

        double Divide(double numA, double numB);

    }

}

<2>.IDuplexCallBack.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using System.Threading.Tasks;


namespace WCFTest.Contracts

{

    public interface IDuplexCallBack

    {

        [OperationContract(IsOneWay = true)]

        void DisplayResult(double result);

    }

}

<3>.IDuplexContract.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using System.Threading.Tasks;


namespace WCFTest.Contracts

{

    #region BaseInfoKnown

    /*

     * 如何理解双工通信？

     * 请求过程中的回调，双工消息交换模式的表现形式，客户端调用服务的时候，附加上一个回调对象；

     * 服务端在处理该请求中，通过客户端附加的回调对象（调用回调服务的代理对象）回调客户端操作（该操作在客户端执行）。

     * 整个消息交换过程由两个基本的消息交换，其一客户端正常的服务请求，其二服务端对客户端的回调。两者可以采用请求-回复模式，也可以采用单向（One-way）的MEP进行消息交换。

     *

     * 如何模拟测试？

     * 本例采用另外一种截然不同的方式调用服务并进行结果的输出：

     * 通过单向（One-way）的模式调用CalculuateService（也就是客户端不可能通过回复消息得到计算结果），服务端在完成运算结果后，通过回调（Callback）的方式在客户端将计算结果打印出来。

     */

    #endregion


[ServiceContract(CallbackContract = typeof(IDuplexCallBack))]

    public interface IDuplexContract

    {

        [OperationContract(IsOneWay = true)]//单向(只是客户端请求，未做响应[回复])

        void Add(double numA, double numB);

    }

}

<4>.IMSMQContract.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using WCFTest.DataContracts;

using System.Threading.Tasks;


namespace WCFTest.Contracts

{

    #region BaseInfoKnown

    /*

     * 比如，在Intranet内，通过TCP进行高效的数据通信；而在Internet内，通常使用Http进行跨平台数据交换。

     * 这些通信的特点都是基于Connection的，也就是说，交互双方必须有一个可用的Connection存在于他们之间。

     * 而在某些时候比如用户拨号、便携式计算机的用户，不能保证需要Server时有一个可用的Connection。这时候，基于Messaging Queue尤为重要。

     * MSMQ的好处：

     * <1>.MSMQ是基于Disconnection。这种通信方式为离线工作成为了可能。

     * <2>.MSMQ天生是One-way、异步的。对于用户的请求，Server端无需立即相应，也就是说，Server对数据的处理无需和Client的数据发送进行同步。这样可以避免峰值负载。

     * <3>.MSMQ能够提供高质量的Reliable Messaging。异步通信，无法获知Message是否抵达Server端，也无法获知Server端的执行结果和出错信息。

     * MSMQ提供Reliable Messaging的机制：

     * a.超时机制(Timeout)

     * b.确认机制(Acknowledgement)

     * c.日志机制(Journaling)：消息被发送或接收后，被Copy一份。

     * d.死信队列(Dead letter Queue):保存发送失败的message。

     *

     * 在WCF中，MSMQ的数据传输功能被封装在一个Binding中，提供WCF Endpoint之间、以及Endpoint和现有的基于MSMQ的Application进行通信的实现。

     * 提供两种不同的built-in binding:

     * <1>.NetMsmqBinding:从提供的功能和使用方式上看，和一般的使用的binding一样，所不同的是，它提供的是基于MSMQ的Reliable Messaging。变成模式和一般的binding完全一样。

     * <2>.MsmqIntergrationBinding:主要用于将我们的WCF Application和现有的基于MSMQ的Application集成的情况。

     * 实现了WCF Endpoint和某个Message Queue进行数据的通信，具体来说，就是实现了单一的向某个Message Queue发送Message，和从某个Message Queue中接收Message的功能。

     *

     * MSMQ则有效地提供了这样的机制：Server端建立一个Message Queue来接收来个客户的订单，客户端通过向该Message Queue发送承载了订单数据的Message实现订单的递交。

     * 如果客户在离线的情况，仍然可以通过客户端进行订单递交的操作，存储着订单数据的Message会被暂保在本地的Message Queue中，一旦客户联机，MSMQ将Message从中取出，发送到真正的接收方，这个动作对于用户的透明的。

     */

    #endregion


[ServiceContract]

    [ServiceKnownType(typeof(Order))]

    public interface IMSMQContract

    {

        [OperationContract(IsOneWay = true)]

        void SubmitOrder(Order order);

    }

}

3.WCFTest.Services类库代码(契约接口业务功能实现)
<1>.CalculatorService.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using WCFTest.Contracts;

using System.Threading.Tasks;


namespace WCFTest.Services

{

    public class CalculatorService : ICalculator

    {

        public double Add(double numA, double numB)

        {

            return numA + numB;

        }


public double Sub(double numA, double numB)

        {

            return numA - numB;

        }


public double Multiply(double numA, double numB)

        {

            return numA * numB;

        }


public double Divide(double numA, double numB)

        {

            if (numB != 0)

            {

                return numA / numB;

            }

            return 0;

        }

    }

}

<2>.DuplexService.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using WCFTest.Contracts;

using System.Threading.Tasks;


namespace WCFTest.Services

{

    /// <summary>

    /// 在Server端，通过OperationContext.Current.GetCallbackChannel<T>()

    /// 获得Client指定的CallbackContent Instance,进行Client调用Opertion

    /// </summary>

    public class DuplexService : IDuplexContract

    {

        public void Add(double numA, double numB)

        {

            double result = numA + numB;

            IDuplexCallBack duplexCall = OperationContext.Current.GetCallbackChannel<IDuplexCallBack>();

            duplexCall.DisplayResult(result);

        }

    }

}

<3>.MSMQService.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using WCFTest.Contracts;

using WCFTest.DataContracts;

using System.Threading.Tasks;


namespace WCFTest.Services

{

    public class MSMQService:IMSMQContract

    {

        //设定服务端请求行为：需求事务操作\自动完成事务

        [OperationBehavior(TransactionScopeRequired=true,TransactionAutoComplete=true)]

        public void SubmitOrder(WCFTest.DataContracts.Order order)

        {

            //将Order数据保存到数据库

            SaveData.SaveOrder(order);


Console.WriteLine("Receive An Order:");

            Console.WriteLine(order.ToString()); //服务端输出的信息，在Host监听器可以看到，服务是不可见的

        }

    }

}

<4>.SaveData.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using WCFTest.DataContracts;

using System.Threading.Tasks;


namespace WCFTest.Services

{

    public class SaveData

    {

        private static Dictionary<Guid, Order> dicOrder = new Dictionary<Guid, Order>();


public static void SaveOrder(Order order)

        {

            if (!dicOrder.Keys.Contains(order.OrderNo))

            {

                dicOrder.Add(order.OrderNo, order);

            }

        }


public static Order GetOrder(Guid orderNo)

        {

            Order order = new Order();

            if (dicOrder.Keys.Contains(orderNo))

            {

                order=dicOrder[orderNo];

            }

            return order;

        }

    }

}

4.WCFTest.Hots 控制台程序代码(多服务宿主程序)
<1>.App.config (服务端和客户端通信配置ABC)


<?xml version="1.0" encoding="utf-8" ?>

<configuration>

    <startup>

        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />

    </startup>

  <system.serviceModel>

    <!--配置行为-->

    <behaviors>

      <!--配置服务端行为-->

      <serviceBehaviors>

        <behavior name="CalculatorBehavior">

          <serviceMetadata httpGetEnabled="true" httpGetUrl="http://localhost:7070/CalculatorService/Metadata"/>

        </behavior>

      </serviceBehaviors>

    </behaviors>

    <!--配置协议-->

    <bindings>

      <!--MSMQBinding配置-->

      <netMsmqBinding>

        <binding name="MSMQBinding" exactlyOnce="true">

          <security mode="None">

            <transport msmqAuthenticationMode="None" msmqProtectionLevel="None"/>

            <message clientCredentialType="None"/>

          </security>

        </binding>

      </netMsmqBinding>

    </bindings>

    <services>

      <!--CalculatorService-->

      <service name="WCFTest.Services.CalculatorService">

        <endpoint address="http://localhost:7070/CalculatorService"

                  binding="basicHttpBinding"

                  contract="WCFTest.Contracts.ICalculator">

        </endpoint>

      </service>

      <!--DuplexService-->

      <service name="WCFTest.Services.DuplexService">

        <endpoint address="net.tcp://localhost:6060/DuplexService"

                  binding="netTcpBinding"

                  contract="WCFTest.Contracts.IDuplexContract">

        </endpoint>

      </service>

      <!--MSMQService-->

      <service  name="WCFTest.Services.MSMQService">

        <endpoint address="net.msmq://localhost/Private/Orders"

                  binding="netMsmqBinding"

                  bindingConfiguration="MSMQBinding"

                  contract="WCFTest.Contracts.IMSMQContract">

        </endpoint>

      </service>

    </services>

  </system.serviceModel>

</configuration>

<2>.Program.cs  (多服务宿主启用监听)


using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using WCFTest.Services;

using System.Configuration;

using System.Threading.Tasks;

using System.Xml;

using System.Configuration;

using System.Messaging;


namespace WCFTest.Hots

{

    /// <summary>

    /// 如何可以按需开启不同的Host

    /// </summary>

    class Program

    {

        static void Main(string[] args)

        {

            #region 单Host调用测试

            ////计算服务Host

            //CalculatorHosts();

            ////双工通信服务Host

            //DuplexHost();

            #endregion


#region 多Host调用测试

            Dictionary<string, ServiceHost> dicHosts = new Dictionary<string, ServiceHost>();

            dicHosts.Add("CalculatorHost", new ServiceHost(typeof(Services.CalculatorService)));

            dicHosts.Add("DuplexHost", new ServiceHost(typeof(Services.DuplexService)));

            dicHosts.Add("MSMQHost", new ServiceHost(typeof(Services.MSMQService)));


foreach (KeyValuePair<string, ServiceHost> keyPair in dicHosts)

            {

                if (keyPair.Key.Contains("MSMQHost"))//MSMQHost的附加逻辑

                {

                    //MSMQ队列不存在,或您没有足够的权限执行该操作异常：因为是这里的路径\Host\Client的地址路径问题

                    string strMSMQPath = @".\Private$\Orders";

                    //string strMSMQPath = ConfigurationManager.AppSettings["MSMQPath"];

                    if (!MessageQueue.Exists(strMSMQPath))

                    {

                        //创建一个MessageQueue,参数说明：MSMQ的位置,支持事务队列

                        MessageQueue.Create(strMSMQPath,true);

                    }

                }


keyPair.Value.Opened += delegate

                {

                    Console.WriteLine(keyPair.Key + " Host Has Been Listening.......");

                };

                keyPair.Value.Open();

            }


Console.WriteLine("\nPlease Enter Any Key To Abort All Hosts:");

            Console.ReadLine();

            foreach (KeyValuePair<string, ServiceHost> keyPair in dicHosts)

            {

                keyPair.Value.Abort();

                keyPair.Value.Close();

                Console.WriteLine(keyPair.Key + " Host Has Been Stoped!");

            }

            #endregion


Console.WriteLine("\nPlease Enter Any Key Exit:");

            Console.Read();

        }


/// <summary>

        /// 计算服务Host

        /// </summary>

        private static void CalculatorHosts()

        {

            using (ServiceHost host = new ServiceHost(typeof(Services.CalculatorService)))

            {

                host.Opened += delegate

                {

                    Console.WriteLine("Host Has Been Opened! Please Enter Any Key To Abort This Host:");

                    Console.ReadKey();

                    host.Abort();

                    host.Close();

                    Console.WriteLine("Host Has Been Stoped!");

                };

                host.Open();

            }

        }


/// <summary>

        /// 双工通信服务Host

        /// </summary>

        private static void DuplexHost()

        {

            using (ServiceHost duplexHost = new ServiceHost(typeof(Services.DuplexService)))

            {

                duplexHost.Opened += delegate

                {

                    Console.WriteLine("Duplex Host Has Been Listening....! Please Enter Any Key To Abort This Host:");

                    Console.ReadLine();

                    duplexHost.Abort();

                    duplexHost.Close();

                    Console.WriteLine("Duplex Host Has Been Stoped!");

                };

                duplexHost.Open();

            }

        }

    }

}

5.WCFTravelReview 控制台程序代码 (客户端调用)
<1>.App.config (客户端和服务端通信配置ABC)


<?xml version="1.0" encoding="utf-8" ?>

<configuration>

    <startup>

        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />

    </startup>

  <system.serviceModel>

    <bindings>

      <netMsmqBinding>

        <binding name="MSMQBinding" exactlyOnce="true">

          <security mode="None">

            <transport msmqAuthenticationMode="None" msmqProtectionLevel="None"/>

            <message clientCredentialType="None"/>

          </security>

        </binding>

      </netMsmqBinding>

    </bindings>


<client >

      <!--CalculatorService终结点-->

      <endpoint name="CalculatorClient"

                address="http://localhost:7070/CalculatorService"

                binding="basicHttpBinding"

                contract="WCFTest.Contracts.ICalculator"></endpoint>

      <!--DuplexService终结点-->

      <endpoint name="DuplexClient"

                address="net.tcp://localhost:6060/DuplexService"

                binding="netTcpBinding"

                contract="WCFTest.Contracts.IDuplexContract"></endpoint>

      <!--MSMQService终结点-->

      <endpoint name="MSMQClient"

                address="net.msmq://loclahost/Private/Orders"

                binding="netMsmqBinding"

                bindingConfiguration="MSMQBinding"

                contract="WCFTest.Contracts.IMSMQContract"></endpoint>

    </client>

  </system.serviceModel>

</configuration>

<2>.DuplexCallBackClient.cs (双工通信回调接口实现)


using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using WCFTest.Contracts;

using System.Threading.Tasks;


namespace WCFTravelReview

{

    //客户端的回调类，显示计算结果，实现ICallback接口

    public class DuplexCallBackClient : IDuplexCallBack

    {

        public void DisplayResult(double result)

        {

            Console.WriteLine("The Result is {0}", result.ToString());

        }

    }

}

<3>.Program.cs (测试客户端调用)


using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using WCFTest.Contracts;

using WCFTest.DataContracts;

using System.Transactions;

using System.Threading.Tasks;


namespace WCFTravelReview

{

    class Program

    {

        static void Main(string[] args)

        {

            //计算服务Client

            CalculatorClient();


//双工服务Client

            DuplexClient();


//消息队列

            MSMQClient();


Console.Read();

        }


/// <summary>

        /// 计算服务Client

        /// </summary>

        private static void CalculatorClient()

        {

            using (ChannelFactory<ICalculator> calculatorChannel = new ChannelFactory<ICalculator>("CalculatorClient"))

            {

                ICalculator proxy = calculatorChannel.CreateChannel();

                using (proxy as IDisposable)

                {

                    Console.WriteLine("计算通信测试：");

                    Console.WriteLine("请输入数字A：");

                    double numA = Convert.ToDouble(Console.ReadLine());

                    Console.WriteLine("请输入数字B：");

                    double numB = Convert.ToDouble(Console.ReadLine());


Console.WriteLine("WCF调用服务计算：");

                    Console.WriteLine("{0}+{1}={2}", numA, numB, proxy.Add(numA, numB));

                    Console.WriteLine("{0}-{1}={2}", numA, numB, proxy.Sub(numA, numB));

                    Console.WriteLine("{0}*{1}={2}", numA, numB, proxy.Multiply(numA, numB));

                    Console.WriteLine("{0}/{1}={2}", numA, numB, proxy.Divide(numA, numB));

                }

            }

        }


/// <summary>

        /// 双工服务Client

        /// </summary>

        private static void DuplexClient()

        {

            #region TCP/IP DuplexInfo Known

            /*

             * 对于双工通信

             * 对于TCP/IP簇中的传输层协议TCP，它则是一个基于Connection的协议，在正式进行数据传输之前，

             * 必须要在Client和Server之后建立一个Connection,Connection的建立通过经典的“3次握手”。

             * TCP具有Duplex的特性，就是说Connection被创建之后，从Client到Server，从Server到Client的数据传递可以利用同一个Connection来实现。

             * 对于WCF的双向通信，Client调用Service,Service Callback Client使用的都是同一个Channel。

             */

            #endregion


InstanceContext instanceContext = new InstanceContext(new DuplexCallBackClient());

            using (DuplexChannelFactory<IDuplexContract> duplexChannel = new DuplexChannelFactory<IDuplexContract>(instanceContext, "DuplexClient"))

            {

                IDuplexContract proxy = duplexChannel.CreateChannel();

                using (proxy as IDisposable)

                {

                    Console.WriteLine("\n双工通信测试：");

                    Console.WriteLine("请输入数字A：");

                    double numA = Convert.ToDouble(Console.ReadLine());

                    Console.WriteLine("请输入数字B：");

                    double numB = Convert.ToDouble(Console.ReadLine());

                    Console.WriteLine("WCF调用双工通信计算：");

                    proxy.Add(numA, numB);

                }

            }

        }


/// <summary>

        /// MSMQ订单Client

        /// </summary>

        private static void MSMQClient()

        {

            //创建订单数据

            Order order = new Order() { OrderNo=Guid.NewGuid(), OrderDate=DateTime.Now, SupplierID=Guid.NewGuid(), SupplierName="SupplierName" };

            OrderItem orderItem = new OrderItem() { ProductID=Guid.NewGuid(), ProductName="PP", Quantity=1, UnitPrice=1 };


order.OrderItems.Add(new OrderItem() { ProductID=Guid.NewGuid(), ProductName="ProductName1", Quantity=300, UnitPrice=10 });

            order.OrderItems.Add(new OrderItem() { ProductID = Guid.NewGuid(), ProductName = "ProductName2", Quantity = 10, UnitPrice = 1 });


ChannelFactory<IMSMQContract> msmqChannel = new ChannelFactory<IMSMQContract>("MSMQClient");

            IMSMQContract proxy = msmqChannel.CreateChannel();

            using (proxy as IDisposable)

            {

                Console.WriteLine("\n消息队列通信测试：");

                Console.WriteLine("MSMQ Submit Order To Server....");

                using (TransactionScope tansactionScope = new TransactionScope(TransactionScopeOption.Required))

                {

                    proxy.SubmitOrder(order);

                    tansactionScope.Complete();

                    Console.WriteLine("Order Has Been Submit! Complete This Order!");

                }

            }


}

    }

}

6.运行效果：

WCF服务通信测试,布布扣,bubuko.com

时间： 2024-10-09 23:00:01

WCF服务通信测试的相关文章

WCF服务部署到IIS7.5

下面介绍如何把WCF服务部署到IIS: 为WCF服务创建.svc文件 我们知道,每一个ASP.NET Web服务都具有一个.asmx文本文件,客户端通过访问.asmx文件实现对相应Web服务的调用.与之类似,每个WCF服务也具有一个对应的文本文 件,其文件扩展名为.svc.基于IIS的服务寄宿要求相应的WCF服务具有相应的.svc文件,.svc文件部署于IIS站点中,对WCF服务的调用体 现在对.svc文件的访问上. .svc文件的内容很简单,仅仅包含一个ServiceHost指令(Direct

C# WCF服务入门

之前在公司用的服务端是wcf写的,但是没有深入研究,最近找工作,面试的时候好多人看到这个总提问,这里做个复习 就用微软官方上的例子,搭一个简单的wcf服务,分6步 1 定义服务协定也就是契约,其实就是定义一个服务接口,这玩意后边是公开客户端用的,然后也告诉后边承载程序应该如何加载服务 主要涉及两个特性:一个是ServiceContract(接口的特性,定义这个是服务契约,里边又一些设置参数可以设置一下),OperationContract设置接口的方法的,如果不设置,方法就不会呗公开 这里是直接

创建WCF服务自我寄宿

WCF服务的寄宿方式 WCF寄宿方式是一种非常灵活的操作,可以寄宿在各种进程之中,常见的寄宿有: IIS服务.Windows服务.Winform程序.控制台程序中进行寄宿,从而实现WCF服务的运行,为调用者方便.高效提供服务调用. 签名 前面介绍过了WCF常用的一种寄宿方式,IIS服务寄宿.这种寄宿方式是最为方便的方式,而且由于服务只需要IIS运行就能自动运行起来,因此广为使用. 创建这种方式IIS寄宿方式的,只需要在解决方案里面,添加WCF服务应用程序,就可以生成这种的服务模块了. 将WCF服

创建WCF服务寄宿到IIS

一.WCF简介: Windows Communication Foundation(WCF)是由微软开发的一系列支持数据通信的应用程序框架,可以翻译为Windows 通讯开发平台. 整合了原有的windows通讯的 .net Remoting,WebService,Socket的机制,并融合有HTTP和FTP的相关技术. 由 .NET Framework 3.0 开始引入. WCF的最终目标是通过进程或不同的系统.通过本地网络或是通过Internet收发客户和服务之间的消息. WCF合并了Web

Ajax跨域访问wcf服务中所遇到的问题总结。

工具说明:vs2012,sql server 2008R2 1.首先,通过vs2012建立一个wcf服务项目,建立好之后.再新开一个vs2012 建立web项目,通过jQuery的ajax方法访问服务. 问题:由于web项目和wcf服务,不在同一个端口之中,所以涉及到“跨域”的问题.跨域访问的时候,需要对服务的接口和方法做一定的限定.具体参考:http://www.cnblogs.com/yangbingqi/p/2096197.html 2.解决了跨域问题,我们需要把服务部署到IIS.vs20

用jQuery的Ajax调用WCF服务编程心得

这两天在写基于WCF服务的后台框架,过程中遇到了一些挫折,经过努力全部解决了,在此分享给大家,使用的工具是Visual Studio 2013. 该后台需要支持通过json来传递和接收数据. 首先,说说搭建过程. 第一步:创建WCF服务应用程序项目WCF. 第二步,创建服务使用的数据类 using System; using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations.Sch

三十、【C#.Net开发框架】WCFHosting服务主机的利用WCF服务通讯和实现思路

回<[开源]EFW框架系列文章索引>        EFW框架源代码下载V1.3:http://pan.baidu.com/s/1c0dADO0 EFW框架实例源代码下载:http://pan.baidu.com/s/1eQCc69G        前言:以前的系统都是直接客户端直连数据库服务器,后来考虑到服务器的安全性.数据库连接数的限制.分布能力差等问题,特别是那几年中间件.SOA.ESB等炒得比较火,为了跟上时代脚本有必要开发一个中间件,把后台逻辑业务在中间件中运行.刚开始考虑过WebS

WCF服务类的实例模式（本文为转载）

WCF开发时如何选择正确的实例模式(InstanceMode)? 在使用WCF实例模型时,你是否思考过这几个的问题: ”WCF中的实例模式如何正确应用”? ”使用WCF中的实例模式有何原则可以遵循吗”? 众所周知:客户端调用服务时,最终会将调用服务端的某个实例来完成.在WCF服务中,可以通过ServiceBehavior的InstanceContextMode设置服务实例. InstanceContextMode定义如下: // 摘要:     //     指定可用来处理包含在传入消息中的调用

一个简单的WCF服务

以订票为例简单应用wcf程序,需要的朋友可以参考下 WCF实例(带步骤) 复制代码代码如下: <xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" /> 本篇转自百度文档,自己试过,确实可以用. 以订票为例简单应用wcf 新建一个wcf服务应用程序 在IService1.cs定义服务契约 复制代码代码如下: namespace WcfDemo { // 注意: 如果