วิธีการแยกสตริงเป็น int nullable

ฉันต้องการแยกสตริงเป็น int nullable ใน C # กล่าวคือ ฉันต้องการกลับค่า int ของสตริงหรือ null ถ้าไม่สามารถแยกวิเคราะห์ได้

ฉันหวังว่ามันจะใช้ได้

int? val = stringVal as int?;

แต่นั่นไม่ได้ผลวิธีที่ฉันทำตอนนี้คือฉันได้เขียนวิธีการขยายนี้

public static int? ParseNullableInt(this string value)
{
    if (value == null || value.Trim() == string.Empty)
    {
        return null;
    }
    else
    {
        try
        {
            return int.Parse(value);
        }
        catch
        {
            return null;
        }
    }
}   

มีวิธีที่ดีกว่าในการทำเช่นนี้?

แก้ไข: ขอบคุณสำหรับคำแนะนำ TryParse ฉันรู้เกี่ยวกับเรื่องนี้ แต่ก็ทำออกมาเหมือนกัน ฉันสนใจที่จะรู้มากขึ้นว่ามีวิธีการสร้างเฟรมเวิร์กที่จะแจงเป็น int ที่ไม่มีค่าหรือไม่?

int.TryParse อาจจะง่ายกว่าเล็กน้อย:

public static int? ToNullableInt(this string s)
{
    int i;
    if (int.TryParse(s, out i)) return i;
    return null;
}

แก้ไข @Glenn int.TryParseคือ "สร้างไว้ในกรอบงาน" และint.Parseมีวิธีการแยกสตริง ints

คุณสามารถทำได้ในหนึ่งบรรทัดโดยใช้โอเปอเรเตอร์ที่มีเงื่อนไขและความจริงที่ว่าคุณสามารถแปลงnullให้เป็นประเภท nullable (สองบรรทัดหากคุณไม่มี int ที่มีอยู่แล้วคุณสามารถใช้เอาท์พุตซ้ำได้TryParse):

ก่อน C # 7:

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

ด้วยไวยากรณ์ที่อัปเดตของ C # 7 ที่ช่วยให้คุณประกาศตัวแปรเอาต์พุตในการเรียกใช้เมธอดสิ่งนี้จะง่ายขึ้นกว่าเดิม

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

[ อัปเดตเพื่อใช้ modern C # ตามคำแนะนำของ @ sblom]

ฉันมีปัญหานี้และฉันก็จบลงด้วยสิ่งนี้ (หลังจากทั้งหมดifและ 2 returnวินาทีนั้นยืดยาวมาก!):

int? ToNullableInt (string val)
    => int.TryParse (val, out var i) ? (int?) i : null;

ในหมายเหตุที่จริงจังมากขึ้นพยายามอย่าผสมintซึ่งเป็นคีย์เวิร์ด C # ด้วยInt32ซึ่งเป็นประเภท. NET Framework BCL แม้ว่าจะใช้งานได้ก็แค่ทำให้โค้ดดูยุ่งเหยิง

Glenn Slaven : ฉันสนใจที่จะรู้มากขึ้นว่ามีวิธีการสร้างเฟรมเวิร์กที่จะแยกวิเคราะห์เป็น int ที่ไม่มีค่าหรือไม่?

มีวิธีนี้ที่จะแยกวิเคราะห์โดยตรงกับ nullable (และไม่ใช่แค่ int) ถ้าค่าถูกต้องเช่น null หรือสตริงว่าง แต่จะโยนข้อยกเว้นสำหรับค่าที่ไม่ถูกต้องดังนั้นคุณจะต้องจับข้อยกเว้นและส่งกลับค่าเริ่มต้น สำหรับสถานการณ์เหล่านั้น:

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

วิธีการนี้ยังสามารถใช้สำหรับการแยกวิเคราะห์ที่ไม่เป็นโมฆะเช่นเดียวกับโมฆะ:

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

หมายเหตุ:มีวิธี IsValid บนตัวแปลงที่คุณสามารถใช้แทนการดักจับข้อยกเว้นได้ (ข้อยกเว้นที่ส่งออกไปส่งผลให้เกิดค่าใช้จ่ายที่ไม่จำเป็นหากคาดหวัง) แต่น่าเสียดายที่มันทำงานเท่านั้นตั้งแต่ .NET 4 แต่ยังคงเป็นปัญหาที่มันไม่ได้ตรวจสอบสถานที่ของคุณเมื่อการตรวจสอบรูปแบบวันที่และเวลาที่ถูกต้องดูข้อผิดพลาด 93559

var result = int.TryParse(foo, out var f) ? f : default(int?);

แหล่งที่มา:

• var
• Int32.TryParse
• ผู้ประกอบการตามเงื่อนไข
• ตัวดำเนินการเริ่มต้น (อธิบายในโพสต์สแต็คโอเวอร์โฟลว์นี้ )
• ประเภทค่า nullable

หัวข้อเก่า แต่จะเกี่ยวกับ:

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

ฉันชอบสิ่งนี้ดีกว่าเพราะการสอบถามว่าจะแยกวิเคราะห์ที่ว่างหรือไม่รุ่น TryParse จะไม่เกิดข้อผิดพลาดเช่น ToNullableInt32 (XXX) ที่อาจแนะนำข้อผิดพลาดเงียบที่ไม่พึงประสงค์

ลองสิ่งนี้:

public static int? ParseNullableInt(this string value)
{
    int intValue;
    if (int.TryParse(value, out intValue))
        return intValue;
    return null;
}

ฉันรู้สึกว่าทางออกของฉันเป็นวิธีที่สะอาดและดีมาก:

public static T? NullableParse<T>(string s) where T : struct
{
    try
    {
        return (T)typeof(T).GetMethod("Parse", new[] {typeof(string)}).Invoke(null, new[] { s });
    }
    catch (Exception)
    {
        return null;
    }
}

นี่เป็นวิธีการแก้ปัญหาทั่วไปที่เพียงต้องการให้อาร์กิวเมนต์ทั่วไปมีวิธีการคงที่ "แยกวิเคราะห์ (สตริง)" ใช้งานได้กับตัวเลขบูลีน DateTime ฯลฯ

คุณสามารถลืมคำตอบอื่น ๆ ทั้งหมด - มีวิธีแก้ปัญหาทั่วไปที่ยอดเยี่ยม: http://cleansharp.de/wordpress/2011/05/generischer-typeconverter/

นี่ช่วยให้คุณเขียนโค้ดที่สะอาดมากเช่นนี้:

string value = null;
int? x = value.ConvertOrDefault();

และนอกจากนี้ยังมี:

object obj = 1;  

string value = null;
int x = 5;
if (value.TryConvert(out x))
    Console.WriteLine("TryConvert example: " + x); 

bool boolean = "false".ConvertOrDefault();
bool? nullableBoolean = "".ConvertOrDefault();
int integer = obj.ConvertOrDefault();
int negativeInteger = "-12123".ConvertOrDefault();
int? nullableInteger = value.ConvertOrDefault();
MyEnum enumValue = "SecondValue".ConvertOrDefault();

MyObjectBase myObject = new MyObjectClassA();
MyObjectClassA myObjectClassA = myObject.ConvertOrDefault();

ต่อไปนี้ควรทำงานกับประเภทของโครงสร้างใด ๆ มันจะตามออกรหัสโดยแมตต์ Manela จากฟอรั่ เนื่องจาก Murph ชี้ให้เห็นว่าการจัดการข้อยกเว้นอาจมีราคาแพงเมื่อเทียบกับการใช้เมธอด TryParse

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

นี่เป็นกรณีทดสอบพื้นฐานที่ฉันใช้

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

ฉันขอแนะนำวิธีการต่อไปนี้สำหรับการแยกสตริงเป็นค่า int ที่มีความสามารถในการกำหนดค่าเริ่มต้นในกรณีที่ไม่สามารถแยกวิเคราะห์:

public static int ParseInt(this string value, int defaultIntValue = 0)
        {
            return int.TryParse(value, out var parsedInt) ? parsedInt : defaultIntValue;
        }

public static int? ParseNullableInt(this string value)
        {
            if (string.IsNullOrEmpty(value))
                return null;

            return value.ParseInt();
        }

วิธีการแก้ปัญหานี้เป็นแบบทั่วไปโดยไม่มีการสะท้อนค่าใช้จ่าย

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

ฉันสนใจที่จะรู้มากขึ้นว่ามีวิธีการสร้างเฟรมเวิร์กที่จะแจงเป็น int ที่ไม่มีค่าหรือไม่

ไม่มี

ฉันรู้สึกว่าฉันควรแบ่งปันของฉันซึ่งเป็นเรื่องธรรมดามากกว่า

การใช้งาน:

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

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

สารละลาย:

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

รุ่นแรกช้ากว่าเนื่องจากต้องลองใช้ แต่ดูสะอาดกว่า ถ้ามันจะไม่ถูกเรียกหลายครั้งด้วยสตริงที่ไม่ถูกต้องมันก็ไม่สำคัญ หากประสิทธิภาพเป็นปัญหาโปรดทราบว่าเมื่อใช้วิธีการ TryParse คุณจะต้องระบุพารามิเตอร์ประเภทของ ParseBy เนื่องจากคอมไพเลอร์ไม่สามารถอนุมานได้ ฉันยังต้องกำหนดผู้รับมอบสิทธิ์เป็นคีย์เวิร์ด out ไม่สามารถใช้ภายใน Func <> แต่อย่างน้อยเวลาคอมไพเลอร์นี้ไม่ต้องการอินสแตนซ์ที่ชัดเจน

ในที่สุดคุณสามารถใช้มันกับ structs อื่น ๆ เช่นทศนิยมทศนิยมวันที่ Guid และอื่น ๆ

ฉันพบและดัดแปลงรหัสสำหรับคลาส Generic NullableParser รหัสเต็มอยู่ในบล็อกของฉันNullable TryParse

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
namespace SomeNamespace
{
    /// <summary>
    /// A parser for nullable types. Will return null when parsing fails.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    ///
    public static class NullableParser<T> where T : struct
    {
        public delegate bool TryParseDelegate(string s, out T result);
        /// <summary>
        /// A generic Nullable Parser. Supports parsing of all types that implements the tryParse method;
        /// </summary>
        /// <param name="text">Text to be parsed</param>
        /// <param name="result">Value is true for parse succeeded</param>
        /// <returns>bool</returns>
        public static bool TryParse(string s, out Nullable<T> result)
        {
            bool success = false;
            try
            {
                if (string.IsNullOrEmpty(s))
                {
                    result = null;
                    success = true;
                }
                else
                {
                    IConvertible convertableString = s as IConvertible;
                    if (convertableString != null)
                    {
                        result = new Nullable<T>((T)convertableString.ToType(typeof(T),
                            CultureInfo.CurrentCulture));
                        success = true;
                    }
                    else
                    {
                        success = false;
                        result = null;
                    }
                }
            }
            catch
            {
                success = false;
                result = null;
            }
            return success;
        }
    }
}

    public static void Main(string[] args)
    {

        var myString = "abc";

        int? myInt = ParseOnlyInt(myString);
        // null

        myString = "1234";

        myInt = ParseOnlyInt(myString);
        // 1234
    }
    private static int? ParseOnlyInt(string s)
    {
        return int.TryParse(s, out var i) ? i : (int?)null;
    }

คุณไม่ควรใช้ข้อยกเว้นถ้าคุณไม่จำเป็นต้อง - ค่าใช้จ่ายที่น่ากลัว

ความหลากหลายของ TryParse ช่วยแก้ปัญหาได้ - หากคุณต้องการสร้างสรรค์ (เพื่อทำให้โค้ดของคุณดูสง่างามยิ่งขึ้น) คุณอาจทำบางอย่างด้วยวิธีการขยายใน 3.5 แต่โค้ดจะเหมือนกันมากหรือน้อย

การใช้ผู้ได้รับมอบหมายรหัสต่อไปนี้สามารถให้ความสามารถในการนำกลับมาใช้ใหม่หากคุณพบว่าตัวเองต้องการการแยกวิเคราะห์แบบ nullable สำหรับประเภทโครงสร้างมากกว่าหนึ่งประเภท ฉันได้แสดงทั้งรุ่น. Parse () และ. TryParse () ที่นี่แล้ว

นี่คือตัวอย่างการใช้งาน:

NullableParser.TryParseInt(ViewState["Id"] as string);

และนี่คือรหัสที่จะพาคุณไปที่นั่น ...

public class NullableParser
  {
    public delegate T ParseDelegate<T>(string input) where T : struct;
    public delegate bool TryParseDelegate<T>(string input, out T outtie) where T : struct;
    private static T? Parse<T>(string input, ParseDelegate<T> DelegateTheParse) where T : struct
    {
      if (string.IsNullOrEmpty(input)) return null;
      return DelegateTheParse(input);
    }
    private static T? TryParse<T>(string input, TryParseDelegate<T> DelegateTheTryParse) where T : struct
    {
      T x;
      if (DelegateTheTryParse(input, out x)) return x;
      return null;
    }
    public static int? ParseInt(string input)
    {
      return Parse<int>(input, new ParseDelegate<int>(int.Parse));
    }
    public static int? TryParseInt(string input)
    {
      return TryParse<int>(input, new TryParseDelegate<int>(int.TryParse));
    }
    public static bool? TryParseBool(string input)
    {
      return TryParse<bool>(input, new TryParseDelegate<bool>(bool.TryParse));
    }
    public static DateTime? TryParseDateTime(string input)
    {
      return TryParse<DateTime>(input, new TryParseDelegate<DateTime>(DateTime.TryParse));
    }
  }

ฉันรู้ว่านี่เป็นหัวข้อเก่า แต่คุณทำไม่ได้ง่ายๆ

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

?

ฉันมากับอันนี้ซึ่งมีคุณสมบัติตรงตามความต้องการของฉัน (ฉันต้องการให้วิธีการขยายของฉันเลียนแบบใกล้เคียงที่สุดเท่าที่จะเป็นไปได้การส่งคืน TryParse ของเฟรมเวิร์ก แต่ไม่ต้องลอง {} catch {} catch บล็อก} ประเภท nullable ภายในวิธีการกรอบ)

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

ฉันแนะนำรหัสร้อง คุณอาจทำงานได้ยกเว้นเมื่อเกิดข้อผิดพลาดในการแปลง

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

ใช้วิธีการส่วนขยายนี้ในรหัส (เติมคุณสมบัติ int? Age ของคลาสบุคคล):

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

หรือ

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