This comprehensive course is a practical introduction to programming in C# utilizing the services provided by .NET. Current to Visual Studio 2012 or 2013 and .NET 4.5.1, this customizable course reviews critical features such as dynamic data type, named and optional arguments, the use of variance in generic interfaces and asynchronous programming keywords. A supplement covers the fundamentals of Language Integrated Query (LINQ).

As the name implies, this course teaches C# programming from an object-oriented perspective. Because it is often difficult for programmers initially training in a procedural language to start ͞thinking in objects,͟ this course introduces object-oriented concepts early and features a case study to illustrate the creation a complete system using C# and .NET.

Course Duration: 5 Days
Prerequisites:

Participants should have programming experience in a high-level language.

Course Outline:
  • .NET – What You Need to Know
    • Getting Started
    • .NET – What Is Really Happening?
    • .NET Programming in a Nutshell
    • Viewing the Assembly
    • Viewing Intermediate Language
    • Understanding .NET
    • Visual Studio
    • Creating a Console Application
    • Adding a C# File
    • Using the Visual Studio Text Editor
    • IntelliSense
    • Build and Run the Project
    • Pausing the Output
    • Visual C# and GUI Programs
    • .NET Documentation
  • First C# Programs
    • Hello, World
    • Compiling, Running (Command Line)
    • Program Structure
    • Namespaces
    • Exercise
    • Answer
    • Variables
    • Expressions
    • Assignment
    • Calculations Using C#
    • More About Output in C#
    • Input in C#
    • More About Classes
    • InputWrapper Class
    • Echo Program
    • Using InputWrapper
    • Compiling Multiple Files
    • Multiple Files in Visual Studio
    • The .NET Framework
    • Lab Exercise
  • Data Types in C#
    • Strong Typing
    • Typing in C#
    • Typing in C++
    • Typing in Visual Basic 6
    • C# Types
    • Integer Types
    • Integer Type Range
    • Integer Literals
    • Floating Point Types
    • Floating Point Literals
    • IEEE Standard for Floating Point
    • Decimal Type
    • Decimal Literals
    • Character Type
    • Character Literals
    • string
    • Escape Characters
    • Boolean Type
    • Implicit Conversions
    • Explicit Conversions
    • Nullable T
    • Lab Exercise
  • Operators and Expressions
    • Operator Cardinality
    • Arithmetic Operators
    • Multiplication
    • Division
    • Additive Operators
    • Increment and Decrement
    • Relational Operators
    • Conditional Logical Operators
    • Short-Circuit Evaluation
    • Ternary Conditional Operators
    • Bitwise Operators
    • Bitwise Logical Operators
    • Bitwise Shift Operators
    • Assignment Operators
    • Expressions
    • Precedence
    • Associativity
    • Checking
    • Lab Exercise
  • Control Structures
    • If Test
    • Blocks
    • Loops
    • while Loop
    • do/while Loops
    • for Loops
    • Arrays
    • foreach Loop
    • break
    • continue
    • goto
    • Structure Programming
    • Multiple Methods
    • switch
    • switch in C# and C/C++
    • Lab Exercise
  • Object-Oriented Programming
    • Objects
    • Objects in the Real World
    • Object Models
    • Reusable Software Components
    • Objects in Software
    • State and Behavior
    • Abstraction
    • Encapsulation
    • Classes
    • Inheritance Concepts
    • Relationships among Classes
    • Polymorphism
    • Object-Oriented Analysis and Design
    • Use Cases
    • CRC Cards and UML
  • Classes
    • Classes as Structure Data
    • Classes and Objects
    • References
    • Instantiating and Using an Object
    • Assigning Object References
    • Garbage Collection
    • Methods
    • Public and Private
    • Abstraction
    • Encapsulation
    • Initialization
    • Initialization with Constructors
    • Default Constructor
    • this
    • Static Fields and Methods
    • Static Methods
    • Static Constructor
    • Constant and Readonly Fields
    • Lab Exercise
  • More About Types
    • Overview of Types in C#
    • Structures
    • Uninitialized Variables
    • Copying a Structure
    • Hotel.cs
    • HotelCopy.cs
    • Classes and Structs
    • Enumeration Types
    • Reference Types
    • Class Types
    • object
    • string
    • Arrays
    • Default Values
    • Boxing and Unboxing
    • Implicitly Types Variables
    • Lab Exercise
  • Methods, Properties and Operators
    • Static and Instance Methods
    • Method Parameters
    • No “Freestanding” Functions in C#
    • Classes with All Static Methods
    • Parameter Passing
    • Parameter Terminology
    • Value Parameters
    • Reference Parameters
    • Output Parameters
    • Structure Parameters
    • Class Parameters
    • Method Overloading
    • Modifiers as Part of the Signature
    • Variable Length Parameter Lists
    • Properties
    • Auto-Implemented Properties
    • Lab Exercise
    • Operator Overloading
    • Operator Overloading in the Class Library
  • Characters and Strings
    • Characters
    • Character Codes
    • ASCII and Unicode
    • Escape Sequences
    • Strings
    • String Class
    • String Literals and Initialization
    • Concatenation
    • Index
    • Relational Operators
    • String Equality
    • String Comparisons
    • String Input
    • String Methods and Properties
    • StringBuilder Class
    • StringBuilder Equality
    • Command Line Arguments
    • Command Line Arguments in the IDE
    • Command Loops
    • Splitting a String
    • Lab Exercise
  • Arrays and Indexers
    • Arrays
    • One-Dimensional Arrays
    • Array
    • Random Number Generation
    • Next Methods
    • Jagged Arrays
    • Rectangular Arrays
    • Arrays as Collections
    • Account Class
    • Bank Class
    • TestBank Class
    • Atm Class
    • Running the Case Study
    • Indexers
    • Using the Indexer
    • Lab Exercise
  • Inheritance
    • Inheritance Fundamentals
    • Inheritance in C#
    • Single Inheritance
    • Root Class – Object
    • Access Control
    • Public Class Accessibility
    • Internal Class Accessibility
    • Member Accessibility
    • Member Accessibility Qualifiers
    • Method Hiding
    • Method Hiding and Overriding
    • Initialization
    • Initialization Fundamentals
    • Default Constructor
    • Overloaded Constructors
    • Invoking Base Class Constructors
    • Bank Case Study Analysis
    • Account
    • CheckingAccount
    • SavingsAccount
    • TestAccount
    • Running the Case Study
    • Lab Exercise
  • Virtual Methods and Polymorphism
    • Introduction to Polymorphism
    • Abstract and Sealed Classes
    • Virtual Methods and Dynamic Binding
    • Type Conversions in Inheritance
    • Converting Down the Hierarchy
    • Converting Up the Hierarchy
    • Virtual Methods
    • Virtual Method Cost
    • Method Overriding
    • The Fragile Base Class Problem
    • override Keyword
    • Polymorphism
    • Polymorphism Using “Type Tags”
    • Polymorphism Using Virtual
    • Abstract Classes
    • Sealed Classes
    • Heterogeneous Collections
    • Case Study Classes
    • Run the Case Study
    • Account
    • CheckingAccount, SavingsAccount
    • Bank and Atm
    • TestBank
    • Lab Exercise
  • Formatting and Conversion
    • Introduction to Formatting
    • ToString
    • ToString in Your Own Class
    • Using Placeholders
    • Format Strings
    • Controlling Width
    • Format String
    • Currency
    • Format
    • PadLeft and PadRight
    • Type Conversions
    • Conversion of Built-In Types
    • Conversion of User-Defined Types
    • Lab Exercise
  • Exceptions
    • Introduction to Exceptions
    • Exception Fundamentals
    • .NET Exception Handling
    • Exception Flow of Control
    • Context and Stack Unwinding
    • Exception
    • User-Defined Exception Classes
    • Structure Exception Handling
    • Finally Block
    • Inner Exceptions
    • Checked Integer Arithmetic
    • Lab Exercise
  • Interfaces
    • Interfaces in C#
    • Interface Inheritance
    • Programming with Interfaces
    • Implementing Interfaces
    • Using an Interface
    • Dynamic Use of Interfaces
    • is Operator
    • as Operator
    • Common Interfaces Case Study – IAccount
    • Apparent Redundancy
    • IStatement
    • IStatement Methods
    • IChecking
    • ISavings
    • The Implementation
    • SavingsAccount
    • The Client
    • Resolving Ambiguity
    • Access Modifier
    • Explicit Interfaces Test Program
  • .NET Interfaces and Collections
    • Overview
    • Collections
    • Count and Capacity
    • foreach Loop
    • Array Notation
    • Adding to the List
    • Remove Method
    • RemoveAt Method
    • Collection Interfaces
    • IEnumerable and IEnumerator
    • ICollection
    • IList
    • A Collection of User-Defined Objects
    • Duplicate Objects
    • A Correction to AccountList (Step 1)
    • Copy Semantics and ICloneable
    • Copy Semantics in C#
    • Shallow Copy and Deep Copy
    • Reference Copy
    • Memberwise Clone
    • Using ICloneable
    • Comparing Objects
    • Sorting an Array
    • Anatomy of Array.Sort
    • Using the is Operator
    • The Use of Dynamic Type Checking
    • Implementing IComparable
    • Running the Program
    • Complete Solution
    • Lab Exercise
    • Writing Generic Code
    • Using a Class of object
    • Generic Types
    • Generic Syntax in C#
    • Generic Client Code
    • Collections.Generic
    • Lab Exercise
    • Object Initializers
    • Collection Initializers
    • Anonymous Types
  • Delegates and Events
    • Overview of Delegates and Events
    • Callbacks and Delegates
    • Usage of Delegates
    • Declaring a Delegate
    • Defining a Method
    • Creating a Delegate Object
    • Calling a Delegate
    • A Random Array
    • Anonymous Methods
    • Combining Delegate Objects
    • Account.cs
    • DelegateAcount.cs
    • Lambda Expressions
    • Named Method
    • Events
    • Events in C# and .NET
    • Client Side Event Code
    • Lab Exercise
  • Introduction to Windows Forms
    • Creating a Windows Forms App
    • Partial Classes
    • Windows Forms Event Handling
    • Add Events for a Control
    • Events Documentation
    • Closing a Form
    • ListBox Control
    • Lab Exercise
  • New Features in C# 4.0 and C# 5.0
    • Dynamic Type
    • Dynamic versus Object
    • Behavior of Object
    • Behavior of Dynamic
    • Names Arguments
    • Optional Arguments
    • Book Class
    • Using Optional Arguments
    • Variance in Generic Interfaces
    • Variance with IComparer
    • Interfaces with Variance Support
    • Asynchronous Programs in C# 5.0
    • Task and Task
    • Aysnc Methods
    • Synchronous Call
    • Async Call
    • Threading
  • Appendix A – Learning Resources