Wednesday, September 30, 2009

Episode 56

In this interview, Microsoft Architect Evangelist Brian Prince describes what makes Windows 7 faster, more reliable and simpler.

Wednesday, September 30, 2009 7:16:25 AM (Eastern Standard Time, UTC-05:00)
 Monday, September 28, 2009

Episode 55

In this interview, Microsoft IT Evangelist Matt Hester describes the new features and enhancements in the upcoming Windows Server 2008 R2.

Sunday, September 27, 2009 11:09:10 PM (Eastern Standard Time, UTC-05:00)
 Saturday, September 26, 2009

We have been hosting Grok Talks at Sogeti since my arrival. Recently we decided to make them available via LiveMeeting and record the presentation. Here is a Grok Talk from September 23 2009.

In this presentation, Sogeti Principal Consultant Dr. David Truxall discusses the challenges of debugging and how to use WinDbg to debug production issues.

.Net | Grok Talk | Sogeti | Video
Saturday, September 26, 2009 10:09:26 AM (Eastern Standard Time, UTC-05:00)
 Friday, September 25, 2009

Episode 54

Kirstin Juhl came to software development from a career in manufacturing, where she learned about Lean principles. Now she sees those same principles being applied to software development. In this interview, she describes Lean in both worlds and compares the two.

Friday, September 25, 2009 6:24:22 AM (Eastern Standard Time, UTC-05:00)
 Wednesday, September 23, 2009

Episode 53

Joe Kunk is writing a chapter covering XTraReports for Paul Kimmel's upcoming DevExpress tools book. In this interview, Joe describes XTraReports and how to use it.

Tuesday, September 22, 2009 11:10:51 PM (Eastern Standard Time, UTC-05:00)
 Tuesday, September 22, 2009

I count many software developers among my friends and colleagues. Many of them tell of writing code in high school or earlier; of hacking during junior high school; or of knowing their career path at an early age.

My programming career began much later in life. Because I grew up with no inkling what I wanted to become, I majored in biochemistry as an undergrad and I studied finance in graduate school. During my eight years of matriculation, I kept busy working as a laborer for a construction company, coaching a high school wrestling team, selling financial securities, interning for a commodity trading advisor and painting. After four years attending grad school at night and working two jobs, I took my MBA and went to work doing accounting and financial analysis for a printer manufacturer. I spent almost four years at this job and it rarely changed. I learned almost nothing after the first year and found myself mightily bored.

At the time, it seemed like misfortune, but I was laid off from this job when the economy turned south and my employer sold off a large subsidiary. Months of job searching during the recession of the early 1990s left me feeling discouraged about my prospects. So I took this as an opportunity to change careers. I had taken a couple programming classes before and I had done well and enjoyed them, so I enrolled at the local university to study Computer Engineering. Sometimes the curriculum was difficult. For example, every other student in my Calculus 4 class had taken the prerequisite class the semester before.  I had taken it nine years earlier.

After two semesters of straight A’s, I was prepared to pursue a degree in Computer Engineering until the phone rang between semesters. It was an old friend of the family calling. He owned a small company in Cincinnati, had heard I knew something about computers and was looking for someone to help him with his computers. I had never been to Cincinnati before, but the offer was good and he was willing to pay for my training so I accepted and moved. Six months later, my house in Michigan sold and my family joined me.

I was a novice at that time and I knew it. I worked my tail off to learn everything I could about networking and programming and computers in general. On most days, I was the first to arrive and the last to leave work. I would get up early and drive in on Saturday to work a few hours before my family woke up. I worked at that company for five years. For most of that time, I was the entire IT department. I managed a LanManager network that I converted to a Windows NT network; I ran a call center of data input operators;  I was the company’s primary computer help desk; I evaluated and bought personal computers and servers and printers; and I wrote all the company’s custom software.

Of these tasks, writing software appealed to me most. In programming, I had the ability to learn technical skills, to practice logical thinking, and to exercise my creativity. It gave me the opportunity to exercise all parts of my brain. I decided I wanted to focus most of my energy on programming.

At that time, my language of choice was FoxPro, which gave me a chance to build Windows user interfaces and to learn about relational databases. I learned about language constructs and programming algorithms and naming conventions and frameworks. I would stay up late into the night reading programming books and technical journals. I enjoyed learning about programming far more than I enjoyed accounting or finance.

When Visual FoxPro was released, I redoubled my efforts, trying to grasp the concepts of object oriented programming and deciding when to use inheritance.

After five years, I got the opportunity to join a local consulting company, where I could focus on software development and training. I would rotate between teaching classes and building business solutions. This was another great learning experience: Teaching made me a better programmer and programming made me a better teacher.

This consulting company was known for its FoxPro expertise but we did a fair amount of Visual Basic programming and I was able to learn my second language. When Microsoft released ASP and Visual InterDev, I learned that and began teaching a class in web development. I taught that class more than any other.  I learned about XML in 2000 and began applying it anywhere I could, like a hammer looking for a nail.

Unfortunately, the company I worked for made some poor business decisions and people began to leave – first the customers, then the consultants. I followed a friend to G.A. Sullivan (aka GAS), a medium-sized consulting company in Cincinnati. I was attracted to GAS because of all the talented developers they had on board already.  Where my old employer seemed to be drifting from day-to-day, the new group had plans. They managed projects with efficiency, they had in-house experts in numerous areas; and they were well-respected by their customers and by other development shops. Not only did I learn a great deal of technology (I was at GAS when I did my first .Net project) but I first began to do public technology presentations at that time. I spoke in front of customers and at the local VB user group (later reborn as CINUG).

To this day, I have not worked with a group as talented and tight as the folks at GA Sullivan. Most of us have moved on, but I remain close friends with a number of my former colleagues from those days.

After a couple years, GAS was purchased by Avanade, a large multi-national consulting company started as a joint venture between Accenture and Microsoft. With such enormous parents, Avanade was able to go after much larger customers. During my years there, I traveled a lot but I was able to work on a number of large enterprise applications, which helped me in understanding scalability, security and how to navigate the bureaucracy of a large corporate environment.

I had my first exposure to Rules Engines, Workflow Foundation, Unit Testing, and Continuous Integration on various projects for Avanade. I spent over a year focused almost exclusively on BizTalk Server, diving deep into Microsoft integration technologies.

I wrote very little code my last year at Avanade as I led a team designing an e-commerce integration project. Instead I got experience writing design specifications and developing project plans for a waterfall project.

In 2007, I left Avanade because I wanted to spend more time with my family. I took a job with Quick Solutions Inc. (QSI) because I was impressed with the smart developers I met there and I admired their passion working and speaking in the community. I got back into coding working on an ASP.Net portal project. I also had a chance to learn from some smart people about Agile development methodologies, Team Foundation Server and the database tools of Visual Studio. Being closer to home allowed me to spend time with the developer community.  For the first time in years, I began actively speaking at conferences and user groups and participating in user groups. In 2008, following a change in ownership, QSI decided to get rid of all their consultants outside of Columbus, OH. 

A year of being active in the local community made it easier to find a new job and I joined Sogeti, my current employer. While here, I’ve worked in a variety of industries and even did my first SharePoint project. I’ve kept active in the development community, in part as a way of expanding my own knowledge of technologies.

I’ve had a number of stops over the past 15 years and I’ve learned something new everywhere I’ve been. Looking back, losing my job as an accountant was a good thing for career and my life.  

Monday, September 21, 2009 11:06:01 PM (Eastern Standard Time, UTC-05:00)
 Monday, September 21, 2009

Episode 52

Often, an application experiences a bottleneck retrieving and delivering data from a database. In this interfview, Jeremiah Peschka discusses ways to troubleshoot performance issues within a database.

Monday, September 21, 2009 6:29:45 AM (Eastern Standard Time, UTC-05:00)
 Saturday, September 19, 2009

I have been working for Sogeti for almost exactly a year now and I'm proud to announce that Microsoft has awarded our team the Partner of the Year award. Although the award goes to the entire unit, it was given for a SharePoint intranet portal produced for Oakland County and most of the work on that project was done by Mike Hacker.

Congratulations to Mike and to Sogeti on this prestigious award.

You can read more about this at http://us.sogeti.com/news/2009/08/31/sogeti-usa-wins-2009-microsoft-central-region-part/

Partner of the Year award

Saturday, September 19, 2009 7:37:30 PM (Eastern Standard Time, UTC-05:00)
 Wednesday, September 16, 2009

Episode 51

Chris Hay is a Scotsman living in Cambridge, England. He has made several trips this year to developer conferences in North America. In this interview, he discusses what goes into a good presentation and how developer communities in the UK differ from those on my side of the ocean.

Wednesday, September 16, 2009 6:55:17 AM (Eastern Standard Time, UTC-05:00)
 Tuesday, September 15, 2009

When I work on a project and I hear advice from others, I’m reminded of all the advice I heard the year my first son was born.  Often one recommendation would directly contradict another. They couldn't all be right, could they? In the end, I decided there are multiple correct ways to raise a child so I followed my own instincts each time I had to make a decision. 

Software design and development are full of decisions – some big and some small. We argue passionately over these decisions. We agonize over them, sometimes even after we make them.  Here are just a few examples

    • Web forms or MVC?
    • ASP.Net or Silverlight?
    • ADO.Net or ORM?
    • Web Services or Remoting?
    • Visual Basic or C#?
    • .Net or Java?
    • Comments evil or comments good?

But are these decisions worth agonizing over? In many cases, they are not.

In my professional life, I have argued vigorously many times for architectural points I believed were correct. Some choices were small and some were large. Sometimes I won and sometimes I lost these arguments. But I accepted those decisions because I recognize that there are multiple right answers to almost every question.  In almost every lost argument, the decision we settled on was good enough to get the job done.

I recognized that the important thing was to commit to a plan of action and move forward with it as a team.

Occasionally I’ve seen colleagues pout over a decision they did not buy into and use that decision as an excuse for failure. This is a self-fulfilling prophecy. A divided team is unlikely to succeed regardless how they design their project.

I am not trying to justify bad decisions. Some mistakes can be fatal and are inexcusable. These should be escalated up the command chain. But the vast majority of software project decisions are not life-threatening – even if they go against our thinking. We may grumble that our path is not optimal, but a decision that moves the project forward is acceptable.

There is very little dogma in software development. Your view works for you but it may not be best for the team or the project. And even if it is best, that doesn’t mean other views will not solve the same problem. Here are some guidelines that I use.

  • Time-box your decisions.  Commit to a decision by a certain date.
  • Don’t feel the need to explore every alternative. Generally speaking, time will not permit this.
  • Pick a good solution that meets your needs. Don’t be swayed by those who insist it is not the absolute best. It’s better to move forward with a workable solution than to delay a project indefinitely in search of the best solution.
  • Debate openly and honestly. Be respectful but recognize the pros and cons of each alternative.
  • Don’t make it personal. Just because someone disagrees with you doesn’t mean he is attacking your intelligence or integrity.
  • Keep an open mind. Consider that there may be an alternative solution with advantages you have not considered.
  • What worked on another project might not be appropriate for this project. Always consider decisions in the context of your current needs.

The overarching theme of this list is you should find a solution that works for your problem and move on, without wasting excessive time doing so.

And for the record, my newborn son is not 18 years old and had turned out better than I ever hoped.

Tuesday, September 15, 2009 10:36:55 AM (Eastern Standard Time, UTC-05:00)
 Monday, September 14, 2009

Episode 50

In this interview, Nathan Blevins describes how to program Microsoft Robotics Studio to control robots via programs written in Visual Studio.

Monday, September 14, 2009 7:29:21 AM (Eastern Standard Time, UTC-05:00)
 Sunday, September 13, 2009

Back To Basics

The yield return and yield break keywords are shortcuts introduced in C# 3.0. They are designed to assist you in a method that returns IEnumerable <T>.
Often such methods consist of the following steps

  1. Create an empty IEnumerable set.
  2. Loop through some data (via a while, foreach or other construct)
  3. Add to the set within your loop.
  4. Exit the loop when some limit is reached.
  5. Return the set.

A sample of such code is shown below.

public IEnumerable<Int32> GetOddNumbers_Old(Int32 maxNumber)
{
    List<Int32> oddSet = new List<Int32>();
    int num = 0;
    while (true)
    {
        System.Threading.Thread.Sleep(1000);
        num++;
        if (num % 2 == 1)
        {
            oddSet.Add (num);
        }
        if (num >= maxNumber)
        {
            break;
        }
    }

    return oddSet;
}

The new yield keywords allow you to shorten your code to only the following steps

  1. Loop through some data
  2. yield return within the loop
  3. yield break if a limit is reached before the loop is complete

That’s it. There is no need to explicitly create or return your IEnumerable set.

The yield return statement appends a value to the IEnumerable set. The yield break statement exits any looping construct to prevent more items being added to the return set. If you omit yield break, the loop exits as it normally would.

The difference between using the yield return and simply returning a set is subtle. Returning a set at the end of the method returns the entire set at once. The client must wait until the method is complete before it can use any values in the return set. Each time the yield return statement executes, the client has access to another element in the set. Essentially the set trickles back a little at a time. This can provide a gain in performance or perceived performance if you have a large set to return.

Here is a sample that returns the same results as above, using yield return and yield break.

public IEnumerable<Int32> GetOddNumbers_Yield(Int32 maxNumber)
{
    int num = 0;
    while (true)
    {
System.Threading.Thread.Sleep(1000); num++; if (num % 2 == 1) { yield return num; } if (num >= maxNumber) { yield break; } } }

If we call the two methods above, we will get the same results but they will return in slightly different ways. I added the System.Threading.Thread.Sleep(1000); line to help demonstrate this. That line simply pauses execution for 1 second each time the loop executes.

Assume the above two methods are in a class named MyMethods.  The following code will call each.

Console.WriteLine("Get Odd Numbers using old way:");
MyMethods mm = new MyMethods();
IEnumerable<Int32> oddNumbers2 = mm.GetOddNumbers_Old(11);
foreach (Int32 n in oddNumbers2)
{
    Console.WriteLine(n);
}

Console.WriteLine();


Console.WriteLine("Get Odd Numbers using new YIELD keyword:");
IEnumerable<Int32> oddNumbers1 = mm.GetOddNumbers_Old(11);
foreach (Int32 n in oddNumbers1)
{
    Console.WriteLine(n);
}

Console.ReadLine();

The above code produces the following output

Get Odd Numbers using old way:
1
3
5
7
9
11

Get Odd Numbers using new YIELD keyword:
1
3
5
7
9
11

Notice that both methods return the same data. However, if you watch the code as it runs, you will notice the first method waits 12 seconds, then immediately outputs all odd numbers; while the second method outputs a number every 2 seconds. Each method returns the same values and each takes the same amount of time, but the second method uses yield return, so the client is able to output a bit of data each time a yield return executes.

There are a few restrictions to using the yield keywords

  • These keywords cannot appear in blocks marked "unsafe"
  • These keywords cannot appear in a method with ref or out parameters
  • The yield return statement is not allowed inside a try-catch block, although it may be located inside a try-finally block.
  • A yield break statement may not be located inside a finally block.

You can download this sample code at DemoYield.zip (45.06 KB)


Mike Wood contributed to this article.

Sunday, September 13, 2009 8:44:07 AM (Eastern Standard Time, UTC-05:00)
 Saturday, September 12, 2009

Back To Basics

Prior to C# 3.0, we had two common ways to initialize the public properties of an object.

  1. We could use the default constructor to instantiate the object; then, use a separate line of code to assign a value to each property. (Listing 1)
  2. We could create a constructor that accepts an argument for each property; and write code in this constructor to assign to each public property the value passed in for each corresponding argument. (Listing 2 and Listing 3)

The first method is quite verbose and requires a lot of code for complex objects.

Listing 1:

Customer cust1 = new Customer();
cust1.CustomerID = 1;
cust1.FirstName = "George";
cust1.LastName = "Washington";
cust1.StreetAddress = "111 A St";
cust1.City = "Aville";
cust1.State = "MI";
cust1.ZipCode = "10001";

Listing 2:

class Customer
{
    public Int32 CustomerID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string StreetAddress { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string ZipCode { get; set; }

    public Customer
        (
        Int32 customerID,
        string firstName,
        string lastName,
        string streetAddress,
        string city,
        string state,
        string zipCode
        )
    {
        CustomerID = customerID;
        FirstName = firstName;
        LastName = lastName;
        StreetAddress = streetAddress;
        City = city;
        State = state;
        ZipCode = zipCode;
    }
}

Listing 3:

Customer cust2 = new Customer
    (
    2,
    "John",
    "Adams",
    "222 B Ave",
    "Beetown",
    "MI",
    "20002"
    );

The second method is more elegant, but assumes we always want to initialize every single public property at object instantiation. Of course, we could create multiple constructors to accommodate times when we only want to initialize certain variables but this can get complex in a hurry when our class has a lot of public properties.

Beginning with C# 3.0, we can now initialize public properties in the same line of that instantiates an object; and we can do so without creating a new constructor. We use object initializers to do this. 

Using object initializers we can still use the default constructor (or any public constructor we want); but we can set public properties by appending the property assignments within a set of curly braces at the end of the object initializer, as shown in listing 4.

Listing 4:

Customer cust4 = new Customer() 
            {   CustomerID = 4, 
                FirstName = "James", 
                LastName = "Monroe" 
            };

This new C# feature is known as object initializers. This method gives us a great deal of flexibility. At the time we instantiate an object, we can decide which properties to initialize. And we can do so without creating a plethora of constructors for the object or return to the verbose way of assigning property values after an object's instantiation.

Object initializers are most useful when you instantiate a class in many different places throughtout an application.

Download this code to view and run a simple application that uses object initializers DemoObjectInitializers.zip (24.92 KB)
Saturday, September 12, 2009 8:10:03 AM (Eastern Standard Time, UTC-05:00)
 Friday, September 11, 2009

Back To Basics

Automatic properties were introduced in C# 3.0 as a convenience to developers.

C# and Visual Basic .Net provide two ways for a class to maintain state: Fields and Properties.

A field is a simply a public variable defined inside a class, such as in the following example

public string foo;

A property looks much like a field to the outside world, but exposes two methods – a “getter” to allow you to retrieve the value of the property and a “setter” to allow you to assign a value to the property. The following sample demonstrates how to implement a read-write property in C#.

private string _firstName;
public string FirstName
{
    get
    {
        return _firstName;
    }
    set
    {
        _firstName = value;
    }
}

This is a common use of property getters and setters – to assign and retrieve the value from a private variable. Because there is no extra logic in these methods, similar functionality could be achieved using a field, but I prefer to use properties in case I decide later to add some validations or calculations to the setter or getter. Making a change like that to a property will not break the class signature, forcing a recompile of dependent objects.

But this is a lot of typing for such simple functionality. So much in fact that Visual Studio 2005 provided a right-click accelerator to type much of it for you.

Beginning with C# 3.0, automatic properties provide a shorthand notation for this functionality.  Simply provide the scope, the type and the name of the property, followed by “{get; set; }” and the framework will automatically create a private variable for you and provide code to save and retrieve to/from that private variable. This is all done behind the scenes for us so we don’t need to write any of this code.  Below is a sample of the code we need to write for a public property.

public string FirstName { get; set; }

To make a property read-only, simply omit the "set" keyword. To make it write-only, omit the "get" keyword. Below is syntax for the same property if I wanted it to be read-only.

public string FirstName { get; }

The only disadvantage to automatic properties is that the rest of the code in our class no longer has access to the private variables create by the framework. Even from within the same class, we must go through the public property in order to get or set the private variable.

This is a small price to pay for the amount of code we are saving.

Automatic properties not only require less typing, they are far easier to read when your class has a bunch of properties. Which of the following easier to read?

public string FirstName { get; set; }
public string LastName { get; set; }
public string StreetAddress { get; set; }
public string City { get; set; }
public string State { get; set; }
public string Zip { get; set; }

or

private string _firstName;
public string FirstName
{
    get
    {
        return _firstName;
    }
    set
    {
        _firstName = value;
    }
}

private string _lastName;
public string LastName
{
    get
    {
        return _lastName;
    }
    set
    {
        _lastName = value;
    }
}

private string _streetAddress;
public string StreetAddress
{
    get
    {
        return _streetAddress;
    }
    set
    {
        _streetAddress = value;
    }
}

private string _city;
public string City
{
    get
    {
        return _city;
    }
    set
    {
        _city = value;
    }
}

private string _state;
public string State
{
    get
    {
        return _state;
    }
    set
    {
        _state = value;
    }
}

private string _zip;
public string Zip
{
    get
    {
        return _zip;
    }
    set
    {
        _zip = value;
    }
}

I think you’ll agree that it is far easier to read and understand the more terse syntax of the first example.  And code that is easier to understand is easier to maintain.

Because both syntax versions compile to the same Intermediate Language, I recommend always using the newer Automatic Properties syntax when you create properties that do nothing more than save and retrieve state.

Download the following sample code to see automatic properties in action: DemoAutomaticProperties.zip (26.83 KB)
Friday, September 11, 2009 7:17:17 AM (Eastern Standard Time, UTC-05:00)
 Thursday, September 10, 2009

Episode 49

In this video, James Bender discusses REST services. He defeines REST, compares it to SOAP and describes how to implement REST services using WCF.

Thursday, September 10, 2009 7:21:19 AM (Eastern Standard Time, UTC-05:00)
 Wednesday, September 09, 2009

Steve Krug’s Don’t Make Me Think is a great book, not only for what it contains, but for what it does not contain.

At a couple hundred pages (most of which are filled with large graphics), Krug is forced to be concise in order to deliver his message. There is no room for irrelevant data in so little text. Happily for the reader, he succeeds brilliantly.

“Don’t Make Me Think” is not just the title of this book - It is the single most important point Krug makes about web usability design.

Throughout the book, he emphasizes that a good user interface should be self-evident. A user seeing a web page for the first time should not have to wonder what the page is for or how to use it.

He provides many examples to illustrate his points – most from actual web sites. Krug holds up Amazon.com as an example of a site that is doing many things right, making itself intuitive for the users. It’s tough to argue this point, given Amazon’s success and enormous growth over the years.

According to Krug, most web designers make the mistake of assuming that visitors to their site will read everything on each page presented to them. The reality is that most visitors quickly scan a page, searching for anything that looks relevant to them. When they find something that seems useful and clickable, they click it. When they actually find something useful, they stop looking.

Because of this behavior, web designers should focus on simplifying their page layout and draw the reader’s eye to the most important parts of the page that support the most common activities. They should provide clear, self-evident labels for the items on their pages: there should be no confusion what each item is for and what will happen if a user clicks on it or otherwise interacts with it.

But following his design advice is not sufficient. Krug also recommends recruiting and observing testers to use your web design. Watch how they interact with the pages; note the pages that they struggle to learn; document unexpected behavior.  A designer does not always think like an end user and users often react in unexpected ways. This type of testing is a good way to learn how end users perceive and interact with your site.

Check out this book if you want a quick way to improve the usability of your web sites.

Wednesday, September 09, 2009 4:20:12 PM (Eastern Standard Time, UTC-05:00)
 Tuesday, September 08, 2009

Episode 48

In this interview, Phil Japikse discusses his involvement with Hopemongers.org, a charity site focused on "micro-giving", allowing donors to give a small amount of money, directly to a charitable project.

Tuesday, September 08, 2009 12:11:52 AM (Eastern Standard Time, UTC-05:00)
 Friday, September 04, 2009

Back To Basics

Extensions methods are a new feature of C# 3.0 and they are easier to use than they first appear.

An extension method is a method that is external to an existing class but appears as if it were a method on that class.

The rules for creating an extension method are simple.

  1. Create a static method
  2. The first parameter of the static method should be the type of the class you wish to extend
  3. Precede the parameter type of this first parameter with the "this" keyword.
  4. Call the method as if it were a method of the class. Omit the first parameter.

An example should clarify this. Assume we have a class Customer with properties FirstName and LastName as shown below

    public class Customer
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }

We can create a new static class MyExtensions with a static method GetFullName that returns the formatted first and last name of the customer. We do so with the following code

   public static class MyExtensions
    {
        public static string GetFullName(this Customer cust)
        {
            string custName = cust.FirstName + " " + cust.LastName;
            return custName.Trim();
        }
    }

Notice the parameter with the "this" keyword. That parameter format tells the compiler that this is an extension method and that it should extend the Customer class. As long as MyExtensions is in the same namespace or in a namespace available to our code (via the "using" statement), we can call this new extension method with the following code

Customer cust 
    = new Customer 
         { FirstName = "David", 
           LastName = "Giard" 
         };
string fName = cust.GetFullName();
Console.WriteLine(fName);

The code above outputs:

   David Giard

As you can see in the above code, it looks as if the GetFullName method is part of the Customer class.

We can add parameters to our extension methods as we would to any other method. The first parameter (with the “this” keyword) is always used to specify the class we are extending. All other parameters act just like normal parameters. The following extension method accepts a parameter “salutation”.

public static string GetGreeting(this Customer cust, string salutation)
{
    string custName = cust.FirstName + " " + cust.LastName;
    custName = custName.Trim();
    return salutation + “ “ + custName + ":"; 
}

Although the extension method has two parameters, we only need to pass the second parameter when calling it, as shown

Customer cust = new Customer { FirstName = "David", LastName = "Giard" };
string greeting = cust.GetGreeting("Dear");
Console.WriteLine(greeting);

The code above outputs:

   Dear David Giard:

In our examples, we were adding extension methods to a class that we just created. Of course, in this case, it would have been simpler to just modify the original class.  But extension methods are more useful if you are working with someone else’s class and modifying the source code is not an option. Extension methods often offer a simpler solution than inheriting from an existing class.

The real power of extension methods comes from the fact that you can even add methods to sealed classes. It is difficult to add functionality to a sealed class because we cannot inherit from it. Change the Customer class to sealed and re-run the code to prove that it still works.

public sealed class Customer

Here is the all code in the above sample

using System;

namespace TestExtensionMethods
{
    class Program
    {
        static void Main(string[] args)
        {
            Customer cust = new Customer { FirstName = "David", LastName = "Giard" };

            string fn = cust.GetFullName();
            Console.WriteLine(fn);

            string greeting = cust.GetGreeting("Dear");
            Console.WriteLine(greeting);

            Console.ReadLine();

        }
    }


    public sealed class Customer
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }


    public static class MyExtensions
    {
        public static string GetFullName(this Customer cust)
        {
            string n = cust.FirstName + " " + cust.LastName;
            return n.Trim();
        }

        public static string GetGreeting(this Customer cust, string salutation)
        {
            string custName = cust.FirstName + " " + cust.LastName;
            custName = custName.Trim();
            return salutation + " " + custName + ":"; 
        }
    }

}

You can download the sample code at TestExtensionMethods.zip (24.26 KB)

 

Friday, September 04, 2009 8:52:43 PM (Eastern Standard Time, UTC-05:00)
 Thursday, September 03, 2009

Recently, I was asked to automate the process of checking a set of known URLs and determining if each URL corresponded to a “live” site. For our purposes, a site is live if I can PING it and get a reply back.

I can open a command prompt and use the PING command and read the response to determine if a site is live. A live site would return a series of messages starting with “Reply from”, while a non-existent site would report an error.

Unfortunately it is difficult to automate this task from the command prompt. Fortunately, the .Net framework provides the tools to allow me to ping a URL with just a few lines of code. The functionality I need is in the System.Net.NetworkInformation namespace.

I have created a public class  PingUtils and added the statement

using System.Net.NetworkInformation;

at the top of this class.

Next, I added the following method to attempt to ping a URL and return true, if successful.

public bool UrlIsLive(string url, int timeOut)
{
    bool pingSuccess = false;
    Ping ping = new Ping();
    string pingData = "TEST";
    byte[] pingDataBytes = Encoding.ASCII.GetBytes(pingData);
    try
    {
        PingReply reply = ping.Send(url, timeOut, pingDataBytes);
        if (reply.Status == IPStatus.Success)
        {
            pingSuccess = true;
        }
    }
    catch(PingException)
    {
        pingSuccess = false;    
    }
    return pingSuccess;
}

That’s it. If an error occurs when I try to ping, it is most likely a PingException, which is equivalent to the "Ping request could not find host" error reported at the command prompt.

This function returns true for a URL that exists and is live; and false for one that does not exist.

The following unit tests should deomonstrate this

/// <summary>
///A positive test for IsLive
///</summary>
[TestMethod()]
public void IsLive_PingGoodUrl_ShouldReturnTrue()
{
    PingUtils pu = new PingUtils();
    string url = @"DavidGiard.com";
    int timeOut = 1000;
    bool siteIsLive = pu.UrlIsLive(url, timeOut);
    Assert.IsTrue(siteIsLive, "PingUtils.IsLive did not return true as expected");
}

/// <summary>
///A negative test for IsLive
///</summary>
[TestMethod()]
public void IsLive_PingBadUrl_ShouldReturnFalse()
{
    PingUtils pu = new PingUtils();
    string url = @"notDavidGiard.com";
    int timeOut = 1000;
    bool siteIsLive = pu.UrlIsLive(url, timeOut);
    Assert.IsFalse (siteIsLive, "PingUtils.IsLive did not return false as expected");
}

It’s worth pointing out a couple limitations of this function.

  • Some site’s reject all PING request as a way to protect themselves against Denial of Service attacks. For example, if you PING Microsoft.com, it will not Reply, even though the site does exist.
  • As with any program that uses networking, the internal firewall rules where the program runs may affect the success of the program.
  • The PING command checks for valid URLs, even if the URL returns an error page. So, foo.DavidGiard will reply to a PING request because my hosting provider redirects this to an error page.

Even given those limitations, this can be a very useful function for testing if all the Links stored in your database are still relevant.

You can download the code here.

Thursday, September 03, 2009 10:23:51 AM (Eastern Standard Time, UTC-05:00)
 Wednesday, September 02, 2009

Episode 47

Leon Gersing is a tall, heavy concoction of rubber with a surprising lightness of gait, especially in a dance.

He is also a Ruby developer and he loves it. In this interview, he shares why he prefers Ruby over Visual Basic and C# as a language to build his applications.

17 mins, 15 secs

Wednesday, September 02, 2009 7:01:55 AM (Eastern Standard Time, UTC-05:00)
 Tuesday, September 01, 2009

Just because I've resigned myself to the inevitability that I will never know everything about every technology, this does not excuse me from having to know a little about everything. As a consultant, I need to be aware of what is going on in the industry: I need speak intelligently about different products and I often have to make educated choices about available technologies.

This is why I'm an avid listener of tech podcast. The recent explosion of available podcasts has helped me stay aware of technology, and to do so in the limited time available to me.

Below is a list of the technology podcasts to which I currently subscribe. The list is presented in no particular order, but I recommend each one. If I don’t like a podcast, I've stopped listening to it and it doesn't appear in this list.

.Net Rocks
http://www.dotnetrocks.com/

This is the first podcast that I started listening to and it remains one of my favorites. Carl Franklin and Richard Campbell have been hosting this show for so long that they have access to almost anyone who does anything related to Microsoft development. The quality of their guests is top notch and I never miss an episode.

Hanselminutes
http://www.hanselminutes.com/

Scot Hanselman is probably my favorite interviewer among tech podcasters. When I do interviews for my show, my goal is to sound as much like Scot as possible. He draws out the guests because he either understands their topic in advance or he quickly grasps it. His humor is understated, which makes for an entertaining show and he has years of real-world experience, making his opinions relevant.

Deep Fried Bytes
http://deepfriedbytes.com/

I started listening to this show because I knew the hosts - Keith and Woody. I continue to listen because I like the content. This is a show that continually improves itself. It's been a couple months since their last episode, so I don't know if they are still committed to a regular schedule.

Polymorphic Podcast
http://polymorphicpodcast.com/

There are two things I really like about Craig Shoemaker's podcast: The guests tend to be those who don't appear on other podcasts; and Craig keeps the show to a reasonable length. The show always remains fresh for me.

Run As Radio
http://www.runasradio.com/

This podcast is a little outside my comfort zone because it focuses on networking and other IT topics, rather than on programming and architecture. But Richard Campbell and Greg Hughes work to keep it accessible, so I always learn something.

Feel the Func
http://feelthefunc.com/

This one is relatively new and I started listening to it right from the start. Mike Neel leads the discussion and does most of the talking. I don’t think they are doing a lot of editing, which means that you always hear the good parts and bad parts of each conversation.  I really enjoyed a recent show in which Mike interviewed Brian Prince and Jennifer Marsman.

SodThis
http://www.sodthis.com/podcast/

I had just about given up hope on this one. I loved the first 5 episodes that DevExpress evangelists Oliver Sturm and Gary Short put together. They combined interesting interviews with their own witty conversations. Then, after five episodes, SodThis disappeared into limbo. I assumed they had abandoned the project but they released Episode 6 yesterday.


Thirsty Developer
http://www.thirstydeveloper.com/

I just recently began to listen to The Thirsty Developer. It sound like many of the episodes were recorded in a busy Starbucks, which degrades the sound quality but creates a more relaxed atmosphere for the guests, so the conversation flows freely and enthusiastically. Larry Clarkin is the main guy, but he is sometimes assisted by Dave Bost.  They do a good job keeping conversations moving and engaging.

Alt.Net
http://altnetpodcast.com/

Technically I'm still subscribing to this podcast, but I don't know if there are any plans to resume it. I really liked the first few shows I heard, which focused on advanced .Net topics. But they haven't released an episode since April and the last two consisted largely of arguments about whether or not the Alt.Net community is still relevant. Maybe the silence answered that question.

Herding Code
http://herdingcode.com/

I've been listening to Herding Code since its first episode. Originally this was very different from most podcasts because they rarely had guests. Instead, the four hosts exchanged ideas with one another on a preselected topic. This format worked because John Galloway, Scott Koon, K. Scott Allen and Kevin Dente are engaging and articulate enough to keep bringing fresh ideas on each topic. Recently, they have switched to inviting more guests to the show.

Stack Overflow
http://blog.stackoverflow.com/category/podcasts/

This is another podcast that seldom relies on guests to interview. Instead, Jeff Atwood and Joel Spolsky chat (or spar) about a variety of topics. Again, this is a format that only works if the hosts are very clever and these two guys definitely are. Because Atwood is still in the process of building the popular StackOverflow web site, much of the conversation revolves around the challenges he faces.

So these are the podcasts that I listen to regularly. I can keep up because I have a long commute and I enjoy my IPod at the gym and while doing housework.  Having said that, I’d love to hear about high-quality technical podcasts that you can recommend.

Tuesday, September 01, 2009 7:13:34 AM (Eastern Standard Time, UTC-05:00)