C# 通用通信框架模式（处理和公开接收的数据）

我目前正在开发一个基于socket的通用通信“框架”实现，该框架在C#和Android之间工作，我在这方面做得很好

构建服务器和客户机非常简单。在技术上没有太大的挑战

此时，实现包含两个主要组件

AndroidTcpListener（tcp套接字类 （处理通信的）处理通信的 AndroidTcpServer（创建 TcpListener和 处理接收到的数据（从 TcpListener）当接收到数据时）

数据在客户端和客户端之间发送 使用标准XML的服务器 序列化程序（我可能会在某些时候转换为JSON） 这一点我暂时没有 （基于XML）

我似乎完全陷入困境的是如何处理和公开接收到的数据

我尝试过使用泛型，但不管我如何构造它，似乎最终我不得不创建一个

AndroidTcpServer

，然后将我限制为一个数据类型

我已经尝试创建一个CustomActivator类

class CustomActivator<T> where T : Serialization.ITcpSerializable<T>
{
    public CustomActivator(String xmlTypeName, Byte[] data) 
    {
        this.XmlTypeName = xmlTypeName;
        this.Data = data;
    }

    public String XmlTypeName { get; set; }
    public Byte[] Data { get; set; }

    public T Activate()
    {
        T res =  Activator.CreateInstance<T>();
        using (MemoryStream stream = new MemoryStream(this.Data))
        {
            return res.Deserialize(XElement.Load(stream));               
        }
    }
}

总之，我希望能得到一些指导，说明人们通常如何处理在这样一个通用框架中公开接收到的数据并实际创建数据实例，以及是否有任何已知模式可用于解决此问题

显然，我可以把所有这些通用实现的东西都删掉，只为我最终尝试构建的任何应用创建一个自定义实现，但我这样做既是一个学习练习，也是我想发布到公众中供其他人使用的东西

---

希望我已经清楚，但如果有人需要澄清这方面的任何方面，请让我知道。首先，我认为服务器的责任应该以引发

TcpServerMessageReceived

事件结束。它的任务是监听传入的连接并接收数据，然后通知感兴趣的任何人

然后，您可以将自定义激活器连接到该事件，如下所示：

class CustomActivator<T> where T : Serialization.ITcpSerializable<T>
{
    public void ListenTo(AndroidTcpServer server)
    {
         server.TcpServerMessageReceived += DataReceived;
    }

    private void DataReceived(object sender, TcpServerMessageReceivedEventArgs e)
    {
        T res =  Activator.CreateInstance<T>();
        using (MemoryStream stream = new MemoryStream(e.Data))
        {
            OnObjectReceived(res.Deserialize(XElement.Load(stream));               
        }
    }

    protected void OnObjectReceived(T obj)
    {
        var handler = ObjectReceived;
        if (handler != null)
        {
            OnObjectReceived(this, new ObjectReceivedEventArgs(obj));
        }
    }
}

class GenericActivator
{
    public void ListenTo(AndroidTcpServer server)
    {
         server.TcpServerMessageReceived += DataReceived;
    }

    private void DataReceived(object sender, TcpServerMessageReceivedEventArgs e)
    {
        var t = Type.GetType(GuessTypeName(e.Data));

        var res =  Activator.CreateInstance(t) as typeof(ITcpSerializable<>).MakeGenericType(t);
        using (MemoryStream stream = new MemoryStream(e.Data))
        {
            OnObjectReceived(res.Deserialize(XElement.Load(stream));               
        }
    }

    protected void OnObjectReceived(object obj)
    {
        var handler = ObjectReceived;
        if (handler != null)
        {
            OnObjectReceived(this, new ObjectReceivedEventArgs(obj));
        }
    }
}

class GenericActivator
{
     private Dictionary<Type, List<Action<object>> _TypeListeners;

     public void Register<T>(Action<object> objectReceived)
     {
         List<Action<object>> listeners;
         if (!_TypeListeners.TryGet(typeof(T), out listeners)
         {
             listeners = new List<Action<object>>();
         }
         listeners.Add(objectReceived);
     }
}

您还可以将类型注册表添加到

GenericaActivator

中，您可以在其中为每种类型注册侦听器，如下所示：

class CustomActivator<T> where T : Serialization.ITcpSerializable<T>
{
    public void ListenTo(AndroidTcpServer server)
    {
         server.TcpServerMessageReceived += DataReceived;
    }

    private void DataReceived(object sender, TcpServerMessageReceivedEventArgs e)
    {
        T res =  Activator.CreateInstance<T>();
        using (MemoryStream stream = new MemoryStream(e.Data))
        {
            OnObjectReceived(res.Deserialize(XElement.Load(stream));               
        }
    }

    protected void OnObjectReceived(T obj)
    {
        var handler = ObjectReceived;
        if (handler != null)
        {
            OnObjectReceived(this, new ObjectReceivedEventArgs(obj));
        }
    }
}

class GenericActivator
{
    public void ListenTo(AndroidTcpServer server)
    {
         server.TcpServerMessageReceived += DataReceived;
    }

    private void DataReceived(object sender, TcpServerMessageReceivedEventArgs e)
    {
        var t = Type.GetType(GuessTypeName(e.Data));

        var res =  Activator.CreateInstance(t) as typeof(ITcpSerializable<>).MakeGenericType(t);
        using (MemoryStream stream = new MemoryStream(e.Data))
        {
            OnObjectReceived(res.Deserialize(XElement.Load(stream));               
        }
    }

    protected void OnObjectReceived(object obj)
    {
        var handler = ObjectReceived;
        if (handler != null)
        {
            OnObjectReceived(this, new ObjectReceivedEventArgs(obj));
        }
    }
}

class GenericActivator
{
     private Dictionary<Type, List<Action<object>> _TypeListeners;

     public void Register<T>(Action<object> objectReceived)
     {
         List<Action<object>> listeners;
         if (!_TypeListeners.TryGet(typeof(T), out listeners)
         {
             listeners = new List<Action<object>>();
         }
         listeners.Add(objectReceived);
     }
}

类泛型激活器
{
private Dictionary首先，我认为服务器的职责应该以引发
TcpServerMessageReceived
事件结束。它的任务是侦听传入的连接并接收数据，然后通知感兴趣的任何人

然后，您可以将自定义激活器连接到该事件，如下所示：

class CustomActivator<T> where T : Serialization.ITcpSerializable<T>
{
    public void ListenTo(AndroidTcpServer server)
    {
         server.TcpServerMessageReceived += DataReceived;
    }

    private void DataReceived(object sender, TcpServerMessageReceivedEventArgs e)
    {
        T res =  Activator.CreateInstance<T>();
        using (MemoryStream stream = new MemoryStream(e.Data))
        {
            OnObjectReceived(res.Deserialize(XElement.Load(stream));               
        }
    }

    protected void OnObjectReceived(T obj)
    {
        var handler = ObjectReceived;
        if (handler != null)
        {
            OnObjectReceived(this, new ObjectReceivedEventArgs(obj));
        }
    }
}

class GenericActivator
{
    public void ListenTo(AndroidTcpServer server)
    {
         server.TcpServerMessageReceived += DataReceived;
    }

    private void DataReceived(object sender, TcpServerMessageReceivedEventArgs e)
    {
        var t = Type.GetType(GuessTypeName(e.Data));

        var res =  Activator.CreateInstance(t) as typeof(ITcpSerializable<>).MakeGenericType(t);
        using (MemoryStream stream = new MemoryStream(e.Data))
        {
            OnObjectReceived(res.Deserialize(XElement.Load(stream));               
        }
    }

    protected void OnObjectReceived(object obj)
    {
        var handler = ObjectReceived;
        if (handler != null)
        {
            OnObjectReceived(this, new ObjectReceivedEventArgs(obj));
        }
    }
}

class GenericActivator
{
     private Dictionary<Type, List<Action<object>> _TypeListeners;

     public void Register<T>(Action<object> objectReceived)
     {
         List<Action<object>> listeners;
         if (!_TypeListeners.TryGet(typeof(T), out listeners)
         {
             listeners = new List<Action<object>>();
         }
         listeners.Add(objectReceived);
     }
}

您还可以将类型注册表添加到
GenericaActivator
中，您可以在其中为每种类型注册侦听器，如下所示：

class CustomActivator<T> where T : Serialization.ITcpSerializable<T>
{
    public void ListenTo(AndroidTcpServer server)
    {
         server.TcpServerMessageReceived += DataReceived;
    }

    private void DataReceived(object sender, TcpServerMessageReceivedEventArgs e)
    {
        T res =  Activator.CreateInstance<T>();
        using (MemoryStream stream = new MemoryStream(e.Data))
        {
            OnObjectReceived(res.Deserialize(XElement.Load(stream));               
        }
    }

    protected void OnObjectReceived(T obj)
    {
        var handler = ObjectReceived;
        if (handler != null)
        {
            OnObjectReceived(this, new ObjectReceivedEventArgs(obj));
        }
    }
}

class GenericActivator
{
    public void ListenTo(AndroidTcpServer server)
    {
         server.TcpServerMessageReceived += DataReceived;
    }

    private void DataReceived(object sender, TcpServerMessageReceivedEventArgs e)
    {
        var t = Type.GetType(GuessTypeName(e.Data));

        var res =  Activator.CreateInstance(t) as typeof(ITcpSerializable<>).MakeGenericType(t);
        using (MemoryStream stream = new MemoryStream(e.Data))
        {
            OnObjectReceived(res.Deserialize(XElement.Load(stream));               
        }
    }

    protected void OnObjectReceived(object obj)
    {
        var handler = ObjectReceived;
        if (handler != null)
        {
            OnObjectReceived(this, new ObjectReceivedEventArgs(obj));
        }
    }
}

class GenericActivator
{
     private Dictionary<Type, List<Action<object>> _TypeListeners;

     public void Register<T>(Action<object> objectReceived)
     {
         List<Action<object>> listeners;
         if (!_TypeListeners.TryGet(typeof(T), out listeners)
         {
             listeners = new List<Action<object>>();
         }
         listeners.Add(objectReceived);
     }
}

类泛型激活器
{
private DictionaryWell，您如何知道哪些对象会出现？我看到的所有xml序列化程序都要求您知道要反序列化的类型。您知道，因为它是xml的一部分，您可以使用反射进行类型匹配（即：）。不完美，但它可以工作。或者，我正在考虑在每次传输时传入另一组包含类型信息的XML。还不确定……那么，您如何知道哪些对象会出现？我看到的所有XML序列化程序都要求您知道要反序列化的类型。您知道，因为它是作为XML，您可以使用反射来进行类型匹配（即：）。虽然不完美，但它可以工作。或者，我正在考虑在每次传输时传入另一组包含类型信息的XML。还不确定……感谢您的输入。这实际上是我一直在考虑的路径（实际上可能更整洁一些）。谢谢你的意见。这实际上是我一直在考虑的方向（实际上可能有点整洁）。