एक अशक्त इंट में एक स्ट्रिंग पार्स करने के लिए कैसे

Question

मैं C # में एक अशक्त int में एक स्ट्रिंग पार्स करना चाहता हूँ। अर्थात। मैं वापस या तो स्ट्रिंग या अशक्त के अंतर मूल्य प्राप्त करना चाहते हैं अगर यह पार्स नहीं किया जा सकता है।

मैं उम्मीद कर रहा था कि यह काम करेगा

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 सुझावों के लिए धन्यवाद, मुझे इसके बारे में पता था, लेकिन इसने उसी के बारे में काम किया। मुझे यह जानने में अधिक दिलचस्पी है कि क्या एक अंतर्निहित ढांचा विधि है जो सीधे एक अशक्त इंट में पार्स करेगी?

Comments

यदि आप लाइन को और अधिक स्पष्ट करने के लिए आप string.IsNullOrEmpty (मान) का उपयोग कर सकते हैं।

— Özgür कपलान

जेनरिक रूपांतरण का उपयोग करने पर विचार करें stackoverflow.com/questions/773078/...

— माइकल Freidgeim

Answer 1

int.TryParse शायद एक बालक आसान है:

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

@ संपादित करेंint.TryParse "फ्रेमवर्क में बनाया गया है"। यह और int.Parseकर रहे हैं जिस तरह से ints को तार पार्स करने के लिए।

Comments

एक कम पंक्ति: Int32.TryParse (s, out i) लौटाएं? मैं: अशक्त;

— क्रिस शट्स

"ए" अशक्त लौटेगा, लेकिन यह इंट नहीं है और इसे अपवाद को फेंक देना चाहिए

— आर्सेन मकर्चियन

@ क्रिस, संकलक आपके इनलाइन को पसंद नहीं करता है यदि कथन (ये प्रकार संगत नहीं हैं: 'int': 'null')। मुझे इसमें संशोधन करना पड़ा: Int32.TryParse (s, out i) लौटाएं? (int?) i: अशक्त;

— मृत्यु_

Int32 इंट करने के लिए सिर्फ एक उपनाम है। मैं संरेखण में उपयोग किए जा रहे प्रकारों को रखने के लिए int.TryParse का उपयोग करूंगा। यदि / जब int का उपयोग किसी भिन्न बिट लंबाई पूर्णांक (जो हुआ है) का प्रतिनिधित्व करने के लिए किया जाता है, तो Int32 int के साथ पंक्तिबद्ध नहीं होगा।

— रिचर्ड कोलेट

int.TryParse (s, i से बाहर) लौटें? (int?) i: अशक्त;

— निक स्प्रीजित

Answer 2

आप सशर्त ऑपरेटर और इस तथ्य का उपयोग करके एक पंक्ति में यह कर सकते हैं कि आप nullएक अशक्त प्रकार (दो पंक्तियों के लिए कास्ट कर सकते हैं, यदि आपके पास पहले से मौजूद इंट नहीं है तो आप आउटपुट के लिए पुन: उपयोग कर सकते हैं 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;

Comments

मुझे लगता है कि सशर्त ऑपरेटर के आपके विचार पर निर्भर करता है। मेरा मानसिक मॉडल यह है कि यह इफ-समतुल्य के लिए बहुत अधिक संश्लिष्ट चीनी है, इस मामले में मेरे संस्करण और मैट समान के करीब हैं, और अधिक स्पष्ट होने के साथ, मेरा अधिक cmopact है।

— मैकेंजी

यहां मूल्यांकन-क्रम का कोई साइड-इफेक्ट नहीं है। सभी चरणों को स्पष्ट रूप से आदेश दिया गया है और सही है।

— जॉन हैना

वापसीint.TryParse(val, out i) ? i : default(int?);

— बार्ट कैलिक्सो

@ बार्ट का "उत्तर" यहाँ सबसे अच्छा है!

— आंद्रे फिग्यूएरेडो

और अब C # 6 में, यह एक पंक्ति हो सकती है! Int32.TryParse (stringVal, var varpVal)? tempVal: (int?) null;

— मर्कोवा

Answer 3

[ @ Sblom के सुझाव के अनुसार आधुनिक C # का उपयोग करने के लिए अद्यतन ]

मुझे यह समस्या थी और मैंने इसे समाप्त कर दिया (आखिरकार, ए ifऔर 2 returnएस सू लंबी-घुमावदार है!)।

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

अधिक गंभीर नोट पर, मिश्रण न करने का प्रयास करें int, जो कि एक C # कीवर्ड है Int32, जो कि .NET फ्रेमवर्क BCL प्रकार है - हालांकि यह काम करता है, यह सिर्फ कोड को गड़बड़ करता है।

Comments

बिल्कुल यकीन नहीं है कि यह वास्तव में किसी भी चीज में अनुवाद करेगा जो एक बार संकलित करने के लिए बेहतर प्रदर्शन करता है

— Buzz

सी # में इससे भी अधिक संक्षिप्त 7: हटाना int i;लाइन और बस के साथ जानेreturn int.TryParse (val, out var i) ? (int?) i : null;

— sblom

तो पूर्णता के लिए ;-)int? ParseNInt (string val) => int.TryParse (val, out var i) ? (int?) i : null;

— डकबॉय

C # 6 के साथ इसे 1 पंक्ति में घटाया जा सकता है: वापसी int.TryParse (मान, बाहर परिणाम)? परिणाम: (int?) null;

— मीनग्रीन

Answer 4

ग्लेन स्लावेन : मुझे यह जानने में अधिक दिलचस्पी है कि क्या कोई अंतर्निहित ढांचा विधि है जो सीधे एक अशक्त उदाहरण में पार्स होगी?

यह दृष्टिकोण है जो सीधे एक अशक्त इंट (और न केवल इंट) के लिए पार्स करेगा यदि मान शून्य या खाली स्ट्रिंग की तरह मान्य है, लेकिन अमान्य मानों के लिए अपवाद नहीं फेंकता है, इसलिए आपको अपवाद को पकड़ने और डिफ़ॉल्ट मान वापस करने की आवश्यकता होगी उन स्थितियों के लिए:

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

NB: कनवर्टर पर एक अमान्य विधि है जिसे आप अपवाद को कैप्चर करने के बजाय उपयोग कर सकते हैं ( यदि अपवाद अपेक्षित हो तो अनावश्यक ओवरहेड में परिणाम होता है)। दुर्भाग्य से यह केवल .NET 4 के बाद से काम करता है, लेकिन अभी भी एक ऐसा मुद्दा है जहां यह सही DateTime स्वरूपों को मान्य करते समय आपके स्थान की जांच नहीं करता है, बग 93559 देखें ।

Comments

मैंने पूर्णांक के लिए इसका परीक्षण किया और यह int.TryParse ((string) value, out var result) की तुलना में बहुत धीमा है। परिणाम: डिफ़ॉल्ट (int;);

— राउटर

Answer 5

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

सूत्रों का कहना है:

• वार
• Int32.TryParse
• सशर्त संचालक
• डिफ़ॉल्ट ऑपरेटर ( इस stackoverflow पोस्ट में समझाया गया है )।
• अशक्त मान प्रकार

Comments

यह कैसे काम कर सकता है? आपके उदाहरण में Tryparse काम नहीं करेगा या अशक्त चर और f को अशक्त होना पड़ेगा।

— जॉन लॉर्ड

कृपया आप यह स्पष्ट कर सकते हैं कि आपका क्या अर्थ है @ जोनलॉर्ड

— जा एच एच

ट्रायपर्स की उम्मीद है कि इसे एक अशोभनीय चर में डाल दिया जाएगा, इसलिए क्या आपका डिफ़ॉल्ट (इंट?) बल संस्करण अशक्त नहीं होगा?

— जॉन लॉर्ड

@JohnLord शायद इस की मदद से आप समझते हैं कि क्या हो रहा है stackoverflow.com/questions/3632918/...

— Jaa एच

Answer 6

पुराना विषय है, लेकिन इसके बारे में कैसे:

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

मैं इस बेहतर के रूप में requriement जहां null पार्स करने के लिए की तरह, TryParse संस्करण उदाहरण के लिए ToNullableInt32 (XXX) पर एक त्रुटि नहीं फेंकेंगे। यह अवांछित मूक त्रुटियों का परिचय दे सकता है।

Comments

यह वास्तव में बिंदु है - अगर स्ट्रिंग को पार्स नहीं किया जा सकता है int, तो इसे वापस आना चाहिए null, अपवाद नहीं फेंकना चाहिए ।

— svick

यदि मान गैर-संख्यात्मक है, तो int.Parse एक अपवाद फेंकता है, जो अशक्त लौटने के समान नहीं है।

— एक फू

Answer 7

इसे इस्तेमाल करे:

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

Answer 8

मुझे लगता है कि मेरा समाधान बहुत साफ और अच्छा समाधान है:

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

यह निश्चित रूप से एक सामान्य समाधान है जिसके लिए केवल यह आवश्यक है कि जेनेरिक तर्क में एक स्थिर विधि "पार्स (स्ट्रिंग)" हो। यह संख्याओं, बूलियन, डेटटाइम आदि के लिए काम करता है।

Answer 9

आप अन्य सभी उत्तरों को भूल सकते हैं - एक महान सामान्य समाधान है: 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();

Comments

यह वास्तव में बहुत उपयोगी है। मेरी राय में यह मानक c # पुस्तकालयों में होना चाहिए क्योंकि हर कार्यक्रम में रूपांतरण बहुत आम हैं;)

— BigChief

यह बहुत अच्छा और उपयोगी है, लेकिन मैं यह जोड़ सकता हूं कि जब आइटमों के एक बड़े संग्रह में प्रत्येक तत्व के लिए रूपांतरण करने की आवश्यकता हो तो यह बहुत धीमी है। मैंने 20000 वस्तुओं के साथ परीक्षण किया है: इस दृष्टिकोण का उपयोग करके, पूरे संग्रह को समाप्त करने के लिए प्रत्येक आइटम के 8 गुणों को परिवर्तित करने में 1 घंटे तक का समय लगता है। एक ही सैंपल डेटा के साथ लेकिन मैट हैमिल्टन के दृष्टिकोण का उपयोग करने में इसे समाप्त होने में कुछ सेकंड लगते हैं।

— zed

Answer 10

किसी भी संरचना प्रकार के लिए निम्नलिखित कार्य करना चाहिए। यह MSDN मंचों से मैट मनीला द्वारा कोड बंद है । जैसा कि मर्फ़ बताते हैं कि टाइपिंग डेडपेयर पद्धति का उपयोग करने की तुलना में अपवाद हैंडलिंग महंगी हो सकती है।

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

Answer 11

मैं सुझाव देता हूं कि यदि मामले में पार्सिंग संभव नहीं है तो डिफ़ॉल्ट मान को परिभाषित करने की क्षमता के साथ स्ट्रिंग पार्सिंग के लिए विस्तार मूल्य निम्नलिखित है।

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

Comments

पहले से ही इतने सारे और यहां तक ​​कि उच्च उत्कीर्ण उत्तर। क्या आपको वास्तव में लगता है कि आपके उत्तर की आवश्यकता है और इस पोस्ट में नई गुणवत्ता जोड़ता है?

— एल। गुटहार्ट

@ L.Guthardt हां, मुझे ऐसा लगता है। जैसा कि मुझे लगता है कि मेरा उत्तर प्रश्न में वर्णित मुद्दे को हल करने के लिए और अधिक सार्वभौमिक तरीका लाता है। धन्यवाद।

— अलेक्सांद्र नेइज़्वेस्टनी

Answer 12

यह समाधान प्रतिबिंब उपरि के बिना सामान्य है।

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

Comments

मुझे लगता है कि आप की जगह ले सकता IsNullOrEmptyसाथIsNullOrWhitespace

— NibblyPig

Answer 13

मुझे यह जानने में अधिक दिलचस्पी है कि क्या एक अंतर्निहित ढांचा विधि है जो सीधे एक अशक्त इंट में पार्स करेगी?

वहाँ नहीं है

Comments

क्या आप इसे प्रत्यक्ष दृष्टिकोण मानेंगे? stackoverflow.com/a/6474962/222748

— माइकल

Answer 14

मुझे लगा कि मुझे अपना हिस्सा देना चाहिए जो थोड़ा अधिक सामान्य है।

उपयोग:

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 के प्रकार के पैरामीटर को निर्दिष्ट करने की आवश्यकता है क्योंकि यह कंपाइलर द्वारा अनुमान नहीं लगाया जा सकता है। मुझे एक प्रतिनिधि को भी परिभाषित करना था क्योंकि फंक <> के भीतर बाहर के कीवर्ड का उपयोग नहीं किया जा सकता है, लेकिन कम से कम इस समय संकलक को एक स्पष्ट उदाहरण की आवश्यकता नहीं है।

अंत में, आप इसे अन्य संरचनाओं के साथ भी उपयोग कर सकते हैं, अर्थात दशमलव, दिनांक समय, दिशा-निर्देश आदि।

Answer 15

मैंने जेनेरिक 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;
        }
    }
}

Comments

404 नहीं मिला। यह सिर्फ एक लिंक देने के लिए एक अच्छा अभ्यास नहीं है

— डर्टी-फ्लो

पूर्ण कोड के साथ उस @ डर्टी-फ्लो अपडेट के बारे में क्षमा करें। देर से कभी नहीं :)

— जॉन Dauphine

Answer 16

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

Comments

यदि myString गैर-संख्यात्मक है, int.Parse एक अपवाद को फेंकता है, जो कि अशक्त लौटने के समान नहीं है।

— एक फू

Answer 17

यदि आपको ओवरहेड भयानक नहीं है तो आपको कभी भी अपवाद का उपयोग नहीं करना चाहिए ।

TryParse पर विविधताएं समस्या को हल करती हैं - यदि आप रचनात्मक प्राप्त करना चाहते हैं (अपने कोड को और अधिक सुरुचिपूर्ण बनाने के लिए) तो आप संभवतः 3.5 में एक विस्तार विधि के साथ कुछ कर सकते हैं, लेकिन कोड कमोबेश यही रहेगा।

Answer 18

प्रतिनिधियों का उपयोग करते हुए, निम्न कोड पुन: प्रयोज्य प्रदान करने में सक्षम है यदि आप पाते हैं कि आपको अपने संरचना प्रकार से अधिक के लिए अशक्त पार्सिंग की आवश्यकता है। मैंने दोनों .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));
    }
  }

Answer 19

मुझे लगता है कि यह एक पुराना विषय है, लेकिन क्या आप इसे सरल नहीं कर सकते:

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

?

Comments

आप कर सकते हैं, लेकिन तब आपको एक अपवाद मिलेगा अगर stringVal गलत प्रारूप में है। Int.Parse प्रलेखन देखें: msdn.microsoft.com/en-us/library/b3h1hf19.aspx

— एलेक्स

Answer 20

मैं इस एक के साथ आया हूं, जिसने मेरी आवश्यकताओं को पूरा किया है (मैं चाहता था कि मेरा एक्सटेंशन तरीका जितना संभव हो उतना संभव है, फ्रेमवर्क के ट्रिपपार्स की वापसी के रूप में अनुकरण करें, लेकिन बिना कोशिश {} कैच {} ब्लॉक करें और संकलक के बिना शिकायत के बारे में शिकायत करना ढांचे के भीतर अशक्त प्रकार)

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

Answer 21

मैं सुझाव देता हूं कोड बोलो। जब त्रुटि हुई तो आप अपवाद के साथ काम कर सकते हैं।

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

कोड में इस विस्तार विधि का उपयोग करें (एक व्यक्ति वर्ग की आयु भरें। संपत्ति):

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