CLR/C#

9:00am – 5:00pm
C1 - A Day of the CLR
Mike Woodring

No matter what type of application you are building on the .NET Framework, you need to have an understanding of the core of the .NET architecture known as the Common Language Runtime (CLR). The CLR is what controls memory management, method dispatching, inheritance, versioning, and a host of other basic needs of your application. This all day tutorial is designed to give programmers with a C++ or Java background the jumpstart they need to start being productive with C# on the CLR. Topics covered will include the architecture of the runtime, its type system, versioned assembly development and configuration, and exception handling.

   Back to Top   

Tuesday, Oct 26

9:00am – 10:30am Keynote

10:45am – 12:15pm
C2 - Delegates and Events
Richard Grimes

In this session Richard will cover .NET delegates and events. He will start by describing what delegates are and how they are declared and used in both C# and VB.NET. He will explain how to call them synchronously and asynchronously and will explain how the async infrastructure works and handles situations like exceptions and return parameters. During this discussion Richard will describe the changes to asynch invocation that there are in Whidbey. In the second half of the session he will explain what events are, how they differ from .NET delegates fields and give examples how the .NET framework uses events. Richard will explain the classes provided by the framework to make events more efficient and explain how to write the event members on your own classes.

1:45pm – 3:15pm
C3 - Multithreading and Thread Synchronization
Mike Woodring

The ability to execute code in an asynchronous fashion can yield tremendous improvements in program responsiveness or performance - if used correctly. In this session, Mike takes you on a tour of the multithreading capabilities of the CLR and then zeroes in on the most important part of multithreading: thread synchronization. Topics covered will include using dedicated threads versus pooled threads, and a look at the numerous synchronization primitives provided by the .NET Framework Class Libraries.

3:30pm – 5:00pm
C4 - Thread-Safe Components
Mike Woodring

In the thread-hot world of the CLR, many of the built-in framework classes support a "just-in-time" form of thread-safety; providing built-in thread-safety only when asked (and not until then). This approach incurs the cost of thread-safety only when needed - a balanced design. This session explains how to leverage this support in built-in framework classes, specifically how and when to use the Synchronized method or SyncRoot property of a class, and then shows you how to build your own "thread-safe on-demand" components.

   Back to Top   

Wednesday, Oct 27

9:00am – 10:30am
C5 - CLR Performance
Maoni Stephens

Write faster managed code! Learn about performance engineering, tools and issues specific to managed code including: garbage collection (GC), managed code deployment and common managed code pitfalls. The session also covers some of the performance improvements scheduled for the next version of the CLR.

Metadata is a vital part of .NET because it provides .NET with the information it needs to determine versioning, type safety and security. Richard will explain what metadata is and how it is extended with attributes. He will look at the various types of attributes and explain how they relate to the runtime. He'll show you how attribute information is stored in assemblies and describe how that data is read at runtime through the Reflection API. Finally, Richard will discuss several examples of using attributes in your own code, as a notation device and as a mechanism to change how other classes use your types.

1:45pm – 3:15pm
C7 - Managed/Native Interop
Jason Whittington

Few of us have the luxury of writing 100% new code. This session will examine strategies for interop with legacy code, including P/Invoke, Managed C++, and COM Interop.

3:30pm – 5:00pm
C8 - Instrumenting your .NET Application
Richard Grimes

.NET provides many features to instrument your application and in this session Richard will investigate those classes and describe some of the issues that occur. He will start by covering the tracing and assert classes in .NET and explain the architecture and illustrate some of the problems that occur when these classes are used incorrectly. You will see how to extend the architecture to provide your own trace listeners. Next Richard will describe using the event log and explain how to generate and read event messages. Again, this facility has its issues and he will explain how to avoid the pitfalls. Finally, Richard will demystify the performance monitor classes and explain how to allow your application to provide information about the work it is doing.

   Back to Top   

Thursday, Oct 28

9:00am – 10:30am
C10 - Peering Inside the Runtime with the .NET Profiling API
Steve Johnson

Have you ever had a difficult time tracking down an exception in a release build? Have you wished you could gather timing statistics from your components or inject tracing code into your functions without modifying your source and recompiling? The .NET Profiling API provides you with the tools you need to monitor and interact with the runtime as your application runs. Using this powerful API, you can monitor many runtime events, including Assembly loads, Exception events, GC events, JIT compilation, function entry and exit and more. You can even inject code on-the-fly. In this sample-packed session, Steve will introduce you to the .NET Profiling API and build a working profiler that provides timing statistics and exception monitoring for an application.

Learn about the different types of interoperability supported by the CLR and the basic performance guidelines associated with each. Topics include: pinvoke performance issues, reverse pinvoke performance issues, and COM interop performance issues.

1:45pm – 3:15pm
C11 - What’s New in Whidbey BCL
Kit George

Come and see what's new in the Base Class libraries for Whidbey. Topics covered include additional features in IO, generics, strongly typed collections, additional features in tracing, serialport support, and making your debugging experience faster, and more productive.

3:30pm – 5:00pm
C12 - Refactoring Support in the Whidbey IDE
Peter Provost

Effective refactoring is one of the most powerful tools a developer can use to create well-structured, loosely-coupled code. The next version of Visual Studio .NET (codenamed "Whidbey") will contain a host of new refactoring tools to make this job easier than ever before. This session will explore those tools and demonstrate how they can make you a mode effective developer.

   Back to Top   

Friday, Oct 29

9:00am – 10:30am
C13 - The .NET Garbage Collector
Brent Rector

Managed code means garbage-collected code. Garbage collection eliminates the possibility of memory leaking from an application due to unpaired news and deletes and reduces the amount of time spent debugging on the back end. This session examines the inner workings of the .NET Framework's garbage collector and imparts the knowledge you need to write "smart" types that wrap database connections and other unmanaged resources.

C# 2.0 introduces some intriguing new constructs for enumeration and iteration in the form of anonymous methods and iterators. This session will force you to reexamine how you think of local variables and method parameters by showing how these features enable a much more functional model of development.

1:45pm – 3:15pm
C15 - Understanding .NET Generics
Brent Rector

Want to be first in line to learn about one of Whidbey's coolest and most anticipated new features? Generics are the moral equivalent of C++ templates, and they're slated to debut in the next major release of the .NET Framework. Join the fun as Brent previews the generics support built into the Whidbey CLR and demonstrates how to use generics to write type-agnostic classes in C#.

3:30pm – 5:00pm
C16 - Effective Unit Testing in C#
Peter Provost

Almost everyone has heard of Unit Testing, but very few people actually do it well. This session will explore the common pitfalls associated with unit testing and provide some tools and techniques to help you create better tests for your code.

   Back to Top