কীভাবে কোনও স্ট্রিংকে একটি শোধনযোগ্য ইন্টিতে পার্স করবেন

Question

আমি সি # তে একটি স্ট্রিংকে একটি nablable 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;
        }
    }
}   

এটি করার আরও ভাল উপায় আছে?

সম্পাদনা: ট্রাইপার্সের পরামর্শের জন্য ধন্যবাদ, আমি সে সম্পর্কে জানতাম, তবে এটি সম্পর্কে কার্যকর হয়েছে। আমি আরও জানার আগ্রহ নিয়ে রয়েছি যে কোনও বিল্ট-ইন ফ্রেমওয়ার্ক পদ্ধতি রয়েছে যা সরাসরি একটি nullable int এ পার্স করবে?

Comments

আপনি যদি স্ট্রিংটি ব্যবহার করতে পারেন তবে if লাইনটি আরও স্পষ্টতর পেতে আইসনুলআরএম্পটি (মান)।

— ü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

আরও একটি কম লাইন: ফিরে আসুন 32. ট্রাইপার্স (গুলি, আমি)? i: নাল;

— ক্রিস

"এ" শূন্য ফিরে আসবে, তবে এটি

— পূর্বসূরি

@ ক্রিস, সংকলকটি আপনার ইনলাইনটি পছন্দ না করলে বিবৃতিটি পছন্দ করে না (এই ধরণেরগুলি সামঞ্জস্যপূর্ণ নয়: 'ইনট': 'নাল')। আমাকে এটিতে সংশোধন করতে হয়েছিল: Int32.TryParse (গুলি, আমি) ফিরিয়ে দেব? (int?) i: নাল;

— মৃত্যু_উ

ইন্ট 32 ইন্টি-তে কেবল একটি উপনাম alias প্রান্তরেখা ব্যবহার করার ধরণগুলি রাখতে আমি int.TryParse ব্যবহার করব। যদি / যখন intটি আলাদা বিট দৈর্ঘ্যের পূর্ণসংখ্যার প্রতিনিধিত্ব করতে ব্যবহৃত হয় (যা ঘটেছে), int32 ইন্টের সাথে লাইন করবে না।

— রিচার্ড কললেট 26'12

রিটার্ন int.TryParse (গুলি, আমি)? (int?) i: নাল;

— নিক স্প্রেইজার

Answer 2

শর্তসাপেক্ষ অপারেটর এবং আপনি যে কাস্ট করতে পারেন তা ব্যবহার করে আপনি এক লাইনে এটি করতে পারেন null একটি নলযোগ্য টাইপ (দুটি লাইন, যদি আপনার পূর্ব-বিদ্যমান কোনটি না থাকে তবে আপনি আউটপুটটির জন্য পুনরায় ব্যবহার করতে পারেন) ব্যবহার করে আপনি এটি এক লাইনে করতে পারেনTryParse ):

প্রাক সি # 7:

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

সি # 7 এর আপডেটড সিনট্যাক্সের সাহায্যে যা আপনাকে মেথড কলের আউটপুট ভেরিয়েবল ঘোষণা করতে দেয়, এটি আরও সহজ হয়ে যায়।

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

Comments

এটি শর্তসাপেক্ষ অপারেটরের আপনার দৃষ্টিভঙ্গির উপর নির্ভর করে, আমি মনে করি। আমার মানসিক মডেলটি হ'ল এটি যদি অন্য সমতুল্যর জন্য যথেষ্ট পরিমাণে সিনট্যাকটিক চিনিযুক্ত হয় তবে এই ক্ষেত্রে আমার সংস্করণ এবং ম্যাটস একইরকম এবং তার স্পষ্টতই, আমার আরও সেমিওপ্যাক্ট।

— ম্যাককেঞ্জিজি

এখানে কোনও অর্ডার অফ-মূল্যায়ন পার্শ্ব-প্রতিক্রিয়া নেই। সমস্ত পদক্ষেপ স্পষ্টভাবে আদেশ এবং সঠিক হয়।

— জন হান্না

ফিরেint.TryParse(val, out i) ? i : default(int?);

— বার্ট ক্যালিক্স্টো

@ বার্টের "উত্তর" এখানে সেরা!

— আন্দ্রে ফিগুয়েরেদো

এবং এখন সি # 6 এ এটি এক লাইন হতে পারে! Int32.TryParse (স্ট্রিংওয়াল, আউট টেম্পভাল)? tempVal: (int?) নাল;

— মেরিকোয়া

Answer 3

[ @ এসবিএম এর পরামর্শ অনুযায়ী আধুনিক সি # ব্যবহার করার জন্য আপডেট হয়েছে ]

আমার এই সমস্যাটি ছিল এবং আমি এটি দিয়ে শেষ হয়ে গেলাম (সর্বোপরি, একটি ifএবং 2 returnগুলি খুব দীর্ঘ-বাতাসযুক্ত!):

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

আরও গুরুতর নোটে, মিশ্রিত না করার চেষ্টা করুন int, যা একটি সি # কীওয়ার্ড Int32, যা একটি। নেট ফ্রেমওয়ার্ক বিসিএল টাইপ - এটি কার্যকর হলেও এটি কোডটিকে অগোছালো দেখাচ্ছে।

Comments

নিশ্চিত নয় যে এটি আসলে এমন কোনও কিছুর মধ্যে অনুবাদ করবে যা একবার সংকলিত আরও ভাল সম্পাদন করে

— বুজজ

সি # 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;

— ডাকবয়

সি # 6 এর সাহায্যে এটিকে 1 লাইনে হ্রাস করা যেতে পারে: রিটার্ন ইনট্রি ট্রাই পার্স (মান, ফলাফলের ফলাফল)? ফলাফল: (int?) নাল;

— মিনগ্রিন

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

এনবি: কনভার্টারে একটি ইস্ভালিড পদ্ধতি রয়েছে যা আপনি ব্যতিক্রম ক্যাপচার করার পরিবর্তে ব্যবহার করতে পারেন (নিক্ষিপ্ত ব্যতিক্রমগুলি প্রত্যাশিত হলে অপ্রয়োজনীয় ওভারহেডের ফল দেয় )। দুর্ভাগ্যক্রমে এটি কেবল নেট নেট 4 থেকে কাজ করে তবে এখনও একটি সমস্যা রয়েছে যেখানে সঠিক তারিখের সময় ফর্ম্যাটগুলি যাচাই করার সময় এটি আপনার লোকেলটি পরীক্ষা করে না, বাগ 93559 দেখুন ।

Comments

আমি এটি পূর্ণসংখ্যার জন্য পরীক্ষা করেছি এবং এটি int.TryParse ((স্ট্রিং) মান, ভেরু ফলাফল) এর চেয়ে অনেক ধীর? ফলাফল: ডিফল্ট (int?);

— ওয়াউটার

Answer 5

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

সূত্র:

• var
• Int32.TryParse
• শর্তসাপেক্ষ অপারেটর
• ডিফল্ট অপারেটর ( এই স্ট্যাকওভারফ্লো পোস্টে ব্যাখ্যা করা হয়েছে )।
• মূল্যহীন মান প্রকার

Comments

কিভাবে এই কাজ করতে পারে? ট্রাইপার্সে কাজ করবে না বা নমনীয় ভেরিয়েবলগুলি এফ হবে এবং এফ উদাহরণস্বরূপ এটিকে nlalable হতে হবে।

— জন লর্ড

আপনারা @ জনলর্ড

— জা এইচ এইচ

ট্রাইপার্স আশা করে একটি নন-অ-পরিবর্তনীয় ভেরিয়েবলের মধ্যে স্থাপন করা যায়, সুতরাং আপনার ডিফল্ট (int?) বলের ভারটি নলাবদ্ধ হয়ে উঠবে না?

— জন লর্ড

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

আমি এটিকে পুনঃসংযোগ হিসাবে আরও ভাল পছন্দ করি যেখানে নালকে পার্স করা যায়, ট্রাই পার্সে সংস্করণ যেমন তৌনুল্লিইন্ট 32 (এক্সএক্সএক্স) তে কোনও ত্রুটি ফেলবে না। এটি অযাচিত নীরব ত্রুটিগুলির পরিচয় দিতে পারে।

Comments

ঠিক এটিই মূল বিষয় - যদি স্ট্রিংটি পার্স করা যায় না তবে intএটি ফিরে আসা উচিত null, ব্যতিক্রম ছুঁড়ে না ফেলে।

— সুইভ

মানটি যদি সংখ্যাসূচক হয়, তবে পার্স একটি ব্যতিক্রম ছুঁড়ে দেয়, যা নাল ফেরানোর মতো নয়।

— একটি phu

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

এটি অবশ্যই একটি জেনেরিক সমাধান যা কেবল জেনারিক যুক্তির একটি স্থির পদ্ধতি "পার্স (স্ট্রিং)" থাকা দরকার require এটি সংখ্যা, বুলিয়ান, ডেটটাইম ইত্যাদির জন্য কাজ করে

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

এটি সত্যিই খুব দরকারী। আমার মতে এটি স্ট্যান্ডার্ড সি # লাইব্রেরিতে থাকতে হবে কারণ রূপান্তরগুলি প্রতিটি প্রোগ্রামে খুব সাধারণ হয়;)

— বিগচিফ

এটি খুব সুন্দর এবং দরকারী, তবে আমি যুক্ত করতে পারি যে আইটেমগুলির একটি বড় সংগ্রহের প্রতিটি উপাদানকে রূপান্তর করার প্রয়োজন হলে এটি অত্যন্ত ধীর হয়। আমি 20000 আইটেম দিয়ে পরীক্ষা করেছি: এই পদ্ধতির সাহায্যে প্রতিটি আইটেমের 8 টি বৈশিষ্ট্য রূপান্তর করতে পুরো সংগ্রহ শেষ করতে 1 ঘন্টা পর্যন্ত সময় লাগে। একই নমুনা ডেটা সহ তবে ম্যাট হ্যামিল্টনের পদ্ধতির ব্যবহারটি শেষ হতে কয়েক সেকেন্ড সময় নেয়।

— জেড

Answer 10

নিম্নলিখিত কোনও কাঠামোর ধরণের জন্য কাজ করা উচিত। এটি এমএসডিএন ফোরামগুলি থেকে ম্যাট ম্যানেলার কোড অফ ভিত্তিক । মারফ উল্লেখ করেছেন যেহেতু টাইপগুলি ডেডিকেটেড ট্রাইপার্স পদ্ধতি ব্যবহারের তুলনায় ব্যতিক্রম হ্যান্ডলিং ব্যয়বহুল হতে পারে।

        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

ইতিমধ্যে অনেকগুলি এবং এমনকি উচ্চ upvated উত্তর আছে আপনি কি সত্যিই ভাবেন যে আপনার উত্তরটি প্রয়োজনীয় এবং এই পোস্টে নতুন গুণ যুক্ত করেছে?

— এল। গুথার্ট

@ এল। গুথার্ড হ্যাঁ, আমিও তাই মনে করি। যেহেতু আমি মনে করি যে আমার উত্তরটি সমস্যার সমাধানের আরও সর্বজনীন উপায় নিয়ে আসে প্রশ্নে বর্ণিত। ধন্যবাদ.

— আলেকসান্ডার নীজভেষ্টেনি

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

— নিবল্লিপিগ

Answer 13

আমি আরও জানার আগ্রহ নিয়ে রয়েছি যে কোনও বিল্ট-ইন ফ্রেমওয়ার্ক পদ্ধতি রয়েছে যা সরাসরি একটি nullable int এ পার্স করবে?

নেই।

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

প্রথম সংস্করণটি ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে এটির চেষ্টা করার প্রয়োজন হলেও এটি আরও পরিষ্কার দেখাচ্ছে। যদি এটি অবৈধ স্ট্রিং সহ অনেক বার বলা হয় না, এটি তেমন গুরুত্বপূর্ণ নয়। পারফরম্যান্স যদি কোনও সমস্যা হয় তবে দয়া করে নোট করুন যে ট্রাইপার্স পদ্ধতি ব্যবহার করার সময় আপনাকে পার্সেবি টাইপের পরামিতি নির্দিষ্ট করতে হবে কারণ এটি সংকলক দ্বারা অনুমান করা যায় না। আমাকে একটি প্রতিনিধিও সংজ্ঞায়িত করতে হয়েছিল কারণ ফানক <> এর মধ্যে আউট কীওয়ার্ডটি ব্যবহার করা যায় না, তবে কমপক্ষে এই সময়ের সংকলকটির জন্য সুস্পষ্ট উদাহরণের প্রয়োজন হয় না।

শেষ অবধি, আপনি এটি অন্যান্য স্ট্রাক্টের সাথেও ব্যবহার করতে পারেন, যেমন দশমিক, ডেটটাইম, গাইড ইত্যাদি

Answer 15

আমি জেনেরিক নুলাবল পার্সার ক্লাসের জন্য কিছু কোড খুঁজে পেয়েছি এবং মানিয়ে নিয়েছি। সম্পূর্ণ কোডটি আমার ব্লগে নুলাবল ট্রাইপার্সে রয়েছে

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 পাওয়া যায়নি. কেবল একটি লিঙ্ক দেওয়া এটি একটি ভাল অনুশীলন নয়

— ময়লা প্রবাহ

সম্পূর্ণ কোড সহ @ ডার্টি-ফ্লো আপডেট সম্পর্কে দুঃখিত। আগের চেয়ে ভাল দেরী :)

— জন ডাউফিন

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

যদি মাইস্ট্রিং অ-সংখ্যাসূচক হয়, তবে পার্স একটি ব্যতিক্রম ছুঁড়ে দেয়, যা নাল ফেরানো সমান নয়।

— একটি phu

Answer 17

আপনার কখনই করা উচিত নয় আপনার ব্যতিক্রম ব্যবহার করা নয় - ওভারহেড ভয়ঙ্কর।

ট্রাইপার্সে বিভিন্নতা সমস্যার সমাধান করে - আপনি যদি সৃজনশীল হতে চান (আপনার কোডটি আরও মার্জিত দেখানোর জন্য) আপনি সম্ভবত 3.5 এ কোনও এক্সটেনশন পদ্ধতিতে কিছু করতে পারেন তবে কোডটি কমবেশি একই রকম হবে।

Answer 18

প্রতিনিধিদের ব্যবহার করে, নীচের কোডটি পুনরায় ব্যবহারযোগ্যতা সরবরাহ করতে সক্ষম হয় যদি আপনি নিজেকে একাধিক কাঠামোর ধরণের জন্য নালযোগ্য পার্সিংয়ের প্রয়োজন মনে করেন। আমি এখানে উভয়। পার্স () এবং .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

আপনি পারেন তবে স্ট্রিংওয়ালটি ভুল ফর্ম্যাটে থাকলে আপনি একটি ব্যতিক্রম পাবেন। : Int.Parse ডকুমেন্টেশন দেখুন msdn.microsoft.com/en-us/library/b3h1hf19.aspx

— অ্যালেক্স

Answer 20

আমি এটির সাথে উপস্থিত হয়েছি, যা আমার প্রয়োজনীয়তাগুলি সন্তুষ্ট করেছে (আমি চাইছিলাম ফ্রেমওয়ার্কের ট্রাইপার্সির রিটার্নটি যতটা সম্ভব সম্ভব করার জন্য আমার এক্সটেনশন পদ্ধতিটি অনুকরণ করতে চেয়েছি, কিন্তু চেষ্টা করে and {ক্যাচ {} ব্লক ছাড়াই এবং সংকলকটি অনুমানের বিষয়ে অভিযোগ না করেই ফ্রেমওয়ার্ক পদ্ধতির মধ্যে nallable প্রকার)

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