ASP Live!    SQL Live!     VBITS     SA Summit     Indigo Day

Session Descriptions

C# Live! delivers two days of intensive, black-belt programming for advanced .NET programmers using the C# language.

Tuesday, February 8

Advanced Threading: Asynchronous Tasks and the Thread Pool
Tom Barnaby, Intertech
10:30 a.m.
Using delegates, the .NET framework provides a consistent pattern for executing tasks asynchronously. Learn about the mechanisms behind this pattern and how to apply it when making asynchronous calls to local objects, remote objects, and Web services. Also demonstrated is how to execute tasks using the runtime’s built-in thread pool and best practices for using this feature. Then, we’ll see how to safely manage asynchronous tasks in a Windows application. Finally, we will look at some .NET 2.0 features related to threading, including the new background worker control and methods for correctly retrieving a thread id.

Fun with GDI+: Two-Dimensional Vector Graphics in C#
Mark Miller, Developer Express
10:30 a.m.
Learn how to exploit the power of GDI+ responsibly. This session will cover the exciting world of 2D graphics to add impact and coolness to your existing business applications. First, we'll start off easy by drawing straight lines and shapes and wrapping text like a pro. Then we'll quickly move on to gradient brushes, transparencies and show how to create smooth curved lines. Finally, we'll dive into graphics paths and the ultra-cool matrix transformations and show just how easy it is to manipulate fonts and vector graphics. This session will include valuable tips and tricks — good advice to follow when you're working with GDI+.

IL Programming for the C# Developer
Godfrey Nolan, RIIS
11:45 a.m.
Taking performance tuning to the next level requires more than a basic knowledge of Microsoft's Intermediate Language (IL) to understand what's really happening in the CLR. If you want to have optimized code you need to know how your C# is being converted into IL and passed to the execution engine or CLR. We’ll begin by taking a quick tour of the different IL opcodes and quickly move on to how the basic C# language constructs, such as for-loops, collections, and method invocation, are compiled into IL. We'll conclude with a look at how the newest features of C# 2.0, such as Generics, Iterators, and Anonymous Methods are implemented in IL.

Applying Domain Driven Design to .NET
Jimmy Nilsson, JNSK AB
11:45 a.m.
Domain-Driven Design (DDD) is quickly gaining momentum. It could be seen as a certain style of structuring the Domain Model. In this session, we will apply some of the ideas behind DDD while moving from requirements to a Domain Model. Along the way, we will discuss DDD-patterns, such as Factories, Repositories, Aggregates, Entities, and Value Objects and Services.

Implementing Design Patterns in C#
Richard Hale Shaw, Richard Hale Shaw Group
2 p.m.
Patterns — particularly Design Patterns — are now vogue with Managed Code developers. Why are Patterns important, and how do you leverage them? When should you use one pattern over another — and more important — how do you evaluate one .NET implementation of a particular pattern in respect to others? You’ll learn how Patterns have become a lingua franca for software developers who want to develop a common vocabulary of Best Practices in a standardized fashion. You’ll also learn how Design Patterns embody best practices for design and architecture, and we’ll examine a number of the key patterns originally defined by the Gang of Four (GoF). Finally, we’ll evaluate several competing C# implementations of these Patterns, how to best use features of the language when implementing them, and learn how the CLR can affect the success of a particular Pattern implementation.

Aspect-Oriented Programming in .NET
Tom Barnaby, Intertech
2 p.m.
Aspect-Oriented Programming (AOP) holds great promise for building flexible and easy to use business frameworks. We’ll review the basic principles of AOP and compare it to traditional strategies such as interception and custom metadata. We’ll also define the bizarre terms used in AOP circles such as join points, point cuts and weaving and discuss the tradeoffs implicit in various AOP implementation strategies. Then we’ll dive into the details of implementing AOP in .NET., discuss the .NET features that make it well-suited for AOP solutions, and survey some emerging .NET AOP tools. Finally, we’ll apply AOP principles to improve upon a well-known business object framework.

Refactor Your C# Code!
Jimmy Nilsson, JNSK AB
3:15 p.m.
Refactoring is becoming extremely popular these days, not least because Visual Studio .NET 2005 will have built-in support in the IDE. We’ll discuss five selected refactorings that go beyond what the IDE can help you with automatically. The refactorings discussed will move towards, to, or from patterns.

Discover Code Access Security (CAS) through the power of Design Patterns
3:15 p.m.
Did you know that ASP.NET applications by default run under Full-Trust permission? Will ASP.NET application work if you limit the permission set? These and many other questions will be answered. Security is not a straightforward topic and we’ll resort to Design Patterns to help describe the CAS fundamentals. We’ll cover policy files, Sandbox Pattern, and other concepts that will provide you with a kick-start for developing applications that can run in semi-trusted environments.

Best Practices: User Settings & Options-Oriented Architectures
Mark Miller, Developer Express
4:30 p.m.
User Settings are a commonplace, yet all-too-often overlooked area of software development. Don't reinvent the same old wobbly wheel each time you need user settings! Instead, learn the best practices and patterns behind a flexible and sophisticated options dialog. Learn about advanced options page and storage architectures, ideal storage locations, on-demand page creation, and how to maximize flexibility and reuse by decoupling everything. We'll put all the pieces together with a great design and valuable tips and tricks to ensure that your options pages never go astray.

Inside Framework 2.0
Richard Hale Shaw, Richard Hale Shaw Group
4:30 p.m.
Think you know the big stories in Framework 2.0? Think again: remember that Framework 1.0 was released along with .NET Passport and My Services, and we all know today that .NET has little to do with either of them. So while you’ll hear a lot about great technologies like Generics, ClickOnce, and the new ASP.NET 2.0 model, the fact is that the CLR and Framework libraries themselves are chock full of new goodies and features you’ll come to know and love, sporting over 10,000 new class members (3,000+ have been removed!). We’ll examine those hidden nuggets in Framework 2.0 libraries. We’ll start with Nullable types and Friend Assemblies, and move on to revered Framework classes — System.String, System.Console, System.Environment, and System.Diagnostics — and then explore new features and facilities that have been added to make them more powerful and useful. We’ll wind up with an overview of the 100+ breaking changes introduced and how you can gird your applications against them.

Advanced CLR Programming with C#
Sam Gentile, Adesso Systems
5:45 p.m.
Examine topics such as assemblies, JIT compiling, Reference versus Value Types, and Garbage Collection. In addition, uncover insights into how to best utilize the .NET Framework in various scenarios, including Interop.

Unit Testing your .NET Application
Walt Ritscher, Scandiasoft
5:45 p.m.
Test Driven Development is gaining ground in the .NET community. Isn't it about time you learned what the buzz is about? Unit testing is a developer testing discipline that proposes that you write your test cases first — before coding your application. It recommends that an automated test environment be used. Can .NET development benefit from this unit test or programmer test approach? The answer is a resounding yes! We will see how to integrate unit tests into Visual Studio.NET and review a number of unit testing application including Nunit. Learn what parts of your .NET application will benefit from unit testing and what parts shouldn’t be included. See the difficulties encountered when attempting to test the user interface portion of your application and look at ways to successfully implement a solid test plan.

Wednesday, February 9

.NET Obsfucation
Godfrey Nolan, RIIS
10:30 a.m.
After peeling back the many layers in a .NET executable, we’ll briefly look and see just how easy it is to take the underlying code and reverse engineer it into the original source. Using ILDUMP, we can also see just what obfuscators are doing to your code when they attempt to protect it. We'll finish with a simple demonstration where we use ILDUMP — and a companion program, ILRECOVER — to convert the XML back into an executable, and create our own simple .NET obfuscator.

C# 2.0: Understanding Generics and Iterators
Richard Hale Shaw, Richard Hale Shaw Group
10:30 a.m.
Generics and Iterators will be the most powerful new features added to the C# language in the Visual Studio 2005 release. The key to understanding Generics and Iterators is a common pattern established in the early days of .NET, which continues to be repeated in C# 2.0: The language lets you create powerful abstractions with relatively little plumbing on your part, and the compiler generates detailed IL code that does the real work. Drill down into these two new features of the C# language, and show practical applications of them in .NET applications and components and the types of constructs that they generate in the resulting IL.

Advanced COM Interop with C#
Sam Gentile, Adesso Systems
11:45 a.m.
Many C# developers are finding that they need to interoperate with existing legacy COM components from their C# applications. There are profound differences between the COM and the CLR model and thus COM Interop out of the box doesn’t always do what the C# developer expects. We’ll review Runtime Callable Wrappers (RCWs) and COM Callable Wrappers (CCWs) and then quickly look at code-focused ways of improving your Interop experience.

Programming Transactions in .NET 2.0
Tom Barnaby, Intertech
11:45 a.m.
The .NET Framework 2.0 delivers radically faster transaction processing through the new System.Transactions namespace. With System.Transactions, you can build reliable distributed applications without paying the performance penalty traditionally associated with transaction programming. In this session, you'll learn about the new in-memory transaction manager for handling volatile resources, as well as the first ever promotable transaction mechanism for dramatically improving efficiency and performance of transactional systems.

Smart Clients 2.0: What's new in Visual Studio 2005 Forms? Parts I and II
Walt Ritscher, Scandiasoft
3:15 p.m.
Arguably the most visible set of new features to be added to .NET Framework 2.0 will be the enhanced support for Rich Client applications. As enhancements to the Base Class Libraries (BCL) in the WinForms namespace, dozens of new controls and features have been added to support dynamic layout, more powerful data binding, richer editing and formatting, and more support for enhancing the overall user experience in your own applications. See why rich client applications will be even more powerful with the Framework 2.0 release.

Patterns for Smart-Client Application Development and Deployment
Maxim Karpov, Faith Interactive
3:15 p.m.
Smart-Client is just another buzzword of the day, but what does it take to develop an application that provides an offline mode to the user? Learn how ADO.NET DataAdaper and Dataset objects provide us with an out-of-the-box ability to detect and resolve data concurrency. Before your eyes, we’ll develop an application framework that is based on Optimistic Offline Lock Pattern, Data Transfer, and Data Mapper.

Advanced ADO.NET/ADO.NET 2.0
Andrew Brust, Citigate Hudson
4:30 p.m.
Visual Studio .NET and the .NET Framework have been out for more than two years now, but there are still advanced features in ADO.NET (such as parameter binding, table mapping, transactional DataAdapters, auto-refreshed Datasets, and rich XML functionality) that many developers are not aware of. Additionally, through early pre-releases of Visual Studio 2005, we now have a chance to see what ADO.NET 2.0 will look like and what new features it will bring, including server-side data access programming for SQL Server 205 (codename “Yukon“).Examine these advanced ADO.NET 1.X and 2.0 features so you can start using them in your own applications.

Toolkit! Live: Essentials for your .NET Toolkit
Panel
4:30 p.m.
VS.NET isn't the only .NET development tool around: just Google for ".NET Tools" and you'll see for yourself. We've asked a group of our speakers to contribute and debate on which .NET tools they insist that you learn.