Every month or so, someone posts a question on one of the .NET forums I frequent asking if such and such will work, or if you can do so and so. The post will detail the background of the issue, including theoretical approaches, possible drawbacks, imaginary contingencies and tangential concepts.  Invariably the poster wants to know the "proper way" to code something, and yet 6 paragraphs later hasn't shown what he or she has already attempted.

Why?

Because the poster hasn't written any code yet. 

Philosophical development discussions can be fun. Reviewing fundamental design issues, or exploring the possibilities of a new technology or entering a new problem space beg for "what if" questions. It's good to have an idea where to go, a vague notion how to get there and to find out how others attempted the journey.   Those are fun questions to answer.

Another excellent time to ask "what if" questions is when facing an irrevocable upgrade or configuration change.  When a wrong step can wreak havoc it wise to ask for advice. That's what a forum is for -- to get pointed in the right direction or pushed back on course or to be told to hurry back to shore.

No, what makes a coding "what if" question a total waste of time and bandwidth is when it asks how to write a relatively small amount of code. The post itself is longer than the most convoluted possible solution. To put it programmatically...

if(Post.Length > Code_Needed_To_See_If_It_Works.Length)
    WasteOfTimeAndBandwidth();

In other words, if the poster had actually tried to code one of the carefully penned theoretical approaches, he or she would have ended up typing a lot less and would have discovered the solution without a trip to forum land. 

Some examples (and I wish I were making these up):

• Is it possible to set SomeObject.SomeProperty = SomeValue?
• Can I put this control inside this other control?
• How long will SomeObject.SomeMethod() take to run?

Programming is a wonderfully empirical undertaking. With IDEs (Integrated Development Environments such as Visual Studio) it is easy to create code and test it.  At the level of of a function or even a web page or windows form, there is no need for thought experiments or theoretical ponderings -- the code either does what it is supposed to or it doesn't.  There is no need to write about it -- just write it.  If it doesn't work, then you can post a question that is based on something real.

Unless you are doing something silly like working on a production system, the cost for trying something out is minimal.  In the worst cases, bad code throws an error or just doesn't work.  Things don't explode, no one dies.  With source code/version control (which everyone should get into the habit of using), it is trivial to roll back to a previous working version. 

So please, for your sake and Pete's, try it first.  See what happens.  You'll save some time and might be pleasantly surprised.

I hate upgrades.  I usually put them off until:

1. Something (someone) puts a gun to my head
2. There is a compelling feature available
3. I'm feeling lucky
   

Case 1 is the usual situation.  When things won't work any more, I'll bite the bullet.  If things are working, I have a tendency to leave them alone because vast experience has taught me that the Law of Unintended Consequences usually makes itself known whenever something gets upgraded.  I don't care how many versions behind it is.  I don't like to blow half a day getting back to where I was before the upgrade.

Case 2 actually popped up twice in the last month.  I moved to Vista finally because I wanted to play with the new PeerToPeer.Collaboration namespace in 3.5.  It hasn't been too horrible, (except for the file search function which is even more obtuse than it was in XP -- which I thought was an impossibility).  It was also just a move to a fresh machine.  I also upgraded my my password management software (SecretServer) install, because I wanted to take advantage of the ActiveDirectory feature.  I was only 3 major versions, 2 minor versions and 30 revisions behind, but with some help from the good support folks at Thycotic I was able to get it current without too much hassle.

Case 3 is something I should avoid.  I should know better, but it happened while I fooling around with this blog last week.  I realized that the blog software (dasBlog) was many versions behind and I figured the last upgrade hadn't been too bad.  There were also a couple quirks I figured would be handled by the new version.  So  I downloaded all the new stuff, merged my web.config file, made the few other changes and pushed everything up.  Worked, mostly.  I couldn't edit or enter new entries.  The FreeTextBox component was displaying a "was not installed correctly" error.  Hours of googling, typing, begging and swearing later still no luck.

So tonight I decided it was time to move on.  dasBlog supports other editors, and John Forsythe has created a lovely little addin for the TinyMCE rich text editor.  I downloaded, uploaded, recycled the app, changed the configuration and behold my dasBlog install once again is back where it was a week ago -- I have a text editor to create entries.

On the positive side, TinyMCE is has more features and the new dasBlog goodies are nice, so I guess it was a worthwhile exercise.  I'm just posting this to remind myself that I should "never feel lucky" when considering an upgrade.

UPDATE:  Just discovered Comments weren't working because I had the Resolve IP Setting turned on. Looks good now. Not that I get lots of comments, but I would like to provide the outlet.

There are four (development) life annoyances that I can do without:

1. Recruiters who only use the state abbreviation to describe a job location. "Urgent need for Senior .NET Developer, Location: CA"
2. Forum posters who demand code for entire applications. "Please send me chat server code -- urgent."
3. Repeated requests for Interview Questions.  I've covered this elsewhere.
   
4. Lazy gits who can't be bothered to learn how to read either C# or VB.NET. "Thanks for the answer, but my project is in VB.NET, I don't understand C#."

ala C#: using System.Data.SqlClient;
ala VB: Imports System.Data.SqlClient

ala C#: public class TheClassINeverHad
           {
             //fields, methods and properties -- oh my!
            }
ala VB: Public Class TheClassINeverHad
             'fields, methods and properties -- oh my!
          End Class

ala C#: public abstract class TheClassINeverHad
ala VB: Public MustInherit Class TheClassINeverHad

ala C#: public sealed class TheClassINeverHad
ala VB: Public NotInheritable Class TheClassINeverHad

ala C#: public interface IPractical
ala VB: Public Interface IPractical

ala C#: public class TheClassINeverHad: APracticalClass
ala VB: Public Class TheClassINeverHad
             Inherits APracticalClass

ala C#: public class TheClassINeverHad: IPractical
ala VB: Public Class TheClassINeverHad
             Implements IPractical

ala C#: public class TheClassINeverHad: IPractical, IRidiculous
ala VB: Public Class TheClassINeverHad
             Implements IPractical
             Implements IRidiculous

ala C#: public class TheClassINeverHad: APracticalClass, IPractical, IRidiculous
ala VB: Public Class TheClassINeverHad
             Inherits APracticalClass
             Implements IPractical
             Implements IRidiculous

ala C#: //This is a 1 line comment
          /* This starts a multiline comment
          This ends a multiline comment */
ala VB: 'This is a one line comment

ala C#: private int SomeNumberIWillUse;
ala VB: Private SomeNumberIWillUse as Integer

ala C#: private const string LAZY_GIT = "Lazy Git";
ala VB: Private Const LAZY_GIT as String = "Lazy Git"

ala C#: public TheClassINeverHad()
            {
                //Do Something Useful
             }
ala VB: public Sub New()
             'Do Something Useful
          End Sub

ala C#: public struct Soda
           {
                 public string Name;
                 public int Calories;
            }
ala VB: Public Structure Soda
             Public Name as String
             Public Calories as Integer
          End Structure

ala C#: public enum PlanetValues
           {
                    Mercury = 0,
                    Venus = 1,
                    Earth = 2,
                    Mars = 3,
                    Jupiter = 4,
                    Saturn = 5,
                    Uranus = 6,
                    Neptune = 7,
                    Pluto = 8
            }
            public enum PlanetValues
           {
                    Mercury,
                    Venus,
                    Earth,
                    Mars,
                    Jupiter,
                    Saturn,
                    Uranus,
                    Neptune,
                    Pluto
            }
ala VB: Public Enum PlanetValues
             Mercury = 0
             Venus = 1
             Earth = 2
             Mars = 3
             Jupiter = 4
             Saturn = 5
             Uranus = 6
             Neptune = 7
             Pluto = 8
          End Enum

        Public Enum PlanetValues
             Mercury
             Venus
             Earth
             Mars
             Jupiter
             Saturn
             Uranus
             Neptune
             Pluto
          End Enum

ala C#: string DeveloperPersona;
ala VB: Dim DeveloperPersona as String

ala C#: string[] CoolDevTools;
           string[] CoolDevTools = new string[5];
           //assignment
          CoolDevTools[0] = SomeString;
ala VB: Dim CoolDevTools as String()
          Dim CoolDevTools(5) as String
          'assignment
          CoolDevTools(0) = SomeString
             

ala C#: AnObjectType SomeObject = (AnObjectType)SomeHashtable[SomeKey];
           AnObjectType SomeObject = (AnObjectType)SomeArrayList[SomeIndex];
ala VB:  Dim SomeObject as AnObjectType = SomeHashtable(SomeKey)
           Dim SomeObject as AnObjectType = SomeArrayList(SomeIndex)
          'or if Option Strict is on
          Dim SomeObject as AnObjectType = CType(SomeHashtable(SomeKey), AnObjectType)
          Dim SomeObject as AnObjectType = CType(SomeArrayList(SomeIndex), AnObjectType)
             

ala C#: public void ThePerfectMethod(string DeveloperName)
             {
                // coding goodness
             }
ala VB: Public Sub ThePerfectMethod(DeveloperName as String)
                'Coding Goodness
          End Sub

ala C#: public int ThePerfectMethod(string DeveloperName)
             {
                // coding goodness
                return 42;
             }
ala VB: Public Function ThePerfectMethod(DeveloperName as String) as Integer
                'Coding Goodness
                Return 42
          End Function

ala C#: public int TheAnswer
             {
               get{   return mTheAnswer;}
               set{  mTheAnswer = value;}
             }
ala VB: Public Property TheAnswer() as Integer
                Get
                    Return mTheAnswer
                End Get
                Set (Value as Integer)
                   mTheAnswer = Value
                End Set
                     
          End Property

ala C#: public int TheAnswer
             {
               get{   return mTheAnswer;}
             }
ala VB: Public ReadOnly Property TheAnswer() as Integer
                Get
                    Return mTheAnswer
                End Get
          End Property

ala C#: public int TheAnswer
             {
               set{  mTheAnswer = value;}
             }
ala VB: Public WriteOnly Property TheAnswer() as Integer
                Set (Value as Integer)
                   mTheAnswer = Value
                End Set
                     
          End Property

ala C#: private static int mANumberEveryoneNeeds;
           public static ANumberEveryoneNeeds
           {
                get{return mANumberEveryoneNeeds;}
           }
           public static void ResetTheNumber()
           {
                mANumberEveryoneNeeds = 0;
           }
ala VB: Private Shared mANumberEveryonNeeds as Integer
           Public Readonly Shared Property ANumberEveryoneNeeds() as Integer
                Get
                   Return mANumberEveryoneNeeds
                End Get
           End Property
           Public Shared Sub ResetTheNumber ()
                 mANumberEveryoneNeeds = 0
           End Sub

ala C#: if(SomeVariable == 42)
             {
                Answer = "That's it!";
                HasWisdom = true;
             }
           else
             {
                Answer = "That's not it.";
                HasWisdon = false;
             }

          //one line syntax
           if(SomeVariable == 42)
                Answer = "That's it!";
           else
                Answer = "That's not it.";
               

ala VB: If SomeVariable = 42 Then
             Answer = "That's it!"
             HasWisdom = True
          Else
             Answer = "That's not it."
             HasWisdom = False
          End if

ala C#: if(!Page.IsPostBack) //Not operator
           if(Night != Day) //Inequality
           if(Night == Day & Pigs.CurrentState == PigState.Flying) // And
           if(Night == Day && Pigs.CurrentState == PigState.Flying) //Conditional And
           if(Night == Day | Pigs.CurrentState == PigState.Flying) // Or
           if(Night == Day || Pigs.CurrentState == PigState.Flying) // Conditional Or
           if(Night == Day ^ Pigs.CurrentState == PigState.Flying) // Xor


ala VB: If Not Page.IsPostBack Then
           If Night <> Day Then 'Inequality
           If Night = Day And Pigs.CurrentState = PigState.Flying Then
           If Night = Day AndAlso Pigs.CurrentState = PigState.Flying Then 'Conditional And
           If Night = Day Or Pigs.CurrentState = PigState.Flying Then
           If Night = Day OrElse Pigs.CurrentState = PigState.Flying Then 'Conditional Or
           If Night = Day Xor Pigs.CurrentState = PigState.Flying Then
          

ala C#: switch(SelectedPlanet)
           {
                 case PlanetValues.Earth:
                      message = "Live there";
                      break;
                 case PlanetValues.Venus:
                 case PlanetValues.Mars:
                      message = "Landed there";
                      break;
                 case PlanetValues.Mercury:
                 case PlanetValues.Jupiter:
                 case PlanetValues.Saturn:
                 case PlanetValues.Uranus:
                 case PlanetValues.Neptune:
                      message = "Flew by";
                      break;
                  case PlanetValues.Pluto:
                      message = "Is it a planet?"
                      break;
                   default:
                      message = "Never heard of it";
                      break;
           }
           
ala VB: Select Case SelectedPlanet
                Case PlanetValues.Earth
                   message = "Live there"
                Case PlanetValues.Venus, PlanetValues.Mars
                   message = "Landed there"
                Case PlanetValues.Mercury, PlanetValues.Jupiter, PlanetValues.Saturn, PlanetValues.Uranus, PlanetValues.Neptune
                   message = "Flew by"
                Case PlanetValues.Pluto
                   message = "Is it a planet?"
                Case Else
                   message = "Never heard of it"
          End Select

ala C#: for(int Index = 0; Index < SomeIntegerArray.Length; Index ++)
             {
                 Total += SomeIntegerArray[Index];
                 CallSomeOtherFunction(SomeIntegerArray[Index]);
             }
             //A single line For Loop can be done without the brackets
            for(int Index = 0; Index < SomeIntegerArray.Length; Index ++)
                Total += SomeIntegerArray[Index];

ala VB: For Index as Integer = 0 to SomeIntegerArray.Length -1
                Total += SomeIntegerArray(Index)
                CallSomeOtherFunction(SomeIntegerArray(Index))
          Next

ala C#: for(int Index = 0; Index < SomeIntegerArray.Length; Index += 2)
             {
                 Total += SomeIntegerArray[Index];
                 CallSomeOtherFunction(SomeIntegerArray[Index]);
             }
           

ala VB: For Index as Integer = 0 to SomeIntegerArray.Length -1 Step 2
                Total += SomeIntegerArray(Index)
                CallSomeOtherFunction(SomeIntegerArray(Index))
          Next

ala C#: for(int Index = 0; Index < SomeIntegerArray.Length; Index += 2)
             {
                 Total += SomeIntegerArray[Index];
                 if(CallSomeOtherFunction(SomeIntegerArray[Index]) == false)
                   break;
             }

ala VB: For Index as Integer = 0 to SomeIntegerArray.Length -1 Step 2
                Total += SomeIntegerArray(Index)
                If CallSomeOtherFunction(SomeIntegerArray(Index)) = False Then
                   Exit For
                End if
          Next

ala C#: foreach(Universe PossibleUniverse in PossibleUniverses)
             {
                 if(PossibleUniverse.HasStrongForce)
                 {
                     
                      AddToViableCandidates(PossibleUniverse);
                 }
             }
           

ala VB: For Each PossibleUniverse as Universe in PossibleUniverses
                If PossibleUniverse.HasStrongForce Then
                   AddToViableCandidates(PossibleUniverse)
                End if
          Next

ala C#: do
             {
                 Total += SomeIntegerArray[Index];
                 if(CallSomeOtherFunction(SomeIntegerArray[Index]) == false)
                   break;
                 Index++;
             }
             while(Index < SomeIntegerArray.Length);

ala VB: Do
                Total += SomeIntegerArray(Index)
                If CallSomeOtherFunction(SomeIntegerArray(Index)) = False Then
                   Exit Do
                End if
                Index += 1
          Loop While Index < SomeIntegerArray.Length

          Do While Index < SomeIntegerArray.Length
                Total += SomeIntegerArray(Index)
                If CallSomeOtherFunction(SomeIntegerArray(Index)) = False Then
                   Exit Do
                End if
                Index += 1
          Loop

ala C#: do
             {
                 Total += SomeIntegerArray[Index];
                 if(CallSomeOtherFunction(SomeIntegerArray[Index]) == false)
                   break;
                 Index++;
             }
             while(Index < SomeIntegerArray.Length);

ala VB: Do
                Total += SomeIntegerArray(Index)
                If CallSomeOtherFunction(SomeIntegerArray(Index)) = False Then
                   Exit Do
                End if
                Index += 1
          Loop Until Index = SomeIntegerArray.Length

          Do Until Index = SomeIntegerArray.Length
                Total += SomeIntegerArray(Index)
                If CallSomeOtherFunction(SomeIntegerArray(Index)) = False Then
                   Exit Do
                End if
                Index += 1
          Loop

ala C#: while(Index < SomeIntegerArray.Length)
             {
                 Total += SomeIntegerArray[Index];
                 if(CallSomeOtherFunction(SomeIntegerArray[Index]) == false)
                   break;
                 Index++;
             }
           
ala VB: While Index < SomeIntegerArray.Length

                Total += SomeIntegerArray(Index)
                If CallSomeOtherFunction(SomeIntegerArray(Index)) = False Then
                   Exit While
                End if
                Index += 1
          End  While
        

ala C#: SomeButton.Click += new ButtonEventHandler(SomeButton_Click);
           
ala VB: AddHandler SomeButton.Click, AddressOf SomeButton_Click

          'or directly declare it
          Sub SomeButton_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SomeButton.Click

• C# Operators
• C# Keywords
• VB.NET Keywords
• Language Equivalents

• Tanglible Software
• Developer Fusion
• Or Google For More