相关疑难解决方法(0)

我最近看到了以下代码:

public class Person
{
    //line 1
    public string FirstName { get; }
    //line 2
    public string LastName { get; } = null!;
    //assign null is possible
    public string? MiddleName {get; } = null;

    public Person(string firstName, string lastName, string middleName)
    {
        FirstName = firstName;
        LastName = lastName;
        MiddleName = middleName;
    }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
        MiddleName = null;
    }
}

基本上我试着深入研究新的c#8功能.其中之一是NullableReferenceTypes.实际上已经有很多关于它的文章和信息.例如,这篇文章非常好.但是我找不到关于这个新陈述的任何信息null! 有人可以向我提供解释吗？为什么我需要使用它？又什么区别line1和line2？

添加<Nullable>enable</Nullable>or 后#nullable enable，我的通用方法遇到了以下问题：

这不起作用：

public T? GetDefault<T>()
{
    return default;
}

这适用于警告：

public T GetDefault<T>()
{
   return default;
}

这单独工作，但不能一起工作。

public T? GetDefault<T>() where T : class
{
    return default;
}

public T? GetDefault<T>() where T : struct
{
    return default;
}

从逻辑上讲，第一种方法应该有效。
在不创建多种方法和抑制警告的情况下，摆脱这种情况的正确方法是什么（在任何框架中）？
[MaybeNull] 属性仅适用于 .Net Core 3.0+。

另外，我在这里问了这个问题

我正在将代码库转换为具有可为空引用类型的 C#8。我遇到了一种类似于这个问题中的方法但异步的方法。

public async Task<T> GetAsync<T>()
{
    // sometimes returns default(T); => warning CS8603 Possible null reference return
}

T 可以是任何类型，包括可为空的引用类型或可为空的值类型。

明确地说，我理解为什么这种方法会触发警告。我想知道的是可以使用哪些注释来解决它。

• 我知道我可以使用 #nullable disable 或default(T)!，但我希望有一些不那么“锤子”的东西。
• 我知道我不能使用，[return: MaybNull]因为那将适用于它Task本身，而不适用于T.

我可以应用任何其他属性/注释来使编译器满意，还是default(T)!我唯一的选择？

在 C# 中使用新的可为空引用类型。很高兴看到他们从 Swift 中挖走了这个！这是一个非常棒的功能！但是...因为它本质上是“固定在”语言上的，所以我正在努力创建一个泛型，它可以采用任何可空类型，无论是值还是引用，这在 Swift 中都是微不足道的。

考虑这个类：

public abstract class LabeledValue<TValue> {
    public string? label { get; set; }
    public TValue? value { get; set; }
}

这是我想要实现的目标，以Int一个名为“Foo”的类为例：

public class LabeledInt : LabeledValue<Int>{}

var myLabeledIntA = new LabeledInt(){
    label = "Forty Four",
    value = 44
}

var myLabeledIntB = new LabeledInt(){
    label = "Not Set",
    value = null
}

public class LabeledFoo : LabeledValue<Foo>{}

var myLabeledFooA = new LabeledFoo(){
    label = "Set",
    value = new Foo()
} …

我的情况类似于描述的可能返回 default(T) 的异步通用方法的正确可为空注释。

但是，我想知道让调用者知道“返回值”可能为空的正确方法。

    public async Task<T> GetAsync<T>()
    {
        // sometimes returns default(T)!;
    }

如果这不是异步方法，我可以使用 MaybeNull 属性。

    [return: MaybeNull]
    public T Get<T>()
    {
        // sometimes returns default(T)!;
    }

如果它不是通用的，我可以只使用?语法。

    public async Task<string?> GetAsync()
    {
        // sometimes returns default(string)!;
    }

有没有办法让调用者知道它可以为空而不添加通用约束？

编辑：澄清我的意思是让编译器知道任务中的值可能为空。我想反过来也是如此。我最感兴趣的是这应该如何与新的 C# 可为空引用语法一起工作。

我可以做这样的事情就好了

    var a = await GetAsync<string?>(); // a is null
    var b = await GetAsync<int?>(); // b is null
    var c = await GetAsync<string>(); // c is null.  Wait string is not supposed …

注意： 我使用的是 C# 8 的可空引用类型。默认情况下，引用类型不可为空。

假设我有以下方法：

public void TestMethod<T>(T[] items)
{

}

在不使用任何通用约束的情况下，如何使用 Nullable 属性指定数组本身不会为空，但数组中的单个项目可能为空？

我的目标如下：

• 没有警告，因为数组本身不为空： var len = items.Length;
• 警告，因为单个项目可以为空： items[0].ToString()
• 没有警告，因为空合并运算符： items[0]?.ToString()

这段代码似乎表明数组本身可以为空，但是，如果数组本身不为空，那么每个数组项也不为空：

public void TestMethod<T>([MaybeNull]T[] items)
{

}

我知道使用泛型约束可以解决这个问题——因为我可以使用T?[] items——但是，我必须创建两个版本的类——一个用于值类型，一个用于引用类型。有没有办法在不使用通用约束的情况下表明这一点？

我正在 C# 8.0 中设计一个nullable启用的接口，目标是 .Net Standard 2.0（使用Nullable 包）和 2.1。我现在面临这个问题T?。

在我的示例中，我正在为缓存构建一个接口，该接口存储Stream由string键标识的 s/字节数据，即文件系统可以通过一个简单的实现。每个条目还由一个版本标识，该版本应该是通用的。例如，此版本可以是另一个string键（如 etag）、 anint或 a date。

public interface ICache<TVersionIdentifier> where TVersionIdentifier : notnull
{
    // this method should return a nullable version of TVersionIdentifier, but this is not expressable due to 
    // "The issue with T?" https://devblogs.microsoft.com/dotnet/try-out-nullable-reference-types/
    Task<TVersionIdentifier> GetVersionAsync(string file, CancellationToken cancellationToken = default);

    // TVersionIdentifier should be not nullable here, which is what we …

我有一个通用方法，需要保证我的方法返回 nullable<T>（例如 source 是 List<int>或 List<int?>必须返回int?），并且我想返回null而不是默认值（例如int的默认值是0。在这种情况下我想返回null）。可以对类型参数添加约束（https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/constraints-on-type-parameters），但我必须采用这种方法2 种方法（其中一种具有结构约束，另一种具有类约束）

我的方法是：

public static T? ElementOrNull<T>(List<T> source, int? index)
{
    if (source == null || index == null || source.Count <= index)
        return null;
    return source[index.Value];
}

我尝试Convert.ChangeType()和反思（Activator.CreateInstance()和Activator.CreateInstance<T?>()）但我无法解决这个问题。

任何和所有反馈都将受到赞赏。谢谢

注意：我在 StackOverflow 中检查了有关泛型及其转换的所有问题，但它们对我没有帮助

我有这个代码：

public T? Foo<T>()
    where T : class?
{
    return null;
}

它给出了一个符合逻辑和预期的错误：

可以为 null 的类型参数必须是值类型或不可为 null 的引用类型。考虑添加“类”、“结构”或类型约束。

现在我再添加一个约束：

public T? Foo<T>()
    where T : class?, IDisposable // Could be any interface I guess
{
    return null;
}

现在有趣的是，错误刚刚消失。尽管在我看来我们确实存在相互冲突的约束，因为接口是non-nullalbewhileclass?是。

我在这里遗漏了什么还是编译器有问题？