4

好的，情况如下：

我有一个具有 2 个设置的客户端：ConnectionState 和 ConnectionSollState，它们都是相同的可枚举（TypeConnectionState），它们存储客户端连接的实际状态和连接应该是的状态。在 to 的每种组合上，都应该发生不同的事情，例如 ConnectionState 为“Connected”但 ConnectionSollState 为“Closed”-> 拆除客户端。所以我有 4 种可能性需要检查。现在每个客户端都可以处理无限数量的会话，并且每个会话也有一个状态（StreamState & StreamSollState），这些状态可以有 6 个可枚举的选项。

从现在开始，我做了大约 20 个开关条件，我的代码看起来非常混乱，我在编码时每 5 分钟就会做错事。有没有更简单的方法来处理这种情况？（如果/否则）会使事情变得更糟。

例子：

private void RTSPWorker() {
    try {
        byte[] buffer = new byte[2048];
        while (!mb_RTSPWorkerAbbort) {
        // Call TransportWD
            Thread.Sleep(100 * mi_ConnectionTimeOut);

            // Check ConnectionSollState
            switch(ConnectionSollState) {
                case TypeConnectionState.Connected:
                    // ConnectionSollState = Connected, check ConnectionState
                    switch(ConnectionState) {
                        case TypeConnectionState.Connected:
                            // ConnectionState is connected, keep-alive!
                            if(GET_PARAMETER() == null) {
                                DESCRIBE();
                            }
                            // Check streams too
                            foreach (cRTSPStream oStream in mo_StreamDict.Values) {
                                // Check StreamSollState
                                switch(oStream.RTSPStreamSollState) {
                                    case cRTSPStream.TypeRTSPStreamState.Play:
                                        // SollState is PLAY, check State
                                        switch(oStream.RTSPStreamState) {
                                            case cRTSPStream.TypeRTSPStreamState.Play:
                                                //Stream is alive, keep-alive!
                                                if (oStream.PLAY() == null) { oStream.DESCRIBE(); } break;
                                            case cRTSPStream.TypeRTSPStreamState.Closed:
                                                // Reinitialise.
                                                if (oStream.SETUP() != null) { oStream.PLAY(); } break;
                                            default:
                                                // Default, send play.
                                                oStream.PLAY(); break;
                                        }
                                    break;
                                case cRTSPStream.TypeRTSPStreamState.Pause:
                                    // SollState is on pause, check State
                                    switch(oStream.RTSPStreamState) {
                                        case cRTSPStream.TypeRTSPStreamState.Closed:
                                            // Reinitialise.
                                            if (oStream.SETUP() != null) { oStream.PLAY(); } break;
                                        default:
                                            oStream.PAUSE();
                                            break;
                                    }
                                break;
                                case cRTSPStream.TypeRTSPStreamState.Closed:
                                    // SollState is closed, check State
                                    switch(oStream.RTSPStreamState) {
                                        case cRTSPStream.TypeRTSPStreamState.Closed:
                                            // Is closed, do nothing
                                            break;
                                        default:
                                            // Default teardown, remove session
                                            oStream.TEARDOWN();
                                            this.RemoveRTSPSession(oStream);
                                            break;
                                        }
                                default:
                                    // Default, what do?
                                    break;
                                }
                            }
                            break;
                        case TypeConnectionState.Closed:
                            // ConnectionState should be connected, re-connect!
                                while(Connect() != true) {
                                    // Sleep for 200ms, try again
                                    Thread.Sleep(200);
                                }
                            break;
                        default:
                            // TODO anything else
                            break;
                    }
                    break;
                case TypeConnectionState.Closed:
                    // Check ConnectionState
                    switch(ConnectionState) {
                        case TypeConnectionState.Connected:
                            // Is connected, should be closed. Close connection & clean up!
                            Close(null);
                            break;
                        default:
                            // Anything other than Connected, do nothing.
                            break;
                    }
                    break;

                default:
                    break;
            }
        }
    } catch {

    }
}
4

3 回答 3

9

天哪，蝙蝠侠，那是你那里的一些难以理解的代码。这里有一些提示可能会改善您的情况。我必须补充一点，这些提示有些偏颇，因为它们更喜欢个人编码风格：

  1. 将 switch 语句重写为 IF 语句。嵌套的 IF 语句比嵌套的 switch 语句更容易阅读，即使您必须编写更多代码才能获得相同的结果。
  2. 将您的方法分解为几个子方法。你的方法可能是试图同时做太多的事情。->关注点分离和单一责任原则
  3. 使用改进的真值表。在您有基于变量组合产生某些结果的逻辑的情况下，您可能需要使用真值表结构。例如，使用List<Tuple<T1,T2,T etc..>>构造。

前任：

var truthTable = List<Tuple<NavigationTab, Role, Action>>
{
    new Tuple<NavigationTab, Role, Action>(NavigationTab.Users, Role.UsersAdministration, MVC.Administration.Users.Index()),
    new Tuple<NavigationTab, Role, Action>(NavigationTab.Users, Role.RolesAdministration, MVC.Administration.Roles.Index()),
    new Tuple<NavigationTab, Role, Action>(NavigationTab.Products, Role.ProductsAdministration, MVC.Administration.Products.Index()),
}
于 2012-09-04T13:16:51.380 回答
1

更好的面向对象通常被认为是 switch 语句的最佳替代方案。例如，您可以使用多态性而不是 switch 语句并执行以下操作：

try {
    byte[] buffer = new byte[2048];
    while (!mb_RTSPWorkerAbbort) {
        Thread.Sleep(100 * mi_ConnectionTimeOut);
        worker.DoWork();
    }
 } catch (Exception ex) {
     Trace.WriteLine(ex);
 }

随着状态的变化，您可以实例化实现不同的不同类型的工作程序类DoWork。一种可能是：

while(Connect() != true) {
    // Sleep for 200ms, try again
    Thread.Sleep(200);
}

当然，我不一定认为你应该这样做。我唯一需要做的就是你发布的代码——所以，可能有更好的方法来实现不同的行为。

这与规范模式非常相似。

于 2012-09-04T13:18:38.767 回答
0

将您的代码分解成更小、更易于管理的部分。

如果您提取案例语句中的逻辑，则可以完全重写主循环而无需切换，例如：

while (!mb_RTSPWorkerAbbort)
{
    // Call TransportWD
    Thread.Sleep(100*mi_ConnectionTimeOut);

    if (ConnectionSollState == TypeConnectionState.Closed)
    {
        CloseIfConnected();
    }

    if (ConnectionSollState == TypeConnectionState.Connected)
    {
        if (ConnectionState == TypeConnectionState.Connected)
        {
            KeepAlive();
            ProcessStreams(); // <--bad example name - rename to what it's actually doing.
        }
        else
        {
            Reconnect();
        }
    }
}

当你在一个月后看到这个时（或者在你需要审查的情况下），你会更容易看到发生了什么。

于 2012-09-04T14:03:07.393 回答