c# - 减少类型转换和更好的造型

考虑以下（讨厌的）代码：

    /// <summary>
    /// Calls matching process error code on response.Code
    /// </summary>
    /// <param name="response">Actually will be of type Response or extend it</param>
    /// <returns>true for successful response, false otherwise</returns>
    private static bool ProcessErrorCode(object response)
    {
        bool isOkay = false;
        const string unknown = "UNKNOWN";
        string errCode = unknown;
        if (response.GetType() == typeof(Response<AResponseCode>))
        {
            AResponseCode code = ((Response<AResponseCode>)response).Code;
            isOkay = code == AResponseCode.Ok;
            errCode = code.ToString();
        }
        if (response.GetType() == typeof(Response<BResponseCode>))
        {
            BResponseCode code = ((Response<BResponseCode>)response).Code;
            isOkay = code == BResponseCode.Ok;
            errCode = code.ToString();
        }
        if (response.GetType() == typeof(DataResponse<CResponseCode,string>))
        {
            CResponseCode code = ((DataResponse<CResponseCode, string>)response).Code;
            isOkay = code == CResponseCode.Ok;
            errCode = code.ToString();
        }
        if (isOkay)
        {
            return true;
        }
        string msg = "Operation resulted in error code:" + errCode;
        LogErrorCode(msg);
        return false;
    }

我试图找到一种减少转换并改善方法风格的方法。
我在Response<TResponseCode>，DataResponse<TResponseCode,string>，AResponseCode，BResponseCode，CResponseCode上没有代码所有权

响应参数的类型为Response<TResponseCode>或从中继承（DataResponse<TResponseCode,string> : Response<TResponseCode>）

所有*ResponseCode都是枚举，并且都具有*ResponseCode.Ok条目

最佳答案

您可以为此使用通用子例程：

    // Mocking your classes, just to check if it compiles. You don't need this.
    class Response<T> {
        public T Code { get { return default(T); } }
    }
    enum AResponseCode { Ok }
    enum BResponseCode { Ok }
    enum CResponseCode { Ok }
    static void LogErrorCode(string msg) { }

    private static bool ProcessErrorCode(object response)
    {
        bool isOkay;
        string errCode;

        if (!TryProcessErrorCode(response, AResponseCode.Ok, out isOkay, out errCode))
            if (!TryProcessErrorCode(response, BResponseCode.Ok, out isOkay, out errCode))
                TryProcessErrorCode(response, CResponseCode.Ok, out isOkay, out errCode);

        if (isOkay)
        {
            return true;
        }
        string msg = "Operation resulted in error code:" + errCode;
        LogErrorCode(msg);
        return false;
    }

    // TResponseCode is automatically inferred by passing the okCode
    private static bool TryProcessErrorCode<TResponseCode>(
        object response, TResponseCode okCode,
        out bool isOkay, out string errCode)
    {
        var resp = response as Response<TResponseCode>;
        if (resp == null)
        {
            isOkay = false;
            errCode = "UNKNOWN";
            return false;
        }
        else
        {
            isOkay = okCode.Equals(resp.Code);
            errCode = resp.Code.ToString();
            return true;
        }
    }