Title page image

C# 7.0 All-in-One For Dummies®

Published by: John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030-5774, www.wiley.com

Published simultaneously in Canada

No part of this publication may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, scanning or otherwise, except as permitted under Sections 107 or 108 of the 1976 United States Copyright Act, without the prior written permission of the Publisher. Requests to the Publisher for permission should be addressed to the Permissions Department, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030, (201) 748-6011, fax (201) 748-6008, or online at http://www.wiley.com/go/permissions.

Trademarks: Wiley, For Dummies, the Dummies Man logo, Dummies.com, Making Everything Easier, and related trade dress are trademarks or registered trademarks of John Wiley & Sons, Inc. and may not be used without written permission. All other trademarks are the property of their respective owners. John Wiley & Sons, Inc. is not associated with any product or vendor mentioned in this book.

LIMIT OF LIABILITY/DISCLAIMER OF WARRANTY: THE PUBLISHER AND THE AUTHOR MAKE NO REPRESENTATIONS OR WARRANTIES WITH RESPECT TO THE ACCURACY OR COMPLETENESS OF THE CONTENTS OF THIS WORK AND SPECIFICALLY DISCLAIM ALL WARRANTIES, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR PURPOSE. NO WARRANTY MAY BE CREATED OR EXTENDED BY SALES OR PROMOTIONAL MATERIALS. THE ADVICE AND STRATEGIES CONTAINED HEREIN MAY NOT BE SUITABLE FOR EVERY SITUATION. THIS WORK IS SOLD WITH THE UNDERSTANDING THAT THE PUBLISHER IS NOT ENGAGED IN RENDERING LEGAL, ACCOUNTING, OR OTHER PROFESSIONAL SERVICES. IF PROFESSIONAL ASSISTANCE IS REQUIRED, THE SERVICES OF A COMPETENT PROFESSIONAL PERSON SHOULD BE SOUGHT. NEITHER THE PUBLISHER NOR THE AUTHOR SHALL BE LIABLE FOR DAMAGES ARISING HEREFROM. THE FACT THAT AN ORGANIZATION OR WEBSITE IS REFERRED TO IN THIS WORK AS A CITATION AND/OR A POTENTIAL SOURCE OF FURTHER INFORMATION DOES NOT MEAN THAT THE AUTHOR OR THE PUBLISHER ENDORSES THE INFORMATION THE ORGANIZATION OR WEBSITE MAY PROVIDE OR RECOMMENDATIONS IT MAY MAKE. FURTHER, READERS SHOULD BE AWARE THAT INTERNET WEBSITES LISTED IN THIS WORK MAY HAVE CHANGED OR DISAPPEARED BETWEEN WHEN THIS WORK WAS WRITTEN AND WHEN IT IS READ.

For general information on our other products and services, please contact our Customer Care Department within the U.S. at 877-762-2974, outside the U.S. at 317-572-3993, or fax 317-572-4002. For technical support, please visit https://hub.wiley.com/community/support/dummies.

Wiley publishes in a variety of print and electronic formats and by print-on-demand. Some material included with standard print versions of this book may not be included in e-books or in print-on-demand. If this book refers to media such as a CD or DVD that is not included in the version you purchased, you may download this material at http://booksupport.wiley.com. For more information about Wiley products, visit www.wiley.com.

Library of Congress Control Number: 2017958295

ISBN: 978-111-9-42811-4; ISBN 978-111-9-42810-7 (ebk); ISBN ePDF 978-111-9-42812-1 (ebk)

C# 7.0 All-in-One For Dummies®

To view this book's Cheat Sheet, simply go to www.dummies.com and search for “C# 7.0 All-in-One For Dummies Cheat Sheet” in the Search box.

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

Introduction

C# is an amazing language! You can use this single language to do everything from desktop development to creating web applications and even web-based application programming interfaces (APIs). While other developers have to overcome deficiencies in their languages to create even a subset of the application types that C# supports with aplomb, you can be coding your application, testing, and then sitting on the beach enjoying the fruits of your efforts. Of course, any language that does this much requires a bit of explanation, and C# 7.0 All-in-One For Dummies is your doorway to this new adventure in development.

So, why do you need C# 7.0 All-in-One For Dummies specifically? This book stresses learning the basics of the C# language before you do anything else. With this in mind, the book begins with all the C# basics in Books 1 through 3, helps you get Visual Studio 2017 installed in Book 4, and then takes you through more advanced development tasks, including basic web development, in Books 5 through 6. Using this book helps you get the most you can from C# 7.0 in the least possible time.

About This Book

Even if you have past experience with C#, the new features in C# 7.0 will have you producing feature-rich applications in an even shorter time than you may have before. C# 7.0 All-in-One For Dummies introduces you to all these new features. For example, you discover the new pattern-matching techniques that C# 7.0 provides. You also discover the wonders of using tuples and local functions. Even the use of literals has improved, but you’ll have to look inside to find out how. This particular book is designed to make using C# 7.0 fast and easy; it removes the complexity that you may have experienced when trying to learn about these topics online.

To help you absorb the concepts, this book uses the following conventions:

Text that you’re meant to type just as it appears in the book is in bold. The exception is when you’re working through a step list: Because each step is bold, the text to type is not bold.
Words for you to type that are also in italics are meant as placeholders; you need to replace them with something that works for you. For example, if you see “Type Your Name and press Enter,” you need to replace Your Name with your actual name.
I also use italics for terms I define. This means that you don’t have to rely on other sources to provide the definitions you need.
Web addresses and programming code appear in monofont. If you’re reading a digital version of this book on a device connected to the Internet, you can click the live link to visit a website, like this: www.dummies.com.
When you need to click command sequences, you see them separated by a special arrow, like this: File ⇒ New File, which tells you to click File and then click New File.

Foolish Assumptions

You might have a hard time believing that I’ve assumed anything about you — after all, I haven’t even met you yet! Although most assumptions are indeed foolish, I made certain assumptions to provide a starting point for the book.

The most important assumption is that you know how to use Windows, have a copy of Windows properly installed, and are familiar with using Windows applications. If installing an application is still a mystery to you, you might find this book a bit hard to use. While reading this book, you need to install applications, discover how to use them, and create simple applications of your own.

You also need to know how to work with the Internet to some degree. Many of the materials, including the downloadable source, appear online, and you need to download them in order to get the maximum value from the book. In addition, Book 6 assumes that you have a certain knowledge of the Internet when working through web-based applications and web-based services.

Icons Used in This Book

As you read this book, you encounter icons in the margins that indicate material of special interest (or not, as the case may be!). Here’s what the icons mean:

Tips are nice because they help you save time or perform some task without a lot of extra work. The tips in this book are timesaving techniques or pointers to resources that you should try so that you can get the maximum benefit when performing C#-related tasks.

I don’t want to sound like an angry parent or some kind of maniac, but you should avoid doing anything that’s marked with a Warning icon. Otherwise, you might find that your configuration fails to work as expected, you get incorrect results from seemingly bulletproof processes, or (in the worst-case scenario) you lose data.

Whenever you see this icon, think advanced tip or technique. You might find these tidbits of useful information just too boring for words, or they could contain the solution you need to get a C# application running. Skip these bits of information whenever you like.

If you don’t get anything else out of a particular chapter or section, remember the material marked by this icon. This text usually contains an essential process or a bit of information that you must know to work with C#.

Beyond the Book

This book isn’t the end of your C# learning experience — it’s really just the beginning. John Mueller provides online content to make this book more flexible and better able to meet your needs. Also, you can send John email. He’ll address your book-specific questions and tell you how updates to C# or its associated add-ons affect book content through blog posts. Here are some cool online additions to this book:

Cheat sheet: You remember using crib notes in school to make a better mark on a test, don’t you? You do? Well, a cheat sheet is sort of like that. It provides you with some special notes about tasks that you can do with C# that not every other person knows. To find the cheat sheet for this book, go to www.dummies.com and search for C# 7.0 All-in-One For Dummies Cheat Sheet. It contains really neat information such as how to figure out which template you want to use.
Updates: Sometimes changes happen. For example, I might not have seen an upcoming change when I looked into my crystal ball during the writing of this book. In the past, this possibility simply meant that the book became outdated and less useful, but you can now find updates to the book at www.dummies.com.

In addition to these updates, check out the blog posts with answers to reader questions and demonstrations of useful book-related techniques at http://blog.johnmuellerbooks.com/.
Companion files: Hey! Who really wants to type all the code in the book manually? Most readers prefer to spend their time actually working with C#, creating amazing new applications that change the world, and seeing the interesting things they can do, rather than typing. Fortunately for you, the examples used in the book are available for download, so all you need to do is read the book to learn C# development techniques. You can find these files at www.dummies.com. You can also download Online Chapters 1–7. To find the source code and online chapters, search this book’s title at www.dummies.com and locate the Downloads tab on the page that appears.

Where to Go from Here

Anyone who is unfamiliar with C# should start with Book 1, Chapter 1 and move from there to the end of the book. This book is designed to make it easy for you to discover the benefits of using C# from the outset. Later, after you’ve seen enough C# code, you can install Visual Studio and then try the programming examples found in the first three minibooks.

This book assumes that you want to see C# code from the outset. However, if you want to interact with that code, you really need to have a copy of Visual Studio 2017 installed. (Some examples will not work at all with older Visual Studio versions.) With this in mind, you may want to skip right to Book 4 to discover how to get your own copy of Visual Studio 2017. To help ensure that everyone can participate, this book focuses on the features offered by Visual Studio 2017 Community Edition, which is a free download. That’s right, you can discover the wonders of C# 7.0 without paying a dime!

The more you know about C#, the further you can start in the book. If all you’re really interested in is an update of your existing skills, check out Book 1, Chapter 1 to discover the changes in C#. Then, scan the first three minibooks looking for points of interest. Install C# by using the instructions in Book 4, Chapter 1, and then move on toward the advanced techniques found in later chapters.