标签: nullable

我的 C# 代码在比我自己的开发环境更旧的 C# 版本 (4.0.30319.34209) 中运行。我想知道我对可空类型的使用是否适用于这个旧版本的 C#。有谁知道 C# 可空类型是在哪个版本中引入的？我的“Google-fu”什么也没想出来。

我很难理解可空值类型在 C#9 中的工作原理。

以下文档来自：

• https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/nullable-value-types

我可以写（没有编译器错误）：

int? a = 10;
a++; // No need for explicit 'a.Value'

但我不能写（编译器错误）：

Span<char> TryFormatOrNull(int? input)
{
    char[] buffer = new char[512];
    if (input == null) return null;
    _ = input.TryFormat(buffer, out _);
    return buffer;
}

我需要写（没有语法糖）：

Span<char> TryFormatOrNull(int? input)
{
    char[] buffer = new char[512];
    if (input == null) return null;
    _ = input.Value.TryFormat(buffer, out _);
    return buffer;
}

我对可空值类型与成员函数/运算符有何误解？

我只有在启用可为空引用类型后才会收到警告，但具体示例实际上是很好的旧Nullable<T>类型：

var nullableItems = new List<int?>();

var actualNonNullValues = nullableItems.Where(x => x.HasValue)
                                       .Select(x => x.Value)
                                       .ToList();

因此，我整理出所有空值，只想要实际的非空项。然而，该部分.Select(x => x.Value)会给我一个编译器警告，警告x这里可能为空。从逻辑上讲，它不是，但对于编译器来说，类型尚未改变，它仍然是一个int?.

!我知道我可以通过将 an 应用于来告诉编译器关闭x，但看起来我作弊了。在我使用的其他语言中，不得不依赖于此被认为是不好的做法，意味着你做错了什么。

我还有哪些其他选择？我能做得比!在这里使用更好吗？

在这种情况下，我似乎无法理解编译器的警告：

using System;
using System.Collections.Generic;

#nullable enable
                    
public class Program
{
    public static void Main()
    {
        Guid guid = Guid.NewGuid();
        
        Dictionary<Guid, string> d = new();
        
        bool found = d.TryGetValue(guid, out string? str);
        
        if (found is false)
        {
            return;
        }
        
        string s = str; // WARNING: possible null value
    }
}

毕竟，我正在执行found检查并在没有值时返回（例如，当out str值为空时）。另外，out该方法的参数.TryGetValue用 注释[MaybeNullWhen(false)]。

感谢您帮助找出我的期望中的错误并修复代码，谢谢。代码在这里。

我有以下代码，

bool HasPassed= (result!= null && result.Identifier.Equals("Passed"))? true : false

这工作得很好，但我想知道是否可以以更好、更简化的方式编写这段代码，也许使用？运算符（或空合并运算符）。我仍在学习这一点，不太明白在这种情况下如何使用它。以下是一个用于测试的最小项目，非常感谢任何建议！

Result result = new Result();
//result.Identifier = "Passed";
result = null;
bool HasPassed = (result != null && result.Identifier.Equals("Passed")) ? true : false;

public class Result
{
    public string Identifier { get; set; }
}

我需要有关 java 8+ 的可选概念之一的帮助。我一直看到开发人员在列表对象上使用Optional.ofNullable，这是不正确的，我不确定它如何在没有错误/缺陷的情况下完美工作。代码是这样的

注意：列表对象是通过从存储库层进行数据库调用来捕获的。

Optional.ofNullable(list) .orElse(Collections.emptyList()) .stream().forEach(x-> { ------ ------};);

如果列表中没有元素，则列表不能为空（[]），那么它如何正确处理Optional.ofNullable（）？我尝试通过在 forEach 中添加打印语句来测试虚拟代码，它会在两种情况下打印（列表为空以及非空）。

我有一个这样定义的参数：params object?[] values并且我不能发送 null （即我想要一个内部有一个 null 的数组）。

它确实可以在没有参数的情况下工作。

错误是：Cannot convert null literal to non-nullable reference type.

public class Foo
{
    private void DoesNotWork(params object?[] values)
    {
    }
    
    private void DoesWork1(object? value)
    {
    }
    
    private void DoesWork2(object?[] values)
    {
    }

    public void Test()
    {
        DoesNotWork(null);
        DoesWork1(null);
        DoesWork2(new object?[] { null });
    }
}

我是否做错了什么，或者编译器是否存在某些限制不允许这样做？

PS 如果方法“DoesNotWork”来自未打开 nullable 的库，它也可以工作，即它的定义如下：DoesNotWork(params object[] values)，所以我可以在那里发送 null 。

PPS 我发现这个解决方法也有效： DoesNotWork((object?) null);。

PPPSDoesNotWork(null!);也能发挥作用

给出以下代码示例：

class Value { }

Value? value = null;

if (value is not null)
{
    Value value2 = value;
}

int? value = null;

if (value is not null)
{
    int value2 = value; // CS0266: Cannot implicitly convert type 'int?' to 'int'.
}

我知道这个问题与引用类型与值类型有关。

但是，在这两种情况下，我都检查是否value为 null，那么为什么编译器不能理解第二个示例中 if 块内的值永远不应该为 null？

我可以通过使用来解决这个问题value.Value，但这似乎违反直觉。

如有帮助，将不胜感激。

如果值类型被声明为可为空,那么我该如何采取预防措施呢？即如果在构造函数中我有:

public Point3 ( Point3 source )
{
    this.X = source.X;
    this.Y = source.Y;
    this.Z = source.Z;
}

如果来源为空,它会失败吗？

我怎么能避免这个字典(或动态创建它)？

Dictionary<Type,Type> CorrespondingNullableType = new Dictionary<Type, Type>
{
    { typeof(bool),    typeof(bool?) },
    { typeof(byte),    typeof(byte?) },
    { typeof(sbyte),   typeof(sbyte?) },
    { typeof(char),    typeof(char?) },
    { typeof(decimal), typeof(decimal?) },
    { typeof(double),  typeof(double?) },
    { typeof(float),   typeof(float?) },
    { typeof(int),     typeof(int?) },
    { typeof(uint),    typeof(uint?) },
    { typeof(long),    typeof(long?) },
    { typeof(ulong),   typeof(ulong?) },
    { typeof(short),   typeof(short?) },
    { typeof(ushort),  typeof(ushort?) },
    { typeof(Guid),    typeof(Guid?) },
};