Here’s what I figured out. On my site, I want to disable a button once it is clicked to prevent multiple posts. So I disable the button on the click utilizing jQuery. However when I do this, the postback occurs but the control that triggered the postback is lost on the server. The server-side code handling that button click does not fire at all. When I check Page.IsPostBackEventControlRegistered, it returns false.

When I attempt to just hide the control on click, the postback details are not lost. However, I would prefer not to do this since it results in layout jitter. Adding in a faux-button span or something like that is possible, but a bit hokey. Disabling the button on click is the most straightforward method to prevent multiple postbacks from the client. I haven’t checked if this issue is caused by jQuery though I doubt it, and think that simply disabling the button in JavaScript is the issue.

Anyone have a similar issue with button disabling?

Maintainability Index

Is a summary measure of the other items in VS’s Code Metrics. The higher the number the better. I’ve read that you want to put some work into any code getting a score of 65 and lower to 80 and lower. Interestingly enough the worst “maintainability” components in my solutions are the auto-generated code for Windows Forms.

Cyclomatic Complexity

This measures how many “paths” your code contains. If you have a simple program with no conditions and no looping, you would have a CC of 1. The algorithm for determining complexity involves creating a node-based diagram and counting pathways and nodes. It can be also be determined by simply counting up each “if”, “else”, “for”, “while”, and “case” in a routine and adding 1. Generally for each member of a class you do not want complexity to exceed 10 or possibly 15. If you get extremely high complexity numbers you can see why you might want to check out that particular method, as it is probably not as easy to understand and maintain as other code.

Lowering the complexity of code involves refactoring. You may be doing several tasks in a single routine that you want to abstract out to another process. This would create another method in your code, but will allow for increased readibility and maintainability.

Depth of Inheritance

In .NET this is basically how many degrees the class lies away from it’s most basic ancestor class. For most classes this will be relative to System.Object. Interfaces can receive a DOI of 0.

Class Coupling

This is the number of classes the particular class in question is dependant on. The less dependency the less liable the code is to breaking.

Conclusion

There is also “lines of code” which is fairly self explanatory. In conclusion there is a healthy amount of criticism against code metrics – since it is an objective measure of code. However, if used with context in mind, I think these metrics can definitely help you find highly complex and unmaintainable chunks of code.

//QUERYSTRING
document.queryStringValues = new Array()
document.queryString = function(key){
	var itemValue

	if(document.queryStringValues.length == 0){
                var i, itemKey, itemPair

		//load querystring
		var strSearch = location.search.substring(1, location.search.length)
		var qsItems = strSearch.split('&')

		//set length
		document.queryStringValues.length = qsItems.length

		for(i = 0; i < qsItems.length; i++){
			itemPair = qsItems[i].split('=')
			itemKey = itemPair[0]
			if(itemPair.length == 2){
				itemValue = itemPair[1]
				document.queryStringValues[itemKey] = itemValue
			}
			else{
				document.queryStringValues[itemKey] = null
			}
		}
	}

	itemValue = document.queryStringValues[key]

	return itemValue
}

The code creates a queryStringValues array under “document” to hold the values of the querystring – which is accessed by the key value. The actual functionality comes through calling “document.queryString(‘somekey’)”. This procedure checks to see if queryStringValues has been loaded. If not the array is loaded up. Then the code checks queryStringValues to find the value based on the key given. If the value is not found a null value is returned.

I allow the queryStringValues to be loaded only the first time the document.queryString so that if it’s unneeded no extra processing/memory is used up. I could add onto this code by adding a variable called “hasLoaded” to the queryStringValues array, so that if the URL querystring has no values, the array will not keep trying to load everytime the procedure is called.

In the end, you have an easy way to retrieve queryString members by calling something like this:

var userName = document.queryString('username')

The “core” file starts with a pseudo-namespace creation – the namespace being “core”:

core = new Object()

The trim function allows you to strip leading or following whitespace from a string. It’s often found in most programming languages. I find myself using it almost always when manipulating strings in compiled code.

core.trim = function(text){
	return text.replace(/^\s*(\S*(\s+\S+)*)\s*$/, "$1");
}
String.prototype.trim = function(){
	return core.trim(this)
}

The first block defines a standalone trim function. Using regular expressions it replaces out whitespace characters. We can expand upon the native String object to add-on a trim function. This ability to add-on methods to native objects really shows some of flexibility and power of javascript. This allows us to modify the String object so that any string that is created heretofore has the trim() method available to it.

You can now take an input from a textbox and trim any outside whitespace like so:

var firstName = document.getElementById('txtFirstName').value
document.write(firstName.trim())

This simplifies trimming across the board for all strings.

As much as we call it computer science – and there is much science to it – programming shares much with poetry – and I mean that literally, not in a fancy poetic way. Both have a (generally) limited set of words to use. You put all those words (or keywords) together to produce a larger meaning. The devil is in the details. As a perfectionistic lyricist it’s easy to generally convey an idea, but I would often tweak each word of a line until I felt they expressed exactly what I desired. The same occurs with code – where the same function can be coded thousands of different ways – yet we each strive for our own “perfect” permutation of code.

In my short coding experience – this has led me to the conclusion that coding is in many ways an art form. And I thoroughly enjoy that. It’s not just functionality. It’s creativity. Increasing vocubulary (keywords) and really understanding the grammar (syntax) of the coding language will not just allow for more efficient code, but more beautiful code. In many ways efficiency and beauty work together in code. When you come across a succinct powerful set of code – it’s pleasing to the eye; not to mention how an application that “just works” is pleasing to users.

You may this is a load of bull, that’s ok. It is a bit cheesy. Still I think everyone takes value in creating something pleasing. Create something beautiful with your code.

You’re still here? I guess I should get started then..

1 Be a Thoughtful Programmer
Yes. Thoughtful. As in, bring your wife roses on your anniversary. Hold the elevator for others. Don’t hog the ball when playing hoops. That kind of thoughtful. When you code, you can’t code for yourself. Even if you’re tasked an assignment that only you will work on. One day, even if it’s years from now, someone else will most likely have to look at your code. This isn’t just some flowery hippie talk. If you take other people’s views into mind, you will become a better programmer.

In English class we called this “Audience-Centered Writing”. Writing while taking the readers point of view. You take into consideration how your program is structured. Does it make sense to someone else looking at it? You examine how you name your variables. What name would most easily make sense to the most people? You take into consideration if your code produces massive amounts of warnings in the compiler. Maybe I don’t want other programmers bogged down with my warnings? And so on. If you follow this simple rule, your code will most likely be cleaner, more organized, and hopefully more efficient. “Audience-Centered Writing”. It actually makes sense when writing code too.

For the sake of all that’s good in the world, COMMENT. Frankly, if you don’t comment your code, you’re being a jerk. I don’t mean over-comment, I mean if you have 2 comments for 10,000 lines of code, I will not like you (and neither will your coworkers).

2 Be Humble
There are a thousand ways to code the simplest action. When you code something, know that it can be better. If you’re that cocky, just pretend. Pretend that maybe you aren’t the world’s greatest programmer. How can this code be more efficient? How can it be more readable? This leads to coding and re-coding. Each revision should make your code better. On the other end, be a perfectionist within reason. Be an artist. Know that you want the code to be really good. But not perfect. Because there is so much flexibility in coding even the smallest tasks – it is more like an art, not a mathematical formula. Make it beautiful and move on.

Related to this is following best practices. Believe it or not, you probably don’t know more about the .NET framework than the people that created it. I know some of you really hate that idea. But it’s a whole freakin’ team of highly-paid highly-experienced doctorates. Trust me, I had a class with a professor who was actually helping to form .NET back in the day. He was a smart guy. And he worked with a bunch of smart guys. Follow their advice. If you’re a .NET programmer, it might be a good idea to follow the Best Practice guides that Microsoft publishes. If nothing else, at least your code will be more readible since more people follow Microsoft’s Best Practices than Joe Schmoe Programmers best practices.

If you’re doing JavaScript work, there are tons of articles on best practices online. There are differing points on specifics (including some bad advice), but try to find where there is consensus and (hopefully) that should be a good starting point.

3 Know your Stuff
The subtitle for this should be “good programming practice over hyped-up new stuff”. Before you read up on YUI, read up on CSS. Before you read up on Entity Framework learn how to use inheritance. Sounds simple but in my experience the exact opposite occurs. What makes for a good coder is not knowing the latest in WPF, WCF, and whatever other fancy new acronym you can think of. Good programming is all about fundamentals. Is your code organized? Is your logic sound? Do you have a firm grasp of the language essentials? It amazes me how many .NET Developers talk about Workflow, but don’t know the first thing about the CollectionBase class or coding interfaces. Similarly how a web developer can tout jQuery, yet still use tables for web page layout. Know your stuff. If you really want to be a good programmer, learn and utilize the fundamentals of what you are coding.

The other stuff – new technologies – should come easy after that. In fact you will have a deeper and much more mature understanding of newer technologies/API’s/etc if you understand the basics of your coding environment. Now I’m not saying I know all my stuff.. but I’m (hopefully) on the path to getting all that core knowledge down as well as gradually picking up on 3rd party libraries, fancy features, and the likes.

Conclusion
To sum it all up: know your fundamentals, include others’ point of view, and don’t be a jerk.

I’ve seen various pieces of code that attempts multi-threading; but fails because basic concepts are not understood. Or heard complaints that multi-threaded code “only runs when not in debug mode”; or that it “fails randomly for no reason”. This is because the debugger will usually not allow cross-thread interaction of form controls. And because when you force that to happen you will get intermittent errors. These explanations are explained further in the following paragraphs. Working with threads is an advanced and complex task – when not accounting for what is called “thread safety” a lot of things can go wrong.

The Apartment Model
The basic idea new multi-thread programmers should familiarize themselves with is the Apartment Model. This is how the .NET framework deals with objects and threads. The analogy is fairly simple. A thread represents an apartment (yes, the kind people live in). Any object created in that thread, lives inside that thread. Each object is unaware of what is happening in other threads.

Hence a particular thread, let’s call it ThisThread has created a ProgressBar object. You manually create another thread in code (let’s say it called OtherThread). OtherThread is tasked with running a long process and you want OtherThread to update the ProgressBar once a step in this process is complete. Bad idea. You cant just have some random stranger walking into someone else’s house and telling them what to do. Same goes here. Darn apartments.

The Dreaded Debugger Message
If you try it, you will most likely end up with this message in the debugger:

Cross-thread operation not valid:
Control 'ProgressBar1' accessed from a thread
other than the thread it was created on.

Uh oh. So how do we ever get that ProgressBar to update? We have to pass the information back to the normal application flow so that the thread that created the ProgressBar can update it. So the task at hand is actually inter-thread communication. Luckily the folks at Microsoft has created a component to ease this entire issue. Enter the BackgroundWorker. This component is available from .NET Framework version 2.0. I will be speaking from experience using it in .NET Framework 3.5 (Visual Studio 2008)

Introducing the BackgroundWorker
The BackgroundWorker is a Windows Form component, meaning it should show up in the toolbox. You can simply drag and drop it into your form to have the functionality of the BackgroundWorker for that form.

The BackgroundWorker has 3 events that can be handled just like you do for other Windows Forms objects. These events are “DoWork”, “ProgressChanged” and “RunWorkerCompleted”. DoWork defines exactly what code should execute in the background. ProgressChanged defines how to report progress that is passed to the BackgroundWorker (if WorkerReportsProgress = True). RunWorkerCompleted allows for the coder to clean up after the process is complete and also to check the outcome of the process (if it was successful, an error occurred, or was cancelled)

There are two key properties that you want to consider when you add a BackgroundWorker. First is “WorkerReportsProgress”; second is “WorkerSupportsCancellation”. If you want to update that ProgressBar after each step, you want to set this to true. Otherwise if you have a process, but don’t need step-by-step updates on progress, set this to false. If the Worker should be able to cancel midway through processing you should set “WorkerSupportsCancellation” to true.

I hope to go further into how to exactly utilize the BackgroundWorker and certain considerations you may want to weigh for whatever process is run by the BackgroundWorker in my next post.

So let’s say you have a 3-tiered application for a Cashier app with the following projects (each project representing a layer):

• CashierDataService (Data Access Layer code)
• CashierLogic (Logic/Business Object code)
• CashierForms (Presentation code)

The Data Access Layer project and the Logic layer project should each be a “Code Library” as its project type. The CashierForms should be a Windows Forms project. Now how do we get all the code connected together

You would build the CashierDataService. Once you have a DLL built from it, go into the CashierLogic project and add a reference to to the CashierDataService. You can do this by opening the Add Reference dialog box. From there go to the “Projects” tab, which should list all the projects in your solution.

Next you would do the same with CashierForms and CashierLogic. That is you would add a reference to CashierLogic inside the CashierForms projects.

General Guidelines
Note that I am not adding a reference to CashierDataService inside of CashierForms. The presentation layer should not directly interact with the Data Access Layer. The Logic (AKA Business or Business Object) layer serves as the middleman between these two layers (among other things). Thus, the actual structure of references enforces the seperation of responsibilities within n-tiered application design.

So in the end, the layers “build up” from each other. The DataAccessLayer serving as the foundation. The Business Logic layer on top of that. And finally the Presentation Layer as the pretty shell that surrounds all that code.

Some Final Thoughts
Now usually you will have more than 3 projects representing 3 layers. But the basic enforcement should be kept the same. The Presentation Layer only has references to Logic Layer. The Logic Layer has only references to the Data Access layer. Often I will have a common or shared project (named something like CashierCommon) that contains common code among all layers. I have to be vigilant to keep bloat down in this layer, since it should only be used as a last resort for (usually) common enumerators or simple logical functions.

I tend to use a lot of the basic interfaces here from IDisposable, IComparer, etc. If you are unfamiliar with interfaces, they are “implemented” by classes. Interfaces set required methods/properties for the implementing class to contain.

Also, for objects that contain collections of custom objects – I tend to use the CollectionBase class. A custom class can inherit from CollectionBase. From there you will probably need to create a few basic procedures such as “Add” and “Item”, along with any other functionality you need. Here’s the basic method signature for add:

Add(Item as MyClass)

I also overload the Add method to include one that utlizes the constructur (New()) of the item. If I had an Item that takes an ID and a Name, I would usually include an Add method like so:

Add(ID as Integer, Name as String)

From there I create a new instance of MyClass, and then add it to the CollectionBase’s “List” variable. You would also need a way to return items via an Index number like so:

Default Readonly Property Item(Index as Integer)

You can add, retrieve items with the underlying “List” variable – and if needed it’s underlying ArrayList, which is called “InnerList” by the CollectionBase.

This post assumes you know how to connect to, read, and update a database in .NET; and that you are somewhat familiar with basic object-oriented concepts such as inheritance and interfaces.To keep things simple, and for the purpose of introducing the concept of a Data Access layer this code omits certain things. For example – it does not deal with database transactions and it only specifies Dataset-based querying (ignores DataReaders). This represents how I like to create DAL’s, and is by no means the only way to do things. I hope to present some basic concepts and ideas along with some concrete code to those unfamiliar with DAL’s.

I initially create a skeleton class which all other classes are derived from. It utilizes a lot of interfaces. Instead of calling a SqlCommand or an OracleConnection – utilize IDbCommand and IDbConnection. This avoids calling specific implementations of DataAdapters and Connections for your child classes. We want to keep the base class as generic as possible, so utilize the various data-related interfaces to keep it as database-agnostic as possible. The base class provides 3 key methods (which will be overloaded) -

Execute – returns a dataset
ExecuteNonQuery – returns an integer indicating RowsAffected
ExecuteScalar – runs a scalar SQL statement and returns an object

Each should be marked “Protected”, so they can only be accessed by child classes and cannot be accessed by other VS Projects – we wouldn’t want non-DAL classes directly executing SQL. This would violate our separation of responsibilities for each application layer. Each of the above methods have 4 overloaded versions. One which passes only the SQL statement. One which passes SQL statement, and a ParamArray of IDbParameters. And versions of the preceding with a Connection object. Like so:

Execute(SQL as String) As Dataset
Execute(SQL as String, ParamArray params as IDbParameter()) As Dataset
Execute(SQL as String, Conn as IDbConnection)…
Execute(SQL as String, Conn as IDbConnection, ParamArray params as IDbParameter())…

This pattern is followed for “ExecuteScalar(…) As Object” and “ExecuteNonQuery(…) As Integer”. This allows for some flexibility in calling these functions. Those signatures with IDbConnection passed in allow the coder to re-use a connection if desired. Which brings us to “helper” functions within the class.

Public GetConnection – which returns an IDbConnection
Protected GetCommand(Command as string, Connection as IDbConnection) – returns an IDbCommand
Protected GetDataAdapter(cmd As IDbConnection) – returns an IDbDataAdapter
Protected GetParam(Name as string, Value as string) – which returns an IDbParameter

I only use method signatures matching the “most-used” initialization method signatures (New(…)) for each of these helper functions; feel free to create functions for whatever different initialization method signatures you want. GetConnection is marked private, so the logic layer can reuse an open connection if needed. When creating your main functions (Execute, ExecuteScalar, and ExecuteNonQuery), be sure to use only interfaces, and to retrieve database objects via the above helper classes.

Protected Function Execute(SQL as String, Conn as IDbConnection) As DataSet
  Dim ds As DataSet
  Dim da as IDbDataAdapter

  Using cmd As IDbCommand = GetCommand(SQL, Conn)
    da = GetAdapter(cmd)
    da.Fill(ds)
  End Using

  Return ds
End Function

Now you can create child classes which inherit from this base class and utilize a specific DBMS. You will only need to specifically detail the GetConnection, GetCommand, GetParam, and GetDataAdapter functions. Everything should “fall into place” from there, since we kept our other method calls vague (via Interfaces).

Finally, there are tools, such as nHibernate that take much of the menial work out of creating DAL’s. I have yet to delve into this as of yet, but hope to in the future.