C# 2010 All-in-One For Dummies

C# 2010 All-In-One For Dummies®
	About the Authors
	Dedication
	Acknowledgments
	Table of Contents
	Introduction
	Book I: Basics of C# Programming
		Chapter 1: Creating Your First C# Console Application
			Getting a Handle on Computer Languages, C#, and .NET
			Creating Your First Console Application
			Making Your Console App Do Something
			Reviewing Your Console Application
			Introducing the Toolbox Trick
		Chapter 2: Living with Variability — Declaring Value-Type Variables
			Declaring a Variable
			What’s an int?
			Representing Fractions
			Handling Floating-Point Variables
			Using the Decimal Type: Is It an Integer or a Float?
			Examining the bool Type: Is It Logical?
			Checking Out Character Types
			What’s a Value Type?
			Comparing string and char
			Calculating Leap Years: DateTime
			Declaring Numeric Constants
			Changing Types: The Cast
			Letting the C# Compiler Infer Data Types
		Chapter 3: Pulling Strings
			The Union Is Indivisible, and So Are Strings
			Performing Common Operations on a String
			Comparing Strings
			What If I Want to Switch Case?
			Looping through a String
			Searching Strings
			Getting Input from the Command Line
			Controlling Output Manually
			Formatting Your Strings Precisely
			StringBuilder: Manipulating Strings More Efficiently
		Chapter 4: Smooth Operators
			Performing Arithmetic
			Performing Logical Comparisons — Is That Logical?
			Matching Expression Types at TrackDownAMate.com
		Chapter 5: Getting Into the Program Flow
			Branching Out with if and switch
			Here We Go Loop-the-Loop
			Looping a Specified Number of Times with for
			Nesting Loops
			Don’t goto Pieces
		Chapter 6: Lining Up Your Ducks with Collections
			The C# Array
			A Loop Made
			Array
			Sorting Arrays of Data
			New Feature: Using var for Arrays
			Loosening Up with C# Collections
			Understanding Collection Syntax
			Using Lists
			Using Dictionaries
			Array and Collection Initializers
			Using Sets
			On Not Using Old-Fashioned Collections
		Chapter 7: Stepping through Collections
			Iterating through a Directory of Files
			Iterating
			Collections: Iterators
			Accessing Collections the Array Way: Indexers
			Looping Around the Iterator Block
		Chapter 8: Buying Generic
			Writing a New Prescription: Generics
			Classy Generics: Writing Your Own
		Chapter 9: Some Exceptional Exceptions
			Using an Exceptional Error-Reporting Mechanism
			Throwing Exceptions Yourself
			Knowing What Exceptions Are For
			Can I Get an Exceptional Example?
			Assigning Multiple catch Blocks
			Planning Your Exception-Handling Strategy
			Grabbing Your Last Chance to Catch an Exception
	Book II: Object-Oriented C# Programming
		Chapter 1: Object-Oriented Programming: What’s It All About?
			Object-Oriented Concept # 1: Abstraction
			Object-Oriented Concept # 2: Classification
			Why Classify?
			Object-Oriented Concept # 3: Usable Interfaces
			Object-Oriented Concept # 4: Access Control
			How C# Supports Object-Oriented Concepts
		Chapter 2: Showing Some Class
			Defining a Class and an Object
			Accessing the Members of an Object
			An Object-Based Program Example
			Discriminating between Objects
			Can You Give Me References?
			Classes That Contain Classes Are the Happiest Classes in the World
			Generating Static in Class Members
			Defining const and readonly Data Members
		Chapter 3: We Have Our Methods
			Defining and Using a Method
			A Method Example for Your Files
			Having Arguments with Methods
			Returning Values after Christmas
		Chapter 4: Let Me Say This about
			Passing an Object to a Method
			Defining Methods
			Accessing the Current Object
		Chapter 5: Holding a Class Responsible
			Restricting Access to Class Members
			Why You Should Worry about Access Control
			Defining Class Properties
			Getting Your Objects Off to a Good Start — Constructors
			The C#-Provided Constructor
			Replacing the Default Constructor
		Chapter 6: Inheritance: Is That All I Get?
			Class Inheritance
			Why You Need Inheritance
			Inheriting from a BankAccount Class ( A More Complex Example)
			IS_ A versus HAS_A — I’m So Confused_A
			When to IS_A and When to HAS_A
			Other Features That Support Inheritance
			The object Class
			Inheritance and the Constructor
			The Updated BankAccount Class
		Chapter 7: Poly-what-ism?
			Overloading an Inherited Method
			Polymorphism
			The Class Business Card: ToString()
			C# During Its Abstract Period
			Sealing a Class
		Chapter 8: Interfacing with the Interface
			Introducing CAN_ BE_USED_AS
			Knowing What an Interface Is
			Using an Interface
			Using the C# Predefined Interface Types
			Looking at a Program That CAN_ BE_ USED_ AS an Example
			Unifying Class Hierarchies
			Hiding Behind an Interface
			Inheriting an Interface
			Using Interfaces to Manage Change in Object-Oriented Programs
		Chapter 9: Delegating Those Important Events
			E.T., Phone Home — The Callback Problem
			Defining a Delegate
			Pass Me the Code, Please — Examples
			A More Real-World Example
			Shh! Keep It Quiet — Anonymous Methods
			Stuff Happens — C# Events
		Chapter 10: Can I Use Your Namespace in the Library?
			Dividing a Single Program into Multiple Source Files
			Dividing a Single Program into Multiple Assemblies
			Putting Your Classes into Class Libraries
			Going Beyond Public and Private: More Access Keywords
			Putting Classes into Namespaces
	Book III: Designing for C#
		Chapter 1: Writing Secure Code
			Designing Secure Software
			Building Secure Windows Applications
			Building Secure Web Forms Applications
			Using System.Security
		Chapter 2: Accessing Data
			Getting to Know System. Data
			How the Data Classes Fit into the Framework
			Getting to Your Data
			Using the System.Data Namespace
		Chapter 3: Fishing the FileStream
			Going Where the Fish Are: The File Stream
			StreamWriting for Old Walter
			Pulling Them Out of the Stream: Using StreamReader
			More Readers and Writers
			Exploring More Streams than Lewis and Clark
		Chapter 4: Accessing the Internet
			Getting to Know System.Net
			How Net Classes Fit into the Framework
			Using the System.Net Namespace
		Chapter 5: Creating Images
			Getting to Know System. Drawing
			How the Drawing Classes Fit into the Framework
			Using the System. Drawing Namespace
	Book IV: A Tour of Visual Studio
		Chapter 1: Getting Started with Visual Studio
			Versioning the Versions
			Installing Visual Studio
			Breaking Down the Projects
		Chapter 2: Using the Interface
			Designing in the Designer
			Paneling the Studio
			Coding in Code View
			Using the Tools of the Trade
		Chapter 3: Customizing Visual Studio
			Setting Options
			Using Snippets
			Hacking the Project Types
		Chapter 4: Transforming Text Templates
			Getting to Know T4
			Figuring Out When to Use T4
			Setting Up the Environment
			Using Some of the T4 Directives
	Book V: Windows Development with WPF
		Chapter 1: Introducing WPF
			Understanding What WPF Can Do
			Introducing XAML
			Diving In! Creating Your First WPF Application
			Whatever XAML Can Do, C# Can Do Better!
		Chapter 2: Understanding the Basics of WPF
			Using WPF to Lay Out Your Application
			Arranging Elements with Layout Panels
			Exploring Common XAML Controls
		Chapter 3: Data Binding in WPF
			Getting to Know Dependency Properties
			Exploring the Binding Modes
			Investigating the Binding Object
			Editing, Validating, Converting, and Visualizing Your Data
			Finding Out More about WPF Data Binding
		Chapter 4: Practical WPF
			Commanding Attention
			Get Your ViewModel On
	Book VI: Web Development with ASP.NET
		Chapter 1: Looking at How ASP.NET Works with C#
			Breaking Down Web Applications
			Questioning the Client
			Dealing with Web Servers
		Chapter 2: Building Web Applications
			Working in Visual Studio
			Developing with Style
		Chapter 3: Controlling Your Development Experience
			Showing Stuff to the User
			Getting Some Input from the User
			Data Binding
			Styling Your Controls
			Making Sure the Site Is Accessible
			Constructing User Controls
			Adding Custom Controls
		Chapter 4: Leveraging the . NET Framework
			Surfing Web Streams
			Securing with ASP.NET
			Navigating with Site Maps
			Managing Files
			Baking Cookies
			Tracing with TraceContext
		Chapter 5: Digging into Web Construction
			Managing Files
			Mastering Master Pages
			Testing Web Applications with Visual Studio
			Deploying Your Masterpiece
	Book VII: Service-Oriented Development
		Chapter 1: Getting Acquainted with Web Services
			Understanding Web Services
			Building Service-Oriented Applications
			Providing XML Web Services
			Building Three Sample Apps
		Chapter 2: Building Web Services with ASMX
			Getting to Know SOAP
			Making an ASMX Service
		Chapter 3: Building Web Services with WCF
			Getting to Know WCF
			Creating a WCF Service
		Chapter 4: Building Web Services with ReST
			Getting to Know ReST
			Understanding the Guiding Principles of ReST
			Changing a WCF Service to Use ReST
	Book VIII: New Features in C# 4.0
		Chapter 1: Programming Dynamically!
			Shifting C# Toward Dynamic Typing
			Programming Dynamically
			Putting Dynamic to Use
			Running with the Dynamic Language Runtime
		Chapter 2: Improving Productivity with Named and Optional Parameters
			Optional Parameters
			Named Parameters
			Overload Resolution
		Chapter 3: Helping Out with Interop
			Using Dynamic Import
			Working without Primary Interop Assemblies
			Skipping the Ref Statement
		Chapter 4: Revising Generics
			Variance
			Contravariance
			Covariance
	Index