Developing in .NET provides several powerful benefits, including less overall code, improved security, ease of updates\/changes, and language independence.<\/p>\n
That said, the system isn\u2019t without errors and problems. From common exceptions to coding mistakes to incorrect assumptions, most of these issues come down to programmer error.<\/p>\n
The list below shares the 50 top .NET software errors from around the web. It includes exceptions, broken data bindings, memory leaks<\/a>, LINQ issues, mistyping errors, and dozens more. We also look at ways to fix each one.<\/p>\n When you’re ready to start coding, download\u00a0our free guide to .NET Profilers<\/a> for some insider knowledge and everything you need to know about code profiling for .NET. And while you’re at it, be sure to check out Prefix<\/a>, our own lightweight profiler for .NET and Java developers. (And, if you’re thinking about .NET Core, read our opinion on why it’s the next big thing here<\/a>.)<\/p>\n This .NET exception gets thrown whenever we try to use a class reference<\/a> that\u2019s set to null\/Nothing, when the code expects otherwise. In the very simple example below, the string \u201cfoo\u201d is set to null<\/em>.<\/p>\n The second line above will throw a NullReferenceException because we can\u2019t call the method on a string that points to null.<\/em><\/p>\n To fix\/avoid this error:<\/p>\n The DivideByZeroException error gets thrown whenever a program tries to divide by zero. To handle it gracefully, protect any code that does arithmetic division within try-catch blocks that look for that specific exception. Here\u2019s an example:<\/p>\n Ways to fix\/prevent DivideByZeroException:<\/p>\n Data bindings in WPF can be a huge time saver \u2013 when they work well. When they break, they\u2019re one of the more frustrating .NET errors out there. In the example below, there\u2019s a TextBlock with a missing data context. Frustratingly, it won\u2019t show errors in Visual Studio\u2019s output window.<\/p>\n Here are a couple of other fixes for the broken data bindings error:<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/brokendatabindingswpf.md<\/a><\/p>\n This problem is specific to C#. In C#, the programmer who writes the object decides whether the value assigned to it is a value or a reference to another object. The example below shows a couple of unwanted surprises.<\/p>\n To fix the problem, look at definitions of the object types. In Visual Studio, do this by putting your cursor over the object\u2019s name and pressing F12.<\/p>\n For a more in-depth explanation of the reference\/value error, see this tutorial<\/a>.<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/using-reference-like-value-vice-versa.md<\/a><\/p>\n This very common issue erodes the strict type checking provided by the C# compiler. The temptation to hide warnings in Visual Studio\u2019s \u201cError List\u201d window can lead to a buildup of hidden or ignored warnings. Unheeded warnings can cause eventual code problems like this:<\/p>\n Of course, the easy fix for the buildup of compiler warnings is to set aside regular time blocks to address them. Spending a few seconds on each warning now can save hours down the road. See this article<\/a> for more.<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/allowing-compiler-warnings-accumulate.md<\/a><\/p>\n Disposing objects before all references to them are out of scope is a housekeeping issue. We might assume the garbage collector will take care of it when it runs the object\u2019s finalizer, but that isn\u2019t always the case.<\/p>\n To fix this error, make sure all .NET objects are explicitly disposed.<\/p>\n While not exactly a .NET error, using too much exception handling with nested methods is definitely a mistake. This one creates a lot of redundant code and a real performance drain. The best practice here is using nested exception handling, which performs the exception handling only once:<\/p>\n For a deeper look at this mistake, see this article<\/a>. (@Codeguru<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/nested-exception-handling.mdown<\/a><\/p>\n LINQ makes it a lot easier to query data than if we use for\/each loops with conditional logic like nested if blocks. But consider the code below, which uses LINQ-to-SQL to get a customer list:<\/p>\n The code seems fine until we try to enumerate the collection. At that point, we\u2019ll get an \u201cObjectDisposedException.\u201d That\u2019s because link won\u2019t actually perform the query until we attempt to enumerate the results.<\/p>\n To fix this, first convert your LINQ queries to a List using ToList(), or to an array using ToArray(). This step will ensure all LINQ queries get evaluated right away. See more on this here<\/a>. (@VSMdev<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/deferred-execution-in-linq.md<\/a><\/p>\n Here\u2019s another \u201cnot quite a .NET error\u201d that\u2019s nonetheless a big mistake. Iterating through long lists of records is far from efficient. Rather than rely on a foreach loop or a for loop, use LINQ. LINQ or Language-Integrated Query is a feature of .NET that makes it easier to query objects like long lists or collections.<\/p>\n The code above returns 1,000 customers. That\u2019s much more efficient than getting 100,000 customers with a foreach loop. For more, see this post<\/a>. (@Upwork<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/iterating-through-values-instead-of-using-linq.md<\/a><\/p>\n This C# error comes from executing code before its time. This can happen when we call an overridden method straight from the constructor of a base class.<\/p>\n In the example below, the virtual method call is made on a class before the class\u2019 constructor has been run.<\/p>\n To fix the problem, first mark your class as sealed. This ensures that it\u2019s the most derived type within the inheritance hierarchy. That way, when we call the virtual method, we don\u2019t get a warning.<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/accessing-virtual-member-in-a-constructor.md<\/a><\/p>\n Logic errors happen when we don\u2019t get the result we expected. They don\u2019t always result in error messages because they\u2019re not technically \u201cbugs.\u201d Instead, they\u2019re problems with programming logic. Take a look at the code below. It tries to add up the numbers from one to ten.<\/p>\n Can you see the error? The answer is zero! The program didn\u2019t run into any code errors, but it gave us the wrong answer. That\u2019s a logic error. We should have set the startLoop variable as 1, and endLoop as 11. To nip logic errors in the bud:<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/logic-error.md<\/a><\/p>\n Most languages use the + sign for both concatenation and arithmetic addition. That means 2 + 2 is 4 and \u201chello \u201d + \u201cworld\u201d is \u201chello world.\u201d But what about \u201chello \u201c + 2? This would result in \u201chello 2\u201d. This would be better expressed as \u201chello \u201d + \u201c2\u201d.<\/p>\n Here\u2019s a less obvious example:<\/p>\n In this case, x + y is 412, where 4 is a number and \u201c12\u201d is a string.<\/p>\n To head this mistake off:<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/concatenating-rather-than-adding.md<\/a><\/p>\n Strings are immutable in .NET. That means once we create a string, we can\u2019t change its value. It may look<\/em> like we\u2019re changing a string\u2019s value, but what we\u2019re really doing is creating a new object with a new value.<\/p>\n The example below shows how forgetting that strings are immutable can lead us into a problem. (@amazedsaint<\/a>)<\/p>\n There\u2019s another great example of an immutable string error here<\/a> that results in the creation of 10,000 unwanted string variables. (@codeproject<\/a>)\u00a0The article presents an elegant solution: using the StringBuilder class to change the text without making thousands of new String class instances.<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/forgetting-that-strings-are-immutable.md<\/a><\/p>\n Here\u2019s a common C# error that results from a multithreading mistake. This happens when we use lock<\/em> with poor code synchronization.<\/p>\n The example below checks for curse words in a string, printing a warning if it finds one. It also performs several other operations. The code isn\u2019t synchronized, however, so it\u2019s not thread safe. For instance, two threads might try to update the same counter at the same time, causing an exception.<\/p>\n To repair this:<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/incorrect-granularity.md<\/a><\/p>\n This may sound like the lost Dali painting, but it\u2019s just a fancy way of saying, \u201cunhandled, handleable exceptions.\u201d Since the definition of exogenous<\/em> is \u201coriginating externally,\u201d these exceptions are beyond our control and must be anticipated and handled.<\/p>\n The code below shows a good example.<\/p>\n We have to use the try-catch block because something might have happened to our file. Use try-catch blocks to avoid an error arising from these exceptions.<\/p>\n See this tutorial<\/a> for a good explanation of the different kinds of exceptions, plus whether and how to handle them. (@ericlippert<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/failure-to-handle-exogenous-exceptions.md<\/a><\/p>\n For any class, the default protection level is \u201cinternal.\u201d For any member in that class, the default level is \u201cprivate.\u201d We can run into an\u00a0issue\u00a0when we forget those facts.<\/p>\n When we declare \u201cMySecondClass\u201d public, its variables don\u2019t also become public. If we want MyFirstClass to be able to access the variables in MySecondClass, we\u2019ll need to set MyFirstClass and the MySecondClass variables to \u201cpublic.\u201d See this post <\/a>for more details. (@DeveloperDrive<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/protection-level-conflicts.md<\/a><\/p>\n Apart from being a popular developer forum, this is also a common error. This one is something like an OutOfMemoryException because it means your code has exceeded a memory boundary. The stack is finite, which means if we have too many memory allocations in it, we\u2019ll get an overflow exception.<\/p>\n The simple C# example below shows an infinite recursion that will trigger a StackOverflowException.<\/p>\n To avoid the StackOverflowException error, try not to have objects mutually reference each other whenever possible. See this discussion<\/a> and this article<\/a> for more insight. (@StackOverflow<\/a> and\u00a0@ExpertsExchange<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/stack-overflow-exception.md<\/a><\/p>\n Using busy-wait instead of correct thread synchronization can deliver a troublesome error. The code below will suck up 100% of the CPU core while the thread in Example() processes the while<\/em> loop.<\/p>\n Some developers will try to use something like Thread.Sleep(100) <\/em>to interrupt an infinite loop. While this works, it\u2019s sloppy coding, since what we really need is an in-built synchronization construct. In general, we should only use Thread.Sleep:<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/busy-waiting-and-thread-sleep.md<\/a><\/p>\n Certain .NET errors in the form of exceptions that can\u2019t be foreseen and that originate from outside our control must be handled. For example, let\u2019s say our program does a check for File.Exists. The file does exist, but between the check and the next operation, the file gets deleted. That said, most exceptions should be avoided whenever possible by writing code that renders them unnecessary. Consider the following three exceptions:<\/p>\n If we use the int.TryParse() method instead of an exception, we get a 0 response. That means this method avoids the need for complex and potentially buggy exception handling.<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/avoiding-exceptions-instead-of-working-with-them.mdown<\/a><\/p>\n Certain assumptions about how multithreading works can lead us to unexpected problems. These are especially likely when working with shared state. Often, the mistakes arise when we think multithreaded code works in the same way as single-threaded code.<\/p>\n One example is a torn read from non-atomic access to a variable.<\/em> The following code will return unwanted values:<\/p>\n The problem\u00a0occurs because one thread can read the value of sharedState halfway through a write by another thread. This forces the variable into values we hadn\u2019t anticipated (or wanted).<\/p>\n To fix the problem, make access to the variable atomic.<\/em> To do this:<\/p>\n For a detailed breakdown of incorrect multithreading assumptions in .NET and how to fix them, see this in-depth tutorial<\/a>. (@Xenoprimate<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/unsafe-assumptions-on-multithreading.md<\/a><\/p>\n A nullable value passed to the stack will create garbage. Paradoxically, a similar variable that\u2019s actually set to null won\u2019t create any garbage.<\/p>\n In the example above, DoTestA() creates zero garbage, while DoTestB() quickly racks up a large amount.<\/p>\n The best way to fix this is to generify our DoSomething method:<\/p>\n For a more detailed explanation of this paradox and how to fix it, see this post<\/a>. (@Xenoprimate<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/nullable-paradox.md<\/a><\/p>\n This common mistake is really one of omission. It can result in user problems with no indication of what went wrong. Consider the case of a user registration functionality with unlogged exceptions. In this case, if registration fails, our log stays empty.<\/p>\n Of course, the fix for this error is to add logging to the try-catch block. To see the full tutorial, click here<\/a>. (@codeproject<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/eating-exceptions.md<\/a><\/p>\n Contention happens when two or more threads try to access the same resource at the same time. They contend<\/em> for the resource. This situation causes several\u00a0issues.<\/p>\n Even when we use thread-safe coding, contention can still add overhead. For example, when we use the lock<\/em> keyword, we force some threads to wait while one thread accesses a scope.<\/p>\n The following multi-threaded code actually works worse than a single-threaded version would, because it creates a lot more overhead while some threads wait.<\/p>\n The solution to this is to split the work into equal chunks before it\u2019s processed. Then, let each thread perform a local count before it updates the global one. To see how that works, take a look at this article<\/a>. (@Xenoprimate<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/unnecessary-contention-in-multithreading.md<\/a><\/p>\n Using old, outdated cryptographic algorithms is one of the most easily avoided errors. Algorithms like TripleDES, SHA1, and RIPEMD160 can\u2019t deliver the level of security that their more modern counterparts can.<\/p>\n To avoid the CA5350 CheckID, use stronger algorithms.<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/using-weak-cryptography.md<\/a><\/p>\n In .NET, using the right collection type can save time and avoid errors. Below is a list of the most commonly used C# collections.<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/Not-using-the-correct-collection-type-depending-on-the-situation.mdown<\/a><\/p>\n This common mistake\u00a0happens when we create an event handler that handles events occurring in an object, but we don\u2019t clear the link when we\u2019ve finished. This oversight can leave behind an unwanted strong reference.<\/p>\n In the code below, we subscribe to an OnPlaced<\/em> event in our Order<\/em> class, and the following code executes on a button click:<\/p>\n When the OrderPlaced<\/em> method is called, the following code executes:<\/p>\n However, a reference to the Order<\/em> object is still held by the OrderPlaced<\/em> event handler. The Order<\/em> object is therefore kept alive, even though we removed it from the collection. For more information on this, see:<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/unregistered-events.md<\/a><\/p>\n This WCF error happens when we fail to keep both getter<\/em> and setter<\/em> in our code when using the ReadOnly shorthand property declaration with the DataMember<\/em> attribute. Without the setter<\/em> part, we\u2019ll get an error.<\/p>\n We can circumvent this problem by setting a block with empty brackets, as shown in this article<\/a>. (@codeproject<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/readonly-shorthand-property-declaration-in-wcf.md<\/a><\/p>\n When we use WCF with Visual Studio, we can run into\u00a0a problem that comes from default configurations.<\/p>\n The code above doesn\u2019t specify a <services> section. It therefore adds a set of default endpoints to your service. This can result in the use of an incorrect service name. To fix this situation, we\u2019ll need to manually change the name of our service in the configuration file. See this tutorial<\/a> for more. (@msdev<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/mistyping-the-wf-wcf-service-configuration-name.md<\/a><\/p>\n We can run into several WCF errors when we modify the SMSvcHost.exe.config file improperly. The sample settings for the file are shown below:<\/p>\n Some common problems that arise from modifying the file include:<\/p>\n For steps to avoid making these common mistakes, see this blog post<\/a> from Microsoft. (@msdev<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/modifying-smsvchost-exe-config.md<\/a><\/p>\n Tracing is a very useful .NET debugging tool. It\u2019s also an excellent way for a hacker to access your system if it\u2019s left in place in a production environment. Don\u2019t fall into the trap shown below:<\/p>\n In the configuration above, any user can access a detailed list of all recent requests to the app. How? By browsing the page \u201ctrace.axd.\u201d The trace log provides a plethora of useful information to the hacker.<\/p>\n The best way to prevent hacks through tracing data is to disable tracing. Do this by setting \u201cenabled\u201d to \u201cfalse\u201d for the <trace> element. For more info, see this tutorial<\/a>. (@dotnetstories<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/leaving-tracing-enabled-in-web-Based-applications.md<\/a><\/p>\n Disabling custom errors in .NET gives clients detailed error messages by default.<\/p>\n With the above configuration, hackers get good information about the source of errors that can help them learn to pick our coding locks. Default ASP.NET error messages show our ASP.NET version and framework, plus the exception type.<\/p>\n To fix the problem:<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/custom-errors-disabled.md<\/a><\/p>\n WPF has several data binding options. If we break them, they can cause memory leaks within our applications. For example, look at the class shown below:<\/p>\n With the example above, in certain cases, WPF will create a runtime leak by creating a reference to the System.Component.Model.PropertyDescriptor class. When this happens, runtime doesn\u2019t know when to deallocate the reference. Therefore, our source object remains in memory.<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/binding-leak.md<\/a><\/p>\n XRSF tokens protect against cross-site request forgeries. We need to use them any time the browser can authenticate the user implicitly. That includes automatic authentication with cookies, or apps using Windows authentication.<\/p>\n The code below passes an XSRF token to the client, avoiding this egregious mistake.<\/p>\n Read the full tutorial on this here<\/a>. (@OdeToCode<\/a>)<\/p>\n https:\/\/github.com\/paologutierrez\/.net50\/blob\/master\/not-protecting-clients-with-xsrf-tokens.md<\/a><\/p>\n A DispatcherTimer leak is an error where improper use of the DispatcherTimer causes a memory leak.<\/p>\n In the example below, the count<\/em> variable gets updated once per second by the DispatcherTimer. The reference is held by the Dispatcher, which keeps each UserControl alive, causing a memory leak.<\/p>\n Fixing this is easy. Just stop the timer<\/a> and set it to null. (@Simple_Talk<\/a>)<\/p>\n1. NullReferenceException<\/h2>\n
string foo = null;\nfoo.ToUpper();\n<\/pre>\n
\n
2. DivideByZeroException<\/h2>\n
try\n{\nint x = SomeService.Calculate();\nint y = 10 \/ x;\n}\ncatch (DivideByZeroException ex)\n{\n\/\/TODO: Write code that should run when x is 0\n}\n<\/pre>\n\n
3. Broken Data Bindings in WPF<\/h2>\n
\n<Window x:Class=\"WpfApplication1.MainWindow\"\n xmlns=\"http:\/\/schemas.microsoft.com\/winfx\/2006\/xaml\/presentation\"\n xmlns:x=\"http:\/\/schemas.microsoft.com\/winfx\/2006\/xaml\"\n Title=\"MainWindow\" Height=\"350\" Width=\"525\">\n <Grid>\n <TextBlock Text=\"{Binding ThereIsNoDataContext}\"\/>\n <\/Grid>\n<\/Window>\n\nWe can fix this by enabling tracing to the output window to reveal any problems:<\/span>\n<\/pre>\n \n <Window x:Class=\"WpfApplication1.MainWindow\"\n xmlns=\"http:\/\/schemas.microsoft.com\/winfx\/2006\/xaml\/presentation\"\n xmlns:x=\"http:\/\/schemas.microsoft.com\/winfx\/2006\/xaml\"\nxmlns:diag=\"clr-namespace:System.Diagnostics;assembly=WindowsBase\"\n Title=\"MainWindow\" Height=\"350\" Width=\"525\">\n <Grid>\n <TextBlock Text=\"{Binding ThereIsNoDataContext,\ndiag:PresentationTraceSources.TraceLevel=High}\" \/>\n <\/Grid>\n<\/Window>\n<\/pre>\n\n
4. Using a Reference Like a Value or Vice Versa<\/h2>\n
Point point1 = new Point(20, 30);\nPoint point2 = point1;\npoint2.X = 50;\nConsole.WriteLine(point1.X); \/\/ 20 (does this surprise you?)\nConsole.WriteLine(point2.X); \/\/ 50\n \nPen pen1 = new Pen(Color.Black);\nPen pen2 = pen1;\npen2.Color = Color.Blue;\nConsole.WriteLine(pen1.Color); \/\/ Blue (or does this surprise you?)\nConsole.WriteLine(pen2.Color); \/\/ Blue\n\n<\/pre>\n
5. Letting Compiler Warnings Accumulate<\/h2>\n
class Account {\n \n int myId;\n int Id; \/\/ compiler warned you about this, but you didn\u2019t listen!\n \n \/\/ Constructor\n Account(int id) {\n this.myId = Id; \/\/ OOPS!\n }\n \n }\n\n<\/pre>\n6. Losing Scope Before Disposing an Object<\/h2>\n
\n
public SerialPort OpenPort1(string portName)\n{\n SerialPort port = new SerialPort(portName);\n port.Open(); \/\/CA2000 fires because this might throw\n SomeMethod(); \/\/Other method operations can fail\n return port;\n}\n\npublic SerialPort OpenPort2(string portName)\n{\n SerialPort tempPort = null;\n SerialPort port = null;\n try\n {\n tempPort = new SerialPort(portName);\n tempPort.Open();\n SomeMethod();\n \/\/Add any other methods above this line\n port = tempPort;\n tempPort = null;\n \n }\n finally\n {\n if (tempPort != null)\n {\n tempPort.Close();\n }\n }\n return port;\n}\n\n<\/pre>\n7. Redundant Nested Exception Handling<\/h3>\n
public class NestedExceptionHandling\n {\n public void MainMethod()\n {\n try\n {\n \/\/some implementation\n ChildMethod1();\n }\n catch (Exception exception)\n {\n \/\/Handle exception\n }\n }\n \n private void ChildMethod1()\n {\n try\n {\n \/\/some implementation\n ChildMethod2();\n }\n catch (Exception exception)\n {\n \/\/Handle exception\n \t throw;\n \n }\n }\n \n private void ChildMethod2()\n {\n try\n {\n \/\/some implementation\n }\n catch (Exception exception)\n {\n \/\/Handle exception\n throw;\n }\n }\n }\n\n<\/pre>\n8. Deferred Execution in LINQ<\/h3>\n
public IEnumerable GetCustomers()\n\t{\n\t\tusing(var context = new DBContext())\n\t\t{\n\t\t\treturn from c in context.Customers\n\t\t\t where c.Balance > 2000\n\t\t\t select c;\n\t\t}\n\t}\n\n<\/pre>\n9. Iterating with Values Instead of with LINQ<\/h3>\n
foreach (Customer customer in CustomerList) {\n if (customer.State == \"FL\") {\n tax += customer.Balance;\n }\n }\n\n<\/pre>\n10. Accessing Virtual Members within a Constructor<\/h3>\n
public class Parent\n{\n public Parent()\n {\n Console.WriteLine(\"Parent Ctor\");\n Method();\n }\n\n public virtual void Method()\n {\n Console.WriteLine(\"Parent method\");\n }\n}\n\npublic class Child : Parent\n{\n public Child()\n {\n Console.WriteLine(\"Child Ctor\");\n }\n\n public override void Method()\n {\n Console.WriteLine(\"Child method\");\n }\n}\n\n<\/pre>\n\n
11. Logic Errors<\/h3>\n
private void button1_Click(object, sender, EventArgs e)\n{\n int startLoop = 11;\n int endLoop = 1;\n int answer = 0;\n \n for (int i = startLoop; i < endLoop; i++)\n {\n answer = answer + i;\n }\n \n MessageBox.Show(\"answer =\" + answer.ToString());\n}\n\n<\/pre>\n\n
12. Mixing Strings and Numbers with +<\/h3>\n
static void Main(string[] args) {\n\n int x = 4;\n string y = \"12\";\n\n Console.WriteLine(string.Format(\"{0}\", x + y)); \/\/ 412\n\n Console.ReadKey();\n}\n\n<\/pre>\n\n
13. Forgetting Strings Are Immutable<\/h3>\n
string = \"Take this out\";\ns.Replace(\"this\", \"that\"); \/\/wrong\n\ns = s.Replace(\"this\", \"that\"); \/\/correct\n\n<\/pre>\n
14. Incorrect Granularity<\/h3>\n
private static List wordList;\nprivate static List curseWords;\nprivate static int currentWordIndex;\nprivate static Dictionary<string, int> wordCountDict;\n\npublic static void CalculateWordCounts() {\n\twordList = GetWordList();\n\tcurseWords = GetCurseWords();\n\tcurrentWordIndex = 0;\n\twordCountDict = new Dictionary<string, int>();\n\n\tThread threadA = new Thread(ThreadDoWork);\n\tThread threadB = new Thread(ThreadDoWork);\n\tThread threadC = new Thread(ThreadDoWork);\n\tThread threadD = new Thread(ThreadDoWork);\n\tthreadA.Start();\n\tthreadB.Start();\n\tthreadC.Start();\n\tthreadD.Start();\n\tthreadA.Join();\n\tthreadB.Join();\n\tthreadC.Join();\n\tthreadD.Join();\n}\n\nprivate static void ThreadDoWork() {\n\tbool atLeastOneWordRemaining;\n\tint thisWordIndex = currentWordIndex;\n\tcurrentWordIndex = currentWordIndex + 1;\n\tif (thisWordIndex >= wordList.Count) atLeastOneWordRemaining = false;\n\telse atLeastOneWordRemaining = true;\n\n\twhile (atLeastOneWordRemaining) {\n\t\tstring thisWord = wordList[thisWordIndex];\n\t\tbool firstOccurrenceOfWord = !wordCountDict.ContainsKey(thisWord);\n\n\t\tif (curseWords.Contains(thisWord)) Console.WriteLine(\"Curse word detected!\");\n\t\tif (firstOccurrenceOfWord) wordCountDict.Add(thisWord, 1);\n\t\telse wordCountDict[thisWord] = wordCountDict[thisWord] + 1;\n\n\t\tthisWordIndex = currentWordIndex;\n\t\tcurrentWordIndex = currentWordIndex + 1;\n\t\tif (thisWordIndex >= wordList.Count) atLeastOneWordRemaining = false;\n\t}\n}\n\n<\/pre>\n\n
15. Unhandled Exogenous Exceptions<\/h3>\n
try \n{ \n using ( File f = OpenFile(filename, ForReading) ) \n {\n \/\/ Blah blah blah \n } \n} \ncatch (FileNotFoundException) \n{ \n \/\/ Handle file not found \n}\n\n<\/pre>\n16. Protection Level Conflicts<\/h3>\n
class MyFirstClass \/\/default protection = internal\n{\n public void NameFunction() {\n MySecondClass sc = new MySecondClass();\n sc.strFirstName = \"Harry\";\n sc.strLastName = \"Potter\";\n Console.WriteLine(\"Name: \" + sc.FirstName + \" \" + sc.strLastName);\n }\n}\n\npublic class MySecondClass\n{\n string strFirstName = \"Roy\";\n string strLastName = \"Weasley\"; \/\/default protection = private\n}\n\n<\/pre>\n17. StackOverflowException<\/h3>\n
class Program\n{\n private static int hitCount;\n\n static void Main(string[] args)\n {\n hitCount = 0;\n MyRecursiveExample(null);\n }\n\n static void MyRecursiveExample(string value)\n {\n hitCount++;\n\n if (value == null)\n {\n MyRecursiveExample(value);\n }\n else\n {\n System.Console.WriteLine(value);\n }\n }\n}\n<\/pre>\n18. Busy-Wait and Thread.Sleep<\/h3>\n
private static string userInput;\n\nprivate static void Example() {\n\tuserInput = null;\n\tGetUserInput(); \/\/ tells the UI to request user input on the UI thread\n\t\n\twhile (userInput == null) ; \/\/ wait for user input\n\t\n\tProcessUserInput(userInput); \/\/ now use that input\n}\n<\/pre>\n\n
19. Handling Non-Exogenous Exceptions<\/h3>\n
string val = null;\n int value = int.Parse(str); \/\/Will throw ArgumentNullException\n\n string val = \"100.11\";\n int value = int.Parse(val); \/\/Will throw FormatException\n\n string val = \"999999999999999999999999999999999999999999\";\n int value = int.Parse(val); \/\/Will throw OverflowException\u203a\u203a\n\n<\/pre>\n
\n
20. Unsafe Assumptions in Multithreading<\/h3>\n
private const int NUM_ITERATIONS = 20000;\nprivate const decimal DENOMINATOR = 200m;\nprivate const decimal MAX_POSSIBLE_VALUE = NUM_ITERATIONS \/ DENOMINATOR;\n\nprivate static decimal sharedState;\npublic static decimal SharedState {\n\tget {\n\t\treturn sharedState;\n\t}\n\tset {\n\t\tsharedState = value;\n\t}\n}\n\nstatic void Main(string[] args) {\n\tThread writerThread = new Thread(WriterThreadEntry);\n\tThread readerThread = new Thread(ReaderThreadEntry);\n\n\twriterThread.Start();\n\treaderThread.Start();\n\n\twriterThread.Join();\n\treaderThread.Join();\n\n\tConsole.ReadKey();\n}\n\nprivate static void WriterThreadEntry() {\n\tfor (int i = 0; i < NUM_ITERATIONS; ++i) {\n\t\tSharedState = i \/ DENOMINATOR;\n\t}\n}\n\nprivate static void ReaderThreadEntry() {\n\tfor (int i = 0; i < NUM_ITERATIONS; ++i) { var sharedStateLocal = SharedState; if (sharedStateLocal > MAX_POSSIBLE_VALUE) Console.WriteLine(\"Impossible value detected: \" + sharedStateLocal);\n\t}\n}\n\n<\/pre>\n\n
21. The Nullable Paradox<\/h3>\n
private static void DoTestA() {\n int? maybeInt = null;\n for (int i = 0; i < 100000; ++i) {\n DoSomething(maybeInt);\n }\n}\n \nprivate static void DoTestB() {\n int? maybeInt = 3;\n for (int i = 0; i < 100000; ++i) {\n DoSomething(maybeInt);\n }\n}\n \nprivate static void DoSomething(object o) {\n \/\/ Do something...\n}\n\n<\/pre>\nPrivate static void DoSomething<T>(T o) {\n\n\/\/ Do something...\n\n}\n\n<\/pre>\n22. Failure to Log Exceptions<\/h3>\n
public class UserService\n{\n private readonly IMessagingService _messagingService;\n public UserService(IMessagingService messagingService)\n {\n _messagingService = messagingService;\n }\n\n public bool RegisterUser(string login, string emailAddress, string password)\n {\n \/\/ insert user to the database\n\n \/\/ generate an activation code to send via email\n\n \/\/ save activation code to the database\n\n \/\/ create an email message object\n try\n {\n _messagingService.SendRegistrationEmailMessage(message);\n }\n catch (Exception)\n {\n \/\/ boom!\n }\n return true;\n\n }\n}\n\n<\/pre>\n23. Unnecessary Contention in Multithreading<\/h3>\n
private static List wordList;\nprivate static List curseWords;\nprivate static int currentWordIndex;\nprivate static Dictionary<string, int> wordCountDict;\nprivate static readonly object wordCountCalculatorSyncObj = new object();\n\npublic static void CalculateWordCounts() {\n\twordList = GetWordList();\n\tcurseWords = GetCurseWords();\n\tcurrentWordIndex = 0;\n\twordCountDict = new Dictionary<string, int>();\n\n\tThread threadA = new Thread(ThreadDoWork);\n\tThread threadB = new Thread(ThreadDoWork);\n\tThread threadC = new Thread(ThreadDoWork);\n\tThread threadD = new Thread(ThreadDoWork);\n\tthreadA.Start();\n\tthreadB.Start();\n\tthreadC.Start();\n\tthreadD.Start();\n\tthreadA.Join();\n\tthreadB.Join();\n\tthreadC.Join();\n\tthreadD.Join();\n}\n\nprivate static void ThreadDoWork() {\n\tbool atLeastOneWordRemaining;\n\tint thisWordIndex;\n\tlock (wordCountCalculatorSyncObj) {\n\t\tthisWordIndex = currentWordIndex;\n\t\tcurrentWordIndex = currentWordIndex + 1;\n\t}\n\tif (thisWordIndex >= wordList.Count) atLeastOneWordRemaining = false;\n\telse atLeastOneWordRemaining = true;\n\n\twhile (atLeastOneWordRemaining) {\n\t\tstring thisWord = wordList[thisWordIndex]\n\t\t\t.ToUpper()\n\t\t\t.Replace(\"-\", String.Empty)\n\t\t\t.Replace(\"'\", String.Empty)\n\t\t\t.Trim();\n\n\t\tif (curseWords.Contains(thisWord)) Console.WriteLine(\"Curse word detected!\");\n\n\t\tlock (wordCountCalculatorSyncObj) {\n\t\t\tbool firstOccurrenceOfWord = !wordCountDict.ContainsKey(thisWord);\n\t\t\n\t\t\tif (firstOccurrenceOfWord) wordCountDict.Add(thisWord, 1);\n\t\t\telse wordCountDict[thisWord] = wordCountDict[thisWord] + 1;\n\t\t\tthisWordIndex = currentWordIndex;\n\t\t\tcurrentWordIndex = currentWordIndex + 1;\n\t\t}\n\t\tif (thisWordIndex >= wordList.Count) atLeastOneWordRemaining = false;\n\t}\n}\n\n<\/pre>\n24. Using Weak Cryptographic Algorithms<\/h3>\n
using System.Security.Cryptography; \n... \nvar hashAlg = SHA1.Create(); \n\n<\/pre>\n
\n
25. Using the Wrong Collection Type<\/h3>\n
var list = new List();\n\n var dictionary = new Dictionary<int, Customer>();\n\n var hashSet = new HashSet();\n\n var stack = new Stack();\n\n var queue = new Queue();\n\n<\/pre>\n
\n
26. Unregistered Events<\/h3>\n
Order newOrder=new Order\n(\u201cEURUSD\u201d, DealType.Buy, Price ,PriceTolerance, TakeProfit, StopLoss);\n\nnewOrder.OnPlaced+=OrderPlaced;\nm_PendingDeals.Add(newOrder);\n\n<\/pre>\n
Void OrderPlace(Order pladedOrder)\n\n{\n\nm_PendingDeals.Remove(placedOrder);\n\n}\n\n<\/pre>\n\n
27. Readonly Shorthand Property Declaration<\/h3>\n
\/\/Data Contract attribute applied to class to make it available to client.\n\n\/\/Data Member attribute applied to the 'MyVar' readonly property.\n\n [DataContract]\n public class MyValueObject\n {\n [DataMember]\n public int MyVar\n {\n get;\n \/\/This will not work, as WCF needs both getter and setter to access property.\n\n }\n } \n\n \/\/Correct version with both getters and setter defined.\n\n [DataContract]\n public class MyValueObject\n {\n [DataMember]\n public int MyVar\n {\n get; \n set {}\n \/\/Empty setter block is supplied for readonly property. \n\n }\n }\n\n<\/pre>\n28. Mistyping the WF\/WCF Service Configuration Name<\/h3>\n
<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<configuration>\n<system.serviceModel>\n<behaviors>\n<serviceBehaviors>\n<behavior>\n<serviceMetadata httpGetEnabled=\"true\"\/>\n<serviceDebug includeExceptionDetailInFaults=\"false\"\/>\n<\/behavior>\n<\/serviceBehaviors>\n<\/behaviors>\n<\/system.serviceModel>\n<\/configuration>\n<\/pre>\n
29. Modifying SMSvcHost.exe.config for WCF<\/h3>\n
<net.tcp listenBacklog=\u201d10? maxPendingConnections=\u201d100? maxPendingAccepts=\u201d2? receiveTimeout=\u201d00:00:10? teredoEnabled=\u201dfalse\u201d>\n<allowAccounts>\n\/\/ LocalSystem account\n<add securityIdentifier=\u201dS-1-5-18?\/>\n\n\/\/ LocalService account\n<add securityIdentifier=\u201dS-1-5-19?\/>\n\n\/\/ Administrators account\n<add securityIdentifier=\u201dS-1-5-20?\/>\n\n\/\/ Network Service account\n<add securityIdentifier=\u201dS-1-5-32-544? \/>\n\n\/\/ IIS_IUSRS account (Vista only)\n<add securityIdentifier=\u201dS-1-5-32-568?\/>\n<\/allowAccounts>\n<\/net.tcp>\n<\/pre>\n
\n
30. Leaving Tracing Enabled in Web-Based Applications<\/h3>\n
<configuration>\n\n<system.web>\n\n<trace enabled=\"true\" localOnly=\"false\">\n<\/pre>\n
31. Custom Errors Disabled<\/h3>\n
<configuration>\n<system.web>\n<customErrors mode=\u201dOff\u201c>\n<\/pre>\n
\n
32. Binding Leak<\/h3>\n
class Person\n{\n public Person(string name)\n {\n Name = name\n }\n \n public string Name {get; set;}\n}\n\n<\/pre>\n\n
33. Forgetting to an XSRF Token to the Client<\/h3>\n
[Route(\"api\/[controller]\")]\npublic class XsrfTokenController : Controller\n{\n private readonly IAntiforgery _antiforgery;\n \n public XsrfTokenController(IAntiforgery antiforgery)\n {\n _antiforgery = antiforgery;\n }\n \n [HttpGet]\n public IActionResult Get()\n {\n var tokens = _antiforgery.GetAndStoreTokens(HttpContext);\n \n return new ObjectResult(new {\n token = tokens.RequestToken,\n tokenName = tokens.HeaderName\n });\n }\n}\n\n<\/pre>\n34. DispatcherTimer Leak<\/h3>\n
public byte[] myMemory = new byte[50 * 1024 * 1024];\n\nSystem.Windows.Threading.DispatcherTimer _timer = new System.Windows.Threading.DispatcherTimer();\nint count = 0;\n\n\nprivate void MyLabel_Loaded(object sender, RoutedEventArgs e)\n{\n\n _timer.Interval = TimeSpan.FromMilliseconds(1000);\n\n _timer.Tick += new EventHandler(delegate(object s, EventArgs ev)\n\n {\n count++;\n textBox1.Text = count.ToString();\n });\n\n _timer.Start();\n}\n\n<\/pre>\n_timer.Stop();\n\n_timer=null;\n\n<\/pre>\n