This two-day intensive course is for the experienced programmer, designed to help them quickly learn the C# language. Important features covered during this class include dynamic data type, named and optional arguments, the use of variance in generic interfaces and asynchronous programming keywords. In addition, an appendix covers the fundamentals of Language Integrated Query (LINQ). If you’re looking for a learning solution that concisely covers the essentials of programming with Microsoft’s C#, this is the course for you. Please note that course material is current to Visual Studio 2013 and .NET 4.5.1 but can be customized as needed.

Course Duration: 2 Days
Prerequisites:

Participants should be experienced application developers or architects. Some background in object-oriented programming is also helpful.

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 2013
    • 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
  • C# Overview for the Sophisticated Programmer
    • Hello, World
    • Compiling, Running (Command Line)
    • Program Structure
    • Namespaces
    • Variables
    • Input in C#
    • More About Classes
    • InputWrapper Class
    • InputWrapper Implementation
    • Compiling Multiple Files
    • Control Structures
    • switch
    • C# Operators
    • Precedence Table
    • Types in C#
    • Simple Types
    • Types in System Namespace
    • Integer Data Types
    • Floating-Point Data Types
    • Implicit Conversions
    • Explicit Conversions
    • Boolean Data Type
    • struct
    • Uninitialized Variables
    • Enumeration Types
    • Nullable Types
    • Reference Types
    • Class Types
    • object
    • string
    • Copying Strings
    • StringBuilder Class
    • Classes and Structs
    • 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
    • Variable Length Parameter Lists
    • Arrays
    • One-Dimensional Arrays
    • System.Array
    • Jagged Arrays
    • Rectangular Arrays
    • foreach for Arrays
    • Boxing and Unboxing
    • Implicitly Typed Variables
    • Output in C#
    • Formatting
    • Exceptions
    • Checked Integer Arithmetic
    • Throwing New Exceptions
    • finally
    • System.Exception
  • Object-Oriented Programming in C#
    • C# Object-Oriented Features
    • Encapsulation and Accessors
    • Asymmetric Accessor Accessibility
    • Using a Property
    • Indexers
    • Visual Studio Console Projects
    • Files in Skeleton Solution
    • Source Files
    • Account Class
    • Constructors
    • Static Members
    • Static in Main
    • Static Constructor
    • Constant and Readonly Fields
    • Auto-Implemented Properties
    • Inheritance in C#
    • New Version of Base Class
    • Features of the New Base Class
    • Derived Class
    • Overriding a Virtual Function
    • Abstract Classes
    • Keyword: abstract
    • Derived Class
    • Sealed Classes
    • Access Control and Assemblies
    • Internal Accessibility
    • Class Libraries
  • C# and the .NET Framework
    • Components and OO in C#
    • Interfaces in C#
    • Interface Inheritance
    • Programming with Interfaces
    • Implementing Interfaces
    • Using an Interface
    • Dynamic Use of Interfaces
    • is Operator
    • as Operator
    • Resolving Ambiguity
    • Explicit Interface Implementation
    • System.Object
    • Collections
    • ArrayList
    • ArrayList Methods
    • IEnumerable and IEnumerator
    • Using Enumerators
    • Collections of User-Defined Objects
    • Account Class
    • AccountList Class
    • Copy Semantics in C#
    • Deep Copy and ICloneable
    • Writing Generic Code
    • Using a Class of object
    • Generic Types
    • Generic Syntax in C#
    • Generic Client Code
    • System.Collections.Generic
    • Object Initializers
    • Collection Initializers
    • Anonymous Types
    • Attributes
  • Delegates and Events
    • Callbacks and Delegates
    • Usage of Delegates
    • Declaring a Delegate
    • Defining a Method
    • Creating a Delegate Object
    • Calling a Delegate
    • Random Number Generation
    • A Random Array
    • Anonymous Methods
    • Combining Delegate Objects
    • Account.cs
    • DelegateAccount.cs
    • Lambda Expressions
    • Named Method
    • Anonymous Method
    • Events
    • Events in C# and .NET
    • Client-Side Event Code
  • 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
  • New Features in C# 4.0 and C# 5.0
    • Dynamic Type
    • Dynamic versus object
    • Behavior of Object
    • Behavior of Dynamic
    • Named 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 – Using Visual Studio 2013
    • Visual Studio Sign In
    • Sign-In Advantages
    • Visual Studio Start Page
    • A Visual Studio Solution
    • Toolbars
    • Customizing a Toolbar
    • Creating a Console Application
    • Adding a C# File
    • Using the Visual Studio Text Editor
    • Build and Run the Bytes Project
    • Running the Bytes Project
    • Executable File Location
    • Managing Configurations
    • Project Configurations
    • Creating a New Configuration
    • Setting Configuration Build Settings
    • Debugging
    • Breakpoints
    • Watch Variables
    • Debug Toolbar
    • Stepping with the Debugger
    • Call Stack and Call Hierarchy
    • Adding a Reference
    • Project Dependencies
    • Startup Project
    • Hidden Files
  • Appendix B – Language Integrated Query (LINQ)
    • Language-Integrated Query (LINQ)
    • Using IEnumerable
    • Basic LINQ Query Operators
    • Obtaining a Data Source
    • Filtering
    • Ordering
    • Aggregation
    • Obtaining Lists and Arrays
    • Deferred Execution
  • Appendix C – Unsafe Code and Pointers in C#
    • Unsafe Code
    • Unsafe Blocks
    • Unsafe Option in Visual Studio
    • Pointers
    • Swapping Via Pointers
    • Fixed Memory
  • Appendix D- Learning Resources