.NET best practices? [closed]

Answer 1

• I find this tip very useful: Setting deployment retail="true" in the system.web tag in the web.config will force the debug flag to be "false". It will also force the custom error message page for the users and disable page output tracing. This is useful when the application is going to a production enviroment.

• Test Driven .Net is an excellent tool to run NUnit test inside Visual Studio.

Answer 2

These aren't really .NET specific, but more general design:

One that immediately springs to mind (because I've seen this today and been ranting about it, and seen too many times before) is wrapping code with conditional checks for broken invariants, in order to avoid exceptions.

So, you end up with a system where some feature isn't working and you have no idea why this is the case, and have zero information on the original cause.

A great example I saw this week was one of our engineers had null reference checks around member variables which the UI framework (WPF) was responsible for assigning. These checks then avoided performing operations which would result in a null ref exception. So, in the event of this (catastrophic error) we have disabled functionality, a confused user and a pissed of support team.

So, fail fast, fail obviously (if possible) and record as much information as possible.

Another one of my favorite guiding principles is to minimize mutability. Where possible I prefer to design immutable classes. Immutability is becoming more fashionable now because of the multicore issue and the need to design for concurrency. I started using it though quite a while back having needed to simplify a system with complex graphs of shared state. I modelled the system on similar ideas to .NET's String and StringBuilder (it's sometimes handy to have a builder class to build up an immutable object particularly if it's fairly complex).

This was in fact my second version of this particular component. What I found was that designing to minimize mutability, and implementing immutable classes massively simplified the code base.

I've found that very few engineers consider this factor even when designing concurrent systems, and often end up with masses of extremely complex fragile code. I'm usually impressed in a way that they can get it to work! But, personally to me really good code should look simple.

Regards, Phil

Answer 3

An interesting exercise is to run your code through a static analysis tool such as FxCop. It will bring up dozens of tips. Some may be appropriate for your application, some not. E.g. Internationalisation.

Answer 4

Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (2nd Edition) by Cwalina and Abrams explains the reasoning behind the FxCop rules, and much more. Not all of these may apply to your project, but you'll learn many best practices by reading this book. I refer to it often.

Answer 5

First, check out patterns & practices - "Use Microsoft's proven practices for software engineering.".

Next check out IDesign: .NET Design and Process Solutions.

After you dig through those to get some ideas make sure to enable code analysis/FxCop on your code base. Start thoroughly going through each warning.

Last, but not least, go check out JetBrains' software and GET ReSharper. ReSharper (or similar tool, some are available out there) is a must have if you want to be 100% efficient and ensure you code to a high standard with a minimal amount of headache! :)

That will get you 99% covered on standards and best practices.

Answer 6

I find people who ask what are the best practices for X, often need to stop and learn to think rather than just getting a magical list from someone. There is no magical list of 5 or 6 items, but rather many times a lot is common sense. Think about what you are attempting to achieve and how this code is executed in your environment.

Personally asking this sort of Q is an instant stop sign for me, because it shows the person has not tried to think for themselves and most likely never will. The most significant attribute in development work is the ability to problem solve and think a task logically. Learning syntax, libraries is just an exercise its not the be all and end all. Any developer can look at a new API and providing its not utter rubbish understand with some trial and error how it works.

Development is not a robotic task that one just follows a list, each and every class/component/insert building block here is different and requires thought and sensibleness.