WCF服务创建多个内部对象？

Question

我是自托管WCF服务，并希望我的服务对象是一个单身人士。我的客户使用频道来访问该服务。主机和客户端是控制台应用程序，如下所示。

我的服务有一个方法，它返回一个内部对象的接口。该内部对象包含获取/设置数字的方法。我的服务有另外的方法来获取/设置内部对象的编号。

我的问题是通过服务返回的接口设置内部对象的编号，并使用服务方法（SetInternalNumber）设置它似乎没有设置相同的对象。当我检索值时，它们是不同的。

我的客户端应用程序显示内部对象的初始编号，更改该编号，获取对象的另一个接口及其初始值，通过服务设置值以及不同值的列表。

我认为我的内部对象的多个实例已经创建，但似乎并非如此。我知道这是因为我在对象构造函数中打印了一行，我只看到该行一次。

到底是怎么回事？我认为也许内部类必须被标记为单例（InstanceContextMde.Single），但这不起作用。

服务界面

[ServiceContract]
public interface IMyService
{
    [OperationContract]
    [ServiceKnownType(typeof(Internal))]
    IInternal GetMyInterface();

    [OperationContract]
    int GetInternalNumber();

    [OperationContract]
    void SetInternalNumber(int number);
}

服务实施

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
public class MyService : IMyService
{
    private IInternal _internal;

    public MyService()
    {
        Random rng = new Random();
        _internal = new Internal(rng.Next());
    }

    public int GetInternalNumber()
    {
        return _internal.GetNumber();
    }

    public IInternal GetMyInterface()
    {
        return _internal;
    }

    public void SetInternalNumber(int number)
    {
        _internal.SetNumber(number);
    }
}

内部对象接口

[ServiceContract]
public interface IInternal
{
    [OperationContract]
    int GetNumber();

    [OperationContract]
    void SetNumber(int number);
}

内部对象实现

[DataContract]
public class Internal : IInternal
{
    [DataMember]
    private int _number;

    public Internal(int number)
    {
        _number = number;
        Console.WriteLine($"creating Internal - {_number}");
    }

    public int GetNumber()
    {
        return _number;
    }

    public void SetNumber(int number)
    {
        _number = number;
    }
}

自助主机应用

    static void Main(string[] args)
    {
        Uri baseAddress = new Uri(@"http://localhost:12345/GettingStarted");            
        MyService singleton = new MyService();
        ServiceHost selfHost = new ServiceHost(singleton, baseAddress);

        try
        {
            selfHost.AddServiceEndpoint(typeof(IMyService), new BasicHttpBinding(), "MyService");
            ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
            smb.HttpGetEnabled = true;
            selfHost.Description.Behaviors.Add(smb);

            selfHost.Open();

            Console.WriteLine("host is open");
            Console.ReadLine();

            selfHost.Close();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"exception: {ex.Message}");
            Console.ReadLine();

            selfHost.Abort();
        }
    }

客户端应用

    static void Main(string[] args)
    {
        var myBinding = new BasicHttpBinding();
        var myEndpoint = new EndpointAddress(@"http://localhost:12345/GettingStarted/MyService");

        using (var myChannelFactory = new ChannelFactory<IMyService>(myBinding, myEndpoint))
        {
            IMyService service = null;

            try
            {
                service = myChannelFactory.CreateChannel();

                Console.WriteLine("channel created");

                // get interface to concrete object 
                IInternal myInternal = service.GetMyInterface();
                Console.WriteLine($"initial number = {myInternal.GetNumber()}");

                Console.ReadLine();

                // set a new # with Internal interface
                Console.WriteLine("set new number");
                myInternal.SetNumber(123);
                Console.WriteLine($"new number = {myInternal.GetNumber()}");

                Console.ReadLine();

                // get another interface, don't set its number
                Console.WriteLine("get another interface, initial value");
                IInternal anotherInternal = service.GetMyInterface();
                Console.WriteLine($"number(another) = {anotherInternal.GetNumber()}");

                Console.ReadLine();

                // set # with service
                Console.WriteLine("set # through server");
                service.SetInternalNumber(789);                    

                // what are the #s?
                Console.WriteLine();
                Console.WriteLine($"from Internal: {myInternal.GetNumber()}");                    
                Console.WriteLine($"from another Internal = {anotherInternal.GetNumber()}");
                Console.WriteLine($"from service = {service.GetInternalNumber()}");

                Console.ReadLine();

                ((ICommunicationObject)service).Close();
                myChannelFactory.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.ReadLine();

                (service as ICommunicationObject)?.Abort();
            }
        }
    }

Answer 1

Wcf是一个发送消息和接收消息的通信框架。

您返回内部的GetMyInterface方法将首先序列化为xml，然后当客户端收到消息时，它将反序列化消息以重建对象。

这意味着如果您的方法返回一个对象，它将始终不是同一个对象，并且与服务中的内部无关，因为客户端从消息重建它。您可以进行如下测试

 Console.WriteLine($"are the two internal the same?" + (myInternal == anotherInternal ? "the same" : "not the same"));

我的结果。

因为客户端中的两个内部和服务中的内部不一样，所以您的SetInternalNumber方法只会将数字设置为分隔内部对象而不会相互影响。

客户端内部只有内部服务的初始值，然后与它无关，并且彼此无关。这就是为什么您的两个客户端内部具有相同的初始编号。