In deference to Martin Richards, the creator of the Basic Combined Programming Language (BCPL) and author of the first "Hello, World!" program, I present a "Hello, World!" program. Actually, I offer an enhanced version that displays "Hello, World!" in English, Italian, or Spanish. The program is a console application.

Here is my version of the "Hello, World!" program, which is stored in a file named hello.cs:

using System;

namespace HelloNamespace {

    class Greetings{
        public static void DisplayEnglish() {
            Console.WriteLine("Hello, world!");
        }
        public static void DisplayItalian() {
            Console.WriteLine("Ciao, mondo!");
        }
        public static void DisplaySpanish() {
            Console.WriteLine("Hola, imundo!");
        }
    }

    delegate void delGreeting();

    class HelloWorld {
        static void Main(string [] args) {
            try {
                int iChoice = int.Parse(args[0]);
                delGreeting [] arrayofGreetings={
                    new delGreeting(Greetings.DisplayEnglish),
                    new delGreeting(Greetings.DisplayItalian),
                    new delGreeting(Greetings.DisplaySpanish)};

                arrayofGreetings[iChoice - 1]();
            }
            catch(Exception ex) {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

Csc.exe is the C# compiler. Enter the following csc command at the Visual Studio command prompt to compile the hello.cs source file and create the executable hello.exe:

csc hello.cs

The hello.exe file is a .NET single-file assembly. The assembly contains metadata and Microsoft Intermediate Language (MSIL) code but not native binary. Mixed assemblies (both native and managed) may contain binary.

Run the Hello application from the command line. Enter the program name and the language (1 for English, 2 for Italian, or 3 for Spanish). For example, the following command line displays "Ciao, mondo!" ("Hello, world!" in Italian).

Hello 2

The source code of the Hello application highlights the common elements of most .NET applications: using statement directive, a namespace, types, access modifiers, methods, exception handling, and data.

Note

C# is case-sensitive.

The HelloNamespace namespace contains the Greetings and HelloWorld types. The Greetings class has three static methods, and each method displays "Hello, World!" in a different natural language. Static methods are invoked on the type (classname.member), not an instance of that type. The static methods of the Greetings type are also public and therefore visible inside and outside the class.

Delegates define a type of function pointer. The delGreeting delegate is a container for function pointers. A delGreeting delegate points to functions that return void and have no parameters. This is (not so coincidentally) the function signature of the methods in the Greetings type.

The entry point of this and any other C# executable is a Main method. Command-line parameters are passed as the args parameter, which is a string array. In the HelloWorld program, the first element of the args array is used as a number indicating the language of choice, as input by the user. The Hello application converts that element to an integer. Next, the program defines an array of function pointers, which is initialized to point to each of the methods of the Greetings class. The following statement invokes a function pointer to display the selected HelloWorld message:

arrayofGreetings[iChoice - 1]();

The value iChoice - 1 is an index into the delegate array. Since arrays are zero-based in C#, iChoice is offset by -1.

Most of the code in the Main method is contained in a try block. The code in the try block is a guarded body. A guarded body is protected against exceptions defined in the corresponding catch filter. When an exception is raised that meets the criteria of the catch filter, execution is transferred to the catch block, which displays the exception message. If no exception is raised, the catch block is not executed. In our HelloWorld application, omitting the choice or entering a non-numeric command-line parameter when running the program will cause an exception, which is caught, and the catch block displays the appropriate message.

There are several statement blocks in the sample code. A statement block contains zero or more statements bracketed with curly braces {}. A single statement can be used separately or within a statement block. The following two code examples are equivalent:

// Example 1
if (bValue)
    Console.WriteLine ("information");

// Example 2
if (bValue)
{
    Console.WriteLine ("information");
}

Because LINQ plays such an important role in Visual C# 2008, here are two sample applications to demonstrate LINQ. Actually, the LINQ example comprises two examples: a traditional version and a LINQ version. Both examples list the names of people that are 30 years old or older. The traditional example filters the names with an if statement. The LINQ example uses a LINQ query to ascertain the correct names. The result of both applications is identical.

Here is the traditional example, stored in a file named people.cs:

using System;

namespace Example {

    class Person {
        public Person(string _name, int _age) {
            name = _name;
            age = _age;
        }
        public string name = "";
        public int age = 0;
    }
    class Startup {
        static void Main() {
            Person [] people = {new Person("John", 35),
                                new Person("Jill", 37),
                                new Person("Jack", 25),
                                new Person("Mary", 28)};
            foreach (Person p in people) {
                if (p.age >= 30) {
                    Console.WriteLine(p.name);
                }
            }
        }
    }
}

The code has a single namespace, which is Example. Example contains the Person and Startup types. The Person class has a public two-argument constructor. A constructor is a method with the same name as its class. This constructor is used to initialize instances of the Person class. The Person type contains two fields—name and age.

Main, the entry point function, is in the Startup class. In Main, an array of four employees is defined. The foreach statement iterates through the elements in the people array. Next, the if statement filters the employees and displays the names of people 30 years old or older in the console window.

The program is compiled with the C# compiler as follows:

csc people.cs

Here is the LINQ version of this example:

using System;
using System.Linq;

namespace Example {

    class Person {
        public Person(string _name, int _age) {
            name = _name;
            age = _age;
        }
        public string name = "";
        public int age = 0;
    }

    class Startup {
        static void Main() {
            Person [] people={new Person("John", 35),
                              new Person("Jill", 37),
                              new Person("Jack", 25),
                              new Person("Mary", 28)};
            var ageQuery = from p in people
                      where p.age >= 30
                      select p;
            foreach (var p in ageQuery) {
                Console.WriteLine(p.name);
            }
        }
    }
}

The LINQ version filters people using a LINQ query instead of an if statement. This highlights the seminal difference between a traditional query and LINQ. The if statement in the traditional version filters data, whereas the LINQ query in the LINQ example filters Person objects. In this way, LINQ removes the disconnect between objects and data.

The var keyword in the ageQuery variable declaration is for type inference. Type inference is not typeless. A specific type is inferred at compile time from the result of the LINQ query expression. This keeps the code type-safe, which is an important tenet of .NET. In our example, the query expression evaluates to an array of Person types. Therefore, at compile time, "var query" implies "Person [] query".