Our .NET 3.5/C# 3.0/VS2008 BootCamp is our mainstream .NET training course for software developers moving to the .NET Framework for the first time. It replaces and supersedes our .NET 2.0 BootCamp which is based on C# 2.0, Framework 2.0 and Visual Studio 2005.

This course is for developers now moving to C#/.NET (it assumes no previous experience).

(If you're looking for a class to follow this one, check out the Advanced .NET 3.5 / C# 3.0 Patterns and Practices course.)

The .NET 3.5 BootCamp is based on C# 3.0, .NET Framework 3.5 and Visual Studio 2008, and it:

• Assumes you have experience with a contemporary OO development environment and language.
• Is a fast-paced, hands-on intensive immersion in designing and implementing .NET components and applications.
• Is presented as 5 very long, intense days with pre-class labs, extensive homework and detailed projects for learning .NET Framework 3.5 from every perspective.
• Contains comprehensive coverage of .NET 3.5 and C# 3.0 for those who are not familiar with .NET (see detailed outline below).
• Is based on over 600 pages of labs and 200 pages of slides.
• Requires that you work over 100 pages of Pre-Class labs before arriving.

In this 5-day course, you'll learn the essentials of the .NET Framework, and how to write managed code that runs under the Common Language Runtime (CLR). You'll learn the fundamentals of C# programming, as well as how to port and re-factor code from C++ and access existing COM components. In generalal, you'll learn how to build .NET components, WinForms applications, Web Form apps, and Web Services in C#.

The course is a complete immersion into .NET 3.5 development with VS2008, and covers more in 1 week than a Microsoft Certification course could offer in 4.

This course is personally taught by Richard Hale Shaw

Here's what previous students of our .NET BootCamps have said.

Request an On-Site presentation of this Class

BACK TO TOP

In this course, you'll:

C# 2.0 is an evolution of the C# language, extended to add a number of new capabilities to C#1.x which shipped with .NET 1.x, in February 2002.

Where C# was already a mature programming language which compete head-on with C++, Delphi and Java, C# 2.0 offers a number of new means of letting developers create more expressive -- but reusable -- programming constructs:

• Generics - a CLR 2.0 feature that's supported directly by the C# language, and gives you the ability to define classes, interfaces, structs, delegates and methods that are in some respect typeless until consumed, at which point, specific typing is added, for the purpose of creating more reusable constructs.
• Nullable types - a .NET 2.0 feature for creating nullable value types, letting you store .NET structs or value types or a null so you can map them directly to database columns and XML attributes.
• Custom iterators - generate an object that implements IEnumerator or IEnumerator<T> (an iterator) by writing a single method, vastly reducing the plumbing required to do so in C# 1.x.
• Partial types - classes, structs and interfaces that can be defined across multiple source files in the same project to be compiled into the same .NET assembly, allowing them to be better managed and edited than types defined in a single source file.
• Static Classes - utility classes that only allow static members, and which cannot be instantiated or derived from.
• Anonymous Methods - the ability to define new methods and event-handlers in the context of existing ones.
• Global namespace qualifier - the ability to clearly show when a type name comes from the outer-most namespace
• Reference Aliases - the ability to assign logical names to reference assemblies, and use that name as an additional namespace when referencing types in that assembly.
• Property Accesors - the ability to set different access specifiers on property getters and setters, rather than a single access specifier.
• Delegate CoVariance - use methods with delegates where the method return value derives from the return type of the delegate.
• Delegate ContraVariance - use methods with delegates where the method parameters derive from the parameters defined in the delegate.
• Fixed size buffers in unsafe code - largely for InterOp.
• #pragma warning - enable/disable warnings.

An evolution of .NET 1.0/1.1, .NET 2.0 extends and broadens the reach of .NET, nearly doubling the services available in terms of public classes and APIs. Many of the sub-frameworks -- ASP.NET, Windows Forms and ADO.NET -- have been extended considerably to offer many more new services, or to offer better, simpler ways to do things that required considerably more code. In some cases, .NET 2.0 offers ways to accomplish with 30% of the code what .NET 1.x required.

Announced by Microsoft and released in early 2002, .NET is simultaneously an evolution of Microsoft's existing component framework -- COM -- along with the deployment vastly improved programming frameworks -- ADO.NET and ASP.NET -- that replace existing Windows platform technologies. Reshaped, redesigned and repackaged as a set of components, objects and libraries, the .NET Framework supercedes older procedural-based APIs (such as the Windows API) and provides richer, more productive programming languages -- C# and VB.NET – which are revolutionary in their significant flattening of the learning curve required by C++ and COM. These new technologies are part of a fully-integrated environment that will be accessible from the next release of Visual Studio, and which will be supported on Windows platforms from Win9x to Windows XP in the short term, but extensible to non-Windows platforms over the long term.

Features of .NET include:

• All programs initially generated as Intermediate Language code which is portable to any .NET-supportive platform
• All programs executing as native code executables on their target processor (after JIT-compilation at installation- or load-time)
• A managed code environment that ensures safer, more secure and type-safe execution
• Fully integrated type information that virtually guarantees type-safe,simpler development
• A Common Language Runtime (CLR) environment which standardizes a core set of types for all languages and platforms
• A suite of first-class, Object-Oriented programming languages:
  • C# (pronounced C-sharp), which features the elegance of Java, the power of C++, and the productivity of Delphi
  • VB.NET, a comprehensive, Object-Oriented upgrade of Visual Basic (VB), with full access to framework services without making procedural sacrifices
  • Managed C++, for creating .NET applications without having to learn a new language, and the ability to combine managed and unmanaged code in the same binary executable
  • JScript.NET, a full OO, compiled-language upgrade from JScript of old.
• Windows Forms, an application framework for elegantly producing rich client UIs
• ASP.NET Web Forms, an OO, compiled language replacement for ASP, that lets you create web pages for browser clients supporting HTML 3.2 and JavaScript, while only requiring that the developer write code in C# or VB.NET (HTML and JavaScript knowledge aren't required)
• ADO.NET:finally, an understandable, OO data access method, which replaces ADO and OLEDB, but can work with SQL Server, Oracle or any OLEDB-accessible data source
• A rich, fully integrated set of base object and component classes which replace the Windows API
• Access to underlying platform-specific APIs (such as the Windows API) from .NET languages
• Access to components written using older component frameworks (such as COM) for continuing to get mileage out of COM components and ActiveX controls
• A repackaging and reintegration of powerful enterprise component services (such as COM+) for all .NET languages and tools to use
• Web Services, an application framework for exposing functionality across the Internet and via an Intranet, with the ease of invoking a local component