Code Puzzle
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
:wtf: How did that person even think that this was ready?
What do you get when you cross a joke with a rhetorical question? The metaphorical solid rear-end expulsions have impacted the metaphorical motorized bladed rotating air movement mechanism. Do questions with multiple question marks annoy you???
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
It may cause NullPointException :
return Container.Find(instance => instance._id == _searchID)
Life is all about share and care... public class Life : ICareable,IShareable { // implements yours... }
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
Singleton! :doh: - Compiler error at
=+- Threading issues: susceptible to multiple instances being created - Possibly a StackOverflowException while "get"ing the Query - Possibly a NullReferenceException while "get"ing the Query - Possibly a NullReferenceException while "set"ing the Query - Should have a static constructorSascha Lefèvre wrote:
Can you guess the intended purpose?
Write a test-friendly class? :-\
You have just been Sharapova'd.
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
Singleton is not thread-safe, Query property is potentially recursive, and can cause null exception. Also shouldn't query container contain list of Query instead of list of QueryContainer if QueryContainer is supposed to be a singleton (i.e. having only one). Also the whole class is crazy. Why have ID counter if you're using kinda "singleton"? Also no comments on what the class does or on public members. This IS Sparta! :-D
-
Singleton! :doh: - Compiler error at
=+- Threading issues: susceptible to multiple instances being created - Possibly a StackOverflowException while "get"ing the Query - Possibly a NullReferenceException while "get"ing the Query - Possibly a NullReferenceException while "set"ing the Query - Should have a static constructorSascha Lefèvre wrote:
Can you guess the intended purpose?
Write a test-friendly class? :-\
You have just been Sharapova'd.
Agent__007 wrote:
Compiler error at
=+Really? That part of the code compiles for me. It doesn't do what the author probably intended, but it compiles.
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
-
Agent__007 wrote:
Compiler error at
=+Really? That part of the code compiles for me. It doesn't do what the author probably intended, but it compiles.
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
It does, indeed! :thumbsup: I was looking at the code and that looked like a mistyped
+=and thought it would give an error. There are times when I don't think at all! :doh: :sigh:You have just been Sharapova'd.
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
Singleton is usually one of the first design patterns people learn. They immediately fall in love with it and are become blind for any other patterns out there. I'd say the problem with this code would be that it causes brain damage.
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
-
Clue bat needed in Aisle 5! Clue bat needed in Aisle 5!
What do you get when you cross a joke with a rhetorical question? The metaphorical solid rear-end expulsions have impacted the metaphorical motorized bladed rotating air movement mechanism. Do questions with multiple question marks annoy you???
-
Yes, I saw it.. sighed, and decided to let someone else answer since he apparently didn't believe me :sigh:
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
Among all the toe-curling flaws in there, these are my two favorites: It's not even a singleton - it's a "noneton": Trying to access the Instance-property will cause a stack overflow due to recursion.. The List<QueryContainer> will be really, really short. Even when fixing the above flaw.. And the answer to the million dollar question: It's supposed to somehow (don't ask me) help with fixing code that is vulnerable to SQL-injection.
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
-
Threading issues certainly. What language?
PIEBALDconsult wrote:
Threading issues certainly.
You're WAY off :laugh: (See my solution-post below)
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
-
Among all the toe-curling flaws in there, these are my two favorites: It's not even a singleton - it's a "noneton": Trying to access the Instance-property will cause a stack overflow due to recursion.. The List<QueryContainer> will be really, really short. Even when fixing the above flaw.. And the answer to the million dollar question: It's supposed to somehow (don't ask me) help with fixing code that is vulnerable to SQL-injection.
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
The new version[^] still doesn't fix the problem. I'm running out of different ways to explain to him why his approach isn't going to work. :sigh:
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
"These people looked deep within my soul and assigned me a number based on the order in which I joined" - Homer
-
The new version[^] still doesn't fix the problem. I'm running out of different ways to explain to him why his approach isn't going to work. :sigh:
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
He might be impervious to advice..
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
-
The new version[^] still doesn't fix the problem. I'm running out of different ways to explain to him why his approach isn't going to work. :sigh:
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
I know one remarkably effective way to explain to him: use SQL Injection to delete his database. And every time he puts it back, it goes again. It's cruel. It's nasty. It's probably illegal. But it's what his best mate will do, just to see the look on his face...
Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
-
Among all the toe-curling flaws in there, these are my two favorites: It's not even a singleton - it's a "noneton": Trying to access the Instance-property will cause a stack overflow due to recursion.. The List<QueryContainer> will be really, really short. Even when fixing the above flaw.. And the answer to the million dollar question: It's supposed to somehow (don't ask me) help with fixing code that is vulnerable to SQL-injection.
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
Sascha Lefèvre wrote:
It's supposed to somehow (don't ask me) help with fixing code that is vulnerable to SQL-injection.
After reading the actual questions, I don't think he is trying to fix the actual vulnerability with his code. Instead he may be trying to cheat the test system (by obfuscation) from detecting that there is an SQL injection vulnerability.
The good thing about pessimism is, that you are always either right or pleasently surprised.
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
"But please - no programming questions."
-
"But please - no programming questions."
As you didn't mark your post as a joke or put a smiley into it I have to assume you're being serious: But my post isn't a programming question.
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
-
How many compiler errors, potential NullReferenceExceptions, StackOverflowExceptions and whatnot can you spot in this presumably review-ready class? And the million dollar question: Can you guess the intended purpose?
public class QueryContainer
{
private static List<QueryContainer> Container;
private static QueryContainer instance;public static QueryContainer Instance { get { if (Instance == null) instance = new QueryContainer(); return instance; } } public int \_searchID; public int ID { get { return \_id; } } public string Query { get { return Container.Find(instance => instance.\_id == \_searchID).Query; } set { Container.Query = value; \_id =+ 1; } } private int \_id; private string \_query; private QueryContainer() { }}
If the brain were so simple we could understand it, we would be so simple we couldn't. — Lyall Watson
1. The
Instanceproperty get will overflow the stack due to recursion. 2. TheQueryproperty set and get will both throwNullReferenceException's, sinceContaineris never initialized. 3. The code shouldn't even compile. TheQueryproperty set assignsvaluetoContainer.Query, but sinceContaineris aList<>, it doesn't have aQueryproperty. I'm going to completely ignore the code's stated purpose, which I don't think what they've provided has the faintest hope of meeting.Software Zen:
delete this;
