কোনটি অগ্রাধিকারযুক্ত: নুলযোগ্য <টি> asহাসভ্যালু বা নলযোগ্য <টি>! = নাল?

Question

আমি সর্বদা ব্যবহার করি Nullable<>.HasValueকারণ আমি শব্দার্থবিজ্ঞান পছন্দ করি। তবে, সম্প্রতি আমি অন্য কারও বিদ্যমান কোডবেসে কাজ করছি যেখানে তারা Nullable<> != nullপরিবর্তে একচেটিয়াভাবে ব্যবহার করেছেন used

একে অপরের উপরে ব্যবহার করার কোনও কারণ আছে, বা এটি নিখুঁতভাবে পছন্দ?

1. int? a;
   if (a.HasValue)
       // ...
   

বনাম

2. int? b;
   if (b != null)
       // ...
   

Comments

আমি একটি অনুরূপ প্রশ্ন জিজ্ঞাসা ... কিছু ভাল উত্তর পেয়েছিলাম: stackoverflow.com/questions/633286/...

— nailitdown

ব্যক্তিগতভাবে , আমি HasValueযেহেতু মনে করি শব্দগুলির চিহ্নগুলির চেয়ে বেশি পঠনযোগ্য বলে মনে করি। যদিও এটি আপনার উপর নির্ভর করে এবং আপনার বিদ্যমান শৈলীতে কী ফিট করে।

— জ্যাক পেট্রোলস

.HasValueএটি আরও অর্থবোধ করে যেহেতু টাইপটি প্রকারের T?চেয়ে প্রকারের পরিবর্তে প্রকারের মতো হয় যা স্ট্রিংয়ের মতো আক্রান্ত হতে পারে।

— ব্যবহারকারী 3791372

Answer 1

সংকলক একটি কল সাথে নাল তুলনাগুলি প্রতিস্থাপন করে HasValue, তাই কোনও আসল পার্থক্য নেই। আপনার এবং আপনার সহকর্মীদের কাছে যেটি আরও বেশি পাঠযোগ্য / আরও বেশি বোঝার যোগ্য তা করুন।

Comments

আমি এতে যুক্ত করব "যেটি আরও সুসংগত / বিদ্যমান কোডিং শৈলীর অনুসরণ করে।"

— জোশ লি

কি দারুন. আমি এই সিনট্যাকটিক চিনি ঘৃণা করি। int? x = nullআমাকে এমন মায়া দেয় যে একটি অযোগ্য উদাহরণ একটি রেফারেন্স টাইপ। তবে সত্যটি হ'ল নলেবল <টি> একটি মান ধরণের। এটা তোলে মতানুযায়ী আমি কি করতে একটি NullReferenceException পেতে চাই: int? x = null; Use(x.HasValue)।

— কেএফএল

@ কেএফএল যদি সিনট্যাকটিক চিনি আপনাকে বিরক্ত করে তোলে, কেবল Nullable<int>পরিবর্তে ব্যবহার করুন int?।

— কোল জনসন

কোনও অ্যাপ্লিকেশন তৈরির প্রাথমিক পর্যায়ে আপনি মনে করতে পারেন যে কিছু তথ্য সংরক্ষণের জন্য একটি অযোগ্য মান ধরণের ব্যবহার করা যথেষ্ট only কেবলমাত্র কিছুক্ষণ পরেই বুঝতে হবে যে আপনার প্রয়োজনের জন্য আপনার একটি উপযুক্ত শ্রেণি প্রয়োজন। শূন্যের সাথে তুলনা করতে মূল কোডটি লিখে রাখলে এর সুবিধা রয়েছে যে আপনার প্রতিটি কলকে ন্যু তুলনা করে হাসভ্যালু () এ অনুসন্ধান করতে / প্রতিস্থাপন করতে হবে না।

— অ্যান্ডার্স

এটা নাল করার জন্য একটি Nullable সেট না করা বা দেওয়া যে নাল এটি তুলনা করতে সক্ষম হচ্ছে সম্পর্কে অভিযোগ চমত্কার বোকামি Nullable নামক । সমস্যাটি হ'ল লোকেরা "নাল হতে পারে" এর সাথে "রেফারেন্স টাইপের" সাথে বিবাদ করছে তবে এটি একটি ধারণাগত বিভ্রান্তি। ফিউচার সি # এ নন-রজনীয় রেফারেন্স টাইপ থাকবে।

— জিম বাল্টার

Answer 2

আমি পছন্দ করি (a != null)যাতে সিনট্যাক্সটি রেফারেন্সের ধরণের সাথে মেলে।

Comments

কোনটি বেশ অবশ্যই বিভ্রান্তিকর হয়, যেহেতু Nullable<>হয় না একটি রেফারেন্স প্রকার।

— লুয়ান

হ্যাঁ, তবে আপনি নাল যাচাই করছেন ঠিক এমন সময়ে বিষয়টির বিষয়টি খুব কম গুরুত্বপূর্ণ।

— সিবিপি

এটি কেবল ধারণাগত বিভ্রান্তির জন্যই বিভ্রান্তিকর। দুটি ভিন্ন ধরণের জন্য একটি সুসংগত বাক্য গঠন ব্যবহার করে বোঝানো হয় না যে তারা একই ধরণের। সি # এর ননযোগ্য রেফারেন্স টাইপ রয়েছে (সমস্ত রেফারেন্স টাইপগুলি বর্তমানে naclable হয় তবে ভবিষ্যতে এটি পরিবর্তিত হবে) এবং মূল্যহীন মান ধরণের। সমস্ত অবিচ্ছিন্ন প্রকারের জন্য একটি সুসংগত বাক্য গঠন ব্যবহার করা বোধগম্য। কোনওভাবেই এটি বোঝায় না যে অণনীয় মান প্রকারগুলি রেফারেন্স প্রকারগুলি বা অণু রেফারেন্সের ধরণগুলি মান ধরণের।

— জিম বাল্টার

আমি পছন্দ HasValueহয়েছে কারণ এটি চেয়ে বেশি পাঠযোগ্য এর!= null

— কনরাড

আপনি যদি একই কোড লেখার বিভিন্ন শৈলীর মিশ্রণ না ঘনেন তবে কোডিং কনসেন্টিরিটি আরও পঠনযোগ্য। যেহেতু সব জায়গাতেই একটি .হ্যাসওয়ালিউ সম্পত্তি নেই তাই এটি ব্যবহারের পরে! = বর্ধিত স্থিরতার জন্য নাল। আমার মতামত।

— ColacX

Answer 3

আমি একটি nullable int মান নির্ধারণ করতে বিভিন্ন পদ্ধতি ব্যবহার করে এ সম্পর্কে কিছু গবেষণা করেছি। আমি বিভিন্ন জিনিস যখন এই কি ঘটেছে। কি চলছে তা স্পষ্ট করে দেওয়া উচিত। মনে রাখবেন: Nullable<something>বা শর্টহ্যান্ড something?এমন একটি কাঠামো যার জন্য কম্পাইলার মনে হচ্ছে শূন্যতার সাথে আমাদের ব্যবহার করতে যেন এটি কোনও শ্রেণি।
আপনি নীচে দেখতে পাবেন, SomeNullable == nullএবং SomeNullable.HasValueসর্বদা প্রত্যাশিত সত্য বা মিথ্যা ফিরে আসবে। যদিও নিচে প্রদর্শিত না হয়, SomeNullable == 3বৈধ খুব (অভিমানী SomeNullable একটি হল int?)।
যদিও SomeNullable.Valueআমাদের একটি রানটাইম ত্রুটি পায় যদি আমরা নির্ধারিত nullকরতে SomeNullable। এটি প্রকৃতপক্ষে একমাত্র ক্ষেত্রে যেখানে ওভারলোডেড অপারেটরগুলির সংশ্লেষের কারণে ধন্যবাদগুলি আমাদের সমস্যার কারণ হতে পারেobject.Equals(obj) পদ্ধতি এবং সংকলক অপ্টিমাইজেশন এবং বানরের ব্যবসা।

আমি দৌড়েছি এমন কিছু কোডের বর্ণনা এবং এটি লেবেলে কী আউটপুট উত্পন্ন করেছিল তা এখানে রয়েছে:

int? val = null;
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

ঠিক আছে, পরবর্তী প্রারম্ভিক পদ্ধতিটি চেষ্টা করে দেখুন:

int? val = new int?();
lbl_Val.Text = val.ToString(); //Produced an empty string.
lbl_ValVal.Text = val.Value.ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValEqNull.Text = (val == null).ToString(); //Produced "True" (without the quotes)
lbl_ValNEqNull.Text = (val != null).ToString(); //Produced "False"
lbl_ValHasVal.Text = val.HasValue.ToString(); //Produced "False"
lbl_NValHasVal.Text = (!(val.HasValue)).ToString(); //Produced "True"
lbl_ValValEqNull.Text = (val.Value == null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")
lbl_ValValNEqNull.Text = (val.Value != null).ToString(); //Produced a runtime error. ("Nullable object must have a value.")

আগের মতই সব। মনে রাখবেন যে int? val = new int?(null);কন্সট্রাক্টরকে নাল দিয়ে প্রারম্ভিককরণ করা হলে একটি জটিল সময় ত্রুটি তৈরি করতে পারে, যেহেতু nullable অবজেক্টের VALUE নমনীয় নয়। এটি কেবল মোড়কের বস্তু যা নালকে সমান করতে পারে।

তেমনি, আমরা এর থেকে একটি সংকলন সময় ত্রুটি পেয়ে যাব:

int? val = new int?();
val.Value = null;

val.Valueএটি যেভাবেই পঠনযোগ্য সম্পত্তি, তা উল্লেখ না করা , যার অর্থ আমরা এমন কিছু ব্যবহার করতে পারি না:

val.Value = 3;

তবে আবার, বহুতল ওভারলোডেড অন্তর্নিহিত রূপান্তর অপারেটররা আমাদের করুক:

val = 3;

পলিসমথিং সম্পর্কে কী চিন্তা করার দরকার নেই যদিও এতক্ষণ এটি সঠিকভাবে কাজ করে? :)

Comments

"মনে রাখবেন: অবিচল << কিছু> বা শর্টহ্যান্ড কিছু? এটি একটি শ্রেণি।" এটা ভুল! অবিচ্ছিন্ন <T> একটি কাঠামো। শূন্যের সাথে তুলনা করলে এটি ওভারলোডগুলি সমান এবং == অপারেটরটিকে সত্যে ফিরে আসে। সংকলক এই তুলনা করার জন্য কোনও অভিনব কাজ করে না।

— অ্যান্ড্রুজ

@ অ্যান্ড্রুজস - আপনি ঠিক বলেছেন যে এটি স্ট্রাক্ট (কোনও শ্রেণি নয়) তবে আপনি ভুল যে এটি == অপারেটরকে ওভারলোড করে। আপনি যদি Nullable<X>ভিজুয়ালস্টুডিও 2013 এবং এফ 12 এ টাইপ করেন তবে আপনি দেখতে পাবেন এটি কেবল রূপান্তরকরণ Xএবং Equals(object other)পদ্ধতিতে ওভারলোড করে । তবে আমি মনে করি যে == অপারেটর ডিফল্টরূপে সেই পদ্ধতিটি ব্যবহার করে, তাই প্রভাবটি একই। আমি আসলে এই উত্তরটি আপাতত কিছু সময়ের জন্য আপডেট করার অর্থ পেয়েছি তবে আমি অলস এবং / অথবা ব্যস্ত। এই মন্তব্যটি এখনই করতে হবে :)

— পেরিন লারসন

আমি ইল্ডাসমের মাধ্যমে একটি দ্রুত চেক করেছি এবং আপনি কম্পাইলার সম্পর্কে কিছু জাদু করছেন ঠিক বলেছেন; একটি নালযোগ্য <T> অবজেক্টের নাল সাথে তুলনা করা আসলে হ্যাসভ্যালুতে একটি কলকে অনুবাদ করে। মজাদার!

— অ্যান্ড্রুজ

@ অ্যান্ড্রুজস প্রকৃতপক্ষে, সংকলক nullables অনুকূল করতে একটি টন কাজ করে। উদাহরণস্বরূপ, আপনি যদি কোনও শনাক্তযোগ্য প্রকারের জন্য একটি মান নির্ধারণ করেন তবে এটি আদৌ কোনও ক্ষুদ্র হবে না (যেমন, int? val = 42; val.GetType() == typeof(int))। সুতরাং কেবল একটি কাঠামোকেই নালার সমান হতে পারে কেবল এটিই নয়, এটি প্রায়শই একেবারে ছোটও হয় না! : ডি একইভাবে, আপনি যখন একটি অযোগ্য মান বক্স করেন, আপনি বক্সিং করছেন int, না int?- এবং যখন এর int?কোনও মান থাকে না, আপনি nullবাক্সযুক্ত নল মানটির পরিবর্তে পান get এর মূল অর্থ

— হ'ল

@ জিমবাল্টার সত্যিই? এটা খুব আকর্ষণীয়। সুতরাং মেমরির প্রোফাইলার আপনাকে একটি ক্লাসে একটি ক্ষুদ্র ক্ষেত্র সম্পর্কে কী বলে? সি # তে অন্য মান ধরণের থেকে উত্তরাধিকার সূত্রে আপনি এমন কোনও মান টাইপ কীভাবে ঘোষণা করবেন? .NET এর nullable টাইপের মতোই আচরণ করে এমন আপনার নিজস্ব নালার টাইপ আপনি কীভাবে ঘোষণা করবেন? কখন থেকে Nullনেট এ টাইপ হয়? আপনি যেখানে সিএলআর / সি # নির্দিষ্টকরণের অংশটি নির্দেশ করতে পারেন যেখানে বলা হয়েছে? সিএলআর স্পেসিফিকেশনে নুলাবলগুলি ভালভাবে সংজ্ঞায়িত হয়েছে, তাদের আচরণটি কোনও "বিমূর্তকরণ বাস্তবায়ন" নয় - এটি একটি চুক্তি । তবে আপনি যদি সর্বোত্তম ব্যবহার করতে পারেন তবে হ'ম হোমের আক্রমণগুলি, নিজেকে উপভোগ করুন।

— লুয়ান

Answer 4

ভিবি.নেটে আপনি যখন ".হ্যাসভ্যালু" ব্যবহার করতে পারেন তখন "ইসনট নথিং" ব্যবহার করবেন না। আমি সবেমাত্র একটি "অপারেশন রানটাইমকে অস্থিতিশীল করতে পারে" মাঝারি বিশ্বাসের ত্রুটি "ইসনট কিছুই না" "এর সাথে প্রতিস্থাপন করে। আমি কেন বুঝতে পারছি না, তবে সংকলকটিতে কিছু অন্যভাবে ঘটছে। আমি ধরে নেব যে সি # তে "! = নাল" একই সমস্যা থাকতে পারে।

Comments

আমি HasValueপঠনযোগ্যতার কারণে পছন্দ করব । IsNot Nothingসত্যই একটি কুৎসিত অভিব্যক্তি (দ্বিগুণ প্রত্যাখ্যানের কারণে)।

— স্টিফান স্টেইনগার

@ স্টেফান "ইসনট নটিং কিছুই না" দ্বিগুণ প্রত্যাখ্যান নয়। "কিছুই না" একটি নেতিবাচক নয়, এটি একটি পৃথক পরিমাণ, এমনকি প্রোগ্রামিংয়ের ক্ষেত্রের বাইরেও। "এই পরিমাণ কিছু নয়।" ব্যাকরণগতভাবে হ'ল "এই পরিমাণটি শূন্য নয়" as এবং দুটিও নেতিবাচক নয়।

— jmbpiano

এমন নয় যে আমি এখানে সত্যের অনুপস্থিতির সাথে একমত হতে চাই না, তবে এখনই আসুন। ইসনট কিছুই কিছুই পরিষ্কার, ভাল, অতিরিক্ত নেতিবাচক নয়। হাসভ্যালুর মতো ইতিবাচক এবং পরিষ্কার কিছু লিখছেন না কেন? এটি ব্যাকরণ পরীক্ষা নয়, কোডিং হচ্ছে, যেখানে মূল উদ্দেশ্যটি স্পষ্ট।

— র্যান্ডি গ্যামেজ

জ্যাম্ব্পিয়ানো: আমি একমত যে এটি দ্বিগুণ প্রত্যাখ্যান নয়, তবে এটি একক অবহেলা এবং এটি প্রায় কুৎসিত এবং সাধারণ ইতিবাচক অভিব্যক্তির মতো পরিষ্কার নয়।

— কাভেহ হাডজারি

Answer 5

আপনি যদি লিনাক ব্যবহার করেন এবং আপনার কোডটি সংক্ষিপ্ত রাখতে চান তবে আমি সর্বদা ব্যবহারের পুনঃসংশোধন করি !=null

এবং এই কারণেই:

কল্পনা করা যাক আমরা Fooএকটি নল ডাবল ভেরিয়েবল সহ কিছু বর্গ আছেSomeDouble

public class Foo
{
    public double? SomeDouble;
    //some other properties
}   

যদি আমাদের কোডটিতে কোথাও আমরা ফু এর সংগ্রহ থেকে সমস্ত নূন্য সামডডুবল মান সহ সমস্ত ফু পেতে চাই (ধরে নিই যে সংগ্রহে কিছু ফুও নাল হতে পারে), তবে আমরা আমাদের ফাংশনটি লেখার জন্য কমপক্ষে তিনটি উপায় নিয়ে শেষ করি (যদি আমরা সি # 6 ব্যবহার করুন:

public IEnumerable<Foo> GetNonNullFoosWithSomeDoubleValues(IEnumerable<Foo> foos)
{
     return foos.Where(foo => foo?.SomeDouble != null);
     return foos.Where(foo=>foo?.SomeDouble.HasValue); // compile time error
     return foos.Where(foo=>foo?.SomeDouble.HasValue == true); 
     return foos.Where(foo=>foo != null && foo.SomeDouble.HasValue); //if we don't use C#6
}

এবং এই ধরণের পরিস্থিতিতে আমি সর্বদা সংক্ষিপ্ততার জন্য ফিরে যেতে চাই

Comments

হ্যাঁ, foo?.SomeDouble.HasValueএই প্রসঙ্গে একটি সংকলন-সময় ত্রুটি (আমার পরিভাষায় "থ্রো" নয়) কারণ এটির ধরণটি কেবলমাত্র bool?নয় bool। ( .Whereপদ্ধতিটি একটি চায় Func<Foo, bool>)) অবশ্যই এটি করার অনুমতি দেওয়া হয়েছে (foo?.SomeDouble).HasValue, যেহেতু এটির ধরন রয়েছে bool। আপনার প্রথম লাইনটি সি # সংকলক (অন্তত আনুষ্ঠানিকভাবে) দ্বারা অভ্যন্তরীণভাবে "অনুবাদ করা"।

— জেপ্প স্টিগ নীলসেন

Answer 6

থাম্বের সাধারণ উত্তর এবং নিয়ম: যদি আপনার কাছে বিকল্প থাকে (যেমন কাস্টম সিরিয়ালাইজারগুলি লিখে) বিভিন্ন পাইপলাইনে নলযোগ্য প্রক্রিয়া করার জন্য object- এবং তাদের নির্দিষ্ট বৈশিষ্ট্যগুলি ব্যবহার করে - এটি করুন এবং নলযোগ্য নির্দিষ্ট বৈশিষ্ট্যগুলি ব্যবহার করুন। সুতরাং ধারাবাহিকভাবে চিন্তাভাবনা দৃষ্টিভঙ্গি থেকে HasValueপছন্দ করা উচিত। ধারাবাহিক চিন্তাভাবনা আপনাকে আরও ভাল কোড লিখতে সহায়তা করতে পারে বিশদে খুব বেশি সময় ব্যয় করবেন না। উদাহরণস্বরূপ, দ্বিতীয় পদ্ধতিটি আরও বহুগুণ কার্যকর হবে (বেশিরভাগ ক্ষেত্রেই ইনাইলাইনিং এবং বক্সিং সংকলকগুলির কারণে তবে এখনও সংখ্যাগুলি খুব স্পষ্টবাদী):

public static bool CheckObjectImpl(object o)
{
    return o != null;
}

public static bool CheckNullableImpl<T>(T? o) where T: struct
{
    return o.HasValue;
}

বেঞ্চমার্ক পরীক্ষা:

BenchmarkDotNet=v0.10.5, OS=Windows 10.0.14393
Processor=Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), ProcessorCount=4
Frequency=3233539 Hz, Resolution=309.2587 ns, Timer=TSC
  [Host] : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0
  Clr    : Clr 4.0.30319.42000, 64bit RyuJIT-v4.6.1648.0
  Core   : .NET Core 4.6.25009.03, 64bit RyuJIT


        Method |  Job | Runtime |       Mean |     Error |    StdDev |        Min |        Max |     Median | Rank |  Gen 0 | Allocated |
-------------- |----- |-------- |-----------:|----------:|----------:|-----------:|-----------:|-----------:|-----:|-------:|----------:|
   CheckObject |  Clr |     Clr | 80.6416 ns | 1.1983 ns | 1.0622 ns | 79.5528 ns | 83.0417 ns | 80.1797 ns |    3 | 0.0060 |      24 B |
 CheckNullable |  Clr |     Clr |  0.0029 ns | 0.0088 ns | 0.0082 ns |  0.0000 ns |  0.0315 ns |  0.0000 ns |    1 |      - |       0 B |
   CheckObject | Core |    Core | 77.2614 ns | 0.5703 ns | 0.4763 ns | 76.4205 ns | 77.9400 ns | 77.3586 ns |    2 | 0.0060 |      24 B |
 CheckNullable | Core |    Core |  0.0007 ns | 0.0021 ns | 0.0016 ns |  0.0000 ns |  0.0054 ns |  0.0000 ns |    1 |      - |       0 B |

বেঞ্চমার্ক কোড:

public class BenchmarkNullableCheck
{
    static int? x = (new Random()).Next();

    public static bool CheckObjectImpl(object o)
    {
        return o != null;
    }

    public static bool CheckNullableImpl<T>(T? o) where T: struct
    {
        return o.HasValue;
    }

    [Benchmark]
    public bool CheckObject()
    {
        return CheckObjectImpl(x);
    }

    [Benchmark]
    public bool CheckNullable()
    {
        return CheckNullableImpl(x);
    }
}

https://github.com/dotnet/BenchmarkDotNet ব্যবহার করা হয়েছিল

দ্রষ্টব্য । লোকেরা বলে যে পরামর্শ "সুসংগত চিন্তাভাবনার কারণে হ্যাসভ্যালু পছন্দ করে" সম্পর্কিত এবং অকেজো নয়। আপনি এর পারফরম্যান্স অনুমান করতে পারেন?

public static bool CheckNullableGenericImpl<T>(T? t) where T: struct
{
    return t != null; // or t.HasValue?
}

পিপিএস লোকজন বিয়োগ অব্যাহত রাখে তবে কেউ এর পারফরম্যান্সের পূর্বাভাস দেওয়ার চেষ্টা করে না CheckNullableGenericImpl। সেখানে কম্পাইলার আপনি প্রতিস্থাপন সাহায্য করবে না !=nullসঙ্গে HasValue। HasValueআপনি যদি পারফরম্যান্সে আগ্রহী হন তবে সরাসরি ব্যবহার করা উচিত।

Comments

আপনার CheckObjectImpl বাক্সগুলি মুছে ফেলা যায় object, যেখানে CheckNullableImplবক্সিং ব্যবহার হয় না। সুতরাং তুলনা খুব অপ্রয়োজনীয়। কেবল এটি ভাড়া নয়, এটিও অকেজো কারণ গ্রহণযোগ্য উত্তরে উল্লিখিত হিসাবে , সংকলক যেভাবেই আবার লিখতে !=পারে HasValue।

— GSerg

পাঠকদের struct হয় প্রকৃতি উপেক্ষা করবেন না Nullable<T>, আপনাকে যা করতে (একটি সেটিকে বক্সিং দ্বারা object)। আপনি যখন != nullবামদিকে শুরুর সাথে আবেদন করেন তখন কোনও বক্সিং হয় না কারণ !=নালাগুলির জন্য সমর্থন সংকলক স্তরে কাজ করে। এটি আলাদা যখন আপনি কম্পাইলার থেকে প্রথমে শুল্কটি একটি বাক্সে মুছে ফেলেন object। আমরাও CheckObjectImpl(object o)না নীতিগতভাবে আপনার বেঞ্চমার্ক জানার।

— জিসার্গ

আমার সমস্যাটি হ'ল আমি এই ওয়েবসাইটে সামগ্রীর গুণমান সম্পর্কে যত্নশীল। আপনি যা পোস্ট করেছেন তা হয় বিভ্রান্তিমূলক বা ভুল। আপনি ওপি এর প্রশ্নের উত্তর দিতে চেষ্টা ছিল, তারপর আপনার উত্তর ফ্ল্যাট আউট ভুল, যা প্রতিস্থাপন প্রমাণ করা সহজ হয় কল করার CheckObjectImplতার সঙ্গে শরীর ভিতরে CheckObject। তবে আপনার সর্বশেষ মন্তব্যগুলি প্রকাশ করে যে আপনি যখন 8 বছরের পুরানো এই প্রশ্নের উত্তর দেওয়ার সিদ্ধান্ত নিয়েছিলেন তখন আপনার মনে একটি সম্পূর্ণ আলাদা প্রশ্ন ছিল, যা মূল প্রশ্নের প্রসঙ্গে আপনার উত্তরটিকে বিভ্রান্ত করে তোলে। ওপি যা জিজ্ঞাসা করছিল তা নয়।

— GSerg

নিজেকে পরবর্তী লোক Google এর এর জুতা রাখুন what is faster != or HasValue। তিনি এই প্রশ্নে উপস্থিত হন, আপনার উত্তরের মাধ্যমে ব্রাউজ করেন, আপনার মানদণ্ডের প্রশংসা করে বলেন, "জি, আমি কখনই ব্যবহার করব না !=কারণ এটি স্পষ্টতই এত ধীর গতিতে এসেছে!" এটি একটি খুব ভুল উপসংহার যা তিনি তারপরে চারদিকে ছড়িয়ে পড়বেন। সে কারণেই আমি বিশ্বাস করি আপনার উত্তর ক্ষতিকারক - এটি একটি ভুল প্রশ্নের উত্তর দেয় এবং এইভাবে সন্দেহাতীত পাঠকের পক্ষে একটি ভুল উপসংহার তৈরি করে। বিবেচনা করুন কি ঘটছে যখন আপনি আপনার পরিবর্তন CheckNullableImplকরার এছাড়াও হতে return o != null;আপনি একই বেঞ্চমার্ক ফলাফলের পাবেন।

— GSerg

আমি আপনার উত্তর দিয়ে তর্ক করছি। আপনার উত্তর চাতুরীর সাথে বলে মনে হচ্ছে মধ্যে পার্থক্য দেখায় !=এবং HasValueযখন এটি আসলে মধ্যে পার্থক্য দেখায় object oএবং T? o। আমি যা প্রস্তাব করেন, তাহলে যে, পুনর্লিখন CheckNullableImplযেমন public static bool CheckNullableImpl<T>(T? o) where T: struct { return o != null; }, আপনি একটি বেঞ্চমার্ক দিয়ে শেষ করবে যে পরিষ্কারভাবে দেখায় !=হয় অনেক ধীর চেয়ে !=। যা আপনাকে এই সিদ্ধান্তে নিয়ে যেতে হবে যে আপনার উত্তরটি যে বর্ণনাটি বর্ণনা করেছে তা !=বনাম সম্পর্কিত HasValueনয়।

— GSerg