int.TryParse zucchero sintattico

Question

int.TryPrase è grande e tutti, ma c'è solo un problema ... ci vogliono almeno due righe di codice da usare:

int intValue; 
string stringValue = "123"; 
int.TryParse(stringValue, out intValue); 
.... 

Certo che posso fare qualcosa di simile:

string stringValue = "123"; 
int intValue = Convert.ToInt32(string.IsNullOrWhiteSpace(stringValue) ? 0 : stringValue); 

su una sola riga di codice.

Come posso eseguire un po 'di magia per ottenere int.TryParse di utilizzare un solo rivestimento, o c'è ancora una terza alternativa là fuori?

Grazie!

Bezden ha risposto alla domanda meglio, ma in realtà ho intenzione di utilizzare la soluzione Reddogs.

Answer 1

int intValue = int.TryParse(stringValue, out intValue) ? intValue : 0; 

Answer 2

Non credo che ci sia qualcosa di veramente bello, ma se ti piace questo si arriva verso il basso per una riga:

string stringValue = "123" 
int intValue = int.TryParse(stringValue, out intValue) ? intValue : 0; 

Answer 3

magari utilizzare un metodo di estensione:

public static class StringExtensions 
{ 
    public static int TryParse(this string input, int valueIfNotConverted) 
    { 
     int value; 
     if (Int32.TryParse(input, out value)) 
     { 
      return value; 
     } 
     return valueIfNotConverted; 
    } 
} 

E utilizzo:

string x = "1234"; 
int value = x.TryParse(0); 

Modifica: E naturalmente è possibile aggiungere l'ovvio sovraccarico che già imposta il valore predefinito a zero se questo è il tuo desiderio.

Answer 4

Non si desidera rendere int.TryParse() una riga. Perché? Perché non è possibile eseguire un'assegnazione a intValue se la stringa di input non è un numero intero valido. L'intero punto di TryParse() è quello di consentire di testare per un buon input e degradare con grazia, piuttosto che dover rilevare un'eccezione.

Int.TryParse() è già una scorciatoia, quindi non è necessario testare un int valido e eseguire l'assegnazione in due passaggi ... è tutto ciò che si vuole prendere.

Answer 5

Poiché essenzialmente restituisce due valori (successo e valore), abbiamo davvero bisogno delle due linee.

Si potrebbe provare una classe wrapper, vale a dire:

void Main() 
{ 
    var result = simpleIntParser.TryParse("1"); 
    if(result) 
    { 
     Console.WriteLine((int)result); 
    } else { 
     Console.WriteLine("Failed"); 
    } 

    result = simpleIntParser.TryParse("a"); 
    if(result) 
    { 
     Console.WriteLine((int)result); 
    } else { 
     Console.WriteLine("Failed"); 
    } 


} 

public class simpleIntParser 
{ 
    public bool result {get; private set;} 
    public int value {get; private set;} 

    private simpleIntParser(bool result, int value) 
    { 
     this.result = result; 
     this.value = value; 
    } 

    public static simpleIntParser TryParse(String strValue) 
    { 
     int value; 
     var result = int.TryParse(strValue, out value); 
     return new simpleIntParser(result, value); 
    } 

    public static implicit operator int(simpleIntParser m) 
    { 
     return m.value; 
    } 

    public static implicit operator bool(simpleIntParser m) 
    { 
     return m.result; 
    } 
} 

Richiede lanciando se il tipo è ambigua (cioè per Console.WriteLine()), ma se si passa come un parametro intero, ad esempio, non è richiesto il lancio

Answer 6

Vorrei creare un metodo di estensione fuori da questo.

public static int? AsInt32(this string s) 
    { 
     int value; 
     if (int.TryParse(s, out value)) 
      return value; 

     return null; 
    } 

Answer 7

Verificare la classe StringExtensions. Contiene un metodo di estensione AsInt(String,Int32) che tenterà di convertire una stringa e, se non riuscito, lo popolerà con il valore Int32 fornito come predefinito.

Esempio:

var intValue = "123".AsInt(-1); 

Answer 8

int val2 = "asd".AsInt(-1); 
//Output : -1 
int val3 = "123".AsInt(-1); 
//Output : 123 

È necessario avere System.Web.WebPages namespace.

Answer 9

Questa risposta è solo per coloro che utilizzano almeno C# 7.

Ora è possibile dichiarare il parametro out in linea.

int.TryParse("123", out var result); 

Per dimostrare che funziona, è possibile eseguire seguendo dotnetfiddle.

int.TryParse("123", out var result); 
Console.WriteLine(result); 
Console.WriteLine(result.GetType()); 

https://dotnetfiddle.net/nn9955