|
|
|
C# 2.0/.NET 2.0: Evolutionary, not Revolutionary...
The February 2002 release of .NET 1.0 signaled the planned obsolescence of every major developer technology that Microsoft had shipped since the advent of the Windows API in 1984: .NET supersedes the Windows API, ADO, OLEDB, ASP, COM, ATL and MFC -- not to mention native C++ and Visual Basic 6.0.
But unlike the disparate technologies that preceded it, .NET 1.0 was (and 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 gains of developers who use it. Breathtaking in its scope and comprehensive in its depth, .NET altered a fundamental role-defining paradigm that had been a mainstay in workstation and server software development since the early '90s: that of component-developers and component users. Instead, .NET lets developers focus their skills on crafting solutions to domain-specific problems, rather than spend all their time on plumbing (as was required by the technologies that preceded it).
Enter .NET 2.0
The release of .NET 2.0 in November 2005 signals more of the same -- but in spades. The CLR has been re-written -- principally to support Generic types, but also to support new security features -- and the Framework libraries have been extensively updated and extended: by my own research, Microsoft has nearly doubled the number of public classes and methods in .NET 2.0 over 1.x. (They've also nearly tripled the number of public properties, but many of these are wrappers for public fields that are now private or internal.) The point of .NET 2.0 is to further the goal stated above: that of moving software developers away from writing plumbing, and more towards solving domain-specific problems but with re-usable solutions.
So where Framework 1.0 was revolutionary, Framework 2.0 is evolutionary: a further evolution of the same ideas that drove the release of Framework 1.0. Among the goals of .NET 2.0:
-
Specific defects in the design and implementation of .NET have been addressed in a number of ways.
-
Re-usable types, in the form of Generics, have been introduced.
-
New classes, that encapsulate a wide number of features, have been added.
-
Sub-frameworks, such as ASP.NET and Windows Forms have been extended.
My C# 2.0 / .NET 2.0 BootCamp comes from a single need: the need to help you become successful and productive with the 2.0 release of these fine software development tools. 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 our C# 2.0 / .NET 2.0 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
|
|
|
.NET 3.5 / C# 3.0 / Visual Studio 2008 Bootcamp
|
|
|
|
|
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:
Utilize C# as a .NET implementation language
Learn the differences between Console, Windows Forms, and Web applications and components
Document, compile, and run C# applications
Debug .NET components and write effective exception-handling code
Effectively create, use -- and understand the difference between -- reference and value variables
Master C# control-flow, method design and definition
Implement .NET collections and learn how to use them
Utilize OO features of C#, such as encapsulation, inheritance, polymorphism and abstraction
Leverage unmanaged resources from managed classes
Write reusable classes and components in C#
Overload operators
Define delegates and events, and implement event-handlers
Implement properties and indexers
Use predefined attributes as well as define custom attributes
Find attributes, dynamically, at runtime
Organize, create and deploy .NET assemblies
Leverage the Common Language Runtime's (CLR) a Managed Environment
Avoid using the Global Assembly Cache -- and learn when you must use it
Sidestep DLL-hell with Side-by-Side Execution
Learn to leverage legacy COM code and DLL and invoke it from C#
Learn when to use Managed C++ as an alternative for leveraging DLL-based code and native C++ code
Build and connect to Remoting objects across process and machine boundaries
Learn when to use Remoting and when to use a Web Service to implement distributed applications
Learn the difference between Marshal-By-Value (MBV) and Marshal-By-Reference (MBR) objects
Learn why MBVs are strictly a by-product of MBRs
Learn how Events are Marshaled in Remoting scenarios
Use WSDL contracts to generate both client-side and server-side code in Web Services
Learn to use Web Service Proxies as Best Practices
Use the built-in Cassinni server in VS2005 to host Web Services, rather than IIS
Leverage State Management in ASP.NET Web Forms
|
|
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
|
|
|
|