Question

现在我们有一套所谓的服务＆＃39; - 具有共同签名方法的类：它们的结果类型具有属性T？错误，其中T是枚举。我们为每个方法都有一个单独的枚举，并为特定方法定义了一组值。

只要我们使用这些服务的最终地点，这种方法就相当不错。来自控制器的方法＆＃39;动作 - 这些错误被返回给客户端，由javascript处理。

但是有时候我们想要编写一些其他服务的调用方法。方法，这是我似乎有问题的地方。我们假设我们有服务的方法A（），它有AError类型的错误。此A（）方法在内部调用方法B（），该方法具有类型为BError的错误。

首先，我们必须将可能的BError映射到AError。并且有可能忘记检查B的错误，并且它的存在仍然是未被观察到的。

对于cource，我知道使用异常来指示方法失败是很常见的。现在，所有控制器都有一个过滤器，它拦截未处理的异常，并返回一个只有单个属性Error的答案，其值为“InternalServerError”＃39; 但是如果我们开始使用异常，我们将失去一个我认为重要的特性：现在在其签名中明确指定了一组可能的方法错误，如果我们使用异常，这将丢失。我知道xml-documentation中有一个标记用于列出异常类型，但它只是文档，不会被编译器检查。

另外，我不明白如何在代码上使用异常：让我们说我们有一些方法首先检查订单的状态。现在它返回＆＃39; InvalidOrderStatus＆＃39;如果订单状态对当前操作无效，则会出错。如果我们使用异常，我们可以创建一个异常InvalidOrderStatusException，但我们怎么知道我们内部调用的代码会抛出异常呢？

我们还可以创建助记符规则：方法A应该有错误类型AError，并且在其中应该抛出一些通用异常（让我们说，ErrorException<>），由此AError参数化。我们可以在所有A的调用中拦截此通用异常ErrorException<AError>并观察其错误代码。但是编译器不会检查这一点：方法A可以抛出任何其他异常，或ErrorException<>，但是由其他一些错误代码进行参数化。

所以我的问题是：a）最好的方法是a）总是知道什么样的异常方法可以抛出，它可以返回什么样的错误，以及b）不能忘记观察方法的结果错误？

Answer 1

如何用这样的东西交换枚举AError：

class ErrorHolder<T> // T would be AError, BError
{
   T ErrorCode {get;}
   object[] InnerErrors {get;}
   // other payload could go here like inner exceptions etc.
}

因此，您可以通过某种方式检查枚举的错误代码，并且可以添加所需的任何有效负载。

Answer 2

使用所需的行为创建一些基本异常，为其处理，处理和转换为发送到javascript的结果提供基本机制。它并不意味着你需要知道你的方法的所有可能的例外的列表（可能这样的列表将永远是谎言，因为可能的非业务异常）。因此派生的异常只是错误代码的替换，包含特定的消息和其他数据（错误代码:)）。如你所说 - ＆＃34;在其签名中明确指出了一组可能的方法错误＆＃34;它不是一个重要的特征。你应该＆＃34;面向对象＆＃34;考虑一般异常处理（在控制器方法代码级别，如HandleError（ExecuteService（））或在动作过滤器级别）。此外，您的错误代码可能看起来不是例外，而是一些＆＃34;执行结果＆＃34;在成功或失败状态下，它不是一种特殊行为，例如＆＃34;未找到实体＆＃34;但服务的预期结果。在这种情况下，我使用以下代码

public class ExecutionResult
{
    public ExecutionResult() : this(null)
    {
    }
    public ExecutionResult(ExecutionResult result)
    {
        if (result != null)
        {
            Success = result.Success;
            Errors = new List<ErrorInfo>(result.Errors);
        }
        else
        {
            Errors = new List<ErrorInfo>();
        }
    }
    private bool? _success;
    public bool Success
    {
        get { return _success ?? Errors.Count == 0; }
        set { _success = value; }
    }
    public IList<ErrorInfo> Errors { get; private set; }
}

/*T is for result (any business object)*/
public class ExecutionResult<T> : ExecutionResult
{
    public ExecutionResult() : this(null)
    {
    }
    public ExecutionResult(T result) : this(null)
    {
        Value = result;
    }
    public ExecutionResult(ExecutionResult result)
        : base(result)
    {
        var r = result as ExecutionResult<T>;
        if (r != null)
        {
            Value = r.Value;
        }
    }
    public T Value { get; set; }
}

Answer 3

所以我的问题是：什么是a）最好的方法总是知道什么样的异常方法可以抛出，它可以返回什么样的错误，以及 b）不能忘记观察方法的结果错误？

解决＆＃34; a＆＃34;：

在编译时很难做到这一点。但是你可以在运行时通过反射来做到这一点。请参阅enumValues类中的静态ErrorHandlerFor<T>字段。

要解决＆＃34; b＆＃34;，您可以这样做：

简而言之：在调用之后，不是switch，而是将错误处理程序（以前在case部分中）准备为lambda，并将它们全部放在ErrorHandlerFor<T>类中并传递这个功能。这增加了为函数提供反馈的额外好处，无论是继续还是中止。

你也可以这样想：

假设你想给一个人做一些工作。这项工作可能会以多种方式失败。

传统上你给这个人做了工作，等到它完成，也许有错误。然后，如有必要，您可以处理错误。

现在你给这个家伙一些电话号码＆＃34;在出现某些错误时拨打电话。如果工作可以继续或需要中止，电话会议的答案甚至可以引导他。

enum AError
{
    AError1,
    AError2,
    AError3,
    AError4,
    AError5,

}


delegate bool SingleErrorHandlerDelegate<T>(T error, object someOtherPayload);

interface IHandle<T>
{
    bool Handle(T error, object someOtherPayload); // return true if handled;
}

class ErrorHandlerFor<T> : IHandle<T>
{
    private Dictionary<T, SingleErrorHandlerDelegate<T>> handlers;
    private static T[] enumValues = Enum.GetValues(typeof(T)).Cast<T>().ToArray();
    public ErrorHandlerFor(IEnumerable<KeyValuePair<IEnumerable<T>, SingleErrorHandlerDelegate<T>>> handlers)
        : this(handlers.SelectMany(h => h.Key.Select(key => new KeyValuePair<T, SingleErrorHandlerDelegate<T>>(key, h.Value))))
    {
    }

    public ErrorHandlerFor(IEnumerable<KeyValuePair<IEnumerable<T>, SingleErrorHandlerDelegate<T>>> handlers, SingleErrorHandlerDelegate<T> fallbackHandler)
        : this(handlers.SelectMany(h => h.Key.Select(key => new KeyValuePair<T, SingleErrorHandlerDelegate<T>>(key, h.Value))), fallbackHandler)
    {
    }



    public ErrorHandlerFor(IEnumerable<KeyValuePair<T, SingleErrorHandlerDelegate<T>>> handlers)
    {
        this.handlers = new Dictionary<T, SingleErrorHandlerDelegate<T>>();
        foreach (var handler in handlers)
        {
            Debug.Assert(handler.Value != null);
            this.handlers.Add(handler.Key, handler.Value);
        }

        checkHandlers();
    }

    public ErrorHandlerFor(IEnumerable<KeyValuePair<T, SingleErrorHandlerDelegate<T>>> handlers, SingleErrorHandlerDelegate<T> fallbackHandler)
    {
        this.handlers = new Dictionary<T, SingleErrorHandlerDelegate<T>>();
        foreach (var handler in handlers)
        {
            Debug.Assert(handler.Value != null);
            this.handlers.Add(handler.Key, handler.Value);
        }
        foreach (var enumValue in enumValues)
        {
            if (this.handlers.ContainsKey(enumValue) == false)
            {
                this.handlers.Add(enumValue, fallbackHandler);
            }
        }

        checkHandlers();
    }



    private void checkHandlers()
    {
        foreach (var enumValue in enumValues)
        {
            Debug.Assert(handlers.ContainsKey(enumValue));
        }
    }

    public bool Handle(T error, object someOtherPayload)
    {
        return handlers[error](error: error, someOtherPayload: someOtherPayload);
    }
}



class Test
{
    public static void test()
    {
        var handler = new ErrorHandlerFor<AError>(
            new[]{
                new KeyValuePair<IEnumerable<AError>, SingleErrorHandlerDelegate<AError>>(
                new []{AError.AError1, AError.AError2, AError.AError4,},
                (AError error, object payload) => { Console.WriteLine(@"handled error 1, 2 or 4!"); return true;}
                ),
                new KeyValuePair<IEnumerable<AError>, SingleErrorHandlerDelegate<AError>>(
                new []{AError.AError3, AError.AError5,},
                (AError error, object payload) => { Console.WriteLine(@"could not handle error 3 or 5!"); return false;}
                ),
            }
            );

        var result = Services.foo(handler);


        var incompleteHandlerButWithFallbackThatWillPassTheTest = new ErrorHandlerFor<AError>(
            new[]{
                new KeyValuePair<IEnumerable<AError>, SingleErrorHandlerDelegate<AError>>(
                new []{AError.AError1, AError.AError2, AError.AError4,},
                (AError error, object payload) => { Console.WriteLine(@"handled error 1, 2 or 4!"); return true;}
                ),
                new KeyValuePair<IEnumerable<AError>, SingleErrorHandlerDelegate<AError>>(
                new []{AError.AError5},
                (AError error, object payload) => { Console.WriteLine(@"could not handle error 3 or 5!"); return false;}
                ),
            }
            // AError.AError3 is not handled!  => will go in fallback
            , (AError error, object payload) => { Console.WriteLine(@"could not handle error in fallback!"); return false; }
            );

        var result2 = Services.foo(incompleteHandlerButWithFallbackThatWillPassTheTest);


        var incompleteHandlerThatWillBeDetectedUponInstantiation = new ErrorHandlerFor<AError>(
            new[]{
                new KeyValuePair<IEnumerable<AError>, SingleErrorHandlerDelegate<AError>>(
                new []{AError.AError1, AError.AError2, AError.AError4,},
                (AError error, object payload) => { Console.WriteLine(@"handled error 1, 2 or 4!"); return true;}
                ),
                new KeyValuePair<IEnumerable<AError>, SingleErrorHandlerDelegate<AError>>(
                new []{AError.AError3},
                (AError error, object payload) => { Console.WriteLine(@"could not handle error 3 or 5!"); return false;}
                ),
            } // AError.AError5 is not handled!  => will trigger the assertion!
            );

    }

}


class Services
{
    public static Result foo(IHandle<AError> errorHandler)
    {
        Debug.Assert(errorHandler != null);

        // raise error...
        var myError = AError.AError1;
        var handled = errorHandler.Handle(error: myError, someOtherPayload: "hello");
        if (!handled)
            return new Result();

        // maybe proceed

        var myOtherError = AError.AError3;
        errorHandler.Handle(error: myOtherError, someOtherPayload: 42); //we'll return anyway in this case...
        return new Result();

    }



    public class Result
    {

    }
}

例外与错误代码

3 个答案: