दिलचस्प पोस्ट
बाद के बाद और PostgreSQL में एक subquery के बीच अंतर क्या है? गतिविधि शुरू नहीं हुई है, इसके वर्तमान कार्य को सामने लाया गया है आईफ़ोन वेबकिट सीएसएस एनिमेशन का कारण झिलमिलाहट लॉगआउट के बाद पहले से दौरा किए गए सुरक्षित पृष्ठ को देखने से उपयोगकर्ता को रोकें "Document.getElementByClass फ़ंक्शन नहीं है" मैं एक सर्वलेट के लिए कैसे पारित यूनिकोड पैरामीटर सही ढंग से व्याख्या करूं डि और आईओसी के साथ फैक्टरी विधि एंड्रॉइड मैप एपीआई v2 के साथ कस्टम-आकार के बिटमैप मार्कर कैसे बनाएं एंड्रॉइड ऐप में पृष्ठभूमि का रंग कैसे बदल सकता है मैं पर्ल वेब क्रॉलर में जावास्क्रिप्ट को कैसे नियंत्रित कर सकता हूं? मुझे क्यों "इंडेंटेशन त्रुटि: एक इंडेंट ब्लॉक की उम्मीद" हो रही है? मेवेन – मैं एक मच्छर वर्ग के प्रवेश को एक जार में कैसे जोड़ सकता हूं? मैं मैक पर जीएनयू के रीडब्लिंग-एफ का व्यवहार कैसे प्राप्त करूं? चींटी संपत्ति में अक्षर बदलने खंड और टुकड़ा गतिविधि के बीच का अंतर

कैसे एक स्ट्रिंग को एक nullable int में पार्स करने के लिए

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

वेब के समाधान से एकत्रित समाधान "कैसे एक स्ट्रिंग को एक nullable int में पार्स करने के लिए"

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

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

ग्लेन int.TryParse ट्री int.TryParse संपादित करें "ढांचे में बनाया गया" यह और int.Parse ints करने के लिए स्ट्रिंग को पार्स करने का तरीका है।

आप इसे एक पंक्ति में, सशर्त ऑपरेटर और तथ्य से कर सकते हैं कि आप एक रिक्त प्रकार (दो पंक्तियों, यदि आपके पास पहले से मौजूद TryParse नहीं है, तो आप TryParse के आउटपुट के लिए पुन: उपयोग कर सकते हैं) को TryParse कर सकते हैं:

पूर्व सी # 7:

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

सी # 7 के अपडेट किए गए सिंटैक्स के साथ आप विधि कॉल में एक आउटपुट वैरिएबल घोषित करने की अनुमति देते हैं, यह आसान भी हो जाता है

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

क्षमा करें, विरोध नहीं कर सके – यह समस्या थी और Google ने मुझे यहां लाया था, लेकिन मैं इसके साथ समाप्त हुआ (आखिरकार, अगर और 2 रिटर्न एसओ लम्बी-वाइल्ड!):

 int? ParseNInt (string val) { int i; return int.TryParse (val, out i) ? (int?) i : null; } 

अधिक गंभीर नोट पर, Int को मिश्रण न करने की कोशिश करें, जो सी # कीवर्ड है, जो इंट32 के साथ है, जो कि एक .NET Framework BCL प्रकार है – हालांकि यह काम करता है, यह सिर्फ कोड को गड़बड़ दिखता है।

ग्लेन स्लावेन : मुझे यह जानने में अधिक दिलचस्पी है कि क्या एक अंतर्निर्मित रूपरेखा पद्धति है, जो सीधे एक नापाक्य अंतर में पार्स करेगी?

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

 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 के बाद ही काम करता है। लेकिन अभी भी एक मुद्दा है जहां यह सही दिनांकित प्रारूपों को मान्य करते समय अपने लोकेल की जांच नहीं करता, बग 9 3559 देखें

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

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

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

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

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

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

निम्नलिखित किसी भी प्रकार के स्ट्रक्चर के लिए काम करना चाहिए। यह एमएसडीएन मंचों से मैट मेनला द्वारा कोड आधारित है। जैसा कि मर्फ़ बताता है कि अपवाद हैंडलिंग प्रकार समर्पित 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); 

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

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

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

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

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

मुझे यह जानने में अधिक दिलचस्पी है कि क्या एक अंतर्निर्मित रूपरेखा पद्धति है जो सीधे एक पूर्णांक में अंतर पार्स करेगी?

वहाँ नहीं है

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

उपयोग:

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

अंत में, आप इसे दूसरे स्ट्रैक्ट्स के साथ भी इस्तेमाल कर सकते हैं, अर्थात् दशमलव, डेटटाइम, गइड आदि।

मैंने एक जेनेरिक नालेबल पार्सर वर्ग के लिए कुछ कोड पाया और उसे अनुकूलित किया। पूर्ण कोड मेरे ब्लॉग पर है 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; } } } 

मैं इस एक के साथ आया हूँ, जिसने मेरी आवश्यकताओं को संतुष्ट कर दिया है (मैं चाहता हूं कि मेरे विस्तार विधि को फ्रेमवर्क के TryParse की वापसी के मुताबिक जितना करीब हो सके, लेकिन बिना प्रयास किए {} कैच करें {} और कंपाइलर के बिना शिकायत के बिना एक फ्रेमवर्क विधि के भीतर नल योग्य प्रकार)

 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 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 में एक एक्सटेंशन विधि के साथ कुछ कर सकते हैं लेकिन कोड अधिक या कम होगा।

प्रतिनिधियों का उपयोग करते हुए, निम्न कोड पुन: प्रयोज्यता प्रदान करने में सक्षम है यदि आप पाते हैं कि आपको एक से अधिक संरचना प्रकार के लिए नल योग्य पार्सिंग की आवश्यकता है। मैंने दोनों। पर्स () और। ट्री पर्स () संस्करणों को दिखाया है।

यह एक उदाहरण उपयोग है:

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

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

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

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

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

?