C# 远程终结点请求的确认地址与应用程序消息的地址不同

我正在为带有WPF客户端的聊天应用程序编写WCF双工服务。服务代码如下

IChatCallback

public interface IChatCallback
{
    #region Public Methods and Operators

    [OperationContract(IsOneWay = true)]
    void Receive(Person sender, string message);

    [OperationContract(IsOneWay = true)]
    void ReceiveWhisper(Person sender, string message);

    [OperationContract(IsOneWay = true)]
    void UserEnter(Person person);

    [OperationContract(IsOneWay = true)]
    void UserLeave(Person person);

    #endregion
}

IChatService

[ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(IChatCallback))]
public interface IChatService
{
    #region Public Methods and Operators

    [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = false)]
    void Say(string message);

    [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = false)]
    void Whisper(string to, string message);

    [OperationContract(IsOneWay = false, IsInitiating = true, IsTerminating = false)]
    Person[] Join(Person person);

    [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = true)]
    void Leave();

    #endregion
}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession, ConcurrencyMode = ConcurrencyMode.Multiple)]
public class ChatService : IChatService
{
    #region Static Fields

    private static object _syncObj = new object();

    private static Dictionary<Person, ChatEventHandler> _chatters = new Dictionary<Person, ChatEventHandler>();

    #endregion

    #region Fields

    private IChatCallback _callback = null;

    private ChatEventHandler _myEventHandler;

    private Person _person;

    #endregion

    #region Delegates

    public delegate void ChatEventHandler(object sender, ChatEventArgs e);

    #endregion

    #region Public Events

    public static event ChatEventHandler ChatEvent;

    #endregion

    #region Public Methods and Operators

    public void Say(string message)
    {
        ChatEventArgs e = new ChatEventArgs(MessageType.Receive, this._person, message);
        this.BroadcastMessage(e);
    }

    public void Whisper(string to, string message)
    {
        ChatEventArgs e = new ChatEventArgs(MessageType.ReceiveWhisper, this._person, message);
        try
        {
            ChatEventHandler chatterTo;
            lock (_syncObj)
            {
                chatterTo = this.GetPersonHandler(to);
                if (chatterTo == null)
                {
                    throw new KeyNotFoundException(
                        string.Format(
                            CultureInfo.InvariantCulture,
                            "The person with name [{0}] could not be found",
                            to));
                }
            }

            chatterTo.BeginInvoke(this, e, new AsyncCallback(EndAsync), null);
        }
        catch (KeyNotFoundException)
        {
        }
    }

    public Person[] Join(Person person)
    {
        bool userAdded = false;
        this._myEventHandler = new ChatEventHandler(this.MyEventHandler);

        lock (_syncObj)
        {
            if (!this.CheckIfPersonExists(person.Name) && person != null)
            {
                this._person = person;
                _chatters.Add(person, this.MyEventHandler);
                userAdded = true;
            }
        }

        if (userAdded)
        {
            this._callback = OperationContext.Current.GetCallbackChannel<IChatCallback>();
            ChatEventArgs e = new ChatEventArgs(MessageType.UserEnter, this._person);
            this.BroadcastMessage(e);
            ChatEvent += this._myEventHandler;
            Person[] list = new Person[_chatters.Count];

            lock (_syncObj)
            {
                _chatters.Keys.CopyTo(list, 0);
            }

            return list;
        }
        else
        {
            return null;
        }
    }

    public void Leave()
    {
        if (this._person == null)
        {
            return;
        }

        ChatEventHandler chatterToRemove = this.GetPersonHandler(this._person.Name);

        lock (_syncObj)
        {
            _chatters.Remove(this._person);
        }

        ChatEvent -= chatterToRemove;
        ChatEventArgs e = new ChatEventArgs(MessageType.UserLeave, this._person);
        this.BroadcastMessage(e);
    }

    #endregion

    private void MyEventHandler(object sender, ChatEventArgs e)
    {
        try
        {
            switch (e.MessageType)
            {
                case MessageType.Receive:
                    this._callback.Receive(e.Person, e.Message);
                    break;

                case MessageType.ReceiveWhisper:
                    this._callback.ReceiveWhisper(e.Person, e.Message);
                    break;

                case MessageType.UserEnter:
                    this._callback.UserEnter(e.Person);
                    break;

                case MessageType.UserLeave:
                    this._callback.UserLeave(e.Person);
                    break;
            }
        }
        catch
        {
            this.Leave();
        }
    }

    private void BroadcastMessage(ChatEventArgs e)
    {
        ChatEventHandler temp = ChatEvent;
        if (temp != null)
        {
            foreach (ChatEventHandler handler in temp.GetInvocationList())
            {
                handler.BeginInvoke(this, e, new AsyncCallback(this.EndAsync), null);
            }
        }
    }

    private bool CheckIfPersonExists(string name)
    {
        foreach (Person p in _chatters.Keys)
        {
            if (p.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }
        }

        return false;
    }

    private void EndAsync(IAsyncResult ar)
    {
        ChatEventHandler d = null;

        try
        {
            AsyncResult asres = (AsyncResult)ar;
            d = (ChatEventHandler)asres.AsyncDelegate;
            d.EndInvoke(ar);
        }
        catch
        {
            ChatEvent -= d;
        }
    }

    private ChatEventHandler GetPersonHandler(string name)
    {
        foreach (Person p in _chatters.Keys)
        {
            if (p.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
            {
                ChatEventHandler chatTo = null;
                _chatters.TryGetValue(p, out chatTo);
                return chatTo;
            }
        }

        return null;
    }
}

[GeneratedCode("System.ServiceModel", "4.0.0.0")]
[ServiceContract(ConfigurationName = "IChatService", CallbackContract = typeof(IChatServiceCallback), 
    SessionMode = SessionMode.Required)]
public interface IChatService
{
    #region Public Methods and Operators

    [OperationContract(IsOneWay = true, IsInitiating = false, Action = "http://tempuri.org/IChatService/Say")]
    void Say(string message);

    [OperationContract(IsOneWay = true, IsInitiating = false, AsyncPattern = true, 
        Action = "http://tempuri.org/IChatService/Say")]
    IAsyncResult BeginSay(string message, AsyncCallback callback, object asyncState);

    void EndSay(IAsyncResult result);

    [OperationContract(IsOneWay = true, IsInitiating = false, Action = "http://tempuri.org/IChatService/Whisper")]
    void Whisper(string to, string message);

    [OperationContract(IsOneWay = true, IsInitiating = false, AsyncPattern = true, 
        Action = "http://tempuri.org/IChatService/Whisper")]
    IAsyncResult BeginWhisper(string to, string message, AsyncCallback callback, object asyncState);

    void EndWhisper(IAsyncResult result);

    [OperationContract(Action = "http://tempuri.org/IChatService/Join", 
        ReplyAction = "http://tempuri.org/IChatService/JoinResponse")]
    Person[] Join(Person person);

    [OperationContract(AsyncPattern = true, Action = "http://tempuri.org/IChatService/Join", 
        ReplyAction = "http://tempuri.org/IChatService/JoinResponse")]
    IAsyncResult BeginJoin(Person person, AsyncCallback callback, object asyncState);

    Person[] EndJoin(IAsyncResult result);

    [OperationContract(IsOneWay = true, IsTerminating = true, IsInitiating = false, 
        Action = "http://tempuri.org/IChatService/Leave")]
    void Leave();

    [OperationContract(IsOneWay = true, IsTerminating = true, IsInitiating = false, AsyncPattern = true, 
        Action = "http://tempuri.org/IChatService/Leave")]
    IAsyncResult BeginLeave(AsyncCallback callback, object asyncState);

    void EndLeave(IAsyncResult result);

    #endregion
}

聊天室

[ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(IChatCallback))]
public interface IChatService
{
    #region Public Methods and Operators

    [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = false)]
    void Say(string message);

    [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = false)]
    void Whisper(string to, string message);

    [OperationContract(IsOneWay = false, IsInitiating = true, IsTerminating = false)]
    Person[] Join(Person person);

    [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = true)]
    void Leave();

    #endregion
}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession, ConcurrencyMode = ConcurrencyMode.Multiple)]
public class ChatService : IChatService
{
    #region Static Fields

    private static object _syncObj = new object();

    private static Dictionary<Person, ChatEventHandler> _chatters = new Dictionary<Person, ChatEventHandler>();

    #endregion

    #region Fields

    private IChatCallback _callback = null;

    private ChatEventHandler _myEventHandler;

    private Person _person;

    #endregion

    #region Delegates

    public delegate void ChatEventHandler(object sender, ChatEventArgs e);

    #endregion

    #region Public Events

    public static event ChatEventHandler ChatEvent;

    #endregion

    #region Public Methods and Operators

    public void Say(string message)
    {
        ChatEventArgs e = new ChatEventArgs(MessageType.Receive, this._person, message);
        this.BroadcastMessage(e);
    }

    public void Whisper(string to, string message)
    {
        ChatEventArgs e = new ChatEventArgs(MessageType.ReceiveWhisper, this._person, message);
        try
        {
            ChatEventHandler chatterTo;
            lock (_syncObj)
            {
                chatterTo = this.GetPersonHandler(to);
                if (chatterTo == null)
                {
                    throw new KeyNotFoundException(
                        string.Format(
                            CultureInfo.InvariantCulture,
                            "The person with name [{0}] could not be found",
                            to));
                }
            }

            chatterTo.BeginInvoke(this, e, new AsyncCallback(EndAsync), null);
        }
        catch (KeyNotFoundException)
        {
        }
    }

    public Person[] Join(Person person)
    {
        bool userAdded = false;
        this._myEventHandler = new ChatEventHandler(this.MyEventHandler);

        lock (_syncObj)
        {
            if (!this.CheckIfPersonExists(person.Name) && person != null)
            {
                this._person = person;
                _chatters.Add(person, this.MyEventHandler);
                userAdded = true;
            }
        }

        if (userAdded)
        {
            this._callback = OperationContext.Current.GetCallbackChannel<IChatCallback>();
            ChatEventArgs e = new ChatEventArgs(MessageType.UserEnter, this._person);
            this.BroadcastMessage(e);
            ChatEvent += this._myEventHandler;
            Person[] list = new Person[_chatters.Count];

            lock (_syncObj)
            {
                _chatters.Keys.CopyTo(list, 0);
            }

            return list;
        }
        else
        {
            return null;
        }
    }

    public void Leave()
    {
        if (this._person == null)
        {
            return;
        }

        ChatEventHandler chatterToRemove = this.GetPersonHandler(this._person.Name);

        lock (_syncObj)
        {
            _chatters.Remove(this._person);
        }

        ChatEvent -= chatterToRemove;
        ChatEventArgs e = new ChatEventArgs(MessageType.UserLeave, this._person);
        this.BroadcastMessage(e);
    }

    #endregion

    private void MyEventHandler(object sender, ChatEventArgs e)
    {
        try
        {
            switch (e.MessageType)
            {
                case MessageType.Receive:
                    this._callback.Receive(e.Person, e.Message);
                    break;

                case MessageType.ReceiveWhisper:
                    this._callback.ReceiveWhisper(e.Person, e.Message);
                    break;

                case MessageType.UserEnter:
                    this._callback.UserEnter(e.Person);
                    break;

                case MessageType.UserLeave:
                    this._callback.UserLeave(e.Person);
                    break;
            }
        }
        catch
        {
            this.Leave();
        }
    }

    private void BroadcastMessage(ChatEventArgs e)
    {
        ChatEventHandler temp = ChatEvent;
        if (temp != null)
        {
            foreach (ChatEventHandler handler in temp.GetInvocationList())
            {
                handler.BeginInvoke(this, e, new AsyncCallback(this.EndAsync), null);
            }
        }
    }

    private bool CheckIfPersonExists(string name)
    {
        foreach (Person p in _chatters.Keys)
        {
            if (p.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }
        }

        return false;
    }

    private void EndAsync(IAsyncResult ar)
    {
        ChatEventHandler d = null;

        try
        {
            AsyncResult asres = (AsyncResult)ar;
            d = (ChatEventHandler)asres.AsyncDelegate;
            d.EndInvoke(ar);
        }
        catch
        {
            ChatEvent -= d;
        }
    }

    private ChatEventHandler GetPersonHandler(string name)
    {
        foreach (Person p in _chatters.Keys)
        {
            if (p.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
            {
                ChatEventHandler chatTo = null;
                _chatters.TryGetValue(p, out chatTo);
                return chatTo;
            }
        }

        return null;
    }
}

[GeneratedCode("System.ServiceModel", "4.0.0.0")]
[ServiceContract(ConfigurationName = "IChatService", CallbackContract = typeof(IChatServiceCallback), 
    SessionMode = SessionMode.Required)]
public interface IChatService
{
    #region Public Methods and Operators

    [OperationContract(IsOneWay = true, IsInitiating = false, Action = "http://tempuri.org/IChatService/Say")]
    void Say(string message);

    [OperationContract(IsOneWay = true, IsInitiating = false, AsyncPattern = true, 
        Action = "http://tempuri.org/IChatService/Say")]
    IAsyncResult BeginSay(string message, AsyncCallback callback, object asyncState);

    void EndSay(IAsyncResult result);

    [OperationContract(IsOneWay = true, IsInitiating = false, Action = "http://tempuri.org/IChatService/Whisper")]
    void Whisper(string to, string message);

    [OperationContract(IsOneWay = true, IsInitiating = false, AsyncPattern = true, 
        Action = "http://tempuri.org/IChatService/Whisper")]
    IAsyncResult BeginWhisper(string to, string message, AsyncCallback callback, object asyncState);

    void EndWhisper(IAsyncResult result);

    [OperationContract(Action = "http://tempuri.org/IChatService/Join", 
        ReplyAction = "http://tempuri.org/IChatService/JoinResponse")]
    Person[] Join(Person person);

    [OperationContract(AsyncPattern = true, Action = "http://tempuri.org/IChatService/Join", 
        ReplyAction = "http://tempuri.org/IChatService/JoinResponse")]
    IAsyncResult BeginJoin(Person person, AsyncCallback callback, object asyncState);

    Person[] EndJoin(IAsyncResult result);

    [OperationContract(IsOneWay = true, IsTerminating = true, IsInitiating = false, 
        Action = "http://tempuri.org/IChatService/Leave")]
    void Leave();

    [OperationContract(IsOneWay = true, IsTerminating = true, IsInitiating = false, AsyncPattern = true, 
        Action = "http://tempuri.org/IChatService/Leave")]
    IAsyncResult BeginLeave(AsyncCallback callback, object asyncState);

    void EndLeave(IAsyncResult result);

    #endregion
}

IChatService

[ServiceContract(SessionMode = SessionMode.Required, CallbackContract = typeof(IChatCallback))]
public interface IChatService
{
    #region Public Methods and Operators

    [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = false)]
    void Say(string message);

    [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = false)]
    void Whisper(string to, string message);

    [OperationContract(IsOneWay = false, IsInitiating = true, IsTerminating = false)]
    Person[] Join(Person person);

    [OperationContract(IsOneWay = true, IsInitiating = false, IsTerminating = true)]
    void Leave();

    #endregion
}

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerSession, ConcurrencyMode = ConcurrencyMode.Multiple)]
public class ChatService : IChatService
{
    #region Static Fields

    private static object _syncObj = new object();

    private static Dictionary<Person, ChatEventHandler> _chatters = new Dictionary<Person, ChatEventHandler>();

    #endregion

    #region Fields

    private IChatCallback _callback = null;

    private ChatEventHandler _myEventHandler;

    private Person _person;

    #endregion

    #region Delegates

    public delegate void ChatEventHandler(object sender, ChatEventArgs e);

    #endregion

    #region Public Events

    public static event ChatEventHandler ChatEvent;

    #endregion

    #region Public Methods and Operators

    public void Say(string message)
    {
        ChatEventArgs e = new ChatEventArgs(MessageType.Receive, this._person, message);
        this.BroadcastMessage(e);
    }

    public void Whisper(string to, string message)
    {
        ChatEventArgs e = new ChatEventArgs(MessageType.ReceiveWhisper, this._person, message);
        try
        {
            ChatEventHandler chatterTo;
            lock (_syncObj)
            {
                chatterTo = this.GetPersonHandler(to);
                if (chatterTo == null)
                {
                    throw new KeyNotFoundException(
                        string.Format(
                            CultureInfo.InvariantCulture,
                            "The person with name [{0}] could not be found",
                            to));
                }
            }

            chatterTo.BeginInvoke(this, e, new AsyncCallback(EndAsync), null);
        }
        catch (KeyNotFoundException)
        {
        }
    }

    public Person[] Join(Person person)
    {
        bool userAdded = false;
        this._myEventHandler = new ChatEventHandler(this.MyEventHandler);

        lock (_syncObj)
        {
            if (!this.CheckIfPersonExists(person.Name) && person != null)
            {
                this._person = person;
                _chatters.Add(person, this.MyEventHandler);
                userAdded = true;
            }
        }

        if (userAdded)
        {
            this._callback = OperationContext.Current.GetCallbackChannel<IChatCallback>();
            ChatEventArgs e = new ChatEventArgs(MessageType.UserEnter, this._person);
            this.BroadcastMessage(e);
            ChatEvent += this._myEventHandler;
            Person[] list = new Person[_chatters.Count];

            lock (_syncObj)
            {
                _chatters.Keys.CopyTo(list, 0);
            }

            return list;
        }
        else
        {
            return null;
        }
    }

    public void Leave()
    {
        if (this._person == null)
        {
            return;
        }

        ChatEventHandler chatterToRemove = this.GetPersonHandler(this._person.Name);

        lock (_syncObj)
        {
            _chatters.Remove(this._person);
        }

        ChatEvent -= chatterToRemove;
        ChatEventArgs e = new ChatEventArgs(MessageType.UserLeave, this._person);
        this.BroadcastMessage(e);
    }

    #endregion

    private void MyEventHandler(object sender, ChatEventArgs e)
    {
        try
        {
            switch (e.MessageType)
            {
                case MessageType.Receive:
                    this._callback.Receive(e.Person, e.Message);
                    break;

                case MessageType.ReceiveWhisper:
                    this._callback.ReceiveWhisper(e.Person, e.Message);
                    break;

                case MessageType.UserEnter:
                    this._callback.UserEnter(e.Person);
                    break;

                case MessageType.UserLeave:
                    this._callback.UserLeave(e.Person);
                    break;
            }
        }
        catch
        {
            this.Leave();
        }
    }

    private void BroadcastMessage(ChatEventArgs e)
    {
        ChatEventHandler temp = ChatEvent;
        if (temp != null)
        {
            foreach (ChatEventHandler handler in temp.GetInvocationList())
            {
                handler.BeginInvoke(this, e, new AsyncCallback(this.EndAsync), null);
            }
        }
    }

    private bool CheckIfPersonExists(string name)
    {
        foreach (Person p in _chatters.Keys)
        {
            if (p.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }
        }

        return false;
    }

    private void EndAsync(IAsyncResult ar)
    {
        ChatEventHandler d = null;

        try
        {
            AsyncResult asres = (AsyncResult)ar;
            d = (ChatEventHandler)asres.AsyncDelegate;
            d.EndInvoke(ar);
        }
        catch
        {
            ChatEvent -= d;
        }
    }

    private ChatEventHandler GetPersonHandler(string name)
    {
        foreach (Person p in _chatters.Keys)
        {
            if (p.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
            {
                ChatEventHandler chatTo = null;
                _chatters.TryGetValue(p, out chatTo);
                return chatTo;
            }
        }

        return null;
    }
}

[GeneratedCode("System.ServiceModel", "4.0.0.0")]
[ServiceContract(ConfigurationName = "IChatService", CallbackContract = typeof(IChatServiceCallback), 
    SessionMode = SessionMode.Required)]
public interface IChatService
{
    #region Public Methods and Operators

    [OperationContract(IsOneWay = true, IsInitiating = false, Action = "http://tempuri.org/IChatService/Say")]
    void Say(string message);

    [OperationContract(IsOneWay = true, IsInitiating = false, AsyncPattern = true, 
        Action = "http://tempuri.org/IChatService/Say")]
    IAsyncResult BeginSay(string message, AsyncCallback callback, object asyncState);

    void EndSay(IAsyncResult result);

    [OperationContract(IsOneWay = true, IsInitiating = false, Action = "http://tempuri.org/IChatService/Whisper")]
    void Whisper(string to, string message);

    [OperationContract(IsOneWay = true, IsInitiating = false, AsyncPattern = true, 
        Action = "http://tempuri.org/IChatService/Whisper")]
    IAsyncResult BeginWhisper(string to, string message, AsyncCallback callback, object asyncState);

    void EndWhisper(IAsyncResult result);

    [OperationContract(Action = "http://tempuri.org/IChatService/Join", 
        ReplyAction = "http://tempuri.org/IChatService/JoinResponse")]
    Person[] Join(Person person);

    [OperationContract(AsyncPattern = true, Action = "http://tempuri.org/IChatService/Join", 
        ReplyAction = "http://tempuri.org/IChatService/JoinResponse")]
    IAsyncResult BeginJoin(Person person, AsyncCallback callback, object asyncState);

    Person[] EndJoin(IAsyncResult result);

    [OperationContract(IsOneWay = true, IsTerminating = true, IsInitiating = false, 
        Action = "http://tempuri.org/IChatService/Leave")]
    void Leave();

    [OperationContract(IsOneWay = true, IsTerminating = true, IsInitiating = false, AsyncPattern = true, 
        Action = "http://tempuri.org/IChatService/Leave")]
    IAsyncResult BeginLeave(AsyncCallback callback, object asyncState);

    void EndLeave(IAsyncResult result);

    #endregion
}

IChatServiceChannel

[GeneratedCode("System.ServiceModel", "4.0.0.0")]
public interface IChatServiceChannel : IChatService, IClientChannel
{
}

和聊天代理

[DebuggerStepThrough]
[GeneratedCode("System.ServiceModel", "4.0.0.0")]
public class ChatProxy : DuplexClientBase<IChatService>, IChatService
{
    #region Constructors and Destructors

    public ChatProxy(InstanceContext callbackInstance)
        : base(callbackInstance)
    {
    }

    public ChatProxy(InstanceContext callbackInstance, string endpointConfigurationName)
        : base(callbackInstance, endpointConfigurationName)
    {
    }

    public ChatProxy(InstanceContext callbackInstance, string endpointConfigurationName, string remoteAddress)
        : base(callbackInstance, endpointConfigurationName, remoteAddress)
    {
    }

    public ChatProxy(
        InstanceContext callbackInstance, 
        string endpointConfigurationName, 
        EndpointAddress remoteAddress)
        : base(callbackInstance, endpointConfigurationName, remoteAddress)
    {
    }

    public ChatProxy(InstanceContext callbackInstance, Binding binding, EndpointAddress remoteAddress)
        : base(callbackInstance, binding, remoteAddress)
    {
    }

    #endregion

    #region Public Methods and Operators

    public void Say(string message)
    {
        this.Channel.Say(message);
    }

    public IAsyncResult BeginSay(string message, AsyncCallback callback, object asyncState)
    {
        return this.Channel.BeginSay(message, callback, asyncState);
    }

    public void EndSay(IAsyncResult result)
    {
        this.Channel.EndSay(result);
    }

    public void Whisper(string to, string message)
    {
        this.Channel.Whisper(to, message);
    }

    public IAsyncResult BeginWhisper(string to, string message, AsyncCallback callback, object asyncState)
    {
        return this.Channel.BeginWhisper(to, message, callback, asyncState);
    }

    public void EndWhisper(IAsyncResult result)
    {
        this.Channel.EndWhisper(result);
    }

    public Person[] Join(Person person)
    {
        return this.Channel.Join(person);
    }

    public IAsyncResult BeginJoin(Person person, AsyncCallback callback, object asyncState)
    {
        return this.Channel.BeginJoin(person, callback, asyncState);
    }

    public Person[] EndJoin(IAsyncResult result)
    {
        return this.Channel.EndJoin(result);
    }

    public void Leave()
    {
        this.Channel.Leave();
    }

    public IAsyncResult BeginLeave(AsyncCallback callback, object asyncState)
    {
        return this.Channel.BeginLeave(callback, asyncState);
    }

    public void EndLeave(IAsyncResult result)
    {
        this.Channel.EndLeave(result);
    }

    #endregion
}

我得到的错误是：

远程终结点请求的确认地址与应用程序消息的地址不同。无法打开通道，因为不支持此操作。确保用于创建通道的终结点地址与设置远程终结点时使用的地址相同

我的问题（很抱歉写了这么长的帖子，但我完全被困在这个问题上）就是，是否有其他人遇到过这个问题，请告诉我答案

编辑：

---

我已经更新了服务器和客户端的完整serviceModel部分，还更新了ProxySingleton，以显示它确实实现了回调接口

主持人:

客户端回调：

public class SimpleChatCallback : IChatServiceCallback
{
    public void Receive(Person sender, string message)
    {
        Console.WriteLine("{0}: {1}", sender.Name, message);
    }

    public void ReceiveWhisper(Person sender, string message)
    {
        Console.WriteLine("{0}: {1}", sender.Name, message);
    }

    public void UserEnter(Person person)
    {
        Console.WriteLine("{0} has entered", person.Name);
    }

    public void UserLeave(Person person)
    {
        Console.WriteLine("{0} has left", person.Name);
    }
}

主机配置：

  <system.serviceModel>
    <services>
      <service behaviorConfiguration="mexBehavior" name="ChatLib.ChatService">
        <clear />
        <endpoint address="ChatService.svc" binding="netTcpBinding" bindingConfiguration=""
          name="netTcpEndpoint" bindingName="NonSecureTcpBinding" contract="Common.IChatService" />
        <endpoint binding="mexHttpBinding" bindingConfiguration="mexHttpBinding"
          name="mexHttpEndpoint" contract="IMetadataExchange" />
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:33334/chatservice" />
            <add baseAddress="net.tcp://localhost:33333/chatservice" />
          </baseAddresses>
          <timeouts openTimeout="00:10:00" />
        </host>
      </service>
    </services>
    <bindings>
      <netTcpBinding>
        <binding name="NonSecureTcpBinding">
          <security mode="None">
            <transport clientCredentialType="None" protectionLevel="None" />
            <message clientCredentialType="None" />
          </security>
        </binding>
      </netTcpBinding>
      <mexHttpBinding>
        <binding name="mexHttpBinding" />
      </mexHttpBinding>
    </bindings>
    <behaviors>
      <serviceBehaviors>
        <behavior name="mexBehavior">
          <serviceDebug includeExceptionDetailInFaults="true" />
          <serviceMetadata httpGetEnabled="true" httpsGetEnabled="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <protocolMapping>
      <remove scheme="net.tcp" />
      <add scheme="net.tcp" binding="netTcpBinding" bindingConfiguration="NonSecureTcpBinding" />
      <add scheme="https" binding="basicHttpsBinding" />
    </protocolMapping>
    <serviceHostingEnvironment multipleSiteBindingsEnabled="true" />
  </system.serviceModel>

客户端1输出：


客户端2输出：


注:

servicerence1
是Visual Studio分配给生成的代理客户端的默认命名空间
ChatServiceClient

ChatLib
是本地分配给
ChatService
实现的名称空间。
首先，如果发布配置文件的整个
部分，效果会更好。在
ProxySingleton
中，将
此
作为参数传递给
InstanceContext
。
ProxySingleton
是否实现了
IChatServiceCallback
？还有，您为什么没有遵循添加->服务引用的标准过程。。。您是否正在手动创建服务代理客户端？WCF错误消息可能很难确定。启用跟踪非常有用：我们自己创建服务代理客户端是一项艰巨的任务。是你干的吗？如果您这样做了，我还建议从您的客户机通过标准过程（添加->服务引用）生成服务代理。在服务主机的
App.config
的
中，您可能希望添加一个http基址，以帮助从该端口创建代理：
，并在主机的
App.config
中添加代理，您可能需要设置
httpGetEnabled=true
：
这样，您就可以自动生成代理类。在Visual Studio中添加ServiceReference和使用svcuti有什么区别，我知道，在我上面实现的任何情况下，在引擎盖下添加使用svcutil的ServiceReference和添加服务引用都是可行的，但这仍然不能回答与我收到的错误消息相关的问题。不过我相信，我收到的错误消息与svcutil和Add->Service Reference之间的差异有关。使用svcutil生成的客户端为异步方法添加了BeginJoin和EndJoin，而Add->Service引用添加了JoinAsync，我相信错误表明对BeginJoin和EndJoin的调用无效，如果错误不太常见，则会更有帮助！！我认为svcutil使用的是.NET4.0框架。同时，由于这解决了我的问题，我觉得奖励奖金是公平的。谢谢！我通过VS和svcutil生成了代理客户端。在这两种情况下，所有方法都是成对生成的MethodName/MethodNameAsync，例如Join/JoinAsync。没有开始/结束连接。因此，差异必须存在于svcuti命令行或配置文件中。
<system.serviceModel>
    <bindings>
        <netTcpBinding>
            <binding name="netTcpEndpoint" />
        </netTcpBinding>
    </bindings>
    <client>
        <endpoint address="net.tcp://localhost:33333/chatservice/ChatService.svc"
            binding="netTcpBinding" bindingConfiguration="netTcpEndpoint"
            contract="ServiceReference1.IChatService" name="netTcpEndpoint">
            <identity>
                <userPrincipalName value="ComputerName\UserName" />
            </identity>
        </endpoint>
    </client>
</system.serviceModel>