0

我想为我的套接字通信的对端实现一个带有控制代码的类。我尝试使用枚举和派生类，但我的尝试不起作用。

我想要一个Type包含不同的Codes. 例如，控制作为类型，唤醒和关闭作为代码信息。

对等方应该能够使用 Switch Case 来识别信息。就像是：

switch(data.Type)
{
    case Control:
        /* Check diffrent codes */
    break;
    case Notification:
        /* Check diffrent codes */
    break;
}

我尝试了以下操作，但遗憾的是我无法使用 Switch Case 或类似工具来识别信息。

public abstract class Type
{
    private readonly String _code;

    protected Type(String code)
    {
        _code = code;
    }

    public String Code
    {
        get { return _code; }
    }
}

public sealed class Control : Type
{
    public static readonly Control Wakeup = new Control("Wakeup");
    public static readonly Control Shutdown = new Control("Shutdown");

    private Control(String code) : base(code)
    {
    }
}

任何想法如何实现这一点？请考虑，TypeXXX不应与CodeYYYY结合使用。感谢您的建议！

编辑

我有一个 TCP 客户端和服务器套接字。一般沟通工作正常。现在我想实现一个类或类似的东西，告诉同伴他收到了哪种信息。他能够决定他应该如何处理这些信息。我认为像ICMP Control Messages这样的东西会很好。我有一个通用的信息类型，代码指定了它。

类型代码关系如下所示：

+--------------+-------------+
|     Type     |    Code     |
+--------------+-------------+
| Control      | Shutdown    |
|              | Wakeup      |
|              | CheckUpdate |
|              | ForceUpdate |
| -----------  | ----------- |
| Notification | Online      |
|              | Offline     |
|              | Login       |
|              | Logoff      |
| -----------  | ----------- |
| Data         | Zip         |
+--------------+-------------+

包看起来像这样：

+------+------+---------+
| Type | Code | Payload |
+------+------+---------+

接收器检查Type和Code之后开始处理有效载荷。

4

4 回答 4

1

创建两个继承自 Control 类的类：

public class WakeUp : Control
{
}

public class ShutDown : Control
{
}

然后使用此方法创建特定控件的新实例：

public T CreateControl<T>() where T : Control, new()
{
    return new T();
}

使用上述方法：

var wakeupControl = CreateControl<WakeUp>();
var shutdownControl = CreateControl<ShutDown>();

更新：

看看策略模式http://www.dofactory.com/Patterns/PatternStrategy.aspx

于 2013-06-11T12:56:49.163 回答
0

这是您如何做到这一点的另一个版本。这是在您的编辑之后，因此它涵盖了所有组合：

public enum CodeValue { Wakeup, ShutDown, CheckUpdate, ForceUpdate, Online, Offline, Login, Logoff, Zip };
public enum TypeValue { Control, Notification, Data, Invalid }

public class Code
{
    public CodeValue CodeValue
    {
        get;
        private set;
    }

    public TypeValue TypeValue
    {
        get;
        private set;
    }

    public Code( CodeValue code )
    {
        CodeValue = code;
        DetermineType();
        if ( TypeValue == TypeValue.Invalid )
            throw new ArgumentException( "code" );
    }


    private bool IsControl()
    {
        return CodeValue == CodeValue.Wakeup || CodeValue == CodeValue.ShutDown || CodeValue == CodeValue.CheckUpdate || CodeValue == CodeValue.ForceUpdate;
    }

    private bool IsNotification()
    {
        return CodeValue == CodeValue.Online || CodeValue == CodeValue.Offline || CodeValue == CodeValue.Login || CodeValue == CodeValue.Logoff;
    }

    private bool IsData()
    {
        return CodeValue == CodeValue.Zip;
    }

    private void DetermineType()
    {
        if ( IsControl() )
            TypeValue = TypeValue.Control;

        if ( IsNotification() )
            TypeValue = TypeValue.Notification;

        if ( IsData() )
            TypeValue = TypeValue.Data;

        TypeValue = TypeValue.Invalid;
    }
}

用户会这样使用它：

    public void ProcessCode( Code code )
    {
        switch ( code.TypeValue )
        {
            case TypeValue.Control:
                // do something
                break;

            case TypeValue.Notification:
                // do something
                break;
        }
    }
于 2013-06-11T15:10:41.737 回答
0

来自 C# 语言参考 (8.7.2)。switch (switch 表达式) { case... }

如果 switch 表达式的类型是sbyte、byte、short、ushort、int、uint、long、ulong、char、string 或 enum-type，那么这是 switch 语句的控制类型。否则，从 switch 表达式的类型到以下可能的控制类型之一必须存在一个用户定义的隐式转换（第 6.4 节）：sbyte、byte、short、ushort、int、uint、long、ulong、char、string . 如果不存在此类隐式转换，或者存在多个此类隐式转换，则会发生编译时错误。

于 2013-06-11T13:01:18.210 回答
0

我认为你过于复杂了。我就是这样做的。

public enum Code { Wakeup, ShutDown, Notification1, Notification2 };
public enum Type { Control, Notification, Invalid }

public static class CodeCheck
{
    public static bool IsControl( Code code )
    {
        return code == Code.Wakeup || code == Code.ShutDown;
    }

    public static bool IsNotification( Code code )
    {
        return code == Code.Notification1 || code == Code.Notification2;
    }

    public static Type GetType( Code code )
    {
        if ( IsControl( code ) )
            return Type.Control;

        if ( IsNotification( code ) )
            return Type.Notification;

        return Type.Invalid;
    }
}

所以用户会做类似的事情：

    public void ProcessCode( Code code )
    {
        switch ( CodeCheck.GetType( code ) )
        {
            case Type.Control:
                // do something
                break;

            case Type.Notification:
                // do something
                break;
        }
    }
于 2013-06-11T14:10:44.767 回答