如何实现空类型的泛型接口？

Question

我有以下代码：

public interface IResult
{
    StatusCode Code { get; }
    string Error { get; }
}

public interface IResult<T> : IResult
{
    T Value { get; }
}

public class Result : IResult
{
    public StatusCode Code { get; set; }
    public string Error { get; set; }
}

public class Result<T> : IResult<T>
{
    public StatusCode Code { get; set; }
    public string Error { get; set; }
    public T Value { get; set; }
}

我有两个接口：IResult 用于没有值的结果（如void）和IResult<T> 用于需要值的结果。但我不想支持两种不同的类型。我想将它们合并为单一类型。如果结果有值，则该值将存在，对于我没有任何值的情况，它将只是 null。

所以它是这样的： （涵盖所有情况）

public interface IResult<T>
{
    StatusCode Code { get; }
    string Error { get; }
    T Value { get; }
}

public class Result<T> : IResult<T>
{
    public StatusCode Code { get; set; }
    public string Error { get; set; }
    public T Value { get; set; }
}

但我正在努力解决T 是empty/null 的情况。如何为这种情况定义一个类？ 到目前为止，我只发现了一个想法：

public class Result<NullValue> : IResult<NullValue>
{
    public StatusCode Code { get; set; }
    public string Error { get; set; }
    public NullValue Value { get; set; }
}

public class NullValue
{
}

我正在寻找除此之外的任何其他想法：

public class ResultWithNoValue : IResult<T>
{
    public StatusCode Code { get; set; }
    public string Error { get; set; }
    public object Value => null;
}

它不起作用，因为我必须使用：

public interface IBaseResponse< out T>
{
    IResult<T> Data { get; }
}

而且这段代码是不可编译的：

public class ResponseWithNoValue : IBaseResponse<object>
{
    public ResultWithNoValue Data { get; }
}

Answer 1

你说过你不想有两种类型，但你没有解释为什么。这使得您很难理解您实际要解决的问题。

正如问题目前所表述的那样，没有正当理由希望将这些类型合并为一个。她们不一样。一个有结果，另一个没有。
它们之间有一些重叠，但这不是删除其中一种类型的论据；这是让他们共享/重用一些通用逻辑的论据。

本质上，你的论点就是说：

我不喜欢有一个基类和一个派生类，所以我只做派生类，并且在我不需要的时候不使用一些属性。

技术上可行吗？当然。这是个好主意吗？没有。它与静态类型、OOP 原则和一般的干净编码实践背道而驰。

通过合并两种结果类型，您省略了无值结果类型，从而导致您面临的确切问题：无法优雅地实现无值结果。

---

我怀疑你可能忽略了Result<T> 可以从Result 继承以及实现IResult<T> 接口：

// other interfaces/classes are unchanged

public class Result<T> : Result, IResult<T>
{
    public T Value { get; set; }
}

这允许您在处理Result<T> 对象时重用一些Result 逻辑，以防您不需要与潜在的返回值进行交互。

请注意，这反映了类似的用例，例如Task 和 Task<T> 在异步代码中返回类型。类型是不同的，因为它们的处理方式不同。但是，任何Task<T> 都可以像任何其他Task 一样对待，因为Task<T> : Task。

---

如果结果有值，则该值将存在，而对于我没有任何值的情况，它将为空。

这只是要求空引用异常。 null 有一些有效的案例，但我强烈建议不要创造更多的理由来编写 null 检查而不是必要的。

通过依赖无值结果类型的静态类型，您可以有效地确保不需要空值检查。

由于给定方法返回无值结果或有值结果的事实无论如何都硬编码在方法主体中，因此方法的返回类型也实际反映这一点并没有什么损失。

这是一个让您的消费者清楚他们可以从您的方法中得到什么的问题。通过合并您的结果类型，您会使其不清楚，从而不必要地混淆您的界面。

---

另请注意，我不完全认为需要在此处使用 IResult/IResult<T> 接口，因为您正在处理本质上是值对象的内容，但由于您的问题涉及上下文，因此可能是不可告人的拥有这个问题中根本不明显的接口的原因。

Answer 2

而且这段代码是不可编译的：

public class ResponseWithNoValue : IBaseResponse<object>
{
    public ResultWithNoValue Data { get; }
}

没有，也没有为Data 使用任何其他实现类；只能是IResult<object>:

public class ResponseWithNoValue : IBaseResponse<object>
{
    public IResult<object> Data { get; }
}

这种方法可能适合您的需求。

当您创建Result<object> 的实例时，请不要设置Value。无论如何，该接口都是 get-only，因此它将是不可变的 null：

public class ResponseWithNoValue : IBaseResponse<object>
{
    public IResult<object> Data { get; }
    public ResponseWithNoValue(StatusCode code, string Error)
    {
        Data = new Result<object> { Code = code, Error = error };
    }
}

var response = new ResponseWithNoValue(SomeCode, "SomeError");
var val = response.Data.Value; // null
response.Data.Value = new object(); // Compilation error

Answer 3

空值的问题在于值类型不能为空。
您可以通过使用default 而不是null 来解决这个问题（如果结果是失败的结果，则根本不初始化Value 属性）。

话虽如此，我建议让你的类不可变：

public class Result<T> : IResult<T>
{
    public Result(T value)
    {
        Value = value;
    }

    public Result(StatusCode code, string error)
    {
        Code = code;
        Error = error;
    }

    public StatusCode Code { get; }
    public string Error { get; }
    public T Value { get; }
}

更好的是 - 使用私有构造函数和静态 Success/Fail 方法来创建 Result<T> 类的实例：

public interface IResult<T>
{
    StatusCode Code { get; }
    string Error { get; }
    T Value { get; }
}

public class Result<T> : IResult<T>
{

    public static Result<T> Success(T value)
    {
        return new Result<T>(null, "", value);
    }

    public static Result<T> Fail(StatusCode code, string Error)
    {
        return new Result<T>(code, error, default);
    }

    private Result(StatusCode code, string error, T value)
    {
        Code = code;
        Error = error;
        Value = value;
    }

    public StatusCode Code { get; }
    public string Error { get; }
    public T Value { get; }
}

用法：

var result = Result<int>.Success(5);

var result = Result<SomeType>.Fail(new StatusCode(1), "Failed to do something");

这使得通过阅读调用代码很容易理解结果是成功还是失败。