• To provide participants with the knowledge and skills for developing .NET applications using the
  newest version of the C# programming language.
• To suggest practical uses of .NET Framework using focusing on encapsulation ans reusability.
• To use the most useful capabilities of Visual Studio environment focusing on designing, refactoring
  and debugging.
• To encourage the following of naming conventions, coding standards and XML-based documentation.
• To familiarize participants with helpful tools, methodologies and best practices for coding in the .NET
  platform.

Introducing C# and .NET
What is .NET?
CTS – Common Type System
5 .NET CTS Types
Type Members
What is C#?

Expressions and Statements
Logical Operators and Precidence
.NET Intrinsic Types
Using Types
Evaluating Objects
Object Initializers
Object Constructors
Using Properties
Checking if String Value is Null or Empty
Type Implicitly with var
Using Generic Types
Array Initializer
Understanding Scope and Accessability
Conditions (if, if-else, switch, ?:, ??:)
Iterations – ForEach Method
Iteration - foreach, for, while and do loops
Iteration - Avoid Loop Nesting
Iteration – Lambda Nesting
Flow Breakers
Method Breakers - throw and return
Loop Breakers - break and continue
Method Parameter Types – out, ref and params

CLR
Managed Code Benefits
CLR Overview
JIT Compiler
Intermediate Language (IL or MSIL)
Runtime Optimization
.NET Assemblies and Manifests
Assembly Loader
Strongly Named Assemblies
Global Assembly Cache (GAC)
Assembly Versions
CLS Compliancy

Creating Object Types
System.Object Methods
Access Modifiers
Encapsualtion
Strive to Give Less Access
Object Fields Auto-Initialization
Object Fields Manual Initialization
Field-Constructor Ordering
Supplying Parameterless Constructor
Supplying Overloaded Constructors
Overloaded Methods
Overloading Constructors
Read-Only Object Fields
Manual Properties
Automatic Properties
Use Automatic Properties for Numerics Only
Indexers
Operator Overloading (Avoid)
Defining Implicit or Explicit Conversions (Avoid)
Partial Classes and Methods
Creating and Using Enums
Creating and Using Bit Flag Enums
Enum Pitfalls
Order of Class Members

Metadata
What is Metadata?
Attributes
Reflection
Extending System.Object Using Reflection
IL – MS Intermediate Language
IL Code and ILDASM Tool
Reflector Tool
Using Attributes - Conditional Compilation
Defining Custom Attributes

Strings
Strings are Immutable
Verbatim Strings
String Manipulation
Formatting Strings
StringBuilder
Regular Expressions
Parsing Strings to Numerics
Converting Strings to Numerics
Alternatives to Literals in Code
Adding Settings to Assembly Properties
Retrieving and Altering Setting Values
Running Applications from Command Line
Parsing Command Line Arguments

Static Classes and Members
Static Fields
Fields Should Not be Init to Default
Static Access
Read-Only Class Fields
Class (Static) Constructors
Class Constructor Pitfalls
Where to Initialize Class Fields?
Constant Values
Class Fields Are Usually Private
Initialize String Field Members to Empty
Properties Are Not for Calculation
Proper Using of const and static readonly
Using Extension Methods
Creating Extension Methods
Using Extension Methods for Debugging
When to Create Extension Methods
Extension Methods Pitfalls
Static Classes and Singletons

Inheritance
Single Inheritance Only
Abstract and Concrete Classes
Abstract and Sealed Classes
Constructor Ordering
Needed Base Constructors
Virtual Methods
Overriding Virtual Methods
Abstract Methods
Consider Overriding ToString()
Virtual and Abstract Properties
Never Call Virtual Functions in Constructor
Two-Steps Object Construction
Forget Hiding Inherited Members
Avoid Hiding Non-Inherited As Well
Sealed Funtions
Explicit Conversions with as operator
as Operator vs. Aggressive Casting
Using is operator Diagnoses Bad Design
Implicit Type Conversions

Interfaces
Interfaces
Defining Interfaces
Publishing Interfaces
Implementing Interfaces
Interface Inheritance
Multiple Interface Implementation
Explicit Interface Implementation
Overriding Interface Implementation
Avoid Hiding Interface Implementation
Interface Guidelines
Similarities in Definition Between Interfaces and Abstract Classes
Differences in Definition Between Interfaces and Abstract Classes
Differences in Implementing Interfaces and Abstract Classes
Choosing Between Interfaces and Abstract Classes

Memory Allocation
Reference Types (classes)
System.MarshalByRefObject
Value Types (structs)
Reference Types vs. Value Types
Value Types are Copied
Structs Should Be Immutable
Type Mutability Comparison
Boxing and Un-boxing
How to Avoid Boxing
Using Nullable Types
Checking if Value is Null

Disposing of Objects
Garbage Collector
Avoid Interfering the Garbage Collector
Cleaning Outer Resources
Consumer Part for Disposing
Object Part - Disposing Pattern
Derived Object Part for Disposing

Code Integrity
Exceptions
When to Throw an Exception
What Exceptions are NOT for
Throwing Exceptions
Which Exception to Throw
Hierarchy of Common Exceptions to Throw
Which Exception NOT to Throw
Avoid Making Your Own Exceptions
Forget Making Your Own Hierarchy
Exceptions thrown by the CLR
When to Catch Exceptions
Multiple Catch Blocks
Forget Swallowing Exceptions
Re-throwing Exceptions
Avoid Translating Exceptions
Introducing Code Analysis
Code Analysis - FxCop
Code Analysis - StyleCop

Arrays
Arrays
Array Random Access
Creating and Initializing Arrays
Polymorphic Array Items
Copying Array Items
Covariance in Array Assignment
Multidimensional Arrays (Rectangular and Jagged)
Returning ReadOnlyCollection
IEnumerable, IEnumerator and foreach
Implementing Enumerators with yield
Investigating Using Predicates
Delegating Actions to Each Item
Comparing Items

Generic Collections
Use Only Generic Collections
Dictionaries and KeyValuePair
Deriving Collections
Sets (HashSet)
Lists
Specific Order Collections
NGenerics Library
Wintellect Power Collections

Functional De-coupling
Inheritance Pitfalls
Dynamic Containment
Delegates Benefits
Introducing Delegates
Delegates – How does it work?
Func and Action Generic Delegates
Prefer Action<> and Func<>
Delegate Class is not a Delegate
Delegate Chaining
Delegate Chaining Pitfalls
Iterating Delegate Chains
Delegates Implementation to Strategy
Observer Pattern
Subscribing to and Handling Events
Defining and Raising Events
Long Notation Event Handlers
Covariance and Contra-variance
Lambda Expressions
Lambda Expressions and Delegates
Compiling Lambda Expressions
Lambda with No Parameters
Lambda with Many Parameters
Strategy Pattern with Lambda
Polymorphism with Lambda
Lambda Statements
Anonymous Methods

Querying Data Using Linq
Implicitly typed arrays
Anonymous Types
Expression Class
Query Operators
Filtering, Grouping and Sorting
Joining and Aggregating
Expression Syntax
Method Synax
Combined Syntax

Lite Object Relation Mapping (ORM)
Linq to SQL
Linq Designer
Linq Mapping
Server (Database) Explorer
Connecting to a Database
Mapping Tables and Stored Procedures
Populating Grids
Querying a Select Statement
Selecting with Lambda
Performing Operations: Updating, Inserting and Deleting
Validating Updates of Properties
Validating Operations
Executing Raw SQL Expressions (Avoid)
Connected vs. Disconnected

Rich Appendices:

Coding Guidelines
Why Coding Guidelines?
camelCasing for Private Fields and Locals
PascalCasing for Everything Else
XML Documentaion
Automatic XML Comment Tags
Additional XML Comment Tags
Namespaces Guidelines
Forget Polluting Global Namespace

Visual Studio 2008
Visual Studio 2008
Creating Solutions and Projects
Building a Project
Console Applications
Windows Forms Applications
WPF Applications
C# Compiler - Your Best Friend
Advised Compiler Tweaks
Referencing Assemblies
Using Namespaces and Aliases
Creating Class Library Assembly
Re-factoring
IntelliSense
Smart Tags
Snippets
Keyboard Bound Shortcuts
Regions
Debugger and Its Windows
Debugger Configuration

Resources
Reference and Learning Sites
C# Best Forums and Sites
Microsoft Israel Resources
Alt.net Approaches and Resources
C# vs. C++
C# vs. Java