|
|
|
.NET is a replacement for every major technology released by Microsoft since the advent of Windows in 1984. ADO, OLEDB, ASP, COM -- even the Windows API itself -- are all superceded by various parts of the .NET Framework.
Unlike the patchwork of APIs that preceded it, .NET is an integrated, interwoven set of technologies that offer a consistent, intuitive approach to software development -- one that flattens the learning curve while it steepens the productivity curve of developers who use it. Breathtaking in its scope and comprehensive in its depth, .NET will alter a fundamental role-defining paradigm that's been a mainstay in workstation and server software development since the early '90s: that of component-developers and component users.
It's my belief that .NET will effectively blur the distinctions between these roles, making it possible for smaller groups -- or even single developers -- to write applications and components that cross a number of technological boundaries -- boundaries where greater numbers of personnel and wider areas of expertise -- until recently -- were required.
It's also my belief that where previous technologies encouraged specialization to increase programmer productivity, .NET will actually promote a form of generalization. I.e., in becoming a .NET specialist, a developer can quickly master a set of disparate technologies. Thus, a team of developers who make a serious investment in .NET education will be able to implement a comprehensive n-tiered architecture application that weaves together a rich, web-based front-end, scalable middle-tier business components and high-performance back-end database -- in the same time that three specialist teams may have done so in the past.
Coupled with a powerful programmer productivity tool like Visual Studio.NET -- not to mention robust, object-oriented component-focused languages like C# and VB.NET -- software developers are in for an unbelievably good time. And where C++ programmers once worked until 3am while their Visual Basic counterparts left at 5pm, .NET developers using C# and VB.NET will be able to complete their tasks while keeping healthy work hours -- and not sacrifice performance, elegant solutions or graceful designs.
My .NET BootCamp comes from a single need: the need to help you become successful and productive with .NET. This doesn't mean you can't take software development seriously: you can't sacrifice serious intent, good design, or effective habits. But you can learn how to be productive with .NET and enjoy the work you do even more than you have in the past. So along the way, my course will delve into design issues and porting strategies, while staying focused on building re-usable components that are assembled into applications.
In .NET BootCamp, you'll find that .NET is a technology that will let you leverage your C++, Java, Delphi, COM or OO development experience to create powerful, scalable, flexible applications and components that can be deployed across enterprise-wide environments. Once you've completed .NET BootCamp, you'll be ready for the real fun: implementing .NET applications.
- Richard Hale Shaw
BACK TO TOP
|
|
|
.NET Bootcamps: Extended Edition and Classic
|
|
|
|
Note: this course has been obsoleted by our C# 2.0 BootCamp, and we're no longer expecting to give public presentations of this course.
However, we still expect to offer this course on-site on a limited basis: Request an On-Site presentation of this Class
The .NET BootCamp is our mainstream .NET training course for developers moving to the .NET Framework from C++, Java, VB6 and Delphi. We offer two forms of it:
Extended Edition: our new course which is taught as 5 very long, very intense days with comprehensive material, extensive homework, and detailed projects for learning the .NET Framework from every perspective (see the outline below). The Extended Edition is a complete immersion into .NET development, and includes nearly 600 pages of lab exercises that cover more in 1 week than a Microsoft Certification course could offer in 4. The Extended Edition is a more expensive than the Classic version but you'll get more than your money's worth, and if you survive the 11hr-12hr days, you'll emerge complete prepared to address any facet of .NET development.
This course is personally taught by Richard Hale Shaw
Classic: also 5 days, but taught in an 8hr day package that's easier to digest. While not as comprehensive as the Extended Edition, the Classic version still gives you your money's worth. This is a good choice when you are watching your budget or simply aren't interested in a total immersion course.
Lead Instructor: Richard Hale Shaw
The .NET BootCamp is our classic, fast-paced, hands-on, intensive immersion approach to designing and implementing .NET components and applications. The C# version of this class is predominately for C++, Java or other OO developers who want to start knowing little or nothing about .NET, but leave after 5 days ready to starting designing and building using the C# language. 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. Build .NET components, WinForms applications, Web Form apps, and Web Services in C#.
Here's what previous students of our .NET BootCamps have said. |
|
What you'll learn at .NET BootCamp
|
|
|
|
|
How to utilize C# as a .NET
implementation language
Differences in structure between Console, Windows
Forms, Web Forms and Web Services applications and components
How to document, compile, and run C#
applications
How to debug .NET components and write effective
exception-handling code
Create and use reference and value variables
Control-flow, method design and definition in C#
.NET collections, how to use them, how to
implement them
How to utilize OO features of C#, such
as encapsulation, inheritance, polymorphism and abstraction
How to manage unmanaged resources from managed
classes written
How to write reusable classes and components in C#
How to overload operators, define delegates and
events, and implement event-handlers
How to implement properties and indexers [c#]
How to implement properties and Item collections [vb]
How to use predefined attributes, and how and when
to define custom attributes
BACK TO TOP
|
|
You should have previous experience with an OO language (such as C++, Java,
Smalltalk, Delphi): we'll not provide any hand-holding with the fundamentals of
object-oriented programming. You do not need previous experience with C# or ASP.
COM programming experience is helpful but not 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
To address these new Frameworks and programming languages, we've developed 3 MiniCamps and 1 BootCamp (to be followed by new BootCamps) which will let you select your area of interest and immerse you head-first into the murky waters of .NET, emerging with a clear, comprehensive view of .NET at the end.
BACK TO TOP
|
.NET was created with some fundamental goals in mind:
-
Increase programmer productivity
-
Make component development scale more naturally for N-tier application
development
-
Treat the Internet and Intranets as an integral part of application architecture and deployment
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.
BACK TO TOP
|
OUTLINE**
Required Material -- [req]
The .NET BootCamp is modular and componentized: many of the
pieces can be presented on a standalone basis, some contain required
material that must be presented in order for others to be presented, and some
are not required. While public enrollment presentations of the course are taught
in their entirety, on-site presentations can be customized to suit the needs of
individual corporate customers. The [req] symbol next to a module indicates that
a module is required and cannot be omitted from customized presentations
without jeopardizing the structure of the course and the student’s
comprehension of the material.
Hands-On Material
-- [labs]
Like our other BootCamps, the .NET BootCamp focuses on
hands-on presentations: we think that the best way to learn and master a
technology is to program with it. Consequently, we include a great deal of
hands-on material in the form of cookbook labs that let the student review and
repeat a series of programming steps as frequently as they like. The notation [labs]
next to an item indicates that the item is can be presented largely presented in
a hands-on fashion.
Overview of Key Course Modules:
- Introduction to .NET
- Fundamentals of .NET Assemblies (Introduction to C#)
- More Advanced .NET Components (using C#)
- Building Simple Windows Forms Applications
- Utilizing the COM and Platform Interop Services
- Building More Complex Windows Forms Applications
- Fundamentals of ADO.NET: interacting with the DataStore
- Building Browser-Independent Front-ends: ASP.NET Web Forms
- Integrating Web Forms with the Middle-Tier
- Exposing Http-Based Functionality: Building ASP.NET XML Web Services
- .NET Remoting
- Building Serviced Components
Introduction to .NET [req]
- What is .NET?
- Deficiencies in Windows, COM and other preceding technologies
- How .NET evolved from Windows DNA
- Key Components of the .NET Framework
- .NET Infrastructure and Framework
- Binary Compatibility
- Benefits of managed environments
An overview of:
Platform Interop
Windows Forms
ASP.NET Web Forms
ADO.NET
ASP.NET Web Services
Building .NET Assemblies with C# [req]
- Building components, not objects
- Assemblies as the building blocks of .NET Applications
- Exploring Assemblies: Manifests, Metadata and IL
- .NET Language requirements, CTS and CLS
- JIT-compilation and the CLR
- Comparing C# to C++, Java, Delphi and IDL
- Managed C++ as a migration tool
- .NET program application structure
- Using the command-line compiler [labs]
- .NET namespaces
- .NET Classes and Types [labs]
- Using the Built-in Types [labs]
- Value Types vs. Reference Types [labs]
- System.Object [labs]
- Type visibility and Namespaces
- Type conversion, boxing & unboxing [labs]
More Powerful .NET Language Constructs [req]
- Generating XML documentation from code [labs]
- Generating Code-Comment Reports
- Language Control Flow
- Language operators, and operator-overloading [labs]
- Properties as accessor interfaces [labs]
- Exposing collection-like features from classes: Indexers [labs]
- .NET collections [labs]
- .NET strings [labs]
- Utilizing unsafe code [labs]
- Delegates as 1-function out-going interfaces [labs]
- Events as a form of Delegate, Event-handling [labs]
- .NET Common Type System (CTS)
- .NET Common Language Specification (CLS)
- Class and interface characteristics [labs]
- Class and member accessibility [labs]
- Exception-Handling [labs]
.NET During Development and at Runtime [req]
- Common Language Runtime (CLR)
- CLR Security Model
- Memory Management
- Deterministic vs. Indeterministic Finalization [labs]
- Attributes and Enumerators [labs]
- Cross-language support
- Manifests
- Metadata vs. typelibs [labs]
- Building, Packaging, Deploying, and Administering Assemblies [labs]
- How components are located [labs]
- Assemblies and Namespaces [labs]
- JIT Compilation: Pre-JIT, JIT & EconoJIT
- JIT verification
- How components are loaded
- Shared vs. Private Assemblies [labs]
- Deploying to the Global Assembly Cache [labs]
- .NET versioning: eliminating DLL Hell [labs]
- Application/Assembly Deployment [labs]
- Debugging and Tracing, Remote Debugging [labs]
Advanced .NET Framework Features
- Platform Interop: Invoking the Windows API from .NET [labs]
- C# to Managed C++ interop [labs]
- Invoking COM objects from .NET [labs]
- Invoking .NET objects from COM [labs]
- Harnessing the COM+ Services from .NET [labs]
- Streams and object serialization [labs]
- Application Domains [labs]
- .NET Remoting [labs]
- Reflection and Metadata [labs]
- Threading [labs]
- Reading, writing, validating and managing XML documents
Building Desktop Applications: Windows Forms
- Creating simple Windows Forms applications from scratch [labs]
- Creating MDI-based Windows Forms [labs]
- Adding event-handlers and file I/O [labs]
- Adding toolbars, icons, menus and tray icons [labs]
- Creating child dialogs [labs]
- Creating form-only applications [labs]
- Using advanced UI controls [labs]
- Multi-language and localization support
- Creating and Using .NET Custom Controls [labs]
- Creating other Windowing types
Writing Database-Independent Data Access Code: ADO.NET
- Writing database-independent code: the ADO.NET interfaces
- Using DataReaders: fast, read-only data access [labs]
- Using DataSets: an in-memory table cache [labs]
- Creating and querying multi-table DataSets [labs]
- Creating and managing 1-many and many-1 relations [labs]
- Adding new rows and columns [labs]
- Wiring up to DataSource-aware controls [labs]
- Reading/writing XML documents into/out-of ADO.NET databases
Building Web-Based Front-Ends: ASP.NET Web Forms
- Creating a simple Web Form front-end [labs]
- Understanding how to use the Code-Behind page [labs]
- Understanding Postbacks: the Page class lifecycle
- Adding Event-handling [labs]
- Debugging Web Forms [labs]
- Web Forms Controls vs. Html Controls [labs]
- Writing client-side validation code [labs]
- State Management: utilizing ViewState and SessionState
- Using DataBinding: DataGrid and DataList
- Application Configuration
- Page Caching
- When to write inline code [labs]
Building XML-based Web Services
- How .NET Web Services work
- Overview of SOAP, HTTP-GET & HTTP-POST
- Understanding WSDL contracts
- How .NET Implements SOAP Servers [labs]
- Testing and Debugging Web Services [labs]
- Creating a Web Service Client [labs]
- Using a Web Service Proxy [labs]
- Using Web Services from other implementations
**Course outline subject to change without notice.
BACK TO TOP
|
|
Regarding .NET 2.0 / C# 2.0 BootCamp"A lot of information in little time but the information given was very good and gives a good look into the world of .NET." --Niklas Nerholt, ERN Datakonsult |
|