我正在尝试新的Nullable Reference Types in C# 8.0,并且遇到了这个问题。有了这个结构
public readonly struct Either<TReturn, TError>
where TReturn : struct
where TError : struct
{
public TError? Error { get; }
public TReturn? Response { get; }
public Either(TError? error, TReturn? response)
{
if (error == null && response == null)
{
throw new ArgumentException("One argument needs not to be null.");
}
if (error != null && response != null)
{
throw new ArgumentException("One argument must be null.");
}
Error = error;
Response = response;
}
}
我如何告诉编译器Error
或Response
都不为空,并且它们都不可以均为空?
有没有办法用新属性来做这样的事情?
答案 0 :(得分:5)
更新结构
当结果类型更改为结构时,代码不会更改。要使用结构类型参数,必须将以下约束添加到接口和类型中:
where TResult : struct
where TError : struct
当我想到Either模式时,我会想到F#,模式匹配和区别联合,而不是null。实际上,Either
是避免空值的一种方法。实际上,问题的代码看起来像是尝试创建Result type的尝试,而不仅是Either。 Scott Wlaschin的Railway Oriented Programming展示了如何使用这种类型以功能语言实现错误处理。
在F#中,Result类型定义为:
type Result<'T,'TError> =
| Ok of ResultValue:'T
| Error of ErrorValue:'TError
在C#8中我们还不能做到这一点,因为没有歧视的联合。这些计划用于C#9。
模式匹配
我们可以做的是使用模式匹配来获得相同的行为,例如:
interface IResult<TResult,TError>{} //No need for an actual implementation
public class Success<TResult,TError>:IResult<TResult,TError>
{
public TResult Result {get;}
public Success(TResult result) { Result=result;}
}
public class Error<TResult,TError>:IResult<TResult,TError>
{
public TError ErrorValue {get;}
public Error(TError error) { ErrorValue=error;}
}
这样就无法创建既成功又出错的IResult<>
。可以与模式匹配一起使用,例如:
IResult<int,string> someResult=.....;
if(someResult is Success<int,string> s)
{
//Use s.Result here
}
简化表达式
鉴于C#8的property patterns,可以将其重写为:
if(someResult is Success<int,string> {Result: var result} )
{
Console.WriteLine(result);
}
或使用开关表达式,进行典型的铁路式呼叫:
IResult<int,string> DoubleIt(IResult<int,string> data)
{
return data switch { Error<int,string> e=>e,
Success<int,string> {Result: var result}=>
new Success<int,string>(result*2),
_ => throw new Exception("Unexpected type!")
};
}
F#不需要throw
,因为Result<'T,'TError>
不可能是Ok
或Error
以外的东西。在C#中,我们还没有 功能。
switch表达式允许穷举匹配。我认为如果缺少默认子句,编译器也会生成警告。
具有解构函数
如果类型具有解构函数,则可以简化表达式,例如:
public class Success<TResult,TError>:IResult<TResult,TError>
{
public TResult Result {get;}
public Success(TResult result) { Result=result;}
public void Deconstruct(out TResult result) { result=Result;}
}
public class Error<TResult,TError>:IResult<TResult,TError>
{
public TError ErrorValue {get;}
public Error(TError error) { ErrorValue=error;}
public void Deconstruct(out TError error) { error=ErrorValue;}
}
在这种情况下,表达式可以写成:
return data switch {
Error<int,string> e => e,
Success<int,string> (var result) => new Success<int,string>(result*3),
_ => throw new Exception("Unexpected type!")
};
可空性
问题始于可为空的引用类型,那么可为性如何呢?如果我们尝试传递nulll,是否会在C#8中收到警告?
是的,只要启用了NRT。这段代码:
#nullable enable
void Main()
{
IResult<string,string> data=new Success<string,string>(null);
var it=Append1(data);
Console.WriteLine(it);
}
IResult<string,string> Append1(IResult<string,string> data)
{
return data switch { Error<string,string> e=>e,
Success<string,string> (var result)=>
new Success<string,string>(result+"1"),
_ => throw new Exception("Unexpected type!")
};
}
生成CS8625: Cannot convert null literal to non-nullable reference type
尝试
string? s=null;
IResult<string,string> data=new Success<string,string>(s);
生成CS8604: Possible null reference argument ....
答案 1 :(得分:2)
在实现Either
monad时,应使用两个不同的构造函数。这样,您就可以轻松摆脱这些检查,因为您的实现将确保没有办法同时分配两个属性。
public readonly class Either<TReturn, TError>
{
bool _successful;
private TError _error { get; }
private TReturn _response { get; }
public Either(TError error)
{
_error = error;
}
public Either(TReturn response)
{
_successful = true;
_response = response;
}
}
除此之外,您需要向该结构添加一个方法,该方法将用于从该结构中提取值,并将其转换为常见的返回类型:
public Match<T>(Func<TError, T> errorFunc, Func<TResponse, T> successFunc)
=> _successful ? successFunc(_response) : errorFunc(_error);
这样,您将强制用户处理两种情况(成功,错误)并提供将转换为常见类型的功能:
var errorEither = new Either<string, int>(10); // example of error code
var successEither = new Either<string, int>("success"); // example of success
var commonValueError = errorEither.Match<bool>(err => false, succ => true);
var commonValueSuccess = successEither.Match<bool>(err => false, succ => true);
答案 2 :(得分:0)
您可以使用Resharper ContractAnnotation
执行类似的操作。它不是特定于C#8的(但是...我认为您的示例无论如何都没有真正使用可空引用类型,是吗?您正在使用可空结构。)
[ContractAnnotation(
"=> pError: null, pResponse: notnull; => pError: notnull, pResponse: null"
)]
public void Get(out TError? pError, out TReturn? pResponse) {
pError = Error;
pResponse = Response;
}
(字符串的含义是,=>
的左边是输入条件,=>
的右边是输出条件,;
分隔不同的情况,并且未标注值因此,在这种情况下:无论输入如何,输出条件都是null / notnull或notnull / null的以太。)
然后使用C#7功能out var
:
GetAnEitherFromSomewhere()
.Get(out var error, out var response);
if (error != null) {
// handle error
return;
}
// response is now known to be not null, because we can only get here if error was null
老实说,我发现JetBrains的注释[NotNull]
,[CanBeNull]
和[ContractAnnotation]
比可为空的引用类型更灵活(尽管更冗长)。基本上,它们允许中间情况,在这种情况下,值可以为null
,但在某些情况下值不能为null
,并且在运行时可以区分。对于可为空的引用类型,我无法指定介于两者之间的情况,我必须选择绝对可为空或绝对不可为空。
甚至像TryParse
这样的常见事物:
// should the result be nullable with nullable reference types on?
// you have to either lie with ! or else use ? and assume it can always be null
public bool TryParse(string pString, out SomeClass pResult) {
if (<cant parse>) {
pResult = null;
return false;
}
pResult = value;
return true;
}
// works great with JetBrains annotations and nullable reference types off
// now you can know that the result is null or notnull
// based on testing the bool return value
[ContractAnnotation("=> true, pResult: notnull; => false, pResult: null")]
public bool TryParse(string pString, out SomeClass pResult) {
...
}