WCF实例模式和对象生命周期

最新推荐文章于 2020-03-31 11:35:26 发布
最新推荐文章于 2020-03-31 11:35:26 发布
阅读量491 收藏 1
点赞数
分类专栏： .NET WCF 文章标签： wcf

1、WCF 几种服务对象实例创建模式

wcf中有三种服务对象实例创建模式：PerCall、PerSession、Single.(具体在哪里设置，最后例子中有很好的阐述)

2、几种模式下服务对象实例的生命周期(这里暂不考虑Mep=Message Exchange Pattern 信息交流模式 )

PerCall模式

这里写图片描述

PerCall模式工作流程如下

客户端创建代理对象(Proxy)
客户端调用代理对象的一个契约操作,代理对象将其传递给服务宿主程序
宿主应用程序创建一新的服务契约对象，并且执行请求操作
在执行完请求操作后，如果要求有应答，那么服务契约会给代理对象一个应答，然后销毁自己

示例代码展示

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

namespace Contract
{
    [ServiceContract(Name="CalculatorService",Namespace="http://www/gxs.com")]
    public interface ICalculator:IDisposable
    {
        [OperationContract(Name = "CalculatorAdd")]
        double Add(double x, double y);
        [OperationContract(Name = "CalculatorSubtract")]
        double Subtract(double x, double y);
    }
}

服务契约代码如下：

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

namespace Service
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall)]
    public class CalculatorPerCall:ICalculator
    {
        public CalculatorPerCall()
        {
            Console.WriteLine("Create a new instance!!!");
        }
        public double Add(double x, double y)
        {
            Console.WriteLine("Call [Add] Method");
            return x + y;
        }
        public double Subtract(double x, double y)
        {
            Console.WriteLine("Call [Subtract] Method");
            return x - y;
        }
        public void Dispose()
        {
            Console.WriteLine("The instance has been disposed!!!");
        }
    }
}

服务端宿主代码如下：

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

namespace Hosting
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServiceHost host = new ServiceHost(typeof(CalculatorPerCall)))
            {
                host.AddServiceEndpoint(typeof(ICalculator), new WSHttpBinding(), "http://127.0.0.1:8089/CalculatorService");
                //ServiceMetadataBehavior:控制服务元数据和相关信息的发布
                if (host.Description.Behaviors.Find<ServiceMetadataBehavior>() == null)
                {
                    ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
                    behavior.HttpGetEnabled = true;
                    behavior.HttpGetUrl = new Uri("http://127.0.0.1:8089/CalculatorService/metadata");
                    host.Description.Behaviors.Add(behavior);
                }
                host.Opened += new EventHandler(host_Opened);
                host.Open();
                Console.Read();
            }
        }

        static void host_Opened(object sender, EventArgs e)
        {
            Console.WriteLine("计算机服务已经被打开了......");
        }
    }
}

客户端代码如下：

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

namespace WcfLifeCycle.Client
{
    /// <summary>
    /// wcf实例模型
    /// </summary>
    public class ClientCalculator
    {
        public static void Main(string[] args)
        {
            CalculatorServiceClient proxy1 = new CalculatorServiceClient();
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("******************************************");
            CalculatorServiceClient proxy2= new CalculatorServiceClient();
            Console.WriteLine("proxy2 Call [Add] method");
            proxy2.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy2 Call [Add] method");
            proxy2.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy2 Call [Add] method");
            proxy2.CalculatorAdd(12d, 13d);
            Console.Read();
        }
    }
}

结果示例图

服务端：
这里写图片描述

客户端
这里写图片描述

小结：Percall模式，客户端每次发出请求后，服务端都会生成一个实例响应，响应完毕后自行销毁。

PerSession模式

这里写图片描述

PerSession模式工作的流程如下：

客户端创建代理对象(Proxy)
客户端第一次调用代理对象的一个契约操作，代理对象将其调用请求传递给服务宿主
宿主程序创建新的服务对象，并执行请求操作，如果有必要，返回客户端应答
客户端再次发出调用操作的请求（图中的proxy一与服务实例一对应，proxy二与服务实例二对应），宿主会先判断是否已有建立好的会话，如果存在，则不需要再创建新的服务对象，直接使用老对象即可，如果不存在则新建一个服务对象。
在时间达到指定要求或者因一些特殊原因，会话会过期，此时服务对象销毁.或者客户端关闭，服务对象也会自动销毁。

示例代码展示

服务契约代码如下：

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

namespace Contract
{
    [ServiceContract(Name="CalculatorService",Namespace="http://www/gxs.com")]
    public interface ICalculator:IDisposable
    {
        [OperationContract(Name = "CalculatorAdd")]
        double Add(double x, double y);
        [OperationContract(Name = "CalculatorSubtract")]
        double Subtract(double x, double y);
    }
}

服务代码如下：

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

namespace Service
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession)]
    public class CalculatorPerSession : ICalculator
    {
        public CalculatorPerSession()
        {
            Console.WriteLine("Create a new instance!!!");
        }
        public double Add(double x, double y)
        {
            Console.WriteLine("Call [Add] Method");
            return x + y;
        }
        public double Subtract(double x, double y)
        {
            Console.WriteLine("Call [Subtract] Method");
            return x - y;
        }
        public void Dispose()
        {
            Console.WriteLine("The instance has been disposed!!!");
        }
    }
}

服务端宿主代码

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

namespace Hosting
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServiceHost host = new ServiceHost(typeof(CalculatorPerSession)))
            {
                host.AddServiceEndpoint(typeof(ICalculator), new WSHttpBinding(), "http://127.0.0.1:8089/CalculatorService");
                //ServiceMetadataBehavior:控制服务元数据和相关信息的发布
                if (host.Description.Behaviors.Find<ServiceMetadataBehavior>() == null)
                {
                    ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
                    behavior.HttpGetEnabled = true;
                    behavior.HttpGetUrl = new Uri("http://127.0.0.1:8089/CalculatorService/metadata");
                    host.Description.Behaviors.Add(behavior);
                }
                host.Opened += new EventHandler(host_Opened);
                host.Open();
                Console.Read();
            }
        }
        static void host_Opened(object sender, EventArgs e)
        {
            Console.WriteLine("计算机服务已经被打开了......");
        }
    }
}

客户端代码如下：

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

namespace WcfLifeCycle.Client
{
    /// <summary>
    /// wcf实例模型
    /// </summary>
    public class ClientCalculator
    {
        public static void Main(string[] args)
        {
            CalculatorServiceClient proxy1 = new CalculatorServiceClient();
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("******************************************");
            CalculatorServiceClient proxy2= new CalculatorServiceClient();
            Console.WriteLine("proxy2 Call [Add] method");
            proxy2.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy2 Call [Add] method");
            proxy2.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy2 Call [Add] method");
            proxy2.CalculatorAdd(12d, 13d);
            Console.Read();
        }
    }
}

结果实例图

服务端
这里写图片描述

客户端
这里写图片描述

小结：PerSession模式，proxy与服务实例对应。不同的proxy有不同的服务实例。

Single模式

Single模式的工作流程如下：

服务端启动，同时创建服务对象
客户端通过代理调用契约操作
第一步中创建的服务对象接受请求 ，并执行操作，进行必要的应答
第一步创建的服务对象将一直保留
服务关闭，第一步创建的对象销毁

示例代码展示：

服务契约代码

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

namespace Contract
{
    [ServiceContract(Name="CalculatorService",Namespace="http://www/gxs.com")]
    public interface ICalculator:IDisposable
    {
        [OperationContract(Name = "CalculatorAdd")]
        double Add(double x, double y);
        [OperationContract(Name = "CalculatorSubtract")]
        double Subtract(double x, double y);
    }
}

服务代码

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

namespace Service
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
    public class CalculatorPerSingle : ICalculator
    {
        public CalculatorPerSingle()
        {
            Console.WriteLine("Create a new instance!!!");
        }
        public double Add(double x, double y)
        {
            Console.WriteLine("Call [Add] Method");
            return x + y;
        }
        public double Subtract(double x, double y)
        {
            Console.WriteLine("Call [Subtract] Method");
            return x - y;
        }
        public void Dispose()
        {
            Console.WriteLine("The instance has been disposed!!!");
        }
    }
}

服务端宿主代码

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

namespace Hosting
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServiceHost host = new ServiceHost(typeof(CalculatorPerSingle), new Uri("http://127.0.0.1:8089")))
            {
                host.AddServiceEndpoint(typeof(ICalculator), new WSHttpBinding(), "CalculatorServiceOne");
                host.AddServiceEndpoint(typeof(ICalculator), new WSHttpBinding(), "CalculatorServiceTwo");
                //ServiceMetadataBehavior:控制服务元数据和相关信息的发布
                if (host.Description.Behaviors.Find<ServiceMetadataBehavior>() == null)
                {
                    ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
                    behavior.HttpGetEnabled = true;
                    behavior.HttpGetUrl = new Uri("http://127.0.0.1:8089/CalculatorService/metadata");
                    host.Description.Behaviors.Add(behavior);
                }
                host.Opened += new EventHandler(host_Opened);
                host.Open();
                Console.Read();
            }
        }
        static void host_Opened(object sender, EventArgs e)
        {
            Console.WriteLine("计算机服务已经被打开了......");
        }
    }
}

客户端一代码

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

namespace WcfLifeCycle.Client
{
    /// <summary>
    /// wcf实例模型
    /// </summary>
    public class ClientOneCalculator
    {
        public static void Main(string[] args)
        {
            CalculatorServiceClient proxy1 = new CalculatorServiceClient("WSHttpBinding_CalculatorService");
            Console.WriteLine("I am EndPointOne");
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            proxy1.Close();
            Console.Read();
        }
    }
}

客户端一配置文件app.config

<?xml version="1.0"?>
<configuration>
    <system.serviceModel>
        <bindings>
            <wsHttpBinding>
                <binding name="WSHttpBinding_CalculatorService" closeTimeout="00:01:00"
                    openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
                    bypassProxyOnLocal="false" transactionFlow="false" hostNameComparisonMode="StrongWildcard"
                    maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
                    messageEncoding="Text" textEncoding="utf-8" useDefaultWebProxy="true"
                    allowCookies="false">
                    <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                        maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                    <reliableSession ordered="true" inactivityTimeout="00:10:00"
                        enabled="false" />
                    <security mode="Message">
                        <transport clientCredentialType="Windows" proxyCredentialType="None"
                            realm="" />
                        <message clientCredentialType="Windows" negotiateServiceCredential="true"
                            algorithmSuite="Default" />
                    </security>
                </binding>
                <binding name="WSHttpBinding_CalculatorService1" closeTimeout="00:01:00"
                    openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
                    bypassProxyOnLocal="false" transactionFlow="false" hostNameComparisonMode="StrongWildcard"
                    maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
                    messageEncoding="Text" textEncoding="utf-8" useDefaultWebProxy="true"
                    allowCookies="false">
                    <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                        maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                    <reliableSession ordered="true" inactivityTimeout="00:10:00"
                        enabled="false" />
                    <security mode="Message">
                        <transport clientCredentialType="Windows" proxyCredentialType="None"
                            realm="" />
                        <message clientCredentialType="Windows" negotiateServiceCredential="true"
                            algorithmSuite="Default" />
                    </security>
                </binding>
            </wsHttpBinding>
        </bindings>
        <client>
            <endpoint address="http://127.0.0.1:8089/CalculatorServiceOne"
                binding="wsHttpBinding" bindingConfiguration="WSHttpBinding_CalculatorService"
                contract="Client.CalculatorService" name="WSHttpBinding_CalculatorService">
                <identity>
                    <userPrincipalName value="guxiaoshi-PC\guxiaoshi" />
                </identity>
            </endpoint>
            <endpoint address="http://127.0.0.1:8089/CalculatorServiceTwo"
                binding="wsHttpBinding" bindingConfiguration="WSHttpBinding_CalculatorService1"
                contract="Client.CalculatorService" name="WSHttpBinding_CalculatorService1">
                <identity>
                    <userPrincipalName value="guxiaoshi-PC\guxiaoshi" />
                </identity>
            </endpoint>
        </client>
    </system.serviceModel>
<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>

客户端二代码

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

namespace ClientTwo
{
    class ClientTwoCalculator
    {
        static void Main(string[] args)
        {
            CalculatorServiceClient proxy1 = new CalculatorServiceClient("WSHttpBinding_CalculatorService1");
            Console.WriteLine("I am EndPointTwo");
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            Console.WriteLine("proxy1 Call [Add] method");
            proxy1.CalculatorAdd(12d, 13d);
            proxy1.Close();
            Console.Read();
        }
    }
}

客户端二配置文件app.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel>
        <bindings>
            <wsHttpBinding>
                <binding name="WSHttpBinding_CalculatorService" closeTimeout="00:01:00"
                    openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
                    bypassProxyOnLocal="false" transactionFlow="false" hostNameComparisonMode="StrongWildcard"
                    maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
                    messageEncoding="Text" textEncoding="utf-8" useDefaultWebProxy="true"
                    allowCookies="false">
                    <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                        maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                    <reliableSession ordered="true" inactivityTimeout="00:10:00"
                        enabled="false" />
                    <security mode="Message">
                        <transport clientCredentialType="Windows" proxyCredentialType="None"
                            realm="" />
                        <message clientCredentialType="Windows" negotiateServiceCredential="true"
                            algorithmSuite="Default" />
                    </security>
                </binding>
                <binding name="WSHttpBinding_CalculatorService1" closeTimeout="00:01:00"
                    openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00"
                    bypassProxyOnLocal="false" transactionFlow="false" hostNameComparisonMode="StrongWildcard"
                    maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
                    messageEncoding="Text" textEncoding="utf-8" useDefaultWebProxy="true"
                    allowCookies="false">
                    <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                        maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                    <reliableSession ordered="true" inactivityTimeout="00:10:00"
                        enabled="false" />
                    <security mode="Message">
                        <transport clientCredentialType="Windows" proxyCredentialType="None"
                            realm="" />
                        <message clientCredentialType="Windows" negotiateServiceCredential="true"
                            algorithmSuite="Default" />
                    </security>
                </binding>
            </wsHttpBinding>
        </bindings>
        <client>
            <endpoint address="http://127.0.0.1:8089/CalculatorServiceOne"
                binding="wsHttpBinding" bindingConfiguration="WSHttpBinding_CalculatorService"
                contract="Client.CalculatorService" name="WSHttpBinding_CalculatorService">
                <identity>
                    <userPrincipalName value="guxiaoshi-PC\guxiaoshi" />
                </identity>
            </endpoint>
            <endpoint address="http://127.0.0.1:8089/CalculatorServiceTwo"
                binding="wsHttpBinding" bindingConfiguration="WSHttpBinding_CalculatorService1"
                contract="Client.CalculatorService" name="WSHttpBinding_CalculatorService1">
                <identity>
                    <userPrincipalName value="guxiaoshi-PC\guxiaoshi" />
                </identity>
            </endpoint>
        </client>
    </system.serviceModel>
</configuration>

结果实例图

服务端
这里写图片描述

客户端一

这里写图片描述

客户端二

这里写图片描述

小结：服务端自始至终只有一个实例与客户端进行消息的交换。

总结：上文是对服务对象实例生命周期的介绍.Percall:新的请求产生新的服务对象与之交换信息，服务对象自行销毁；PerSession：相同的客户端由同一个服务对象与之交换信息(这里的客户端指proxy)；Single:服务端只有一个服务实例，服务打开时服务实例就会被创建。

.NET跨平台
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
WCF实例化服务-单调服务
02-21
在WCF中，服务实例化是控制服务对象创建的关键部分，而“单调服务”（Singleton Service）模式就是其中的一种实例化策略。这种模式确保任何时候只有一个服务实例存在，所有客户端请求都会共享这个单个实例。 **单调...
WCF实例行为
09-25
**WCF（Windows Communication Foundation）实例行为** WCF是微软.NET框架中的一种服务导向架构，用于构建可互操作的...通过学习和分析这些示例，你可以深入了解WCF实例行为的工作原理，并在实际项目中灵活运用。
WCF 学习总结3 -- 实例模式
Lullaby's Blog
01-09 7805
通过WCF的ServiceBehaviorAttribute设定InstanceContextMode有下面的3中模式： 1. Single —— 表示所有的客户端共享一个会话(服务对象)(服务关闭时才会销毁服务对象) 2. PerCall —— 表示每次调用都会创建一个会话(服务对象)(调用完毕后就会销毁服务对象) 3. PerSession —— 表示为每个连接(每个客户端代理对象) 创建一个
无废话WCF入门教程五[WCF的通信模式]
weixin_30808693的博客
10-03 372
一、概述 　　WCF在通信过程中有三种模式：请求与答复、单向、双工通信。以下我们一一介绍。 二、请求与答复模式 　　描述： 　　客户端发送请求，然后一直等待服务端的响应(异步调用除外)，期间处于假死状态，直到服务端有了答复后才能继续执行其他程序，如下图所示(图中的粗红线在此时代表顺序并不代表调用)： 　　请求与答复模式为WCF的默认模式，如下代码所示： 1 ...
WCF学习--WCF服务实例模式
rrrrssss00的专栏
09-21 4441
学习WCF的目的在于使用WCF建立服务，使Sivlerlight程序能够查询和修改Oracle数据的内容，数据库的操作不可避免要涉及数据库事务（Transaction），而基于数据库事务的操作则要求对于某特定客户端程序，开始事务（Transaction Begin）后，事务对象保持不变，才能保证Commit或Rollback操作的成功，为此，查询了相关资料，好像可以通过WCF的服务实例（Servi
WPF经典编程实例/C#/.NET/MVVM/WCF/XAML/WinForm
06-28
本课程通过一个个实战的案例，详细介绍了在WPF编程中用到的各种技巧，帮你进一步掌握WPF这种优秀的编程框架。也许你曾经为了一个WPF又酷又炫的功能，查遍资料却终无所获，最后无奈遗憾放弃。如果你学习了这门课程，要么再回味一下这门课程“曾经赵老师讲过，这样可以实现”，再看看视频，再看看代码，也许再也不留遗憾。如果你是WPF的开发人员、或者是WPF的爱好者，学习这门课，将为你节省大量自我探索的时间成本。
WCF - 服务实例管理模式
微软新技术
01-17 1018
WCF 提供了三种实例上下文模式：PreCall、PreSession 以及 Single。开发人员通过ServiceBehavior.InstanceContextMode 就可以很容易地控制服务对象的实例管理模式。而当 WCF释放服务对象时，会检查该对象是否实现了 IDisposable 接口，并调用其 Dispose方法，以便及时释放相关资源，同时也便于我们观察对象释放行为。1.
wcf实例demo
11-29
这将帮助初学者理解WCF服务的生命周期和调用流程。 另一方面，“WcfTestClient.zip”可能是一个客户端示例，其中包含了如何使用WCF客户端代理类来调用服务的方法。客户端通常通过`svcutil.exe`工具生成代理类，然后...
WCF实例程序
12-10
这个“WCF实例程序”包含了两个关键部分：HeartbeatHost（主机程序）和HeartbeatClient（客户端程序），它们是WCF服务和客户端交互的基本组件。 1. **WCF基础概念**： - **服务**: WCF服务是提供功能的实体，可以...
WCF实例-多种部署方式
08-26
- 单例模式：整个服务生命周期只有一个实例，适合低并发、高资源消耗的服务。 - 常驻实例模式：每个会话都有自己的实例，适用于需要保持状态的会话。 - 池化实例模式：通过池中的实例处理请求，节省资源，适用于...
WCF完整实例(Windows服务宿主)
10-26
一个傻瓜式的Windows服务宿主模式下的WCF的完整示例 全部文档包含：代码，说明文档，编译后文件 只注重于实现，不讲理论
WCF中实例模式(InstanceContextMode)与会话模式(SessionMode)
xwnxwn的专栏
03-31 890
InstanceContextMode为服务端实现服务契约类的实例模式，有三种类型，分别为：PerCall-每次服务操作调用创建一次， 调用完后进行销毁；PerSession-同一个会话期间创建一次，客户端代理第一次操作(IsInitiating = true)调用创建， 调用代理的Close方法销毁或者调用IsTerminating服务操作销毁；Single-服务只会创建一次，服务开始...
WCF实例生命周期
极客神殿
02-05 418
WCF的工作原理 首先： WCF的全称是Windows Communication Foundation，Windows通信基础的意思，是Microsoft为构建面向服务的应用程序而提供的统一编程模型，它整合.NET平台下所有和分布式系统有关的技术。 其次： WCF本质是面向服务的。主要分为服务端和客户端两部分。服务端和客户端进行通信的过程如下图所示： 在上图中，主机进程就是服务端，
WCF开发时如何选择正确的实例模式(InstanceMode)？
weixin_33753845的博客
10-12 102
在使用WCF实例模型时，你是否思考过这几个的问题：”WCF中的实例模式如何正确应用”？”使用WCF中的实例模式有何原则可以遵循吗”？  众所周知：客户端调用服务时，最终会将调用服务端的某个实例来完成。在WCF服务中，可以通过ServiceBehavior的InstanceContextMode设置服务实例。InstanceContextMode定义如下： // 摘要:    //     指定可用...
WCF的基本编程生命周期
weixin_33774615的博客
11-04 81
Windows Communication Foundation (WCF) 可让应用程序通报它们是在同一台计算机上、分布在 Internet 上还是在不同的应用程序平台上。本主题概述了生成 WCF 应用程序所需的任务。 基本任务 要执行的基本任务依次为： 定义服务协定。服务协定指定服务的签名、服务交换的数据和其他协定要求的数据。 实现协定。若要实现...
WCF服务的并发与实例管理模式解析
"WCF并发与实例管理是WCF（Windows Communication Foundation）服务的重要特性，涉及到如何处理多个同时到达的服务请求以及服务实例的生命周期管理。这一主题由金旭亮设计的教学资源详细讲解，旨在帮助开发者理解和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值