The keywords listed in the previous chapter always have to be written exactly as they are shown there. You may have noticed that they're all in lower case.

So if you ever write the word "If" or "IF" instead of "if", the computer will simply refuse to carry on - it does not understand things unless you write them according to the rules.

Don’t be too hard on it – it has some strengths where you have weaknesses, like being able to remember absolutely everything you’ve ever told it over the last 10 years and doing so in a fraction of a second! Can you do that? Mmm, not so chirpy now are you? Anyway, we’re digressing, let’s get on with it.

Now what about words that you've made up yourself? Suppose for example, you have created a class called "myClass" which has a field called "numberOfSpots".

class myClass
{
      int numberOfSpots;
}

Do small versus capital letters matter? The answer is quite obvious really, and that is Yes. Whenever you talk about these names in a C# program you must write them exactly as you originally defined them. The following, for example, will fail.

class myClass
{
      // Field

      int numberOfSpots;

      // Method
      
      public void Main()
      {
            MyClass x = new MyClass();
            x.NUMBEROFSPOTS = 365;
      }
}

But when written as follows, the code will run correctly:

class myClass
{
      // Field

      int numberOfSpots;
      
      // Method
      
      public void Main()
      {
            myClass x = new myClass();
            x.numberOfSpots= 365;
      }
}

So although you may choose to write a class name/field name/method name/etc. with a mixture of small and big letters (NUMBEROFSPOTS or numberofspots or NuMbErOfSpOtS, etc), it is very important that you then continue to write that name the very same way throughout your program.

When we humans work with things in our brains, we also use places in our memory to hold answers; but we do it almost without realizing it. Suppose you're asked to

• add the numbers 10, 20 and 50

• then multiply that answer by 2

One likely way you'd approach this is

• Work out 10 + 20. Hold this answer (30) in your head.

• Work out 30 + 50. Now hold this answer (80) in your head.

• Work out 80 x 2. Hold that in your head until you're ready to give it to the person who asked you to work this out.

• Once you've done what you needed to do, stop trying so hard to remember it - that answer is of no value anymore - rather free up your memory to be used for other things.

So we're not always that different from our digital friends.

A variable is really a lot like a field or a parameter except that it does not have anything directly to do with a particular class or object - we just need a temporary place to store something so we can work with it.

But variables, just like fields (which are actually a kind of variable), are always of a particular type. E.g.

string myString;
int theAnswer;
bool isFinished;

(If you haven't read the chapter "Fields and Their Types", consider going and reading it so you understand more about "types")

Another way that values can be changed from one type to another is through something called casting. To cast something means to convert it to a different type, but unlike the "convert" examples above, casting only works when the type you're changing from is very similar to the type you're changing to. It is useful, for example, for converting between two number types, but is useless for converting between a number and a string. The way you write a cast is also very different to the above examples; before the variable that you wish to convert you must write, in parenthesis, the type that you want to convert to.

To show an example, we need to introduce you to another number type - let's use the type called "double". For those of you who have covered scientific notation in school Math or Science, the "double" and "float" types are very similar to that - they allow you to work with decimal numbers, allowing the decimal point to "float". E.g. 5.0x10³ is the same number as 50.0x10² or 0.50x10⁴ and so on.

int x;
double y;
int theAnswer;

x = 10;
y = 15;
theAnswer = x + (int) y;

The code (int) y converts y to an integer.

By the way, this particular cast will only work if the number held in y is something that can be properly converted into an integer. So the example above will be fine, but if y had a value of 15.5 instead this code would fail. In a real program you would probably add some more code to first round off y to a whole number using Math.Round(y).

You probably won't need to use casting in your early programs, but you may well see it being used in other people's examples that you read through. Now at least you'll know what's going on.

Hey, want to try something really stupid? Leave out the line x = x + 1. That way, x will NEVER get any bigger and so it will ALWAYS be less than 11 and we’ll go around and around the loop FOREVER – or at least until the computer runs out of memory, throwing up an ugly error message. Whenever you write an endless loop, you should feel suitably embarrassed.

In the previous chapters, we've been looking at specific concepts and how to explain each of those ideas to the computer. But we have not considered what a "whole program" should look like. How do we start the program and what are the parts that have to be there for it to work.

So in this chapter we discuss the basic structure that a C# program must have. The idea is not to confuse ourselves with all the detail - just to understand the basic outline of a program - the skeleton.

If you went camping in the mountains for the weekend, you would use a structure such as a tent - not a house that needs brick foundations. You use a structure that suits the environment you're in. Tents and houses are basically the same, but tents are specifically structured for camping purposes.

In a comparable way, C# and the .NET framework can be used to create applications for different environments. The language is the same in each case, but there are some specific differences in how you structure the program - depending on the environment you're working in. Here are some examples of different types of C# programs.

• Windows Forms applications

• Class libraries

• Windows services

• Console applications

• ASP.NET web applications

This book focuses on only two of these types of programs - Console applications and Windows Forms applications. But the knowledge you gain in these two environments is also directly useful in the other types of applications.

A console application is one which can display and read text only - no pictures, graphs, etc. If you've ever opened a "command prompt" and typed a command like DIR to see a list of files, then you've already used a console application. When you want to try something out quickly, or want to write a program that doesn't need anything other than text, you will often use a console application, because that's the simplest type of program you can write with C#.

Here is an example of a simple, but complete, console application:

1. using System;
2.
3. class PleaseSayYo
4. {
5.    static void Main()
6.    {
7.          Console.WriteLine("Yo!");
            Console.ReadLine();
8.    }
9. }

And this is what you'll see on the screen when you run it. It simply writes a line of text to the screen:

The program's pretty short isn't it? But let's break it down and discuss the structure.

• Line 1 tells the computer that something later on in our program is going to be using some class from the namespace called "System". The particular class whose code we'll be using is "Console". This is a class, written by Microsoft, which has all sorts of things that console applications need. Instead of us writing lots of lines of code to do something simple, like write a word to the screen, we simply call the method "WriteLine" from the System.Console class.

• Between lines 3 and 9 we "define the class". In the class we write our program by writing down properties and methods. This particular class has no properties (it just doesn't need any) but does have one method.

• Between lines 5 and 8, we define a method. This method is very much like the methods we discussed earlier in this book, but it is a special one - it MUST be called "Main" - we're not allowed to choose our own name. When the computer is asked to run a C# program, it needs to know where to start. It has been taught that, for C# programs, the programmer will always write a method called "Main" and that's where it must start - that's the entry point. You are allowed to put this method anywhere in your class - top, bottom or anywhere else - the computer will find it as long as you've called it "Main".

• In line 7, we call the "WriteLine" method from the System.Console class, which writes out the text we specify.

Console applications can, of course, do way more than what we've shown here, and they will typically have a lot more code, but generally they start out with a basic structure like the two examples shown above.

The one strange word you'll see in the program above is "static". To explain this, let's first write a slightly more complex example of a console application. Read the "Main" method through carefully - do you understand what it's doing ?

1. using System;
2. 
3. class SimpleConsoleApp
4. {
5.    public void MySimpleMethod()
6.    {
7.          Console.WriteLine("Yo!");
8.    }
9.    
10.   static void Main()
11.   {
12.         SimpleConsoleApp s;
13.         s = new SimpleConsoleApp();
14.         s.MySimpleMethod();
15.   }
16. }

This example really shows the object-oriented approach better than the previous one. Instead of just writing our code directly in the "Main" method, we have, in lines 12 and 13, declared and constructed an object - an instance of this class. Then, in line 14, we have called a method of that object.

You'll notice that the method "MySimpleMethod" does not have the word "static" in front of it, while the method "Main" does. This is why:

• The word "static" is added to the beginning of a method definition if that method is not meant for operating on a specific object.

• Now since the "Main" method is the "entry point" method, it is called before any objects are constructed - so it has to be defined as "static".

Here is a further example to illustrate the “static” concept. We draw your attention particularly to the bold text.

using System;

class SchoolTest
{
    public string testName;
    public decimal total;
    public decimal myScore;

    // A constructor method for this class
    public SchoolTest(string tn, int s, int tot)
    {
        this.testName = tn;
        this.myScore = s;
        this.total = tot;
    }

    // A STATIC method to calculate the percentage from ANY two numbers 
    public static decimal CalculateAnyPercentage(decimal numerator, decimal denominator) 
    {
        decimal percentage = (numerator / denominator) * 100; 
        return percentage; 
    }

    // An INSTANCE method to calculate the percentage of an instance of SchoolTest 
    public decimal CalculateThisPercentage() 
    { 
        decimal percentage = (this.myScore / this.total) * 100; 
        return percentage; 
    } 

    static void Main()
    {
        // Use the static method to calculate a percentage without any instance
        Console.WriteLine("123/200 = " + SchoolTest.CalculateAnyPercentage(123, 200));

        // Create a new instance of a SchoolTest, passing in the scores
        SchoolTest t = new SchoolTest("Geography", 12, 60);

        // Use the instance method to calculate the percentage of this instance
        Console.WriteLine( "Percentage for test = " + t.CalculateThisPercentage() );

        // Wait until ENTER is pressed
        Console.ReadLine();
    }
}

The important thing to notice is that we have two very similar methods – they both calculate percentages – but their usage is quite different. The one with the word “static” in it can be used without any need to declare a new SchoolTest() instance, while the other one can ONLY work on an instance. In the above example, our instance is named “t”.

So static methods have a kind of “I’m above all this – I work where I want to!” feel to them, while instance methods acknowledge “I only come into being when an actual object arises – and then I only work inside that object”.

Once you know the general structure of a Console application, it's easy to graduate to more complex program types, because the basic structure remains the same. Here is a simple Windows forms application.

using System.Windows.Forms;

class SimpleWindowsApp : Form
{
      // Constructor method

      public SimpleWindowsApp()
      {
            this.Text = "A really Simple Form";
      }

      // Entry point for the program

      static void Main()
      {
            Application.Run( new SimpleWindowsApp() );
      }
}

The two "new" things here are:

1. The ": Form" piece

   This is saying "my class is going to inherit everything from the class called 'Form'". This is quite an important secret, discussed in the chapter named “Inheritance”. Microsoft has written a large set of classes which know how to create buttons, menus, picture boxes, checkboxes and all sorts of other things to put in applications. Simply by adding ": Form", your own class can suddenly have access to all those things.

2. The "Application.Run" bit. This is the standard way to start a Windows forms application. It is a method which "runs" your forms application. You pass to that method a new instance of your class.

The "System.Drawing" part of the .NET Framework Class Library contains many useful classes for working with pictures.  Let's use it to illustrate how to use other people's code in your own program.

The System.Drawing.Image class has a method called RotateFlip, which will rotate (turn around) or flip (reverse) any picture that you pass to it. Suppose you want to use that method in your own program - you want to load a picture file from disk, flip it horizontally, and save a copy of the flipped picture back to disk. Here's one way to do so. This is a complete, working program. (If you're experimenting, note that program 9 in the collection of example files provided with this book, is a similar program).

class PhotoSizer
{
      public PhotoSizer()
      {
            // Load a photograph from disk into the computer's memory
            System.Drawing.Image img;
            img = new System.Drawing.Bitmap(@"d:\samples\myDog.jpg");

            // Flip the image horizontally
            img.RotateFlip( System.Drawing.RotateFlipType.RotateNoneFlipX );

            // Save the flipped photo to a different disk file
            img.Save( @"d:\samples\myDogFlipped.jpg" );
      }

      static void Main()
      {
            PhotoSizer p = new PhotoSizer();
      }
}

A quick note about the @ symbol :

The C# @ symbol used above can be added at the beginning of a string to “escape” or ignore backslash characters if the path includes special characters like backslashes. Backslashes can confuse C# as they have special meaning. So usually you would have to write such a path with double backslashes, such as d:\\samples\\myDog.jpg. The @ symbol avoids the need to do that.)

What we've done in the example above is to use a class from a library. The class is called Image and it is in the section of the library called System.Drawing.

After creating an Image object, we called two methods of the image class. The methods' names are RotateFlip and Save.

But you can see that each time you need to talk about something in the System.Drawing space, you need to write those long words again. This is a waste of energy and there is a way to avoid it. Instead, you can tell your program once at the top that you'll be "using" some things from the System.Drawing namespace as well as some things from the System.Drawing.Imaging namespace specifically.

using System.Drawing;
using System.Drawing.Imaging;
  
class PhotoSizer
{
      public PhotoSizer()
      {
            // Load a photograph from disk into the computer's memory
            Image img = new Bitmap(@"d:\samples\myDog.jpg");

            // Flip the image horizontally
            img.RotateFlip( RotateFlipType.RotateNoneFlipX );

            // Save the flipped photo to a different disk file
            img.Save( @" d:\samples\myDogFlipped.jpg" );
      }

      static void Main()
      {
            PhotoSizer p = new PhotoSizer();
      }
}

When creating a Visual C# Express project, it is also necessary to create something called a "reference" pointing to the Class Library file which holds the library code you want to use (these files have a “.dll” extension that stands for “Dynamic Link Library"). Fortunately, the most common references are usually added for you automatically.

The picture below, for example, shows the references that are added when you create a “Windows Application” project. Visual C# Express guesses the parts of the library that it thinks you might use for an application like that.

In the example above, you can see that the classes of the System.Drawing namespace are held in a file called System.Drawing.dll.

If the part of the library you want to use has not been automatically referenced for you, you need to add a reference yourself. Suppose, for example, you find a code example that uses the System.Web.HttpRequest class to retrieve some information from a web server, and you want to try it. You would right-click on “References”, select “Add Reference” and select the System.Web part of the library. Now you will find you can use its classes in your code.

So it's quite simple to include code from a library. The hard part is knowing what classes, methods, etc. are available for you to use in this vast library.

That's why part IV of this book has been written - to expose you to some of the useful parts of Microsoft's .NET Framework class library.