Secondo te cosa è più leggibile:??(operatore) o l'uso di if's

Question

Ho un metodo che riceverà un file string, ma prima di poterlo lavorare, devo convertirlo in int.A volte può essere null e devo cambiarne il valore in "0".Oggi ho:

public void doSomeWork(string value)
{
   int SomeValue = int.Parse(value ?? "0"); //it can throw an exception(i know)
}

L'ho fatto, ma il mio capo mi ha chiesto di rifattorizzarlo in:

public void doSomeWork(string value)
{
    if(string.IsNullOrEmpty(value))
        value = "0";
    int SomeValue = int.Parse(value);
}

secondo voi qual'è la soluzione migliore?

Answer 1

Personalmente mi piacerebbe andare per la versione corretta dei vostri capi - forse con ancora più controlli su di esso - se del stringa vuota, la tua volontà, come dici tu un'eccezione, come "" non è un numero ben formattato e ?? controlla solo per nulla.

Qualcosa di simile:

public int doSomeWork(string value) {
  int someValue = 0;

  if (!string.IsNullOrEmpty(value)) {
    Int.TryParse(value, out someValue);
  }
}

Il che risolve il problema dove il valore è uguale a "Forty Two".

Answer 2

Perché non usare TryParse()?

public int doSomeWork(string stringValue)
{
    int value;
    int.TryParse(stringValue, out value);

    return value;
}

Il codice qui sopra tornare 0 se il valore è tutt'altro che un numero reale.

Quindi, a mio parere, il mio esempio è il più leggibile. Io cerco di analizzare l'int e restituirlo. Nessun operatore si fondono, e nessun metodo stringa vengono utilizzati. Questo metodo gestisce anche le eccezioni che potrebbero essere lanciati durante l'analisi (a meno che non si desidera che le eccezioni ...).

Answer 3

Credo che la soluzione migliore è quella di fare quello che dice il tuo capo, questo non vale la pena! Detto questo, aggiungere un paio di spazi intorno tuo e mi piace di più.

int someValue = int.Parse(value ?? "0");

Answer 4

Io sicuramente preferisco l'operatore nulla coalesce (??) su una serie di istruzioni if. Soprattutto quando si ha bisogno a fondersi più di un valore, l'approccio dell'operatore è molto più leggibile. Questo gioca in altre nuove caratteristiche di C #, ad esempio espressioni lambda, la sintassi LINQ zucchero, ecc meno codice v'è di confondere il codice intentful reale, il più chiaro l'intento dovrebbe / sarà.

Answer 5

Perché analizzare la stringa "0" solo per ottenere valore intero 0? Io sicuramente preferisco questo:

public int doSomeWork(string value) {
   int someValue;
   if (String.IsNullOrEmpty(value)) {
      someValue = 0;
   } else {
      someValue = Int32.Parse(value);
   }
}

Answer 6

Il mio refactoring sarebbe simile a questo

public int doSomeWork(string value)
{
   int result = 0; //default?

   if(string.IsNullOrEmpty(value))
   {
      result = 0;
   }
   else
   {
      result = int.Parse(value); //you could also consider using TryParse(...) if your string could possibly also be different from a number.
   }

   //do some calculations upon "result"


   return result;
}

Attualmente sto leggendo Libro di Martin Fowler sul refactoring (volevo leggerlo già da più tempo ormai) e questo è quello che normalmente preferisco e ho scoperto che è anche uno "schema" comunemente suggerito nel libro.

Answer 7

le due opzioni non sono equivalenti. Una parte da un errore nel secondo frammento (si legga if(string.IsNullOrEmpty(value)), gestirà due casi, stringhe nulle e vuote, mentre l'operatore ?? gestisce solo i valori nulli.

A parte che è molto più leggibile. Mi schiero con il tuo capo.

Answer 8

Un'altra soluzione è

int someValue = string.IsNullOrEmpty (valore)? 0: int.Parse (value);

Answer 9

Il primo frammento di controllerà solo se value == null, ma i secondi frammento controlla se value == string.Empty || value == null. Non so quali sono i requisiti del metodo non è che quei due frammenti farò cose diverse.

Answer 10

In realtà si potrebbe refactoring per

Valore var = 0;
  int.TryParse (StringaBella, fuori value);

in entrambi i casi si ha sempre un intero valido (se questo è l'obiettivo)

Answer 11

Si può fare a modo tuo? Cool!

Se è sicuramente più leggibile, a meno che non tutti sono più di un C # wonk di me.

Answer 12

In questo caso il precedente è più leggibile perché è un esempio banale. ** Tuttavia nel caso in cui essi non sono equivalenti, come ?? non è lo stesso di string.IsNullOrEmpty **

Il secondo sarebbe meglio nei casi in cui il caso era complesso. Direi cavalli per i corsi. Dipende solo sul pubblico. Cercate di mantenere le cose semplici.

public int doSomeWork(string value)
{
  return int.Parse(value ?? "0");
}



public int doSomeWork(string value)
{
   if(value == null)
      value = "0";
    int SomeValue = int.Parse(value);
    return SomeValue;
}

Answer 13

[Dando per scontato che solo bisogno di verificare la presenza di nulla, e non stringa vuota anche, come altri hanno fatto notare]

La differenza semantica tra i due è che ?? è un'espressione, mentre if è una dichiarazione. Un'espressione dice "eseguire un calcolo e restituisce un risultato", esattamente la semantica che cercate. Più lavoro deve essere fatto per consentire una dichiarazione if per esprimere la stessa semantica; oltre a questo, il if lascia spazio per più logica rispetto al calcolo, stanza non è necessario.

Si consiglia di utilizzare l'operatore ?? perché esprime esattamente l'intento desiderato.