Wie analysiere ich einen String in einen Nullable Int

Können Sie dies tun, in einer Linie mit dem bedingten operator und die Tatsache, dass Sie werfen kann, ist null zu einem nullable-Typ (zwei Zeilen, wenn Sie nicht eine bereits bestehende int, die Sie wiederverwenden können, für die Ausgabe der TryParse):

Pre C#7:

int tempVal;
int? val = Int32.TryParse(stringVal, out tempVal) ? Int32.Parse(stringVal) : (int?)null;

Mit C#7 die aktualisierte syntax, die es Ihnen erlaubt zu erklären, eine output-variable in der Methode aufrufen, wird dies noch einfacher.

int? val = Int32.TryParse(stringVal, out var tempVal) ? tempVal : (int?)null;

InformationsquelleAutor der Antwort McKenzieG1

Glenn Slaven: ich bin mehr daran interessiert zu wissen, wenn
es ist ein built-in-framework-Methode
analysieren können direkt in eine
nullable int?

Es ist dieser Ansatz, analysieren die direkt an eine null-int (und nicht nur int), wenn der Wert gültig ist wie null oder leeren string, aber nicht werfen eine exception für ungültige Werte, so dass Sie brauchen, um die Ausnahme zu fangen und zurück der Standardwert für diese Situationen:

public static T Parse<T>(object value)
{
    try { return (T)System.ComponentModel.TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(value.ToString()); }
    catch { return default(T); }
}

Dieser Ansatz kann weiterhin verwendet werden für nicht-null-Werte zulässt analysiert sowie nullable:

enum Fruit { Orange, Apple }
var res1 = Parse<Fruit>("Apple");
var res2 = Parse<Fruit?>("Banana");
var res3 = Parse<int?>("100") ?? 5; //use this for non-zero default
var res4 = Parse<Unit>("45%");

NB: Es ist eine IsValid-Methode auf dem Konverter Sie verwenden können, anstelle der Erfassung die Ausnahme (Ausnahmen ausgelöst, führt unnötiger overhead, wenn erwartet). Leider funktioniert es nur, da .NET 4, aber es gibt noch ein Problem, wo es nicht überprüfen Sie Ihre Gebietsschema, wenn die Validierung richtigen Formate für Datum und Uhrzeit, siehe bug 93559.

InformationsquelleAutor der Antwort Michael

Altes Thema, aber wie wäre es mit:

public static int? ParseToNullableInt(this string value)
{
     return String.IsNullOrEmpty(value) ? null : (int.Parse(value) as int?);
}

Ich mag dieses besser als das requirement where to parse null, die TryParse-version würde nicht werfen ein Fehler auf, z.B. ToNullableInt32(XXX). Das einführen kann unerwünschte silent Fehler.

InformationsquelleAutor der Antwort mortb

Folgende arbeiten sollten für jeden struct-Typ. Es basiert auf code von Matt Manela von MSDN-Foren. Als Murph Punkte aus dem exception-handling könnte teuer werden im Vergleich zu den Arten gewidmet TryParse-Methode.

        public static bool TryParseStruct<T>(this string value, out Nullable<T> result)
            where T: struct 
        {
            if (string.IsNullOrEmpty(value))
            {
                result = new Nullable<T>();

                return true;
            }

            result = default(T);
            try
            {
                IConvertible convertibleString = (IConvertible)value;
                result = new Nullable<T>((T)convertibleString.ToType(typeof(T), System.Globalization.CultureInfo.CurrentCulture));
            }
            catch(InvalidCastException)
            {
                return false;
            }
            catch (FormatException)
            {
                return false;
            }

           return true;
        }

Diese waren die grundlegenden test-Fälle, die ich verwendet.

        string parseOne = "1";
        int? resultOne;
        bool successOne = parseOne.TryParseStruct<int>(out resultOne);
        Assert.IsTrue(successOne);
        Assert.AreEqual(1, resultOne);

        string parseEmpty = string.Empty;
        int? resultEmpty;
        bool successEmpty = parseEmpty.TryParseStruct<int>(out resultEmpty);
        Assert.IsTrue(successEmpty);
        Assert.IsFalse(resultEmpty.HasValue);

        string parseNull = null;
        int? resultNull;
        bool successNull = parseNull.TryParseStruct<int>(out resultNull);
        Assert.IsTrue(successNull);
        Assert.IsFalse(resultNull.HasValue);

        string parseInvalid = "FooBar";
        int? resultInvalid;
        bool successInvalid = parseInvalid.TryParseStruct<int>(out resultInvalid);
        Assert.IsFalse(successInvalid);

InformationsquelleAutor der Antwort Daniel Ballinger

Diese Lösung ist allgemein gehalten, ohne Reflexion overhead.

public static Nullable<T> ParseNullable<T>(string s, Func<string, T> parser) where T : struct
{
    if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(s.Trim())) return null;
    else return parser(s);
}

static void Main(string[] args)
{
    Nullable<int> i = ParseNullable("-1", int.Parse);
    Nullable<float> dt = ParseNullable("3.14", float.Parse);
}

InformationsquelleAutor der Antwort Qi Luo

Spürte ich, sollte ich Teile mir das ein bisschen mehr generisch.

Verwendung:

var result = "123".ParseBy(int.Parse);

var result2 = "123".ParseBy<int>(int.TryParse);

Lösung:

public static class NullableParse
{
    public static Nullable<T> ParseBy<T>(this string input, Func<string, T> parser)
        where T : struct
    {
        try
        {
            return parser(input);
        }
        catch (Exception exc)
        {
            return null;
        }
    }

    public delegate bool TryParseDelegate<T>(string input, out T result);

    public static Nullable<T> ParseBy<T>(this string input, TryParseDelegate<T> parser)
        where T : struct
    {
        T t;
        if (parser(input, out t)) return t;
        return null;
    }
}

Erste version ist langsamer, da es erfordert eine try-catch, aber es sieht sauberer aus. Wenn es nicht zu viele Male aufgerufen werden, mit ungültigen Zeichenfolgen, ist es auch nicht wichtig.
Wenn die Leistung ein Problem, bitte beachten Sie, dass bei der Verwendung von TryParse-Methoden, müssen Sie den type-parameter von ParseBy, wie es kann nicht gefolgert werden, der vom compiler. Ich hatte auch zum definieren eines Delegierten als out-Schlüsselwort nicht verwendet werden können, innerhalb von Func<>, aber zumindest dieses mal-compiler erfordert keine explizite Instanz.

Schließlich, Sie können es mit anderen Strukturen, nämlich decimal, DateTime, Guid, etc.

InformationsquelleAutor der Antwort orcun

Habe ich mit kommen dieses hier, das erfüllt meine Anforderungen (ich wollte meine Erweiterung Methode zu emulieren, so nah wie möglich die Rückkehr von framework TryParse, aber ohne try{} catch {} - Blöcke und ohne dass der compiler meckert über die Herleitung eines nullable-Typ innerhalb der framework-Methode)

private static bool TryParseNullableInt(this string s, out int? result)
{
    int i;
    result = int.TryParse(s, out i) ? (int?)i : null;
    return result != null;
}

InformationsquelleAutor der Antwort wmoecke

Sollten Sie nie verwenden, eine Ausnahme, wenn Sie nicht müssen - der Aufwand ist schrecklich.

Varianten TryParse das problem lösen - wenn Sie möchten, um kreativ zu werden (um Ihren code zu mehr elegant Aussehen), Sie könnten wahrscheinlich etwas zu tun mit einer Erweiterung Methode in 3.5, aber der code wäre mehr oder weniger das gleiche.

InformationsquelleAutor der Antwort Murph

Schlage ich code unten. Sie arbeiten vielleicht mit Ausnahme beim konvertieren Fehler aufgetreten.

public static class Utils {      
public static bool TryParse<Tin, Tout>(this Tin obj, Func<Tin, Tout> onConvert, Action<Tout> onFill, Action<Exception> onError) {
  Tout value = default(Tout);
  bool ret = true;
  try {
    value = onConvert(obj);
  }
  catch (Exception exc) {
    onError(exc);
    ret = false;
  }
  if (ret)
    onFill(value);
  return ret;
}

public static bool TryParse(this string str, Action<int?> onFill, Action<Exception> onError) {
  return Utils.TryParse(str
    , s => string.IsNullOrEmpty(s) ? null : (int?)int.Parse(s)
    , onFill
    , onError);
}
public static bool TryParse(this string str, Action<int> onFill, Action<Exception> onError) {
  return Utils.TryParse(str
    , s => int.Parse(s)
    , onFill
    , onError);
}
}

Diese Erweiterung-Methode im code (fill int? Age-Eigenschaft der person-Klasse):

string ageStr = AgeTextBox.Text;
Utils.TryParse(ageStr, i => person.Age = i, exc => { MessageBox.Show(exc.Message); });

ODER

AgeTextBox.Text.TryParse(i => person.Age = i, exc => { MessageBox.Show(exc.Message); });

InformationsquelleAutor der Antwort lison

Merke ich, das ist ein altes Thema, aber kannst du nicht einfach:

(Nullable<int>)int.Parse(stringVal);

?

InformationsquelleAutor der Antwort Leigh Bowers