Cleverest Code of the Day!
-
While comparing my changes with the server source code, just saw with my two eyes this great piece of code which checks if an nullable int is null or not :
private bool IsHasValue(int? a)
{
if (a== null)
{
return false;
}
return true;
}The code is written by very senior developer on my team with huge years of experience in c# :laugh:
Well, it works.
-
Well, it works.
who said it does not works, it's about reinventing the wheel :)
-
While comparing my changes with the server source code, just saw with my two eyes this great piece of code which checks if an nullable int is null or not :
private bool IsHasValue(int? a)
{
if (a== null)
{
return false;
}
return true;
}The code is written by very senior developer on my team with huge years of experience in c# :laugh:
My advice - don't change the code, and hope your "very senior developer" doesn't have a CP account.
".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
When you pry the gun from my cold dead hands, be careful - the barrel will be very hot. - JSOP, 2013 -
While comparing my changes with the server source code, just saw with my two eyes this great piece of code which checks if an nullable int is null or not :
private bool IsHasValue(int? a)
{
if (a== null)
{
return false;
}
return true;
}The code is written by very senior developer on my team with huge years of experience in c# :laugh:
That code certainly .HasValue
-
My advice - don't change the code, and hope your "very senior developer" doesn't have a CP account.
".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
When you pry the gun from my cold dead hands, be careful - the barrel will be very hot. - JSOP, 2013i won't change and i am sure senior dev does not use CP :laugh:
-
While comparing my changes with the server source code, just saw with my two eyes this great piece of code which checks if an nullable int is null or not :
private bool IsHasValue(int? a)
{
if (a== null)
{
return false;
}
return true;
}The code is written by very senior developer on my team with huge years of experience in c# :laugh:
A consultant friend of mine who has been programming far longer than I have—he started programming on the early Macs and helped write the first music notation software for the Mac—doesn't see why C# should need to use .SubString() to get the left/right most characters from a string and instead wrote these. I don't really have a problem with this sort of thing. I just don't see the point, but that's just me.
public string LeftStringFunction(string sValue, int iMaxLength) { //Check if the value is valid if (string.IsNullOrEmpty(sValue)) { //Set valid empty string as string could be null sValue = string.Empty; } else if (sValue.Length > iMaxLength) { //Make the string no longer than the max length sValue = sValue.Substring(0, iMaxLength); } //Return the string return sValue; } public string RightStringFunction(string sValue, int iMaxLength) { //Check if the value is valid if (string.IsNullOrEmpty(sValue)) { //Set valid empty string as string could be null sValue = string.Empty; } else if (sValue.Length > iMaxLength) { //Make the string no longer than the max length sValue = sValue.Substring(sValue.Length - iMaxLength, iMaxLength); } //Return the string return sValue; }"...JavaScript could teach Dyson how to suck." -- Nagy Vilmos
-
i won't change and i am sure senior dev does not use CP :laugh:
You see that large number at the top left of this website? A large fraction of those are actually sockpuppets with John pulling the strings. Don't be surprised if the 'persona' of your senior colleague appears out of nowhere. Best Wishes, -David Delaune
-
A consultant friend of mine who has been programming far longer than I have—he started programming on the early Macs and helped write the first music notation software for the Mac—doesn't see why C# should need to use .SubString() to get the left/right most characters from a string and instead wrote these. I don't really have a problem with this sort of thing. I just don't see the point, but that's just me.
public string LeftStringFunction(string sValue, int iMaxLength) { //Check if the value is valid if (string.IsNullOrEmpty(sValue)) { //Set valid empty string as string could be null sValue = string.Empty; } else if (sValue.Length > iMaxLength) { //Make the string no longer than the max length sValue = sValue.Substring(0, iMaxLength); } //Return the string return sValue; } public string RightStringFunction(string sValue, int iMaxLength) { //Check if the value is valid if (string.IsNullOrEmpty(sValue)) { //Set valid empty string as string could be null sValue = string.Empty; } else if (sValue.Length > iMaxLength) { //Make the string no longer than the max length sValue = sValue.Substring(sValue.Length - iMaxLength, iMaxLength); } //Return the string return sValue; }"...JavaScript could teach Dyson how to suck." -- Nagy Vilmos
Looks like somebody's trying to reinvent VB6's
Left$andRight$, neither of which throw an exception if you specify a length that's longer than the string. :)
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
-
Looks like somebody's trying to reinvent VB6's
Left$andRight$, neither of which throw an exception if you specify a length that's longer than the string. :)
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
Left$ would be GwBasic (not VB6 where the $s were dropped) :-)
Nish Nishant Consultant Software Architect Ganymede Software Solutions LLC www.ganymedesoftwaresolutions.com
-
who said it does not works, it's about reinventing the wheel :)
Not just reinventing it, but reinventing it to be less efficient. The actual HasValue implementation just checks an internal flag that's set to true when a value is assigned.
Nish Nishant Consultant Software Architect Ganymede Software Solutions LLC www.ganymedesoftwaresolutions.com
-
My advice - don't change the code, and hope your "very senior developer" doesn't have a CP account.
".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
When you pry the gun from my cold dead hands, be careful - the barrel will be very hot. - JSOP, 2013Especially since OP's using his real name :-)
Nish Nishant Consultant Software Architect Ganymede Software Solutions LLC www.ganymedesoftwaresolutions.com
-
While comparing my changes with the server source code, just saw with my two eyes this great piece of code which checks if an nullable int is null or not :
private bool IsHasValue(int? a)
{
if (a== null)
{
return false;
}
return true;
}The code is written by very senior developer on my team with huge years of experience in c# :laugh:
-
Well obviously checking for false (in the calling code) is so much better than checking for null. Plus, if the int isn't null (contains a value) then you get the wonderful True back and true just makes you feel good. :laugh:
Yes exactly :laugh:
-
While comparing my changes with the server source code, just saw with my two eyes this great piece of code which checks if an nullable int is null or not :
private bool IsHasValue(int? a)
{
if (a== null)
{
return false;
}
return true;
}The code is written by very senior developer on my team with huge years of experience in c# :laugh:
Remimds me of the code generated by a compiler I once knew: This was in the days of the superminis, very much CISC. This machine (called ND-500) had a "LoadIndex [register] [indexvalue] [min] [max]" instruction: If the value at [indexvalue] was not between [min] and [max], a exception was generated. This compiler could (optionally) verify all array indexing, using this instruction, but not quite in the straightforward way that you might think. A disassembly showed something like this LOAD R4, indexvalue COMP R4, min JUMPLT error COMP R4, max JUMPGT error % everything is OK, go ahead ... error: LOADINDEX R4, R4, 0, -1 % no legal range, will unconditionally generate exception Generating six instructions to replace a single one can be meaningful, but hardly when one of the six is the instruction you want to replace... I was working in the company making both the CPU and the compiler, so I went to the compiler guy for an explanation. He insisted that since index check was an option, it should not change any code generated, only add code: The index check is like a debugging aid that you might turn off in a production build, and the production version should be exactly the code you debugged, minus the debug features. With the option off, the first instruciton (LOAD R4, indexvalue) was generated. Turn it on, and you get the five additional instructions. Needless to say: Even though his argument sort of sounds plausible, I strongly disagreed with him. First, index checking is not a debug feature; you keep it on in the production version. Second: Given an option set, the compiler should be free to the best code for that selection of options, ignoring other option sets (think of optimization options!) After much arguing, he agreed to rather generate LOAD R4, indexvalue LOADINDEX R4, R4, min, max ... two instructions is better than six. But he stuck to his principles: I never got him to generate a singel LOADINDEX.
-
Remimds me of the code generated by a compiler I once knew: This was in the days of the superminis, very much CISC. This machine (called ND-500) had a "LoadIndex [register] [indexvalue] [min] [max]" instruction: If the value at [indexvalue] was not between [min] and [max], a exception was generated. This compiler could (optionally) verify all array indexing, using this instruction, but not quite in the straightforward way that you might think. A disassembly showed something like this LOAD R4, indexvalue COMP R4, min JUMPLT error COMP R4, max JUMPGT error % everything is OK, go ahead ... error: LOADINDEX R4, R4, 0, -1 % no legal range, will unconditionally generate exception Generating six instructions to replace a single one can be meaningful, but hardly when one of the six is the instruction you want to replace... I was working in the company making both the CPU and the compiler, so I went to the compiler guy for an explanation. He insisted that since index check was an option, it should not change any code generated, only add code: The index check is like a debugging aid that you might turn off in a production build, and the production version should be exactly the code you debugged, minus the debug features. With the option off, the first instruciton (LOAD R4, indexvalue) was generated. Turn it on, and you get the five additional instructions. Needless to say: Even though his argument sort of sounds plausible, I strongly disagreed with him. First, index checking is not a debug feature; you keep it on in the production version. Second: Given an option set, the compiler should be free to the best code for that selection of options, ignoring other option sets (think of optimization options!) After much arguing, he agreed to rather generate LOAD R4, indexvalue LOADINDEX R4, R4, min, max ... two instructions is better than six. But he stuck to his principles: I never got him to generate a singel LOADINDEX.
that's why i wouldn't get in discussion with senior dev on this :laugh:
-
A consultant friend of mine who has been programming far longer than I have—he started programming on the early Macs and helped write the first music notation software for the Mac—doesn't see why C# should need to use .SubString() to get the left/right most characters from a string and instead wrote these. I don't really have a problem with this sort of thing. I just don't see the point, but that's just me.
public string LeftStringFunction(string sValue, int iMaxLength) { //Check if the value is valid if (string.IsNullOrEmpty(sValue)) { //Set valid empty string as string could be null sValue = string.Empty; } else if (sValue.Length > iMaxLength) { //Make the string no longer than the max length sValue = sValue.Substring(0, iMaxLength); } //Return the string return sValue; } public string RightStringFunction(string sValue, int iMaxLength) { //Check if the value is valid if (string.IsNullOrEmpty(sValue)) { //Set valid empty string as string could be null sValue = string.Empty; } else if (sValue.Length > iMaxLength) { //Make the string no longer than the max length sValue = sValue.Substring(sValue.Length - iMaxLength, iMaxLength); } //Return the string return sValue; }"...JavaScript could teach Dyson how to suck." -- Nagy Vilmos
-
Looks like somebody's trying to reinvent VB6's
Left$andRight$, neither of which throw an exception if you specify a length that's longer than the string. :)
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
Richard Deeming wrote:
either of which throw an exception if you specify a length that's longer than the string.
Why on Earth should they?
GCS d-- s-/++ a- C++++ U+++ P- L+@ E-- W++ N+ o+ K- w+++ O? M-- V? PS+ PE- Y+ PGP t+ 5? X R+++ tv-- b+(+++) DI+++ D++ G e++ h--- ++>+++ y+++* Weapons extension: ma- k++ F+2 X
-
While comparing my changes with the server source code, just saw with my two eyes this great piece of code which checks if an nullable int is null or not :
private bool IsHasValue(int? a)
{
if (a== null)
{
return false;
}
return true;
}The code is written by very senior developer on my team with huge years of experience in c# :laugh:
-
the parameter is itself a
Nullableand i know this is the latest code that we are working on in .NET 4.0 using C# 6 language in it. -
While comparing my changes with the server source code, just saw with my two eyes this great piece of code which checks if an nullable int is null or not :
private bool IsHasValue(int? a)
{
if (a== null)
{
return false;
}
return true;
}The code is written by very senior developer on my team with huge years of experience in c# :laugh:
