- •Contents at a Glance
- •Table of Contents
- •Acknowledgments
- •Introduction
- •Who This Book Is For
- •Finding Your Best Starting Point in This Book
- •Conventions and Features in This Book
- •Conventions
- •Other Features
- •System Requirements
- •Code Samples
- •Installing the Code Samples
- •Using the Code Samples
- •Support for This Book
- •Questions and Comments
- •Beginning Programming with the Visual Studio 2008 Environment
- •Writing Your First Program
- •Using Namespaces
- •Creating a Graphical Application
- •Chapter 1 Quick Reference
- •Understanding Statements
- •Identifying Keywords
- •Using Variables
- •Naming Variables
- •Declaring Variables
- •Working with Primitive Data Types
- •Displaying Primitive Data Type Values
- •Using Arithmetic Operators
- •Operators and Types
- •Examining Arithmetic Operators
- •Controlling Precedence
- •Using Associativity to Evaluate Expressions
- •Associativity and the Assignment Operator
- •Incrementing and Decrementing Variables
- •Declaring Implicitly Typed Local Variables
- •Chapter 2 Quick Reference
- •Declaring Methods
- •Specifying the Method Declaration Syntax
- •Writing return Statements
- •Calling Methods
- •Specifying the Method Call Syntax
- •Applying Scope
- •Overloading Methods
- •Writing Methods
- •Chapter 3 Quick Reference
- •Declaring Boolean Variables
- •Using Boolean Operators
- •Understanding Equality and Relational Operators
- •Understanding Conditional Logical Operators
- •Summarizing Operator Precedence and Associativity
- •Using if Statements to Make Decisions
- •Understanding if Statement Syntax
- •Using Blocks to Group Statements
- •Cascading if Statements
- •Using switch Statements
- •Understanding switch Statement Syntax
- •Following the switch Statement Rules
- •Chapter 4 Quick Reference
- •Using Compound Assignment Operators
- •Writing while Statements
- •Writing for Statements
- •Understanding for Statement Scope
- •Writing do Statements
- •Chapter 5 Quick Reference
- •Coping with Errors
- •Trying Code and Catching Exceptions
- •Handling an Exception
- •Using Multiple catch Handlers
- •Catching Multiple Exceptions
- •Using Checked and Unchecked Integer Arithmetic
- •Writing Checked Statements
- •Writing Checked Expressions
- •Throwing Exceptions
- •Chapter 6 Quick Reference
- •The Purpose of Encapsulation
- •Controlling Accessibility
- •Working with Constructors
- •Overloading Constructors
- •Understanding static Methods and Data
- •Creating a Shared Field
- •Creating a static Field by Using the const Keyword
- •Chapter 7 Quick Reference
- •Copying Value Type Variables and Classes
- •Understanding Null Values and Nullable Types
- •Using Nullable Types
- •Understanding the Properties of Nullable Types
- •Using ref and out Parameters
- •Creating ref Parameters
- •Creating out Parameters
- •How Computer Memory Is Organized
- •Using the Stack and the Heap
- •The System.Object Class
- •Boxing
- •Unboxing
- •Casting Data Safely
- •The is Operator
- •The as Operator
- •Chapter 8 Quick Reference
- •Working with Enumerations
- •Declaring an Enumeration
- •Using an Enumeration
- •Choosing Enumeration Literal Values
- •Choosing an Enumeration’s Underlying Type
- •Working with Structures
- •Declaring a Structure
- •Understanding Structure and Class Differences
- •Declaring Structure Variables
- •Understanding Structure Initialization
- •Copying Structure Variables
- •Chapter 9 Quick Reference
- •What Is an Array?
- •Declaring Array Variables
- •Creating an Array Instance
- •Initializing Array Variables
- •Creating an Implicitly Typed Array
- •Accessing an Individual Array Element
- •Iterating Through an Array
- •Copying Arrays
- •What Are Collection Classes?
- •The ArrayList Collection Class
- •The Queue Collection Class
- •The Stack Collection Class
- •The Hashtable Collection Class
- •The SortedList Collection Class
- •Using Collection Initializers
- •Comparing Arrays and Collections
- •Using Collection Classes to Play Cards
- •Chapter 10 Quick Reference
- •Using Array Arguments
- •Declaring a params Array
- •Using params object[ ]
- •Using a params Array
- •Chapter 11 Quick Reference
- •What Is Inheritance?
- •Using Inheritance
- •Base Classes and Derived Classes
- •Calling Base Class Constructors
- •Assigning Classes
- •Declaring new Methods
- •Declaring Virtual Methods
- •Declaring override Methods
- •Understanding protected Access
- •Understanding Extension Methods
- •Chapter 12 Quick Reference
- •Understanding Interfaces
- •Interface Syntax
- •Interface Restrictions
- •Implementing an Interface
- •Referencing a Class Through Its Interface
- •Working with Multiple Interfaces
- •Abstract Classes
- •Abstract Methods
- •Sealed Classes
- •Sealed Methods
- •Implementing an Extensible Framework
- •Summarizing Keyword Combinations
- •Chapter 13 Quick Reference
- •The Life and Times of an Object
- •Writing Destructors
- •Why Use the Garbage Collector?
- •How Does the Garbage Collector Work?
- •Recommendations
- •Resource Management
- •Disposal Methods
- •Exception-Safe Disposal
- •The using Statement
- •Calling the Dispose Method from a Destructor
- •Making Code Exception-Safe
- •Chapter 14 Quick Reference
- •Implementing Encapsulation by Using Methods
- •What Are Properties?
- •Using Properties
- •Read-Only Properties
- •Write-Only Properties
- •Property Accessibility
- •Understanding the Property Restrictions
- •Declaring Interface Properties
- •Using Properties in a Windows Application
- •Generating Automatic Properties
- •Initializing Objects by Using Properties
- •Chapter 15 Quick Reference
- •What Is an Indexer?
- •An Example That Doesn’t Use Indexers
- •The Same Example Using Indexers
- •Understanding Indexer Accessors
- •Comparing Indexers and Arrays
- •Indexers in Interfaces
- •Using Indexers in a Windows Application
- •Chapter 16 Quick Reference
- •Declaring and Using Delegates
- •The Automated Factory Scenario
- •Implementing the Factory Without Using Delegates
- •Implementing the Factory by Using a Delegate
- •Using Delegates
- •Lambda Expressions and Delegates
- •Creating a Method Adapter
- •Using a Lambda Expression as an Adapter
- •The Form of Lambda Expressions
- •Declaring an Event
- •Subscribing to an Event
- •Unsubscribing from an Event
- •Raising an Event
- •Understanding WPF User Interface Events
- •Using Events
- •Chapter 17 Quick Reference
- •The Problem with objects
- •The Generics Solution
- •Generics vs. Generalized Classes
- •Generics and Constraints
- •Creating a Generic Class
- •The Theory of Binary Trees
- •Building a Binary Tree Class by Using Generics
- •Creating a Generic Method
- •Chapter 18 Quick Reference
- •Enumerating the Elements in a Collection
- •Manually Implementing an Enumerator
- •Implementing the IEnumerable Interface
- •Implementing an Enumerator by Using an Iterator
- •A Simple Iterator
- •Chapter 19 Quick Reference
- •What Is Language Integrated Query (LINQ)?
- •Using LINQ in a C# Application
- •Selecting Data
- •Filtering Data
- •Ordering, Grouping, and Aggregating Data
- •Joining Data
- •Using Query Operators
- •Querying Data in Tree<TItem> Objects
- •LINQ and Deferred Evaluation
- •Chapter 20 Quick Reference
- •Understanding Operators
- •Operator Constraints
- •Overloaded Operators
- •Creating Symmetric Operators
- •Understanding Compound Assignment
- •Declaring Increment and Decrement Operators
- •Implementing an Operator
- •Understanding Conversion Operators
- •Providing Built-In Conversions
- •Creating Symmetric Operators, Revisited
- •Adding an Implicit Conversion Operator
- •Chapter 21 Quick Reference
- •Creating a WPF Application
- •Creating a Windows Presentation Foundation Application
- •Adding Controls to the Form
- •Using WPF Controls
- •Changing Properties Dynamically
- •Handling Events in a WPF Form
- •Processing Events in Windows Forms
- •Chapter 22 Quick Reference
- •Menu Guidelines and Style
- •Menus and Menu Events
- •Creating a Menu
- •Handling Menu Events
- •Shortcut Menus
- •Creating Shortcut Menus
- •Windows Common Dialog Boxes
- •Using the SaveFileDialog Class
- •Chapter 23 Quick Reference
- •Validating Data
- •Strategies for Validating User Input
- •An Example—Customer Information Maintenance
- •Performing Validation by Using Data Binding
- •Changing the Point at Which Validation Occurs
- •Chapter 24 Quick Reference
- •Querying a Database by Using ADO.NET
- •The Northwind Database
- •Creating the Database
- •Using ADO.NET to Query Order Information
- •Querying a Database by Using DLINQ
- •Creating and Running a DLINQ Query
- •Deferred and Immediate Fetching
- •Joining Tables and Creating Relationships
- •Deferred and Immediate Fetching Revisited
- •Using DLINQ to Query Order Information
- •Chapter 25 Quick Reference
- •Using Data Binding with DLINQ
- •Using DLINQ to Modify Data
- •Updating Existing Data
- •Adding and Deleting Data
- •Chapter 26 Quick Reference
- •Understanding the Internet as an Infrastructure
- •Understanding Web Server Requests and Responses
- •Managing State
- •Understanding ASP.NET
- •Creating Web Applications with ASP.NET
- •Building an ASP.NET Application
- •Understanding Server Controls
- •Creating and Using a Theme
- •Chapter 27 Quick Reference
- •Comparing Server and Client Validations
- •Validating Data at the Web Server
- •Validating Data in the Web Browser
- •Implementing Client Validation
- •Chapter 28 Quick Reference
- •Managing Security
- •Understanding Forms-Based Security
- •Implementing Forms-Based Security
- •Querying and Displaying Data
- •Understanding the Web Forms GridView Control
- •Displaying Customer and Order History Information
- •Paging Data
- •Editing Data
- •Updating Rows Through a GridView Control
- •Navigating Between Forms
- •Chapter 29 Quick Reference
- •What Is a Web Service?
- •The Role of SOAP
- •What Is the Web Services Description Language?
- •Nonfunctional Requirements of Web Services
- •The Role of Windows Communication Foundation
- •Building a Web Service
- •Creating the ProductsService Web Service
- •Web Services, Clients, and Proxies
- •Talking SOAP: The Easy Way
- •Consuming the ProductsService Web Service
- •Chapter 30 Quick Reference
Chapter 2 Working with Variables, Operators, and Expressions |
33 |
The variable type int is the name of one of the primitive C# types, integer, which is a whole number. (You’ll learn about several primitive data types later in this chapter.)
Note Microsoft Visual Basic programmers should note that C# does not allow implicit variable declarations. You must explicitly declare all variables before you use them.
After you’ve declared your variable, you can assign it a value. The following statement assigns age the value 42. Again, you’ll see that the semicolon is required.
age = 42;
The equal sign (=) is the assignment operator, which assigns the value on its right to the variable on its left. After this assignment, the age variable can be used in your code to refer to the value it holds. The next statement writes the value of the age variable, 42, to the console:
Console.WriteLine(age);
Tip If you leave the mouse pointer over a variable in the Visual Studio 2008 Code and Text Editor window, a ScreenTip appears, telling you the type of the variable.
Working with Primitive Data Types
C# has a number of built-in types called primitive data types. The following table lists the most commonly used primitive data types in C# and the range of values that you can store in each.
Data type |
Description |
Size (bits) |
Range 1 |
Sample usage |
int |
Whole numbers |
32 |
–231 through |
int count; |
|
|
|
231 – 1 |
count = 42; |
long |
Whole numbers (bigger |
64 |
–263 through |
long wait; |
|
range) |
|
263 – 1 |
wait = 42L; |
float |
Floating-point numbers |
32 |
±1.5 × 1045 through |
float away; |
|
|
|
±3.4 × 1038 |
away = 0.42F; |
double |
Double-precision (more |
64 |
±5.0 × 10−324 |
double trouble; |
|
accurate) floating-point |
|
through ±1.7 × 10308 |
trouble = 0.42; |
|
numbers |
|
|
|
|
|
|
|
|
decimal |
Monetary values |
128 |
28 significant figures |
decimal coin; |
|
|
|
|
coin = 0.42M; |
34 |
Part I Introducing Microsoft Visual C# and Microsoft Visual Studio 2008 |
|||
|
Data type |
Description |
Size (bits) |
Range 1 |
|
string |
Sequence of characters |
16 bits per |
Not applicable |
|
|
|
character |
|
Sample usage
string vest; vest = “fortytwo”;
char |
Single character |
16 |
0 through 216 – 1 |
char grill; |
|
|
|
|
grill = ‘x’; |
|
|
|
|
|
bool |
Boolean |
8 |
True or false |
bool teeth; |
teeth = false;
Unassigned Local Variables
When you declare a variable, it contains a random value until you assign a value to it. This behavior was a rich source of bugs in C and C++ programs that created a variable and accidentally used it as a source of information before giving it a value. C# does not allow you to use an unassigned variable. You must assign a value to a variable before
you can use it; otherwise, your program might not compile. This requirement is called the Definite Assignment Rule. For example, the following statements will generate a
compile-time error because age is unassigned:
int age;
Console.WriteLine(age); // compile-time error
Displaying Primitive Data Type Values
In the following exercise, you’ll use a C# program named PrimitiveDataTypes to demonstrate how several primitive data types work.
Display primitive data type values
1.Start Visual Studio 2008 if it is not already running.
2.If you are using Visual Studio 2008 Standard Edition or Visual Studio 2008 Professional Edition, on the File menu, point to Open, and then click Project/Solution.
If you are using Visual C# 2008 Express Edition, on the File menu, click Open Project. The Open Project dialog box appears.
3.Move to the \Microsoft Press\Visual CSharp Step by Step\Chapter 2\PrimitiveDataTypes
folder in your Documents folder. Select the PrimitiveDataTypes solution file, and then click Open.
The solution loads, and Solution Explorer displays the PrimitiveDataTypes project.
Chapter 2 Working with Variables, Operators, and Expressions |
35 |
Note Solution file names have the .sln suffix, such as PrimitiveDataTypes.sln. A solution can contain one or more projects. Project files have the .csproj suffix. If you open a project rather than a solution, Visual Studio 2008 will automatically create a new solution file for it. If you build the solution, Visual Studio 2008 automatically saves any new or updated files, so you will be prompted to provide a name and location for the new solution file.
4.On the Debug menu, click Start Without Debugging. The following application window appears:
5.In the Choose a data type list, click the string type. The value “forty two” appears in the Sample value box.
6.Click the int type in the list.
The value to do appears in the Sample value box, indicating that the statements to display an int value still need to be written.
7.Click each data type in the list. Confirm that the code for the double and bool types also must be completed.
8.Click Quit to close the window and stop the program.
Control returns to the Visual Studio 2008 programming environment.
Use primitive data types in code
1.In Solution Explorer, double-click Window1.xaml.
The WPF form for the application appears in the Design View window.
2.Right-click anywhere in the Design View window displaying the Window1.xaml form, and then click View Code.
The Code and Text Editor window opens, displaying the Window1.xaml.cs file.
36 |
Part I Introducing Microsoft Visual C# and Microsoft Visual Studio 2008 |
Note Remember that you can also use Solution Explorer to access the code; click the plus sign, +, to the left of the Window1.xaml file, and then double-click Window1.xaml.cs.
3. In the Code and Text Editor window, find the showFloatValue method.
Tip To locate an item in your project, on the Edit menu, point to Find and Replace, and then click Quick Find. A dialog box opens, asking what you want to search for. Type the
name of the item you’re looking for, and then click Find Next. By default, the search is not
case-sensitive. If you want to perform a case-sensitive search, click the plus button, +, next to the Find Options label to display additional options, and select the Match Case check
box. If you have time, you can experiment with the other options as well.
You can also press Ctrl+F (press the Control key, and then press F) to display the Quick Find
dialog box rather than using the Edit menu. Similarly, you can press Ctrl+H to display the
Quick Replace dialog box.
The showFloatValue method runs when you click the float type in the list box. This method contains the following three statements:
float variable; variable=0.42F; value.Text = “0.42F”;
The first statement declares a variable named variable of type float.
The second statement assigns variable the value 0.42F. (The F is a type suffix specifying
that 0.42 should be treated as a float value. If you forget the F, the value 0.42 will be treated as a double, and your program will not compile because you cannot assign a
value of one type to a variable of a different type without writing additional code—C# is very strict in this respect.)
The third statement displays the value of this variable in the value text box on the
form. This statement requires a little bit of your attention. The way in which you display an item in a text box is to set its Text property. Notice that you access the property
of an object by using the same “dot” notation that you saw for running a method. (Remember Console.WriteLine from Chapter 1?) The data that you put in the Text prop-
erty must be a string (a sequence of characters enclosed in double quotation marks), and not a number. If you try to assign a number to the Text property, your program
will not compile. In this program, the statement simply displays the text “0.42F” in the
text box. In a real-world application, you would add statements that convert the value of the variable variable into a string and then put this into the Text property, but you
need to know a little bit more about C# and the Microsoft .NET Framework before you can do that. (Chapter 11, “Understanding Parameter Arrays,” and Chapter 21, “Operator Overloading,” cover data type conversions.)
Chapter 2 Working with Variables, Operators, and Expressions |
37 |
4. In the Code and Text Editor window, locate the showIntValue method. It looks like this:
private void showIntValue()
{
value.Text = “to do”;
}
The showIntValue method is called when you click the int type in the list box.
Tip Another way to find a method in the Code and Text Editor window is to click the Members drop-down list that appears above the window, to the right. This window displays a list of all the methods (and other items) in the class displayed in the Code and Text Editor window. You can click the name of a member, and you will be taken directly to it in the Code and Text Editor window.
5.Type the following two statements at the start of the showIntValue method, on a new line after the opening brace, as shown in bold type in the following code:
private void showIntValue()
{
int variable; variable = 42;
}
6.In the original statement in this method, change the string “to do” to “42”. The method should now look exactly like this:
private void showIntValue()
{
int variable; variable = 42; value.Text = “42”;
}
Note If you have previous programming experience, you might be tempted to change the third statement to
value.Text = variable;
This looks like it should display the value of variable in the value text box on the form. However, C# performs strict type checking; text boxes can display only string values, and variable is an int, so this statement will not compile. You will see how to convert between
numeric and string values later in this chapter.
7.On the Debug menu, click Start Without Debugging. The form appears again.
