Hands-On Object-Oriented Programming with C#电子书

Title Page

Copyright and Credits

Hands-On Object-Oriented Programming with C#

About Packt

Why subscribe?

Packt.com

Contributors

About the author

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Conventions used

Get in touch

Reviews

Overview of C# as a Language

Evolution of C#

Managed code

Generics

LINQ

Dynamics

Async/await

Compiler as a service

Exception filters

C# 8 and beyond

Architecture of .NET

Common Language Runtime

Common Type System

.NET framework class libraries

Just-in-time compiler

Fundamentals and syntax of C# language

Data types

Nullable types

Literals

Boolean

Integer

Real

Character

String

Programming syntax – conditions

If-else construct

Switch-case construct

goto statements

Programming syntax – loops

The while construct

The do-while construct

The for construct

The foreach construct

Contextual – break and continue statements

Break

Continue

Writing your first C# program in a console application

Visual Studio as an editor

Evolution of Visual Studio

Types of Visual Studio

Visual Studio Community

Visual Studio Professional

Visual Studio Enterprise

Visual Studio Code

Introduction to the Visual Studio IDE

New Project

Solution Explorer

Main workspace area

Output window

The Command and Immediate windows

Search option in IDE

Writing your first program in Visual Studio

How to debug

Debugging through code

Summary

Hello OOP - Classes and Objects

Classes in OOP

The general form of a class

Writing a simple class

Objects in OOP

How to create objects

Variables in C#

Methods in a class

Creating a method

Constructor of a class

Characteristics of OOP

Inheritance

Encapsulation

Abstraction

Polymorphism

Summary

Implementation of OOP in C#

Interfaces

The abstract class

The partial class

The sealed class

Tuples

Properties

Access specifiers for classes

Public

Private

Internal

Protected

Protected internal

Summary

Object Collaboration

Examples of object collaboration

Different types of object collaboration in C#

Case study

Dependency

Association

Aggregation

Composition

Inheritance

Summary

Exception Handling

Why we need exception handling in programming

Exception handling in C# programming

Basics of exception handling

Try and catch

What happens if you don't handle exceptions?

Multiple catch blocks

Using the throw keyword

What does the finally block do?

Exception class

Some common exception classes

User-defined exceptions

The exception filter

Exception handling best practices

Summary

Events and Delegates

What is a delegate?

How to create and use delegates

Method group conversion

Using the static and instance methods as delegates

Multicasting

Covariance and contravariance

Events

Multicasting events

Event guidelines from .NET

Summary

Generics in C#

What are generics?

Why do we need generics?

Different constraints of generics

Base class constraints

Interface constraints

Reference type and value type constraints

Multiple constraints

Generic methods

Type-inferencing

Covariance and contravariance in generics

Covariance

Contravariance

Summary

Modeling and Designing Software

The importance of design diagrams

Different UML diagrams

Class diagrams

Inheritance

Association

Aggregation

Composition

Dependency

An example of a class diagram

Use case diagrams

The actor

The use case

The communication link

The system boundaries

An example of a use case diagram

A sequence diagram

An actor

A lifeline

An activation

A call message

A return message

A self message

A recursive message

A create message

A destroy message

A duration message

A note

An example of a sequence diagram

Summary

Visual Studio and Associated Tools

Visual Studio project types and templates

Visual Studio Editor and different windows

Editor window

Solution Explorer

Output window

Debugging windows

Breakpoints window

Exception Settings

Output

Diagnostic Tools

Immediate window

Python debugger window

Breakpoints, Call Stack Trace, and Watch

Breakpoint

Call Stack Trace

Watch window

Git in Visual Studio

Refactoring and code-optimization techniques

Rename

Changing the method signature

Encapsulate Field

Extract Method

Summary

Exploring ADO.NET with Examples

The fundamentals of ADO.NET

Data providers

Connection objects

The Command object

The DataReader object

DataAdapter

Connecting to various databases

SQL Server

The Oracle database

Working with DataReaders and DataAdapters

DataReaders

DataAdapters

Working with stored procedures

Working with the Entity Framework

What is an entity in the Entity Framework?

Different types of Entity properties

Scalar properties

Navigation properties

The code-first approach

The database-first approach

Using the Entity Framework

Transactions in SQL

Atomic

Consistent

Isolated

Durable

Summary

New Features in C# 8

Environment Setup

Nullable reference types

Async streams

Ranges and indices

Default implementation of interface members

Switch expressions

Target-typed new expressions

Summary

Understanding Design Patterns and Principles

Design principles

The single responsibility principle

The open-closed principle

The Liskov substitution principle

The interface segregation principle

The dependency inversion principle

Creational design patterns

The abstract factory pattern

The builder pattern

The factory method pattern

The prototype pattern

The singleton pattern

Structural design patterns

The adapter pattern

The decorator pattern

The facade pattern

The proxy pattern

Behavioral design patterns

The command pattern

The observer pattern

The strategy pattern

The MVC pattern

Summary

Git - The Version Control System

What is version control?

How Git works

Modified

Staged

Committed

Installing Git on Windows

The basics of Git

Git config

Git init

Git clone

Git status

Git add

Git commit

Git log

Git remote

Git push

Git pull

Git fetch

Branching in Git

Creating a branch

Viewing available branches

Changing branches

Deleting a branch

Merging in Git

Summary

Prepare Yourself - Interviews and the Future

Interview questions

What are the fundamental principles of object-oriented programming?

What is inheritance?

What is encapsulation?

What is abstraction?

What is polymorphism?

What is an interface?

What is an abstract class?

What is a sealed class?

What is a partial class?

What are the differences between interfaces and abstract classes?

What is the difference between method-overloading and method-overriding?

What are access modifiers?

What is boxing and unboxing?

What are the differences between a struct and a class?

What is an extension method in C# and how do we use it?

What is managed and unmanaged code?

What is a virtual method in C#?

What do you understand by value types and reference types in C#.NET?

What are design principles?

What is the single responsibility principle?

What is the Open/Closed principle?

What is the Liskov substitution principle?

What is the interface segregation principle?

What is the dependency inversion principle?

Interview and career tips

Improving your communication skills

Keep practicing

Things to learn next

Building the habit of reading

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think