Microsoft Visual C# 2010 Step by Step

Description

Covers the fundamentals of Visual C# and how to use it to build .NET-connected applications, covering topics including syntax, Web services, and operators. Cover Copyright page Acknowledgments Introduction Who This Book Is For Finding Your Best Starting Point in This Book Conventions and Features in This Book Conventions Other Features Prerelease Software Hardware and Software Requirements Code Samples Installing the Code Samples Using the Code Samples Uninstalling the Code Samples Find Additional Content Online Support for This Book Questions and Comments Part I: Introducing Microsoft Visual C# and Microsoft Visual Studio 2010 Chapter 1: Welcome to C# Beginning Programming with the Visual Studio 2010 Environment Writing Your First Program Using Namespaces Creating a Graphical Application Chapter 1 Quick Reference Chapter 2: Working with Variables, Operators, and Expressions Understanding Statements Using Identifiers Identifying Keywords Using Variables Naming Variables Declaring Variables Working with Primitive Data Types Unassigned Local Variables 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 Prefix and Postfix Declaring Implicitly Typed Local Variables Chapter 2 Quick Reference Chapter 3: Writing Methods and Applying Scope Creating Methods Declaring a Method Returning Data from a Method Calling Methods Specifying the Method Call Syntax Applying Scope Defining Local Scope Defining Class Scope Overloading Methods Writing Methods Using Optional Parameters and Named Arguments Defining Optional Parameters Passing Named Arguments Resolving Ambiguities with Optional Parameters and Named Arguments Chapter 3 Quick Reference Chapter 4: Using Decision Statements Declaring Boolean Variables Using Boolean Operators Understanding Equality and Relational Operators Understanding Conditional Logical Operators Short-Circuiting 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 Chapter 5: Using Compound Assignment and Iteration Statements Using Compound Assignment Operators Writing while Statements Writing for Statements Understanding for Statement Scope Writing do Statements Chapter 5 Quick Reference Chapter 6: Managing Errors and Exceptions Coping with Errors Trying Code and Catching Exceptions Unhandled Exceptions Using Multiple catch Handlers Catching Multiple Exceptions Using Checked and Unchecked Integer Arithmetic Writing Checked Statements Writing Checked Expressions Throwing Exceptions Using a finally Block Chapter 6 Quick Reference Part II: Understanding the C# Language Chapter 7: Creating and Managing Classes and Objects Understanding Classification The Purpose of Encapsulation Defining and Using a Class 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 Static Classes Anonymous Classes Chapter 7 Quick Reference Chapter 8: Understanding Values and References 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 Chapter 9: Creating Value Types with Enumerations and Structures 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 Chapter 10: Using Arrays and Collections 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 Using Multidimensional Arrays Using Arrays to Play Cards 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 Chapter 11: Understanding Parameter Arrays Using Array Arguments Declaring a params Array Using params object[ ] Using a params Array Comparing Parameters Arrays and Optional Parameters Chapter 11 Quick Reference Chapter 12: Working with Inheritance What Is Inheritance? Using Inheritance 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 Chapter 13: Creating Interfaces and Defining Abstract Classes Understanding Interfaces Defining an Interface Implementing an Interface Referencing a Class Through Its Interface Working with Multiple Interfaces Explicitly Implementing an Interface Interface Restrictions Defining and Using Interfaces Abstract Classes Abstract Methods Sealed Classes Sealed Methods Implementing and Using an Abstract Class Chapter 13 Quick Reference Chapter 14: Using Garbage Collection and Resource Management 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 Implementing Exception-Safe Disposal Chapter 14 Quick Reference Part III: Creating Components Chapter 15: Implementing Properties to Access Fields 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 Chapter 16: Using Indexers 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 Chapter 17: Interrupting Program Flow and Handling Events 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 Enabling Notifications with Events 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 Chapter 18: Introducing Generics 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 Defining a Generic Method to Build a Binary Tree Variance and Generic Interfaces Covariant Interfaces Contravariant Interfaces Chapter 18 Quick Reference Chapter 19: Enumerating Collections Enumerating the Elements in a Collection Manually Implementing an Enumerator Implementing the IEnumerable Interface Implementing an Enumerator by Using an Iterator A Simple Iterator Defining an Enumerator for the Tree Class by Using an Iterator Chapter 19 Quick Reference Chapter 20: Querying In-Memory Data by Using Query Expressions What Is Language Integrated Query? Using LINQ in a C# Application Selecting Data Filtering Data Ordering, Grouping, and Aggregating Data Joining Data Using Query Operators Querying Data in Tree Objects LINQ and Deferred Evaluation Chapter 20 Quick Reference Chapter 21: Operator Overloading Understanding Operators Operator Constraints Overloaded Operators Creating Symmetric Operators Understanding Compound Assignment Evaluation Declaring Increment and Decrement Operators Comparing Operators in Structures and Classes Defining Operator Pairs Implementing Operators Understanding Conversion Operators Providing Built-in Conversions Implementing User-Defined Conversion Operators Creating Symmetric Operators, Revisited Writing Conversion Operators Chapter 21 Quick Reference Part IV: Building Windows Presentation Foundation Applications Chapter 22: Introducing Windows Presentation Foundation Creating a WPF Application Building the WPF 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 Chapter 23: Gathering User Input 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 Improving Responsiveness in a WPF Application Chapter 23 Quick Reference Chapter 24: Performing Validation Validating Data Strategies for Validating User Input An Example—Order Tickets for Events Performing Validation by Using Data Binding Changing the Point at Which Validation Occurs Chapter 24 Quick Reference Part V: Managing Data Chapter 25: Querying Information in a Database 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 LINQ to SQL Defining an Entity Class Creating and Running a LINQ to SQL Query Deferred and Immediate Fetching Joining Tables and Creating Relationships Deferred and Immediate Fetching Revisited Defining a Custom DataContext Class Using LINQ to SQL to Query Order Information Chapter 25 Quick Reference Chapter 26: Displaying and Editing Data by Using the Entity Framework and Data Binding Using Data Binding with the Entity Framework Using Data Binding to Modify Data Updating Existing Data Handling Conflicting Updates Adding and Deleting Data Chapter 26 Quick Reference Part VI: Building Professional Solutions with Visual Studio 2010 Chapter 27: Introducing the Task Parallel Library Why Perform Multitasking by Using Parallel Processing? The Rise of the Multicore Processor Implementing Multitasking in a Desktop Application Tasks, Threads, and the ThreadPool Creating, Running, and Controlling Tasks Using the Task Class to Implement Parallelism Abstracting Tasks by Using the Parallel Class Returning a Value from a Task Using Tasks and User Interface Threads Together Canceling Tasks and Handling Exceptions The Mechanics of Cooperative Cancellation Handling Task Exceptions by Using the AggregateException Class Using Continuations with Canceled and Faulted Tasks Chapter 27 Quick Reference Chapter 28: Performing Parallel Data Access Using PLINQ to Parallelize Declarative Data Access Using PLINQ to Improve Performance While Iterating Through a Collection Specifying Options for a PLINQ Query Canceling a PLINQ Query Synchronizing Concurrent Imperative Data Access Locking Data Synchronization Primitives in the Task Parallel Library Cancellation and the Synchronization Primitives The Concurrent Collection Classes Using a Concurrent Collection and a Lock to Implement Thread-Safe Data Access Chapter 28 Quick Reference Chapter 29: Creating and Using a Web Service What Is a Web Service? The Role of Windows Communication Foundation Web Service Architectures SOAP Web Services REST Web Services Building Web Services Creating the ProductInformation SOAP Web Service SOAP Web Services, Clients, and Proxies Consuming the ProductInformation SOAP Web Service Creating the ProductDetails REST Web Service Consuming the ProductDetails REST Web Service Chapter 29 Quick Reference Appendix: Interoperating with Dynamic Languages Summary Index About the Author Survey page