实验5 wcf消息通信练习

好的，以下是一些WCF消息通信的练习：

1. 创建一个WCF服务契约，包含一个服务操作，接受一个自定义的消息类型作为参数，并返回一个自定义的响应消息类型。

2. 创建一个WCF客户端代理，调用服务操作，并传递一个自定义的消息类型作为参数。

3. 在客户端代理中使用自定义的编解码器，将消息序列化为XML格式，并发送给服务端。

4. 在服务端实现服务契约中定义的操作，处理客户端发送的消息，并返回一个自定义的响应消息类型。

5. 在客户端代理中使用自定义的编解码器，将响应消息反序列化为对象，并返回给调用方。

6. 配置WCF服务和客户端，指定使用的传输协议、绑定和终结点等。

需要注意的是，实现自定义的消息类型和编解码器需要一定的编程技巧和经验。在实际开发中，可以参考WCF官方文档和相关教程，逐步掌握WCF消息通信的技术和方法。

相关问题

实验5 wcf消息通信练习代码

以下是一个简单的WCF消息通信的示例代码，供参考：

服务契约：

[ServiceContract]
public interface IMyService
{
    [OperationContract]
    MyResponseMessage DoSomething(MyRequestMessage request);
}

[MessageContract]
public class MyRequestMessage
{
    [MessageBodyMember]
    public string Text { get; set; }
}

[MessageContract]
public class MyResponseMessage
{
    [MessageBodyMember]
    public int Result { get; set; }
}

服务实现：

public class MyService : IMyService
{
    public MyResponseMessage DoSomething(MyRequestMessage request)
    {
        int result = 0;
        // 处理请求消息
        // ...
        // 返回响应消息
        return new MyResponseMessage { Result = result };
    }
}

客户端代理：

public class MyClient : ClientBase<IMyService>, IMyService
{
    public MyResponseMessage DoSomething(MyRequestMessage request)
    {
        // 将消息序列化为XML格式
        XmlSerializer serializer = new XmlSerializer(typeof(MyRequestMessage));
        StringWriter writer = new StringWriter();
        serializer.Serialize(writer, request);
        string xml = writer.ToString();

        // 调用服务操作
        string resultXml = base.Channel.DoSomething(xml);

        // 将响应消息反序列化为对象
        XmlSerializer resultSerializer = new XmlSerializer(typeof(MyResponseMessage));
        StringReader resultReader = new StringReader(resultXml);
        MyResponseMessage result = (MyResponseMessage)resultSerializer.Deserialize(resultReader);

        return result;
    }
}

自定义编解码器：

public class MyMessageEncoder : MessageEncoder
{
    private const string XmlMediaType = "text/xml";

    private readonly XmlWriterSettings _writerSettings;

    public MyMessageEncoder()
    {
        _writerSettings = new XmlWriterSettings
        {
            Encoding = Encoding.UTF8,
            OmitXmlDeclaration = true
        };
    }

    public override string ContentType => XmlMediaType;

    public override string MediaType => XmlMediaType;

    public override MessageVersion MessageVersion => MessageVersion.Soap11;

    public override bool IsContentTypeSupported(string contentType)
    {
        return contentType == XmlMediaType || base.IsContentTypeSupported(contentType);
    }

    public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
    {
        byte[] messageBytes = buffer.Array;
        int messageOffset = buffer.Offset;
        int messageLength = buffer.Count;

        MemoryStream stream = new MemoryStream(messageBytes, messageOffset, messageLength);
        XmlReader reader = XmlReader.Create(stream);

        return Message.CreateMessage(reader, int.MaxValue, MessageVersion);
    }

    public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
    {
        MemoryStream stream = new MemoryStream();
        XmlWriter writer = XmlWriter.Create(stream, _writerSettings);
        message.WriteMessage(writer);
        writer.Flush();

        byte[] messageBytes = stream.ToArray();

        int totalLength = messageBytes.Length + messageOffset;
        byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
        Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageBytes.Length);

        ArraySegment<byte> byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageBytes.Length);

        return byteArray;
    }
}

客户端代理使用自定义编解码器：

public class MyClient : ClientBase<IMyService>, IMyService
{
    public MyResponseMessage DoSomething(MyRequestMessage request)
    {
        // 将消息序列化为XML格式
        XmlSerializer serializer = new XmlSerializer(typeof(MyRequestMessage));
        StringWriter writer = new StringWriter();
        serializer.Serialize(writer, request);
        string xml = writer.ToString();

        // 使用自定义编解码器发送消息
        MyMessageEncoder encoder = new MyMessageEncoder();
        Message requestMessage = Message.CreateMessage(MessageVersion.Soap11, "", xml);
        requestMessage.Headers.To = new Uri(base.Endpoint.Address.Uri, "DoSomething");
        Message responseMessage = base.Channel.Request(requestMessage, encoder);

        // 将响应消息反序列化为对象
        XmlSerializer resultSerializer = new XmlSerializer(typeof(MyResponseMessage));
        StringReader resultReader = new StringReader(responseMessage.GetBody<string>());
        MyResponseMessage result = (MyResponseMessage)resultSerializer.Deserialize(resultReader);

        return result;
    }
}

服务端使用自定义编解码器：

public class MyService : IMyService
{
    public MyResponseMessage DoSomething(MyRequestMessage request)
    {
        // 将消息反序列化为对象
        XmlSerializer serializer = new XmlSerializer(typeof(MyRequestMessage));
        StringReader reader = new StringReader(request);
        MyRequestMessage message = (MyRequestMessage)serializer.Deserialize(reader);

        int result = 0;
        // 处理请求消息
        // ...
        // 返回响应消息
        MyResponseMessage response = new MyResponseMessage { Result = result };

        // 将响应消息序列化为XML格式
        StringWriter writer = new StringWriter();
        XmlSerializer resultSerializer = new XmlSerializer(typeof(MyResponseMessage));
        resultSerializer.Serialize(writer, response);
        string resultXml = writer.ToString();

        // 使用自定义编解码器发送响应消息
        MyMessageEncoder encoder = new MyMessageEncoder();
        Message responseMessage = Message.CreateMessage(MessageVersion.Soap11, "", resultXml);
        return responseMessage;
    }
}

配置WCF服务和客户端：

<system.serviceModel>
  <bindings>
    <customBinding>
      <binding name="MyBinding">
        <textMessageEncoding messageVersion="Soap11" />
        <httpTransport />
      </binding>
    </customBinding>
  </bindings>
  <services>
    <service name="MyService">
      <endpoint address="" binding="customBinding" bindingConfiguration="MyBinding" contract="IMyService" />
    </service>
  </services>
  <client>
    <endpoint address="http://localhost/MyService" binding="customBinding" bindingConfiguration="MyBinding" contract="IMyService" />
  </client>
</system.serviceModel>

以上是一个简单的WCF消息通信的示例，可以根据实际需求进行修改和扩展。

signalr与wcf双工通信的优劣

SignalR和WCF都可以用于双工通信，但它们具有不同的优缺点。

SignalR是一种轻量级的跨平台实时通信框架，它可以在Web应用程序和移动应用程序之间实现实时通信。它使用WebSockets、Server-Sent Events(SSE)和长轮询等技术来提供实时通信服务。SignalR具有以下优点：

1. 高效性：SignalR使用WebSockets技术可以实现高效的双向通信，可以在客户端和服务器之间传输数据，而不需要频繁地发送HTTP请求。

2. 跨平台：SignalR可以在多个平台上运行，包括Windows、Linux、macOS等，可以在Web应用程序和移动应用程序之间实现实时通信。

3. 简单易用：SignalR的API简单易用，可以快速开始构建实时应用程序。

WCF是一种基于SOAP协议的通信框架，它可以用于构建分布式应用程序。WCF可以实现双工通信，但是相对于SignalR来说，它有以下缺点：

1. 复杂性：WCF的配置和使用相对比较复杂，需要进行大量的配置才能实现双工通信。

2. 性能：WCF使用SOAP协议进行通信，相对于SignalR来说，它的性能较低。

综上所述，如果需要构建实时通信应用程序，SignalR是更好的选择。如果需要构建分布式应用程序，并且对性能和可扩展性要求较高，可以考虑使用WCF。