控件类型和代码的类或枚举结构

Question

I would like to implement a class with control codes for the peers of my socket communication. I tried it with enums and derived classes but my tries doesn't work.

I would like to have a Type which contains different Codes . For example Control as type with Wakeup and Shutdown as code information's.

The peer should be able to use a Switch Case to identify the information. Something like:

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

I tried it with following, but sadly I cannot use Switch Case or similar to identify the information.

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)
    {
    }
}

Any Idea how to implement this? Please consider, that TypeXXX should not combinable with CodeYYYY . Thanks for your advices!

Edit

I have a TCP Client and Server Socket. The general communication works fine. Now I would like to implement a class or something similar that tells the peer which kind of information he received. That he is able to decide what he should he do with the information. I thought something like the ICMP Control Messages would be nice. I have a general Type of Information and the Code specify it.

The type code relationship looks like this:

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

The package looks like this:

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

The receiver checks the Type and Code and after that start to process the payload.

Answer 1

Create two classes that inherits from Control class:

public class WakeUp : Control
{
}

public class ShutDown : Control
{
}

Then use this method to create a new instance of the specific control:

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

Use the above method as:

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

UPDATE:

Have a look at the strategy pattern http://www.dofactory.com/Patterns/PatternStrategy.aspx

Answer 2

From C# language reference (8.7.2). switch (switch expression) { case... }

If the type of the switch expression is sbyte, byte, short, ushort, int, uint, long, ulong, char, string, or an enum-type , then that is the governing type of the switch statement. Otherwise, exactly one user-defined implicit conversion (Section 6.4) must exist from the type of the switch expression to one of the following possible governing types: sbyte, byte, short, ushort, int, uint, long, ulong, char, string . If no such implicit conversion exists, or if more than one such implicit conversion exists, a compile-time error occurs.

Answer 3

I think that you are overcomplicating. This is how I would do it.

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;
    }
}

So user would do something like:

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

            case Type.Notification:
                // do something
                break;
        }
    }

Answer 4

Here is another version of how you can do it. This is after your edit so it covers all combinations:

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;
    }
}

User would use it like this:

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

            case TypeValue.Notification:
                // do something
                break;
        }
    }