In this chapter, you were introduced to some of the tools that you will use throughout the rest of this book. You have had a quick tour around the Visual Studio .NET development environment and used it to build two types of applications. The simpler of these, the console application, is quite enough for most of your needs and allows you to focus on the basics of C# programming. Windows applications are more complicated but are visually more impressive and intuitive to use to
In this chapter, you learned:
How the Visual Studio 2005 development environment works
How to create a simple console application
How to get a Windows application up and running
Now that you know how you can create simple applications, you can get down to the real task of learning C#. The
To learn how to use C# effectively, it's important to understand what you're actually doing when you create a computer program. Perhaps the most fundamental description of a computer program is that it is a series of operations that manipulate data. This is true even of the most complicated examples, such as vast, multifeatured Windows applications like the Microsoft Office Suite. Although this is often completely hidden from the users of applications, it is always going on behind the scenes.
To
Of course, there are less abstract situations that show this just as well. If you use a calculator application, you are supplying data in the form of numbers and performing operations on these
If computer programs are fundamentally performing operations on data, then this implies that you need some way of storing that data and some
Before you start with that, though, you should take a look at the basic syntax involved in C# programming, because you need a context within which to learn about and use variables and expressions in the C# language.
The look and feel of C# code is similar to that of C++ and Java. At first, this syntax can look quite confusing and is a lot less like written English than some other languages. However, you will find as you immerse yourself in the world of C# programming that the style used is a
Unlike the compilers of some other languages, C# compilers take no notice of additional spacing in code, whether made up of spaces,
C# code is made up of a series of
statements
, each of which is
C# is a
block-structured
language, meaning that all statements are part of a
block
of code. These blocks, which are delimited with curly brackets (
{
and
}
), may contain any number of statements, or none at all. Note that the curly
So, a simple block of C# code could take the following form:
{ <code line 1, statement 1>; <code line 2, statement 2> <code line 3, statement 2>; }
Here, the < code line x, statement y > sections are not actual pieces of C# code; I've just used this text as a placeholder where C# statements would go. Note that in this case, the second and third lines of code are part of the same statement, because there is no semicolon after the second line.
In this simple section of code, I have also used indentation to clarify the C# itself. This isn't some random invention of mine, it is standard practice, and in fact VS will automatically do this for you by default. In general, each block of code has its own level of indentation, meaning how far to the right it is. Blocks of code may be nested inside each other (that is, blocks may contain other blocks), in which case nested blocks will be indented further:
{ <code line 1>; { <code line 2>; <code line 3>; } <code line 4>; }
Also, lines of code that are continuations of previous lines are usually indented further as well, as in the third line of code in the first example above.
| Note |
If you look in the VS Options dialog, accessible via Tools Options, you can find the rules that VS uses for formatting your code. There are a whole lot of these, in
|
Remember, this kind of style is by no means mandatory. If you don't use it, however, you will quickly find that things can get very confusing as you move through this book!
Another thing you will often see in C# code is
comments
. A comment is not
To mark out comments using the first method, you use /* characters at the start of the comment and */ characters at the end. These may occur on a single line, or on different lines, in which case all lines in between are part of the comment. The only thing you can't type in the body of a comment is */ , because this is interpreted as the end marker. So, the following are OK:
/* This is a comment */ /* And so... ... is this! */
But the following will cause problems:
/* Comments often end with "*/" characters */
Here, the end of the comment (the characters after " */ ") will be interpreted as C# code, and errors will occur.
The other commenting approach involves starting a comment with // . Next, you can write whatever you like — as long as you keep to one line! The following is OK:
// This is a different sort of comment.
But the following will fail, because the second line will be interpreted as C# code:
// So is this, but this bit isn't.
This sort of commenting is useful to document statements, because both can be placed on a single line:
<A statement>;
// Explanation of statement
Previously, I said that there were two ways of commenting C# code. However, there is a third type of comment in C# — although strictly speaking this is a development of the // syntax. You can use single- line comments that start with three / symbols instead of two, like this:
/// A special comment
Under normal circumstances, they are ignored by the compiler — just like other comments, but you can configure VS to extract the text after these comments and create a specially formatted text file when a project is compiled, which you can then use to create documentation. This is covered in detail in Chapter 28.
A very important point to note about C# code is that it is case-sensitive . Unlike some other languages, you must enter code using exactly the right case, because simply using an uppercase letter instead of a lower- case one will prevent a project from compiling.
This is difficult to
Console.WriteLine("The first app in Beginning C# Programming!");
This code is
console.WriteLine("The first app in Beginning C# Programming!"); CONSOLE.WRITELINE("The first app in Beginning C# Programming!"); Console.Writeline("The first app in Beginning C# Programming!");
Here, the casing used is wrong, so the C# compiler won't know what you are trying to do.
Luckily, as you soon discover, VS is very helpful when it comes to entering code, and most of the time it
Let's take a closer look at the console application example from Chapter 2 ( ConsoleApplication1 ), and break down the structure a bit. The code was:
using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { // Output text to the screen. Console.WriteLine("The first app in Beginning C# Programming!"); Console.ReadKey(); } } }
You can immediately see that all the syntactic elements discussed in the last section are present here. There are semicolons, curly braces, and comments, along with appropriate indentation.
The most important section of code as far as you're
static void Main(string[] args) { // Output text to the screen. Console.WriteLine("The first app in Beginning C# Programming!"); Console.ReadKey(); }
This is the code that is executed when you run your console application, or to be more precise, the code block
At this point, it's worth noting how to achieve the code outlining functionality that was seen in the last chapter, albeit for a Windows application, since it is such a useful feature. You can do this with the
#region
and
#endregion
keywords, which define the start and end of a region of code that can be expanded and
#region Using directives using System; using System.Collections.Generic; using System.Text; #endregion
This would allow you to collapse these lines of code into a single line, and expand it again later should you want to look at the details. the using statements contained here, and the namespace statement just underneath, will be explained at the end of this chapter.
| Note |
Note that any keyword that starts with a # is actually a preprocessor directive and not, strictly speaking, a C# keyword. Other than the two described here, #region and #endregion, these can be quite complicated, and have quite specialized uses. For that reason this is one subject you might like to investigate yourself once you have worked through this book. |
For now, you shouldn't worry about the other code in the example, because the purpose of these first few chapters is to explain basic C# syntax, so the exact method of how the application execution gets to the point where Console.WriteLine() is called is of no concern. Later on, the significance of this additional code will be made clear.