by John Paul Mueller, Bill Sempf, and Chuck Sphar

6 Books in One

Book 1: The Basics of C# Programming

Book 2: Object-Oriented C# Programming

Book 3: Designing for C#

Book 4: A Tour of Visual Studio

Book 5: Windows Development with WPF

Book 6: Web Development with ASP.NET

Purchase Now !
Just with Paypal

Book Details

Price	5.00 USD
Pages	827 p
File Size	9,900 KB
File Type	PDF format
ISBN ISBN ePDF	978-111-9-42811-4 978-111-9-42810-7 (ebk) 978-111-9-42812-1 (ebk)
Copyright	2018 by John Wiley & Sons, Inc

About the Author

John Mueller is a freelance author and technical editor. He has writing in his

blood, having produced 104 books and more than 600 articles to date. The

topics range from networking to artificial intelligence and from database

management to heads-down programming. Some of his current works include

a book about machine learning, a couple of Python books, and a book about

MATLAB. He has also written AWS For Admins For Dummies, which

provides administrators with a great place to start with AWS, and AWS For

Developers For Dummies, the counterpart for developers. His technical

editing skills have helped more than 70 authors refine the content of their

manuscripts. John has always been interested in development and has written

about a wide variety of languages, including a highly successful C++ book.

Be sure to read John’s blog at http://blog.johnmuellerbooks.com/. You

can reach John on the Internet at John@JohnMuellerBooks.com.

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.

Table of Contents

Cover

Introduction

About This Book

Foolish Assumptions

Icons Used in This Book

Beyond the Book

Where to Go from Here

Book 1: The 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

Processing Arrays by Using foreach

Sorting Arrays of Data

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 foreach 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

Revising Generics

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

Throwing Expressions

Chapter 10: Creating Lists of Items with

Enumerations

Seeing Enumerations in the Real World

Working with Enumerations

Creating Enumerated Flags

Defining Enumerated Switches

Book 2: 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

Returning Multiple Values Using Tuples

Chapter 4: Let Me Say This about this

Passing an Object to a Method

Defining Methods

Accessing the Current Object

Using Local Functions

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

Using Expression-Bodied Members

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

Chapter 11: Improving Productivity with Named

and Optional Parameters

Exploring Optional Parameters

Looking at Named Parameters

Dealing with Overload Resolution

Using Alternative Methods to Return Values

Chapter 12: Interacting with Structures

Comparing Structures to Classes

Creating Structures

Using Structures as Records

Book 3: 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 File Stream

Going Where the Fish Are: The File Stream

StreamWriting for Old Walter

Pulling Them Out of the Stream: Using StreamReader

C# 7.0 All-in-One For Dummies

by John Paul Mueller, Bill Sempf, and Chuck Sphar

6 Books in One

Contact Form