c# - valid - ¿Hay una manera más elegante de agregar entradas que puedan ser anulables?

summary param name c#

Question

Necesito agregar numerosas variables de tipo nullable int. Utilicé el operador de unión nula para reducirlo a una variable por línea, pero tengo la sensación de que hay una forma más concisa de hacerlo, por ejemplo, ¿no puedo encadenar estas afirmaciones de alguna manera? He visto eso antes en otras código.

using System;

namespace TestNullInts
{
    class Program
    {
        static void Main(string[] args)
        {
            int? sum1 = 1;
            int? sum2 = null;
            int? sum3 = 3;

            //int total = sum1 + sum2 + sum3;
            //int total = sum1.Value + sum2.Value + sum3.Value;

            int total = 0;
            total = total + sum1 ?? total;
            total = total + sum2 ?? total;
            total = total + sum3 ?? total;

            Console.WriteLine(total);
            Console.ReadLine();
        }
    }
}

Answer 1

¿Cómo sobre el método de ayuda -

static int Sum(params int?[] values)
{
  int total = 0;
  for(var i=0; i<values.length; i++) {
     total += values[i] ?? 0;
  }
  return total;
}

OMI, no muy elegante, pero al menos agrega tantos números como quieras de una sola vez.

total = Helper.Sum(sum1, sum2, sum3, ...);

Answer 2

¿Qué tal si solo se sustituye (sumX ?? 0) por sumX en la expresión no anulable correspondiente?

using System; 

namespace TestNullInts 
{ 
    class Program 
    { 
        static void Main(string[] args) 
        { 
            int? sum1 = 1; 
            int? sum2 = null; 
            int? sum3 = 3; 

            int total = 0; 
            total += (sum1 ?? 0) + (sum2 ?? 0) + (sum3 ?? 0); 

            Console.WriteLine(total); 
            Console.ReadLine(); 
        } 
    } 
} 

Answer 3

El uso más simple y elegante de LINQ:

var list = new List<Nullable<int>> { 1, 2, null, 3 };
var sum = list.Sum(s => s ?? 0);
Console.WriteLine(sum);

Necesita el AFAIK de coalescencia para asegurarse de que el resultado no sea anulable.

Answer 4

Podrías hacerlo

total += sum1 ?? 0;
total += sum2 ?? 0;
total += sum3 ?? 0;

Answer 5

Sólo para responder a la pregunta más directamente:

int total = (sum1 ?? 0) + (sum2 ?? 0) + (sum3 ?? 0);

De esta manera, las declaraciones se "encadenan" juntas según lo solicitado utilizando un +

Answer 6

List<Nullable<int>> numbers = new List<Nullable<int>>();
numbers.Add(sum1);
numbers.Add(sum2);
numbers.Add(sum3);

int total = 0;
numbers.ForEach(n => total += n ?? 0);

De esta manera puedes tener tantos valores como quieras.

Answer 7

total += sum1.GetValueOrDefault();

etc.

Answer 8

var nums = new int?[] {1, null, 3};
var total = nums.Sum();

Esto se basa en la IEnumerable<Nullable<Int32>>overload del Método Enumerable.Sum , que se comporta como cabría esperar.

Si tiene un valor predeterminado que no es igual a cero, puede hacerlo:

var total = nums.Sum(i => i.GetValueOrDefault(myDefaultValue));

o la taquigrafía

var total = nums.Sum(i => i ?? myDefaultValue);