- •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
464 |
Part IV Working with Windows Applications |
Shortcut Menus
Many Windows-based applications make use of pop-up menus that appear when you rightclick a form or control. These menus are usually context-sensitive and display commands that
are applicable only to the control or form that currently has the focus. They are usually referred to as context or shortcut menus. You can easily add shortcut menus to a WPF application by using the ContextMenu class.
Creating Shortcut Menus
In the following exercises, you will create two shortcut menus. The first shortcut menu is attached to the firstName and lastName text box controls and allows the user to clear these
controls. The second shortcut menu is attached to the form and contains commands for saving the currently displayed member’s information and for clearing the form.
Note Text box controls are associated with a default shortcut menu that provides Cut, Copy, and Paste commands for performing text editing. The shortcut menu that you will define in the
following exercise will override this default menu.
Create the and shortcut menu
1.In the Design View window displaying Window1.xaml, add the following ContextMenu element shown in bold type to the end of the window resources in the XAML pane after the style definitions:
<Window.Resources>
...
<ContextMenu x:Key=”textBoxMenu” Style=”{StaticResource bellRingersFontStyle}”> </ContextMenu>
</Window.Resources>
This shortcut menu will be shared by the firstName and lastName text boxes. Adding the shortcut menu to the window resources makes it available to any controls in the window.
2.Add the following MenuItem element shown in bold type to the textBoxMenu shortcut menu:
<Window.Resources>
...
<ContextMenu x:Key=”textBoxMenu” Style=”{StaticResource bellRingersFontStyle}”>
<MenuItem Header=”Clear Name” Name=”clearName” />
</ContextMenu>
</Window.Resources>
Chapter 23 Working with Menus and Dialog Boxes |
465 |
This code adds to the shortcut menu a menu item called clearName with the legend “Clear Name”.
3.In the XAML pane, modify the definitions of the firstName and lastName text box controls, and add the ContextMenu property, shown here in bold type:
<TextBox ... Name=”firstName” ContextMenu=”{StaticResource textBoxMenu}” ... />
...
<TextBox ... Name=”lastName” ContextMenu=”{StaticResource textBoxMenu}” ... />
The ContextMenu property determines which menu (if any) will be displayed when the user right-clicks the control.
4.Return to the definition of the textBoxMenu style, and to the clearText menu item add a Click event method called clearName_Click. (This is the default name generated by the
<New Event Handler> command.)
<MenuItem Header=”Clear Text” Name=”clearText” Click=”clearName_Click” />
5.In the Code and Text Editor window displaying Window1.xaml.cs, add the following statements to the clearName_Click event method that the <New Event Handler> command generated:
firstName.Text = String.Empty; lastName.Text = String.Empty;
This code clears both text boxes when the user clicks the Clear Name command on the shortcut menu.
6.On the Debug menu, click Start Without Debugging to build and run the application. When the form appears, click File, and then click New Member.
7.Type a name in the First Name and Last Name text boxes. Right-click the First Name text box. On the shortcut menu, click the Clear Name command, and verify that both text boxes are cleared.
8.Type a name in the First Name and Last Name text boxes. This time, right-click the Last Name text box. On the shortcut menu, click the Clear Name command and again verify that both text boxes are cleared.
9.Right-click anywhere on the form outside the First Name and Last Name text boxes.
Only the First Name and Last Name text boxes have shortcut menus, so no pop-up menu should appear.
10.Close the form, and return to Visual Studio 2008.
Now you can add the second shortcut menu, which contains commands that the user can use to save member information and to clear the fields on the form. To provide a bit of variation, and to show you how easy it is to create shortcut menus dynamically, in the following
466 Part IV Working with Windows Applications
exercise you will create the shortcut menu by using code. The best place to put this code is in the constructor of the form. You will then add code to enable the shortcut menu for the window when the user creates a new member.
Create the window shortcut menu
1.Switch to the Code and Text Editor window displaying the Window1.xaml.cs file.
2.Add the following private variable shown in bold type to the Window1 class:
public partial class Window1 : Window
{
...
private ContextMenu windowContextMenu = null;
...
}
3.Locate the constructor for the Window1 class. This is actually the first method in the class and is called Window1. Add the statements shown in bold type after the code that calls the Reset method to create the menu items for saving member details:
public Window1()
{
InitializeComponent();
this.Reset();
MenuItem saveMemberMenuItem = new MenuItem(); saveMemberMenuItem.Header = “Save Member Details”; saveMemberMenuItem.Click += new RoutedEventHandler(saveMember_Click);
}
This code sets the Header property for the menu item and then specifies that the Click event should invoke the saveMember_Click event method; this is the same method that you wrote in an earlier exercise in this chapter. The RoutedEventHandler type is a del-
egate that represents methods for handling the events raised by many WPF controls. (For more information about delegates and events, refer to Chapter 17, “Interrupting Program Flow and Handling Events.”)
4.In the Window1 constructor, add the following statements shown in bold type to create the menu items for clearing the fields on the form and resetting them to their default values:
public Window1()
{
...
MenuItem clearFormMenuItem = new MenuItem(); clearFormMenuItem.Header = “Clear Form”; clearFormMenuItem.Click += new RoutedEventHandler(clear_Click);
}
This menu item invokes the clear_Click event method when clicked by the user.
Chapter 23 Working with Menus and Dialog Boxes |
467 |
5.In the Window1 constructor, add the following statements shown in bold type to construct the shortcut menu and populate it with the two menu items you have just created:
public Window1()
{
...
windowContextMenu = new ContextMenu(); windowContextMenu.Items.Add(saveMemberMenuItem); windowContextMenu.Items.Add(clearFormMenuItem);
}
The ContextMenu type contains a collection called Items that holds the menu items.
6.At the end of the newMember_Click event method, add the statement shown in bold type to associate the context menu with the form:
private void newMember_Click(object sender, RoutedEventArgs e)
{
...
this.ContextMenu = windowContextMenu;
}
Notice that the application associates the shortcut menu with the form only when the new member functionality is available. If you were to set the ContextMenu property of the form in the constructor, the Save Member Details and Clear Details shortcut menu
items would be available even when the controls on the form were disabled, which is not how you want this application to behave.
Tip You can disassociate a shortcut menu from a form by setting the ContextMenu property of the form to null.
7.On the Debug menu, click Start Without Debugging to build and run the application.
8.When the form appears, right-click the form and verify that the shortcut menu does not appear.
9.On the File menu, click New Member, and then input some details for a new member.
10.Right-click the form. On the shortcut menu, click Clear Form and verify that the fields on the form are reset to their default values.
11.Input some more member details. Right-click the form. On the shortcut menu, click Save Member Details. Verify that the “Member details saved” message box appears, and then click OK.
12.Close the form, and return to Visual Studio 2008.
