Our Advanced .NET 3.5 / C# 3.0 BootCamp is for software developers who:

• Have a minimum of at least 1 year of experience programming .NET Framework 2.x or later in C#2.0 with VS.NET 2005, or
• Have a minimum of at least 2 years of experience programming .NET Framework 1.x in C#1.0 with VS.NET 2003, or
• Previously attended either our classic .NET BootCamp / C# or its successor the C# 2.0 / .NET 2.0 BootCamp are ready to learn intermediate and advanced techniques with C# 3.0, .NET 3.5, VS2008.

Sorry, there'll be no hand-holding if you don't meet these qualifications! If that's the case, you should instead attend our C# 2.0 / .NET 2.0 BootCamp or the .NET 3.5 BootCamp.

You should already have 2+ years experience programming the .NET Framework 1.x using C# 1.0 and VS.NET 2003 or at least 1+ years programming .NET 2.0 (or later) with C# 2.0 before attending this course.

Alternatively, if you've previously attended our classic .NET BootCamp or the .NET 2.0 BootCamp, you also qualify: this course is the designated follow-on for .NET BootCamp or .NET 2.0 BootCamp graduates who want to extend their knowledge of .NET and C#. (This course overlaps with no more than 10% of the .NET 2.0 BootCamp material.)

• Why loose coupling means never having to say you're sorry
• How to build Generic types in C# 2.0
• When to create static classes in C# 2.0
• How to refactor types across assemblies with [InternalsVisibleTo]
• What New Features were added to the FW 2.0 Base Class Libraries (50% more classes and methods)
• What Anonymous Methods in C# 2.0 are -- and how to use them.
• A simpler way of wiring up events and event-handlers
• How to use the new Reference Alias feature in C# 2.0
• How to create Generic Methods in C# 2.0
• Why Delegate CoVariance and ContraVariance C# 2.0 aren't a big deal (they should have worked in C# 1.0!)
• How to understand the Patterns built-into C# 1.0 work: lock, foreach, using, as/is and unsafe
• What new patterns are built into C# 2.0: yield, delegate
• How C# 2.0 Custom iterators and anonymous methods are the basis for the Sequencing libraries and lambda expressions in C# 3.0
• Why static cast is an anti-Pattern
• Best Practice: using Implicit vs. Explicit interface implementation
• Using partial to segregate implementations
• Best Practice: using Interfaces or Abstract Base Classes
• How Generics differ from C++ Templates
• How Generics will improve the performance of handling both Value Types (structs) and Reference Types (classes)
• The value of creating and using Generic Interfaces and Delegates
• The built-in Generic Delegates in Framework 2.0 -- and how to leverage them for creating thin layers of abstraction.
• How the CLR specializes Value Types differently from Reference Types
• What Generic Constraints are
• When to use Constraints in defining your own Generic Types
• How to use Reflection to create new Generic Types dynamically
• How to serialize Generic types (and when you can't)
• How to expose Generic types via .NET Remoting
• When to derive from Generic types -- both with or without a type argument -- and why
• Why you should avoid using ArrayList in the future
• Why you should avoid using System.Object in the future
• What parts of the Base Class Libraries are potential bottlenecks
• The value of type-safe collections
• The difficulties of creating type-safe collections in .NET 1.x
• How to create type-safe collections in .NET 2.0 with Generic types
• How the new Collection interfaces in .NET 2.0 differ from those .NET 1.1
• How to use the new Collection classes in .NET 2.0
• When to use List<T> vs. Collection<T> vs. ReadOnlyCollection<T>
• How to leverage the new Generic Delegates with Array.ForEach<T>, Array.TrueForAll<T>, List<T>.ForEach and others
• How to write your own Sequencing libraries to leverage Custom Iterators and Anonymous methods
• What Nullable Value Types are
• The differences between struct Nullable<T> and class Nullable
• How to specialize Nullable types in C#
• How to use Nullable Value Types
• Minor deficiencies in Nullable<T>
• Casting Nullable Types
• The value of custom iterators
• The difficulties of creating custom iterators in .NET 1.x
• The fast, powerful way to create custom iterators with C# 2.0
• How to pipeline IEnumerator<T> from one iterator to another
• How to create iterators that filter their results
• How to create iterators that order their results
• How to create recursive iterators -- and when to do so
• Why iterators aren't continuations and don't use multi-threading
• When your iterator should return IEnumerator<T> vs. IEnumerable<T>
• When you should use yield return vs. yield break
• When you should and shouldn't create multiple AppDomains
• How to implement the Hot Update Pattern with AppDomains
• Why "strong naming" doesn't prevent tampering
• How to leverage the CLR APIs from C#
• Best Practices for Naming Conventions
• Best Practices for creating Value Types
• Best Practices for implementing ICloneable -- and why ICloneable<T> is better
• The difference between ReferenceEquals vs. Equals
• When and how to implement Comparers in C# 2.0
• When and how to use static constructors
• How AppDomains scope the lifetime of static members
• How to leverage the .NET Component Pattern
• How Delegates and Events implement the Observer Design Pattern
• How to create Limited Subscription Observers
• How to use the Bridge Pattern to expose internal Observed Objects
• How to implement Weak-Reference Events
• How to leverage the BackGroundWorker Component
• How to use Asynchronous Delegates
• How to implement the "Fire and Forget" Pattern with Async Delegates
• How to implement the "Notify Me" Pattern with Async Delegates
• How to implement the "Don't Call Me, I'll Call You" Pattern with Async Delegates
• When to use the AsyncOperation class
• How to create Mult-threaded WinForms
• How to create async Web Pages
• How to implement Finalize-Dispose in a thread-safe fashion

C# 2.0 is an evolution of C# 1.0, which shipped with .NET 1.0 in February, 2002. It extends the C# langauge in several major ways and few minor ones:

Major extensions to C# in 2.0:

• Support for Generic classes, structs, interfaces, delegates and methods that give you major re-usability options over ordinary inheritance and containment, and allow for even more loose-coupling arrangements than previously available.
• Custom iterators: classes that can implement IEnumerator<T> (and its non-Generic counterpart) via methods that return IEnumerable<T>, allowing you to easily create methods for sorting, searching, filtering and otherwise processing groups of objects, be they in collections or not.
• Anonymous methods: methods defined an used in the same context, inside of an existing method, letting you create methods that are small, light-weight, easy-to-maintain building blocks.

Minor extensions to C# in 2.0:

• More flexibility in using delegate methods with derivative return values.
• More flexibility in using delegate methods with base class parameter types.
• static classes: classes that are sealed, abstract and only allow static members
• partial types: interfaces, classes, structs and enums whose definition extends across source boundaries of a single assembly/project.
• The global namespace qualifier operator, ::, for identifying types in the outer-most namespaces.
• Reference aliases, as a means of assigning further identifying information to types from a particular assembly (via the :: operator)
• The use of differing access specifiers on the getter/setter of a property (e.g., for a public getter but an internal setter).

Non-extensions to C#:

• "Friend assemblies": often documented as a C# feature, this a .NET Framework feature that has nothing to do with the C# language.

In my opinion, you can make the case that these extensions simultaneously do 2 things:

• Make C# even more productive than it was in C# 1.0.
• Position C# for the new features -- in the form of lambda expressions, sequence-processing and extension methods -- being added in C# 3.0.

.NET 2.0 is an order-of-magnitude extension to .NET 1.1 in the way of 8500 public classes (over the 5300 in 1.1), 84,000 public methods (vs. 54,000 in 1.1) of which 50,000 are not property/event accesor methods (vs. 36,000 which weren't in .NET 1.1).

It adds a new CLR with a smaller working set, more efficient execution in many areas (such as delegate invocation), support for runtime JIT of Generic types into concrete types, and enhanced security features.

.NET 2.0 adds functionality over .NET 1.1 in the following areas:

• String management
• Data collection
• Database access - typed DataSets come out of the closet for everyday use.
• File I/O - easier-to-use file read/write for simple scenarios.
• Encryption
• Diagnostics/Debugging
• Project Build Management
• Code/assembly generation
• Collections - full-scale support for Generics at the type, interface and metadata level.
• Component Development
• Configuration - full .config read/write, a more powerful Configuration object, plus user/application settings.
• Deployment/Installation
• Networking/sockets - richer objects for networking.
• Security/Cryptography - more information in Security exceptions, improved cryptography APIs.
• Threading - across-the-board improvements in the Thread class, asynch threading and easier-to-use worker controls and components.
• Transactions - full-scale, multi-machine transactions that obviate the need for Enterprise Services.
• Web Development - an overhaul of the Web Forms model and huge number of new services and controls.
• WinForms - improved menu/toolbar components and cleaned up eventing, plus a number of new controls.

There are hundreds of tiny improvements that were added in this release that don't fit neatly in any category.

Among the few areas left untouched by .NET 2.0 over 1.1 are:

• Web Services and .NET Remoting (both superceded by the release of WCF in .NET 3.0 -- which is really .NET 2.5)

Introduction to .NET 3.5
• Targeting Multiple Frameworks with VS2008
• What’s New in CLR 2.0?
VS2008 Professional
• Debugging
• Debugger Visualizers
Patterns and Practices in C#
• Best Practices for C# Type and Member Design
• Review: What’s New in C#2.0
• C# 2.0 and Generics
• Implementing Type-Safe Managed Collections
• Nullable Value Types
• Custom Iterators
• Iterator Best Practices
An Introduction to C# 3.0
• Lambda Expressions
• Extension Methods
• Anonymous Types
• Partial Methods
• Auto-implemented Properties
• Local variable initializers
• Object initializers
• Collection Initializers
• Implicitly Typed Arrays
• Query expressions
LINQ to Objects
• Queries as Objects
• IEnumerable<T> Patterns
• Basic Linq Queries
• Standard Query Operators
• Creating/managing XML Documents with XLINQ
Patterns and Practices in Managed Code
• Using AppDomain Services and Multiple AppDomains
• The HotUpdate Pattern
• Creating Add-Ins and Extensible Applications
• Asynchronous Events and the Event-based Async Pattern
• Read-Write Thread Locks
• Implementing Thread-Safe a Finalize-Dispose Pattern
• The Weak-Reference Event Pattern
• Using Named/Anonymous Pipes SYLLABUS
Patterns for Data: Linq-to-SQL and ADO.NET
• Typed DataSets come out of the Closet
• .NET 2.0 Transactions
• Introduction to Linq-to-SQL
• Linq Wrappers around SQL
• Using, Creating and Querying Databases and Tables
Patterns for the Presentation Layer: Windows Presentation Foundation (WPF)
• Overview of WPF
• WPF Framework Architecture
• Introduction to XAML Programming
• Events and Properties
• Controls and Layout
• Building Custom Controls
• Pages and navigation
• Data Binding
• Client Application Services

Patterns for Connected Systems: Windows Communication Foundation (WCF)

• Introduction to WCF
• How WCF uses a single programming model to:
• Replace .ASMX Web Services
• Replace .NET Remoting
• Service-enable any Managed type
• Introduction to Service-Oriented Architectures
• Fundamentals of WCF
• Getting Started with WCF
• Working with Contracts
• Implementing Your Service
• More Powerful WCF Clients
• Service Management
• Durable Services
  

Patterns for Testing

• Built-in Unit Testing Support in VS2008
• A Practical Testing Philosophy: Test the Heck out of it!
• Unit Testing 
• Web Testing
• Design Patterns for Testing
• Code Coverage Analysis 
• Dynamic code analysis 
• Static code analysis
• Profiling