static using 与 global using的使用和隐式类型的转换

Result 类型是许多编程语言中处理错误的常用方式，包括 C# 的 dotNext 库。在本文中，我们将通过例子回顾 C# 中 using 语句和隐式类型转换的使用。

预期效果

下面是一个示例代码，演示了 Result 类型的使用方法：

namespace TestProject1;
 
public class GetResultTests
{
    [Test]
    public void Test1()
    {
        // 通过 GetResult 方法获取 Result 类型的返回值
        var result = GetResult();
        Assert.Pass();
    }
 
    public Result GetResult()
    {
        if (DateTime.Now.Second > 30)
        {
            // 如果成功，返回 Ok
            return Ok();
        }
        else
        {
            // 如果失败，返回 Error
            return Error();
        }
    }
}

 

此文为了简易演示没有演示带值的 Result 类型，实际使用中可以通过泛型来实现带值的 Result 类型。

下面我们来通过一些步骤来实现这个功能。

static using 与 global using

在 C# 中，using 语句用于指定要包含在代码文件中的命名空间。其中特殊的，Static Using 和 Global Using 需要特别介绍一下。

Static Using 允许你在不指定命名空间的情况下访问命名空间中的类型。特别对于静态方法，这很有用。

例如，你可以使用以下代码使用 Static Using：

using static System.Math;
 
double x = 3.14;
double y = Sqrt(x);
Console.WriteLine(y); // Outputs 1.77

在这个例子中，我们使用 Static Using 将 System.Math 命名空间包含在代码文件中，并使用 Sqrt 函数。

Global Using 允许你在整个代码文件中包含命名空间中的所有类型。

int[] numbers = { 1, 2, 3, 4, 5 };
int sum = numbers.Sum();
Console.WriteLine(sum); // Outputs 15

而在 Using.cs 文件中，我们可以使用 Global Using：

global using System.Linq;

在这个例子中，我们使用 Global Using 将 System.Linq 命名空间包含在代码文件中，并使用 Sum 函数计算数组 numbers 中的所有元素的和。

隐式类型转换

隐式类型转换允许你在不指定转换的情况下将一种类型的值转换为另一种类型。当你有一种类型的值，并需要将其作为另一种类型使用时，这很有用。

例如，你可以使用以下代码使用隐式类型转换将一个整数转换为一个 double：

int x = 1234;
double y = x;
Console.WriteLine(y); // Outputs 1234

我们也可以为自定义类型实现类型的隐式转换。比如此处我们定义一个 Id 类型，并且让其支持从 string 进行隐式类型转换。

public struct Id
{
    public string Value { get; }
 
    public Id(string value)
    {
        Value = value;
    }
 
    public static implicit operator Id(string value) => new Id(value);
}

那么我们就可以使用以下代码进行隐式类型转换：

Id id = "123";

实现 Result 类型

我们可以通过上面的知识来实现 Result 类型。

首先，我们定义一个 Result 类型，它包含一个 IsSuccess 属性。

public readonly struct Result
{
    public Result(bool isSuccess)
    {
        IsSuccess = isSuccess;
    }
 
    public bool IsSuccess { get; }
}

然后我们分别定义两种类型的 Result，分别是 Ok 和 Error。

public readonly struct ErrorTag
{
}
 
public readonly struct SuccessTag
{
}

并且，我们在 Result 类型中实现对应的隐式类型转换。

public readonly struct Result
{
    public Result(bool isSuccess)
    {
        IsSuccess = isSuccess;
    }
 
    public bool IsSuccess { get; }
 
    public static implicit operator Result(SuccessTag _) => new Result(true);
    public static implicit operator Result(ErrorTag _) => new Result(false);
}

这样，我们就可以使用以下代码来创建 Result 类型的实例：

Result ok = new SuccessTag();
Result error = new ErrorTag();

然后我们在按照预期，使用方法来取代 new SuccessTag() 和 new ErrorTag()。

public static class ResultHelper
{
    public static SuccessTag Ok() => new();
    public static ErrorTag Error() => new();
}

这样，我们就可以使用以下代码来创建 Result 类型的实例：

Result ok = ResultHelper.Ok();
Result error = ResultHelper.Error();

最终，我配合 static using 语法和 global using 语法。

global using static ResultHelper;

这样，我们就可以使用以下代码来创建 Result 类型的实例：

Result ok = Ok();
Result error = Error();

总结

本文介绍了隐式类型转换的概念，并且通过隐式类型转换来实现 Result 类型。

参考资料

• Global using Directive in C# 10^[1]
• Static using^[2]
• dotNext Result Type^[3]
• User-defined explicit and implicit conversion operators^[4]

• 本文作者： newbe36524
• 本文链接： https://www.newbe.pro/ChatAI/0x012-How-to-implement-implicit-type-conversion/
• 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！

参考资料

[1] Global using Directive in C# 10: https://www.c-sharpcorner.com/article/global-using-directive-in-c-sharp-102/
[2] Static using: https://learn.microsoft.com/dotnet/csharp/language-reference/keywords/using-directive?WT.mc_id=DX-MVP-5003606#static-modifier
[3] dotNext Result Type: https://dotnet.github.io/dotNext/features/core/result.html
[4] User-defined explicit and implicit conversion operators: https://learn.microsoft.com/dotnet/csharp/language-reference/operators/user-defined-conversion-operators?WT.mc_id=DX-MVP-5003606

 

 

出处：https://www.cnblogs.com/newbe36524/p/17018761.html