Esta é a limitação da verificação anulável do C #? [duplicado]

Dec 18 2020

Recebi o seguinte aviso CS8629 em minha referência a x. Por causa da wherecláusula antes de select, tenho certeza de que x.Valuenunca será uma referência anulável. É esta a limitação intrínseca da verificação de nulos do C #? Existe alguma maneira de se livrar do aviso CS8629 além de suprimi-lo?

var myEnums = myStrings
      .Select(x => x.ToEnum<MyEnum>())
      .Where(x => x.HasValue)
      .Select(x => x.Value)  //CS8629 on x.
      .ToList();
MyEnum? ToEnum(this string str);

Respostas

2 Sweeper Dec 18 2020 at 08:50

Sim, esse é o limite. LINQ ainda não está anotado com anotações anuláveis. Veja esta resposta , este problema e este problema , que estão todos abertos.

Se você realmente não deseja usar !, pode escrever algo como:

static IEnumerable<T> AsEnumerable<T>(this Nullable<T> t) where T : struct {
    if (t.HasValue) {
        return Enumerable.Repeat(t.Value, 1);
    }
    return Enumerable.Empty<T>();
}

Então use SelectMany:

var myEnums = myStrings
      .Select(x => x.ToEnum())
      .SelectMany(x => x.AsEnumerable())
      .ToList();
UsemeAlehosaini Dec 18 2020 at 08:48

Embora não haja nenhum retorno nulo, tente converter o MyEnum?para MyEnum.

Como isso:

MyEnum myEnums = myStrings
      .Select(x => x.ToEnum<MyEnum>())
      .Where(x => x.HasValue)
      .Select(x => x.Value)  //CS8629 on x.
      .ToList();