Our C# 2.0 / .NET 2.0 BootCamp is our mainstream .NET training course for software developers moving to the .NET Framework 2.0. It replaces and supersedes the old .NET BootCamp / C#, which is based on C# 1.0, Framework 1.0/1.1 and VS.NET 2003.

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 C# 2.0 / .NET 2.0 Patterns and Practices course.)

The .NET 2.0 BootCamp is based on C# 2.0, .NET Framework 2.0 and Visual Studio 2005, 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 2.0 from every perspective.
• Contains comprehensive coverage of .NET 2.0 and C# 2.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 2.0 development with VS2005, 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.

Register for a Public presentation of this Class

Request an On-Site presentation of this Class

BACK TO TOP

This is a course for those who have a background in Object-Oriented programming who are ready to move to the .NET Framework. Previous experience with Visual Studio or C# isn't required.

You should already be fluent with one of the following programming languages:

• C++
• Java
• Smalltalk
• Delphi
• Some other OO programming language (VB6 is not one, sorry)

This means you should have -- at minimum -- some familiarity with:

• Objects
• Classes
• Methods
• Inheritance
• Polymorphism
• Type-safety

This course is NOT for software developers who don't already have a background in OOP. For on-site presentations of this course, we can add an Introduction to Object-Oriented Programming (OOP) to the course, but this will likely mean dropping another module or adding a day to the course. If you're interested in this option, just ask.

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

.NET was created with some fundamental goals in mind:

Programmer Productivity
Earlier component technologies (like COM) and front-end UI frameworks (MFC and Visual Basic -- both based on the Windows API) were simply more complicated than they should have been. In the case of COM, the complexity arose because too much of the underlying plumbing -- IUnknown, QI, GUIDs, proxy-stubs -- was exposed and required direct programmer interaction when used from high-performance languages or tools (and when used from high-level languages such as Visual Basic, too much was hidden!). The objective of .NET is to abstract away the plumbing details and instead let the software developer focus on the details of putting together his/her domain-specific application or component.

Scalable Component Development
In the case of the Windows API, the complexity grew because the original windowing functions -- designed in 1984! -- were extended to cover areas that had little or nothing to do with windowing and UIs! Coupled with the fact that Windows as we've known it -- was designed at a time when all applications were written to be monolithic EXEs where the only notion of component development was the (limited) use of DLLs. The objective of .NET is to make N-tier application development -- via component-based architectures -- simpler and easier.

Integral Internet/Intranet Support
Windows was not written with the Internet or even local Intranets in mind: instead, it was extended to accommodate these over time. .NET takes these into account from the first moment you use it, so that deploying applications over Intranets or the Internet, and making these an integral part of your application architecture becomes an ordinary, day-to-day operation. Part of the way .NET takes care of this is by creating a managed execution environment based on a Common Language Runtime (CLR), where every aspect of code execution is controlled, regardless of source development language. The CRL handles memory management, provides a secure runtime environment, ensures object location transparency and provides concurrency management -- while still giving you access to underlying operating system services. Because the CLR gives you a high degree of language interoperability and component re-use, you can even use one language to derive a new class from a class written in another language. But the differences in.NET from existing technologies are substantial: it's not just syntax that you'll have to learn, but you'll have to think in n-tiers like you never did before.