C# 2010 All-in-One For Dummies

Introduction

C# 2010 All-in-One For Dummies represents a different way of looking at programming languages. Rather than present the standard For Dummies format, which includes only 350 pages on quite a large subject, the book was expanded to include a broader scope and just a few pages were added.

So, although you find all the original C# For Dummies goodness in this book, you also find discussions about Visual Studio, Windows Presentation Foundation (WPF), service-oriented development, Web development, and a host of other topics. This book is a one-stop shop for a C# developer.

The C# programming language is a powerful and, at some nine years old, relatively mature descendant of the earlier C, C++, and Java languages. Programming with C# is lots of fun, as you’re about to find out in this book.

Microsoft created C# as a major part of its .NET initiative. The company turned over the specifications for the C# language to the ECMA (pronounced ek-ma) international standards committee in the summer of 2000 so that any company can, in theory, come up with its own version of C# written to run on any operating system, on any machine larger than a calculator.

When the first edition of this book was published, the Microsoft C# compiler was the only game in town, and its Visual Studio .NET suite of tools was the only way to program C# (other than at the Windows command line). Since then, however, Visual Studio has undergone three major revisions — the latest is Visual Studio 2010. And, at least two other players have entered the C# game.

You can now write and compile C# programs on Windows and a variety of Unix-based machines using implementations of .NET and C#, such as Mono (www. mono-project.com), an open source software project sponsored by Novell Corporation. Version 1.2 was released in November 2006. Though Mono lags Microsoft .NET by half a version or so, it appears to be moving fast, having implemented basically all of .NET 1.1 and much of .NET 2.0, along with those versions of C#.

Both Mono and a less well developed competitor, Portable .NET (www.dotgnu.org/pnet.htm), claim to run C# programs on Windows and a variety of Unix flavors, including Linux and the Apple Macintosh operating system. At the time of this writing, Portable .NET reaches the greater number of flavors, whereas Mono boasts a more complete .NET implementation. So choosing between them can be complicated, depending on your project, your platform, and your goals. (Books about programming for these platforms are becoming available already. Check online booksellers.)

remember.eps Open source software is written by collaborating groups of volunteer programmers and is usually free to the world.

A description of how to make C# and other .NET languages portable to other operating systems is far beyond the scope of this book. But you can expect that within a few years, the C# Windows programs you discover how to write in this book will run on all sorts of hardware under all sorts of operating systems — matching the claim of Sun Microsystems’ Java language to run on any machine. That’s undoubtedly a good thing, even for Microsoft. The road to that point is still under construction, so it’s no doubt riddled with potholes and obstacles to true universal portability for C#. But it’s no longer just Microsoft’s road.

For the moment, however, Microsoft Visual Studio has the most mature versions of C# and .NET and the most feature-filled toolset for programming with them.

Note: Though three authors contributed to this book, saying I rather than we throughout the main text seemed more economical, so that’s what we (or I) do throughout.

What’s New in C# 4.0

Although much of C# 4.0 is still virtually the same as the previous version, this new version adds some exciting new features, most of which revolve around COM Interop, to assist with Office development. The big new additions that this book covers include these topics:

♦ Dynamic types: Functional programming is all the rage these days, with the cool kids programming in Ruby and Haskell. Functional programming certainly has some benefits that have a place in the more tightly woven world of C#, and dynamic typing is one of them. As supported in C++ and Visual Basic, dynamic types allow runtime declaration when you don’t know the type of a variable and then have the compiler figure it out. Properly used, dynamic typing is quite powerful; poorly used, it’s quite dangerous.

♦ Named and optional parameters: In C# 3.0, you had to provide a value for every parameter in a method call. In C# 4.0 — again, to optimize interactions with COM — you can mark parameters as optional and accept outside objects that have optional parameters.

♦ Variance in generics: Although objects in previous versions of C# are variant, generic collections of objects are invariant. This statement means that although the compiler accepts an apple when you’re asked for a fruit, it doesn’t accept a basket of apples when you’re asked for a basket of fruit. This issue is fixed in C# 4.0.

Leaving aside a few of the more esoteric and advanced additions, we mention a few smaller items here and there as appropriate. (Don’t worry if parts of this introduction are Geek to you. You’ll get there.)

Because the features of C# 4.0 all tie together for use in a single major operation — COM Interop — we bundled discussions of these features in the back of this book, in Book VIII. Throughout this book, we have updated chapters from the original C# 3.0 material wherever it seemed appropriate.

About This Book

The goal of this book is to explain C# to you. To write usable programs, you need a specific coding environment. We’re betting that most readers will use Microsoft Visual Studio, although we suggest alternatives. Because this book is an All-in-One, we give you comprehensive coverage of Visual Studio in Book IV.

The original version of C# For Dummies (like all programming language books) focused on C# as a language, not all of the things you do with C#. This version of the book — in the mondo-size All-in-One format — covers Windows development, Web development, service development, and .NET Framework development, such as graphics and databases.

Our goal is to make a one-stop shop for development with Microsoft products, though there is indeed more to the topics than fits in this book. Office development isn’t covered, for instance. SharePoint has way too much going on to cover it along with everything else (although Bill co-authored VSTO For Dummies). This book is designed to handle the vast majority of C# users, though 20 percent of our readers will be working on something that we don’t cover. Sorry about that — we’ll try to stretch the book to 1,000 pages next time.

Another point is that every programming problem is different. Although many different situations are covered between the covers of this book, your specific situation is different. Some interpolation has to be taking place. If you have a question about how your personal situation fits in, send the author an e-mail at csharpfordummies.net and we’ll try to help.

What You Need in Order to Use This Book

You need, at minimum, the .NET Common Language Runtime (CLR) before you can even execute the programs generated by C#. Visual Studio 2010 copies the CLR onto your machine as part of its installation procedure. Alternatively, you can download the entire .NET package, including the C# compiler and many other useful tools, from the Microsoft Web site at msdn.microsoft.com. Look for the .NET Software Development Kit (SDK). The book’s Web site at csharpfordummies.net explains how to get these items.

tip.eps If all you need is C#, you can download the free version of Visual Studio, Visual C# 2010 Express, from msdn.microsoft.com/vstudio/express. The Express versions include the new C# 4.0 features. Alternatively, see SharpDevelop (www.icsharpcode.net), a good, free Visual Studio workalike, which are provided on the Web site for this book.

tip.eps You can still create most of the programs in this book using earlier versions of Visual Studio, such as Visual Studio 2008, if you need to. The exceptions are the programs that cover the new features available only in C# 4.0, which we describe in Book VIII.

How to Use This Book

We’ve made this book as easy to use as possible. Figuring out a new language is hard enough — why make it any more complicated than it needs to be? Though this book is divided into eight minibooks, we use an even easier subdivision.

Books I and II comprise the bulk of the original C# For Dummies book, and they cover the C# language, updated for version 4.0. Books III and IV cover technologies that are peripheral to C#. Books V, VI, and VII cover the three main types of development you do in C# — Windows Presentation Foundation, Web development, and service-oriented programming. We finish with the (thankfully short) Book VIII, about new C# 4.0 features.

If you’re brand new, start at the beginning and read the first two minibooks. You’ll discover a lot. Really. It will seem as though you’re reading a lot of text, but it is engaging and has interesting examples.

If you’re using the .NET Framework (which you probably are), read Book III as well. If you’re using Visual Studio, read Book IV. (Note that we use Visual Studio 2010 Professional edition, so if you’re using Express or Ultimate, your screens might look slightly different.)

Finally, you can focus on your project type — Books V, VI, and VII are specific to project type, and you can pick and choose what to read. These three minibooks are organized more as a collection of related articles than as discrete book units. You’ll find them easier to use that way.

How This Book Is Organized

Here’s a brief rundown of what you’ll find in each part of this book.

Book I: The Basics of C# Programming

This minibook is the first of two that are based on the original C# For Dummies.

Book II: Object-Oriented C# Programming

In Book II, we dig into the meat of the matter and discuss which tasks C# is good for. This minibook covers how to create good class libraries and use the built-in libraries correctly. We also give you a good dose of theory and practical knowledge.

Book III: Designing for C#

.NET is essentially the set of libraries that you get to use with C#. This broad topic covers almost everything that Microsoft products can do, from coding for Windows Mobile to accessing XML files. Book III covers four of the most-needed topics:

♦ Databases

♦ Files

♦ Graphics

♦ Security

Book IV: A Tour of Visual Studio

Because Visual Studio is the tool that 95 percent of C# programmers use, it’s the tool that is the focus of Book IV. It covers the use, optimization, and customization of this graphical user interface.

Book V: Windows Development with WPF

This minibook is an unconventional choice for Windows development. For years in .NET — since its inception — the choice for Windows developers was Windows Forms, the successor to the Ruby engine in Visual Basic 6. That’s just how you build Windows applications.

Even with the introduction of C# 4.0 and Visual Studio 2010, Windows Forms is likely the most common choice for development of Windows applications. However, it’s not the future. Windows Presentation Foundation — built on the XML derivative XAML — is the future.

For that reason, we include chapters on Windows development with WPF. If you’re looking for Windows Forms 101, we include it at csharpfordummies.net.

Book VI: Web Development with ASP.NET

Some people would argue that ASP.NET Web Forms is falling by the wayside because of ASP.NET MVC, but we believe that it’s a version or two away. In this book, we look at ASP.NET application creation and form controls and the other usual suspects. (Look for MVC in the next edition of this book, though.)

Book VII: Service-Oriented Development

On the topic of Web services, we decided to give you an overview. Our experience shows that ASP.NET Web Services, Windows Communication Foundation (WCF), and REpresentational State Transfer, or ReST, are all used in the wild, so we describe a piece of all of them.

Book VIII: New Features in C# 4.0

In the last minibook in this book, we describe some of the new features in C# 4.0, with a focus on the COM Interop changes.

Icons Used in This Book

Throughout the pages of this book, we use the following icons to highlight important information:

technicalstuff.eps This scary-sounding icon flags technical information that you can skip on your first pass through the book.

tip.eps The Tip icon highlights a point that can save you a lot of time and effort.

remember.eps Remember this information. It’s important.

warning_bomb.eps Try to retain any Warning information you come across, too. This one can sneak up on you when you least expect it and generate one of those extremely hard-to-find bugs. Or, it may lead you down the garden path to La-La Land.

ontheweb.eps This icon identifies code samples you can find on the book’s Web sites. Csharp102.info has the samples for Book I and II, and many of the articles. Csharpfordummies.net has a current blog, errata, and examples for the rest of the book. This feature is designed to save you some typing time when your fingers start to cramp, but don’t abuse it: You gain a better understanding of C# when you enter the programs yourself and then use them as test beds for your explorations and experiments in C#.

Conventions Used in This Book

Throughout this book, we use several conventions to help you get your bearings. Terms that aren’t real words, such as the names of program variables, appear in this font to minimize confusion. Program listings are offset from the text this way:

use System;

namespace MyNameSpace

{

public class MyClass

{

}

}

Each listing is followed by a clever, insightful explanation. Complete programs are included on the Web site for your viewing pleasure; small code segments are not.

When you see a command arrow, as in the instruction Choose File⇒Open With⇒Notepad, you simply choose the File menu option. Then, from the menu that appears, choose Open With. Finally, from the resulting submenu, choose Notepad.

About this book’s Web site

Two main Web sites expand on the content in this book.

♦ At csharp102.info, you can find support for the original C# For Dummies book as well as a host of bonus material. A set of utilities is also included. We’ve used the SharpDevelop utility enough to know that it can handle the task of writing almost any program example in this book (with the possible exception, for now, of the new LINQ features). The Reflector tool lets you peek under the covers to see what the compiler has created from your lovely C# source code. The NUnit testing tool, wildly popular among C# programmers, makes testing your code easy, whether it’s in Visual Studio or SharpDevelop.

♦ At csharpfordummies.net, you can find the source code for all projects in this book, updated for Visual Studio 2010. We give you a set of links to other resources and a (short, we hope) list of any errata found in this book. You can also contact the authors at this site.

Additionally, you can find access to both sites at this book’s companion Web site — check out www.dummies.com/go/csharp2010aiofd.

If you encounter a situation that you can’t figure out, check the Frequently Asked Questions (FAQ) list at the original Web site for the C# For Dummies book, at csharp102.info.

In addition, both sites include bonus chapters, a list of any mistakes that may have crept into the book, and other material on C# and programming that you may find useful. Finally, you can find links to the authors’ e-mail addresses, in case you can’t find the answer to your question on the site.

Where to Go from Here

Obviously, your first step is to figure out the C# language — ideally, by using C# 2010 All-in-One For Dummies, of course. You may want to give yourself a few months of practice in writing simple C# programs before taking the next step of discovering how to create graphical Windows applications. Give yourself many months of Windows application experience before you branch out into writing programs intended to be distributed over the Internet.

In the meantime, you can keep up with C# goings and comings in several locations. First, check out the official source: msdn.microsoft.com/msdn. In addition, various programmer Web sites have extensive material on C#, including lively discussions all the way from how to save a source file to the relative merits of deterministic versus nondeterministic garbage collection. (Around Bill’s house, garbage collection is quite deterministic: It’s every Wednesday morning.) Here’s a description of a few large C# sites:

♦ msdn.microsoft.com/vcsharp, the C# home page, directs you to all sorts of C# and .NET resources.

♦ blogs.msdn.com/csharpfaq is a C# blog with Frequently Asked Questions.

♦ msdn.microsoft.com/vcsharp/team/blogs is composed of the personal blogs of C# team members.

♦ www.c-sharpcorner.com and www.codeproject.com are two major C# sites that have articles, blogs, code, job information, and other C#-related resources.

Book I

Basics of C# Programming

Chapter 1: Creating Your First C# Console Application

In This Chapter

A quick introduction to programming

Creating a simple console application

Reviewing the console application

Saving code for later

In this chapter, I explain a little bit about computers, computer languages — including the computer language C# (pronounced see sharp) — and Visual Studio 2010. Then I take you through the steps for creating a simple program written in C#.

Getting a Handle on Computer Languages, C#, and .NET

A computer is an amazingly fast but incredibly stupid servant. Computers will do anything you ask them to (within reason); they do it extremely fast — and they’re getting faster all the time.

Unfortunately, computers don’t understand anything that resembles a human language. Oh, you may come back at me and say something like, Hey, my telephone lets me dial my friend by just speaking his name. I know that a tiny computer runs my telephone. So that computer speaks English. But that’s a computer program that understands English, not the computer itself.

The language that computers truly understand is machine language. It’s possible, but extremely difficult and error-prone, for humans to write machine language.

Humans and computers have decided to meet somewhere in the middle. Programmers create programs in a language that isn’t nearly as free as human speech, but it’s a lot more flexible and easy to use than machine language. The languages occupying this middle ground — C#, for example — are high-level computer languages. (High is a relative term here.)

What’s a program?

What is a program? In a practical sense, a Windows program is an executable file that you can run by double-clicking its icon. For example, the version of Microsoft Word that I’m using to write this book is a program. You call that an executable program, or executable for short. The names of executable program files generally end with the extension .exe. Word, for example, is Winword.exe.

But a program is something else, as well. An executable program consists of one or more source files. A C# source file, for instance, is a text file that contains a sequence of C# commands, which fit together according to the laws of C# grammar. This file is known as a source file, probably because it’s a source of frustration and anxiety.

Uh, grammar? There’s going to be grammar? Just the C# kind, which is much easier than the kind most of us struggled with in junior high school.

What’s C#?

The C# programming language is one of those intermediate languages that programmers use to create executable programs. C# combines the range of the powerful but complicated C++ (pronounced see plus plus) with the ease of use of the friendly but more verbose Visual Basic. (Visual Basic’s newer .NET incarnation is almost on par with C# in most respects. As the flagship language of .NET, C# tends to introduce most new features first.) A C# program file carries the extension .cs.

Some wags have pointed out that C-sharp and D-flat are the same note, but you shouldn’t refer to this new language as D-flat within earshot of Redmond, Washington.

C# is

♦ Flexible: C# programs can execute on the current machine, or they can be transmitted over the Web and executed on some distant computer.

♦ Powerful: C# has essentially the same command set as C++ but with the rough edges filed smooth.

♦ Easier to use: C# error-proofs the commands responsible for most C++ errors, so you spend far less time chasing down those errors.

♦ Visually oriented: The .NET code library that C# uses for many of its capabilities provides the help needed to readily create complicated display frames with drop-down lists, tabbed windows, grouped buttons, scroll bars, and background images, to name just a few.

♦ Internet-friendly: C# plays a pivotal role in the .NET Framework, Microsoft’s current approach to programming for Windows, the Internet, and beyond.

tip.eps .NET is pronounced dot net.

♦ Secure: Any language intended for use on the Internet must include serious security to protect against malevolent hackers.

Finally, C# is an integral part of .NET.

remember.eps This book is primarily about the C# language. If your primary goal is to use Visual Studio, program Windows applications, or use ASP.NET, the For Dummies books on those topics go well with this book. You can find a good amount of information later in this book on how to use C# to write Windows, Web, and service applications. You can also find good stuff about robots, compilers, and artificial intelligence — in case you’re thinking of building a robot to take over the world.

What’s .NET?

.NET began several years ago as Microsoft’s strategy to open up the Web to mere mortals like you and me. Today, it’s bigger than that, encompassing everything Microsoft does. In particular, it’s the new way to program for Windows. It also gives a C-based language, C#, the simple, visual tools that made Visual Basic so popular.

A little background helps you see the roots of C# and .NET. Internet programming was traditionally very difficult in older languages such as C and C++. Sun Microsystems responded to that problem by creating the Java programming language. To create Java, Sun took the grammar of C++, made it a lot more user-friendly, and centered it around distributed development.

remember.eps When programmers say distributed, they’re describing geographically dispersed computers running programs that talk to each other — in many cases, via the Internet.

When Microsoft licensed Java some years ago, it ran into legal difficulties with Sun over changes it wanted to make to the language. As a result, Microsoft more or less gave up on Java and started looking for ways to compete with it.

Being forced out of Java was just as well because Java has a serious problem: Although Java is a capable language, you pretty much have to write your entire program in Java to get the full benefit. Microsoft had too many developers and too many millions of lines of existing source code, so Microsoft had to come up with some way to support multiple languages. Enter .NET.

.NET is a framework, in many ways similar to Java’s libraries — and the C# language is highly similar to the Java language. Just as Java is both the language itself and its extensive code library, C# is really much more than just the keywords and syntax of the C# language. It’s those things empowered by a well-organized library containing thousands of code elements that simplify doing about any kind of programming you can imagine, from Web-based databases to cryptography to the humble Windows dialog box.

Microsoft would claim that .NET is much superior to Sun’s suite of Web tools based on Java, but that’s not the point. Unlike Java, .NET doesn’t require you to rewrite existing programs. A Visual Basic programmer can add just a few lines to make an existing program Web-knowledgeable (meaning that it knows how to get data off the Internet). .NET supports all the common Microsoft languages — and hundreds of other languages written by third-party vendors. However, C# is the flagship language of the .NET fleet. C# is always the first language to access every new feature of .NET.

What is Visual Studio 2010? What about Visual C#?

(You sure ask lots of questions.) The first Visual language from Microsoft was Visual Basic. The first popular C-based language from Microsoft was Visual C++. Like Visual Basic, it had Visual in its name because it had a built-in graphical user interface (GUI — pronounced GOO-ee). This GUI included everything you needed to develop nifty-gifty C++ programs.

Eventually, Microsoft rolled all its languages into a single environment — Visual Studio. As Visual Studio 6.0 started getting a little long in the tooth, developers anxiously awaited version 7. Shortly before its release, however, Microsoft decided to rename it Visual Studio .NET to highlight this new environment’s relationship to .NET.

That sounded like a marketing ploy to me — until I started delving into it. Visual Studio .NET differed quite a bit from its predecessors — enough to warrant a new name. Visual Studio 2010 is the third-generation successor to the original Visual Studio .NET. (Book IV is full of Visual Studio goodness, including instructions for customizing it.)

remember.eps Microsoft calls its implementation of the language Visual C#. In reality, Visual C# is nothing more than the C# component of Visual Studio. C# is C#, with or without Visual Studio.

Okay, that’s it. No more questions. (For now, anyway.)

Creating Your First Console Application

Visual Studio 2010 includes an Application Wizard that builds template programs and saves you a lot of the dirty work you’d have to do if you did everything from scratch. (I don’t recommend the from-scratch approach.)

Typically, starter programs don’t really do anything — at least, not anything useful. (Sounds like most of my programs.) However, they do get you beyond that initial hurdle of getting started. Some starter programs are reasonably sophisticated. In fact, you’ll be amazed at how much capability the App Wizard can build on its own, especially for graphical programs.

This starter program isn’t even a graphical program, though. A console application is one that runs in the console within Windows, usually referred to as the DOS prompt or command window. If you press Ctrl+R and then type cmd, you see a command window. It’s the console where the application will run.

remember.eps The following instructions are for Visual Studio. If you use anything other than Visual Studio, you have to refer to the documentation that came with your environment. Alternatively, you can just type the source code directly into your C# environment. See the Introduction to this book for some alternatives to Visual Studio.

Creating the source program

To start Visual Studio, choose Start⇒All Programs⇒Microsoft Visual Studio 2010⇒Microsoft Visual Studio 2010.

Complete these steps to create your C# console app:

1. Open Visual Studio 2010 and click the New Project icon, shown in Figure 1-1.

Visual Studio presents you with lots of icons representing the different types of applications you can create, as shown in Figure 1-2.

2. In this New Project window, click the Console Application icon.

warning_bomb.eps Make sure that you select Visual C# — and under it, Windows — in the Project Types pane; otherwise Visual Studio may create something awful like a Visual Basic or Visual C++ application. Then click the Console Application icon in the Templates pane.

remember.eps Visual Studio requires you to create a project before you can start entering your C# program. A project is a folder in which you throw all the files that go into making your program. It has a set of configuration files that help the compiler do its work. When you tell your compiler to build (compile) the program, it sorts through the project to find the files it needs in order to re-create the executable program.

3. The default name for your first application is ConsoleApplication1, but change it this time to Program1 by typing in the Name field.

Figure 1-1: Creating a new project starts you down the road to a better Windows application.

Figure 1-2: The Visual Studio App Wizard is eager to create a new program for you.

tip.eps The default place to store this file is somewhere deep in your Documents directory. Maybe because I’m difficult (or maybe because I’m writing a book), I like to put my programs where I want them to go, not necessarily where Visual Studio wants them. To simplify working with this book, you can change the default program location. Follow these steps to make that happen:

a. Choose Tools⇒Options.

The Options dialog box opens.

b. Choose Projects and Solutions⇒General.

c. Select the new location in the Projects Location field, and click OK.

(I recommend C:\C#Programs for this book.)

You can create the new directory in the Projects Location dialog box at the same time. Click the folder icon with a small sunburst at the top of the dialog box. (The directory may already exist if you’ve installed the example programs from the Web site.)

You can see the Options dialog box in Figure 1-3. Leave the other fields in the project settings alone for now. Read more about customization of Visual Studio in Book IV.

Figure 1-3: Changing the default project location.

4. Click the OK button.

After a bit of disk whirring and chattering, Visual Studio generates a file named Program.cs. (If you look in the window labeled Solution Explorer, you see some other files; ignore them for now. If Solution Explorer isn’t visible, choose View⇒Solution Explorer.)

C# source files carry the extension .cs. The name Program is the default name assigned for the program file.

The contents of your first console app appear this way:

using ...

namespace Program1

{

class Program

{

static void Main(string[] args)

{

}

}

}

remember.eps Along the left edge of the code window, you see several small plus (+) and minus (–) signs in boxes. Click the + sign next to using .... This expands a code region, a handy Visual Studio feature that minimizes clutter. Here are the directives that appear when you expand the region in the default console app:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

Regions help you focus on the code you’re working on by hiding code that you aren’t. Certain blocks of code — such as the namespace block, class block, methods, and other code items — get a +/– automatically without a #region directive. You can add your own collapsible regions, if you like, by typing #region above a code section and #endregion after it. It helps to supply a name for the region, such as Public methods. This code section looks like this:

#region Public methods

... your code

#endregion Public methods

remember.eps This name can include spaces. Also, you can nest one region inside another, but regions can’t overlap.

For now, using System; is the only using directive you really need. You can delete the others; the compiler lets you know whether you’re missing one.

Taking it out for a test drive

To convert your C# program into an executable program, choose Build⇒Build Program1. Visual Studio responds with the following message:

- Build started: Project: Program1, Configuration: Debug Any CPU -

Csc.exe /noconfig /nowarn ... (and much more)

Compile complete -- 0 errors, 0 warnings

Program1 -> C:\C#Programs\ ... (and more)==Build: 1 succeeded or up-to-date, 0 failed, 0 skipped==

The key point here is the 1 succeeded part on the last line.

tip.eps As a general rule of programming, succeeded is good; failed is bad. The bad — the exceptions — is covered in Chapter 9 of this minibook.

To execute the program, choose Debug⇒Start. The program brings up a black console window and terminates immediately. (If you have a fast computer, the appearance of this window is just a flash on the screen.) The program has seemingly done nothing. In fact, this is the case. The template is nothing but an empty shell.

tip.eps An alternative command, Debug⇒Start Without Debugging, behaves a bit better at this point. Try it out.

Making Your Console App Do Something

onthecd.eps Edit the Program.cs template file until it appears this way:

using System;

namespace Program1

{

public class Program

{

// This is where your program starts.

static void Main(string[] args)

{

// Prompt user to enter a name.

Console.WriteLine(Enter your name, please:);

// Now read the name entered.

string name = Console.ReadLine();

// Greet the user with the name that was entered.

Console.WriteLine(Hello, + name);

// Wait for user to acknowledge the results.

Console.WriteLine(Press Enter to terminate...);

Console.Read();

}

}

}

tip.eps Don’t sweat the stuff following the double or triple slashes (// or ///), and don’t worry about whether to enter one or two spaces or one or two new lines. However, do pay attention to capitalization.

Choose Build⇒Build Program1 to convert this new version of Program.cs into the Program1.exe program.

From within Visual Studio 2008, choose Debug⇒Start Without Debugging. The black console window appears and prompts you for your name. (You may need to activate the console window by clicking it.) Then the window shows Hello, followed by the name entered, and displays Press Enter to terminate . . . . Pressing Enter closes the window.

technicalstuff.eps You can also execute the program from the DOS command line. To do so, open a Command Prompt window and enter the following:

CD \C#Programs\Program1\bin\Debug

Now enter Program1 to execute the program. The output should be identical to what you saw earlier. You can also navigate to the \C#Programs\Program1\bin\Debug folder in Windows Explorer and then double-click the Program1.exe file.

tip.eps To open a Command Prompt window, try choosing Tools⇒Command Prompt. If that command isn’t available on your Visual Studio Tools menu, choose Start⇒All Programs⇒Microsoft Visual Studio 2008⇒Visual Studio Tools⇒Visual Studio 2008 Command Prompt.

Reviewing Your Console Application

In the following sections, you take this first C# console app apart one section at a time to understand how it works.

The program framework

The basic framework for all console applications starts as the following:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Program1

{

public class Program

{

// This is where your program starts.

public static void Main(string[] args)

{

// Your code goes here.

}

}

}

The program starts executing right after the statement containing Main() and ends at the closed curly brace (}) following Main(). (I explain the meaning of these statements in due course. More than that, I cannot say for now.)

remember.eps The list of using directives can come immediately before or immediately after the phrase namespace Program1 {. The order doesn’t matter. You can apply using to lots of things in .NET. I explain the whole business of namespaces and using in the object-oriented programming chapters in Book II.

Comments

The template already has lots of lines, and I’ve added several other lines, such as the following (in boldface):

// This is where your program starts.

public static void Main(string[] args)

C# ignores the first line in this example. This line is known as a comment.

tip.eps Any line that begins with // or /// is free text, and C# ignores it. Consider // and /// to be equivalent for now.

Why include lines if the computer ignores them? Because comments explain your C# statements. A program, even in C#, isn’t easy to understand. Remember that a programming language is a compromise between what computers understand and what humans understand. These comments are useful while you write the code, and they’re especially helpful to the poor sap — possibly you — who tries to re-create your logic a year later. Comments make the job much easier.

tip.eps Comment early and often.

The meat of the program

The real core of this program is embedded within the block of code marked with Main(), like this:

// Prompt user to enter a name.

Console.WriteLine(Enter your name, please:);

// Now read the name entered.

string name = Console.ReadLine();

// Greet the user with the name that was entered.

Console.WriteLine(Hello, + name);

tip.eps Save a ton of routine typing with the new C# Code Snippets feature. Snippets are great for common statements like Console.WriteLine. Press Ctrl+K and then Ctrl+X to see a pop-up menu of snippets. (You may need to press Tab once or twice to open the Visual C# folder or other folders on that menu.) Scroll down the menu to cw and press Enter. Visual Studio inserts the body of a Console.WriteLine() statement with the insertion point between the parentheses, ready to go. When you have a few of the shortcuts, such as cw, for, and if, memorized, use the even quicker technique: Type cw and press Tab twice. (Also try selecting some lines of code, pressing Ctrl+K, and then pressing Ctrl+S. Choose something like if. An if statement surrounds the selected code lines.)

The program begins executing with the first C# statement: Console.WriteLine. This command writes the character string Enter your name, please: to the console.

The next statement reads in the user’s answer and stores it in a variable (a kind of workbox) named name. (See Chapter 2 of this minibook for more on these storage locations.) The last line combines the string Hello, with the user’s name and outputs the result to the console.

The final three lines cause the computer to wait for the user to press Enter before proceeding. These lines ensure that the user has time to read the output before the program continues:

// Wait for user to acknowledge the results.

Console.WriteLine(Press Enter to terminate...);

Console.Read();

This step can be important, depending on how you execute the program and depending on the environment. In particular, running your console app inside Visual Studio, or from Windows Explorer, makes the preceding lines necessary — otherwise, the console window closes so fast you can’t read the output. If you open a console window and run the program from there, the window stays open regardless.

Introducing the Toolbox Trick

The key part of the program you create in the preceding section consists of the final two lines of code:

// Wait for user to acknowledge the results.

Console.WriteLine(Press Enter to terminate...);

Console.Read();

The easiest way to re-create those key lines in each future console application you write is described in the following sections.

Saving code in the Toolbox

The first step is to save those lines in a handy location for future use in a handy place: the Toolbox window. With your Program1 console application open in Visual Studio, follow these steps:

1. In the Main() method of class Program, select the lines you want to save — in this case, the three lines mentioned previously.

2. Make sure the Toolbox window is open on the left. (If it isn’t, open it by choosing View⇒Toolbox.)

3. Drag the selected lines into the General tab of the Toolbox window and drop them. (Or copy the lines and paste them into the Toolbox.)

The Toolbox stores the lines there for you in perpetuity. Figure 1-4 shows the lines placed in the Toolbox.

Figure 1-4: Setting up the Toolbox with some handy saved text for future use.

Reusing code from the Toolbox

Now that you have your template text stored in the Toolbox, you can reuse it in all console applications you write henceforth. Here’s how to use it:

1. In Visual Studio, create a new console application as described earlier in this chapter.

2. Click in the editor at the spot where you’d like to insert some Toolbox text.

3. With the Program.cs file open for editing, make sure the Toolbox window is open. (If it isn’t, see the procedure above.)

4. In the General tab of the Toolbox window (other tabs could be showing), find the saved text you want to use and double-click it.

The selected item is inserted at the insertion point in the editor window.

With that boilerplate text in place, you can write the rest of your application above those lines. That’s it. You now have a finished console app. Try it out for about 30 seconds. Then you can check out Chapter 2 of this minibook.

Chapter 2: Living with Variability — Declaring Value-Type Variables

In This Chapter

Visiting the train station — the C# variable as storage locker

Using integers — you can count on it

Handling fractional values — what’s half a duck?

Declaring other types of variables — dates, characters, strings

Handling numeric constants — Π in the sky

Changing types — cast doesn’t mean toss

Letting the compiler figure out the type — var magic

The most fundamental of all concepts in programming is that of the variable. A C# variable is like a small box in which you can store things, particularly numbers, for later use. (The term variable is borrowed from the world of mathematics.)

Unfortunately for programmers, C# places several limitations on variables — limitations that mathematicians don’t have to consider. This chapter takes you through the steps for declaring, initializing, and using variables. It also introduces several of the most basic data types in C#.

Declaring a Variable

When the mathematician says, "n is equal to 1," that means the term n is equivalent to 1 in some ethereal way. The mathematician is free to introduce variables in a willy-nilly fashion. For example, the mathematician may say this:

x = y² + 2y + y

if k = y + 1 then

x = k²

Programmers must define variables in a particular way that’s more demanding than the mathematician’s looser style. For example, a C# programmer may write the following bit of code:

int n;

n = 1;

The first line means, "Carve off a small amount of storage in the computer’s memory and assign it the name n." This step is analogous to reserving one of those storage lockers at the train station and slapping the label n on the side. The second line says, "Store the value 1 in the variable n, thereby replacing whatever that storage location already contains. The train-locker equivalent is, Open the train locker, rip out whatever happens to be in there, and shove a 1 in its place."

remember.eps The equals symbol (=) is called the assignment operator.

technicalstuff.eps The mathematician says, "n equals 1. The C# programmer says in a more precise way, Store the value 1 in the variable n." (Think about the train locker, and you see why that’s preferable.) C# operators tell the computer what you want to do. In other words, operators are verbs and not descriptors. The assignment operator takes the value on its right and stores it in the variable on the left. We say a lot more about operators in Chapter 3 of this minibook.

What’s an int?

In C#, each variable has a fixed type. When you allocate one of those train lockers, you have to pick the size you need. If you pick an integer locker, for instance, you can’t turn around and hope to stuff the entire state of Texas in it — maybe Rhode Island, but not Texas.

For the example in the preceding section of this chapter, you select a locker that’s designed to handle an integer — C# calls it an int. Integers are the counting numbers 1, 2, 3, and so on, plus 0 and the negative numbers –1, –2, –3, and so on.

remember.eps Before you can use a variable, you must declare it. After you declare a variable as int, it can hold and regurgitate integer values, as this example demonstrates:

// Declare a variable named n - an empty train locker.

int n;

// Declare an int variable m and initialize it with the value 2.

int m = 2;

// Assign the value stored in m to the variable n.

n = m;

The first line after the comment is a declaration that creates a little storage area, n, designed to hold an integer value. The initial value of n is not specified until it is assigned a value. The second declaration not only declares an int variable m but also initializes it with a value of 2, all in one shot.

remember.eps The term initialize means to assign an initial value. To initialize a variable is to assign it a value for the first time. You don’t know for sure what the value of a variable is until it has been initialized. Nobody knows.

The final statement in the program assigns the value stored in m, which is 2, to the variable n. The variable n continues to contain the value 2 until it is assigned a new value. (The variable n doesn’t lose its value when you assign its value to m. It’s like cloning n.)

Rules for declaring variables

You can initialize a variable as part of the declaration, like this:

// Declare another int variable and give it the initial value of 1.

int p = 1;

This is equivalent to sticking a 1 into that int storage locker when you first rent it, rather than opening the locker and stuffing in the value later.

tip.eps Initialize a variable when you declare it. In most (but not all) cases, C# initializes the variable for you — but don’t rely on it to do that.

You may declare variables anywhere (well, almost anywhere) within a program.

warning_bomb.eps However, you may not use a variable until you declare it and set it to some value. Thus the last two assignments shown here are not legal:

// The following is illegal because m is not assigned

// a value before it is used.

int m;

n = m;

// The following is illegal because p has not been

// declared before it is used.

p = 2;

int p;

Finally, you cannot declare the same variable twice in the same scope (a function, for example).

Variations on a theme: Different types of int

Most simple numeric variables are of type int. However, C# provides a number of twists to the int variable type for special occasions.

All integer variable types are limited to whole numbers. The int type suffers from other limitations as well. For example, an int variable can store values only in the range from roughly –2 billion to 2 billion.

A distance of 2 billion inches is greater than the circumference of the Earth. In case 2 billion isn’t quite large enough for you, C# provides an integer type called long (short for long int) that can represent numbers almost as large as you can imagine. The only problem with a long is that it takes a larger train locker: A long consumes 8 bytes (64 bits) — twice as much as a garden-variety 4-byte (32-bit) int. C# provides several other integer variable types, as shown in Table 2-1.

As I explain in the section Declaring Numeric Constants, later in this chapter, fixed values such as 1 also have a type. By default, a simple constant such as 1 is assumed to be an int. Constants other than an int must be marked with their variable type. For example, 123U is an unsigned integer, uint.

Most integer variables are called signed, which means they can represent negative values. Unsigned integers can represent only positive values, but you get twice the range in return. As you can see from Table 2-1, the names of most unsigned integer types start with a u, while the signed types generally don’t have a prefix.

tip.eps You don’t need any unsigned integer versions in this book.

Representing Fractions

Integers are useful for most calculations. One of this book’s authors made it into the sixth grade before he ever found out that anything else existed, and he still hasn’t forgiven his sixth-grade teacher for starting him down the slippery slope of fractions.

Many calculations involve fractions, which simple integers can’t accurately represent. The common equation for converting from Fahrenheit to Celsius temperatures demonstrates the problem, like this:

// Convert the temperature 41 degrees Fahrenheit.

int fahr = 41;

int celsius = (fahr - 32) * (5 / 9)

This equation works just fine for some values. For example, 41 degrees Fahrenheit is 5 degrees Celsius. Correct, Mr. Davis, says Stephen’s sixth-grade teacher.

Okay, try a different value: 100 degrees Fahrenheit. Working through the equation, 100–32 is 68; 68 times 5//9 is 37. No, she says, The answer is 37.78. Even that’s wrong because it’s really 37.777 . . . with the 7s repeating forever, but I don’t push the point.

remember.eps An int can represent only integer numbers. The integer equivalent of 37.78 is 37. This lopping off of the fractional part of a number to get it to fit into an integer variable is called integer truncation.

technicalstuff.eps Truncation is not the same thing as rounding. Truncation lops off the fractional part. Goodbye, Charlie. Rounding picks the closest integer value. Thus, truncating 1.9 results in 1. Rounding 1.9 results in 2.

For temperatures, 37 may be good enough. It’s not like you wear short-sleeve shirts at 37.7 degrees but pull on a sweater at 37 degrees. But integer truncation is unacceptable for many, if not most, applications.

Actually, the problem is much worse than that. An int can’t handle the ratio 5//9 either; it always yields the value 0. Consequently, the equation as written in this example calculates celsius as 0 for all values of fahr. Even I admit that’s unacceptable.

ontheweb.eps This book’s Web site includes an int-based temperature-conversion program contained in the ConvertTemperatureWithRoundOff directory. At this point, you may not understand all the details, but you can see the conversion equations and execute the program ConvertTemperatureWithRoundOff.exe to see the results. (Review Chapter 1 of this minibook if you need a hand running it.)

Handling Floating-Point Variables

The limitations of an int variable are unacceptable for some applications. The range generally isn’t a problem — the double-zillion range of a 64-bit-long integer should be enough for almost anyone. However, the fact that an int is limited to whole numbers is a bit harder to swallow.

In some cases, you need numbers that can have a nonzero fractional part. Mathematicians call these real numbers. (Somehow that always seemed like a ridiculous name for a number. Are integer numbers somehow unreal?)

remember.eps Notice that I said a real number can have a nonzero fractional part — that is, 1.5 is a real number, but so is 1.0. For example, 1.0 + 0.1 is 1.1. Just keep that point in mind as you read the rest of this chapter.

Fortunately, C# understands real numbers. Real numbers come in two flavors: floating-point and decimal. Floating-point is the most common type. I describe the decimal type a little later in this chapter.

Declaring a floating-point variable

A floating-point variable carries the designation float, and you declare one as shown in this example:

float f = 1.0;

After you declare it as float, the variable f is a float for the rest of its natural instructions.

Table 2-2 describes the two kinds of floating-point types. All floating-point variables are signed. (There’s no such thing as a floating-point variable that can’t represent a negative value.)

remember.eps You might think float is the default floating-point variable type, but actually the double is the default in C#. If you don’t specify the type for, say, 12.3, C# calls it a double.

The Accuracy column in Table 2-2 refers to the number of significant digits that such a variable type can represent. For example, 5//9 is actually 0.555 . . . with an unending sequence of 5s. However, a float variable is said to have six significant digits of accuracy — which means numbers after the sixth digit are ignored. Thus 5//9 may appear this way when expressed as a float:

0.5555551457382

Here you know that all the digits after the sixth 5 are untrustworthy.

The same number — 5//9 — may appear this way when expressed as a double:

0.55555555555555557823

The double packs a whopping 15 to 16 significant digits.

tip.eps Use double variable types unless you have a specific reason to do otherwise.

Converting some more temperatures

Here’s the formula for converting from Fahrenheit to Celsius temperatures using floating-point variables:

double celsius = (fahr - 32.0) * (5.0 / 9.0)

ontheweb.eps The Web site contains a floating-point version of the temperature-conversion program called ConvertTemperatureWithFloat.

The following example shows the result of executing the double-based ConvertTemperatureWithFloat program:

Enter temp in degrees Fahrenheit:100

Temperature in degrees Celsius = 37.7777777777778

Press Enter to terminate...

Examining some limitations of floating-point variables

You may be tempted to use floating-point variables all the time because they solve the truncation problem so nicely. Sure, they use up a bit more memory. But memory is cheap these days, so why not? But floating-point variables also have limitations, which I discuss in the following sections.

Counting

You can’t use floating-point variables as counting numbers. Some C# structures need to count (as in 1, 2, 3, and so on). You know that 1.0, 2.0, and 3.0 are counting numbers just as well as 1, 2, and 3, but C# doesn’t know that. For example, given the accuracy limitations of floating-points, how does C# know that you aren’t actually saying 1.000001?

remember.eps Whether you find that argument convincing, you can’t use a floating-point variable when counting things.

Comparing numbers

You have to be careful when comparing floating-point numbers. For example, 12.5 may be represented as 12.500001. Most people don’t care about that little extra bit on the end. However, the computer takes things extremely literally. To C#, 12.500000 and 12.500001 are not the same numbers.

So, if you add 1.1 to 1.1, you can’t tell whether the result is 2.2 or 2.200001. And if you ask, Is doubleVariable equal to 2.2? you may not get the results you expect. Generally, you have to resort to some bogus comparison like this: Is the absolute value of the difference between doubleVariable and 2.2 less than .000001? In other words, within an acceptable margin of error.

technicalstuff.eps The Pentium processor plays a trick to make this problem less troublesome than it otherwise may be: It performs floating-point arithmetic in an especially long double format — that is, rather than using 64 bits, it uses a whopping 80 bits. When rounding off an 80-bit float into a 64-bit float, you (almost) always get the expected result, even if the 80-bit number was off a bit or two.

Calculation speed

Processors such as the x86 varieties used in older Windows-based PCs could perform integer arithmetic much faster than arithmetic of the floating-point persuasion. In those days, programmers would go out of their way to limit a program to integer arithmetic.

The ratio in additional speed on a Pentium III processor for a simple (perhaps too simple) test of about 300,000,000 additions and subtractions was about 3 to 1. That is, for every double add, you could have done three int adds. (Computations involving multiplication and division may show different results.)

Not-so-limited range

In the past, a floating-point variable could represent a considerably larger range of numbers than an integer type. It still can, but the range of the long is large enough to render the point moot.

warning_bomb.eps Even though a simple float can represent a very large number, the number of significant digits is limited to about six. For example, 123,456,789F is the same as 123,456,000F. (For an explanation of the F notation at the end of these numbers, see Declaring Numeric Constants, later in this chapter.)

Using the Decimal Type: Is It an Integer or a Float?

As I explain in previous sections of this chapter, both the integer and floating-point types have their problems. Floating-point variables have rounding problems associated with limits to their accuracy, while int variables just lop off the fractional part of a variable. In some cases, you need a variable type that offers the best of two worlds:

♦ Like a floating-point variable, it can store fractions.

♦ Like an integer, numbers of this type offer exact values for use in computations — for example, 12.5 is really 12.5 and not 12.500001.

Fortunately, C# provides such a variable type, called decimal. A decimal variable can represent a number between 10–28 and 10²⁸ — that’s a lot of zeros! And it does so without rounding problems.

Declaring a decimal

Decimal variables are declared and used like any variable type, like this:

decimal m1 = 100; // Good

decimal m2 = 100M; // Better

The first declaration shown here creates a variable m1 and initializes it to a value of 100. What isn’t obvious is that 100 is actually of type int. Thus, C# must convert the int into a decimal type before performing the initialization. Fortunately, C# understands what you mean — and performs the conversion for you.

The declaration of m2 is the best. This clever declaration initializes m2 with the decimal constant 100M. The letter M at the end of the number specifies that the constant is of type decimal. No conversion is required. (See the section Declaring Numeric Constants, later in this chapter.)

Comparing decimals, integers, and floating-point types

The decimal variable type seems to have all the advantages and none of the disadvantages of int or double types. Variables of this type have a very large range, they don’t suffer from rounding problems, and 25.0 is 25.0 and not 25.00001.

The decimal variable type has two significant limitations, however. First, a decimal is not considered a counting number because it may contain a fractional value. Consequently, you can’t use them in flow-control loops, which I explain in Chapter 5 of this minibook.

The second problem with decimal variables is equally as serious or even more so. Computations involving decimal values are significantly slower than those involving either simple integer or floating-point values — and I do mean significant. On a crude benchmark test of 300,000,000 adds and subtracts, the operations involving decimal variables were approximately 50 times slower than those involving simple int variables. The relative computational speed gets even worse for more complex operations. Besides that, most computational