C'è un modo più elegante per aggiungere int nullable?

Question

Ho bisogno di aggiungere numerose variabili di tipo int nullable. Ho usato il nulla coalescenza all'operatore di ottenere il basso per una variabile per riga, ma ho la sensazione che ci sia un modo più conciso per fare questo, per esempio Non posso concatenare queste dichiarazioni insieme in qualche modo, ho visto che prima di altro codice.

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

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

Questa si basa sulla IEnumerable<Nullable<Int32>>overload della Enumerable.Sum metodo, che si comporta come ci si aspetterebbe.

Se si dispone di un default-valore che non è uguale a zero, si può fare:

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

o la scorciatoia:

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

Answer 2

total += sum1.GetValueOrDefault();

ecc.

Answer 3

Proprio per rispondere alla domanda più diretta:

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

In questo modo le dichiarazioni sono "incatenati" insieme come ha chiesto con un +

Answer 4

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);

questo modo è possibile avere tanti valori che si desidera.

Answer 5

Come su metodo di supporto -

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

IMO, non molto elegante, ma almeno aggiungere i numeri che si desidera in un una sola volta.

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

Answer 6

Si potrebbe fare

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

Answer 7

Come circa appena sostituendo (sumX ?? 0) per sumX nell'espressione non annullabile corrispondente?

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 8

più semplice, più l'uso elegante di LINQ:

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

È necessario il COALESCE per quanto ne so per assicurarsi che il risultato non è annullabile.