Attendees, access your Virtual Conference material here: www.ftpconferences.com/vc You’ll find your username and password on the first page of your proceedings booklet!

September 12
KEYNOTE: Data Access with Visual Studio .NET
Advanced Datagrid Programming: Pushing the Envelope of Advanced UIs
.NET Context and Interception — And Why You Should Care
The Common Language Infrastructure and Platform — Independent .NET
Practical .NET Security
Top 10 Best Practices for .NET Development

C# Live Sessions — September 11

Microsoft-Sponsored Breakfast Session: Development Opportunities with the New Microsoft Office System
Robert Green, Microsoft
Heavy investments in standards-based XML and .NET technologies provide developers with a host of new development opportunities around the Microsoft Office System. Come see how XML leads to better solutions for end users and enables information to be more easily captured, used and repurposed throughout organizations. New tools and interfaces in the Microsoft Office System give developers greater control over the use and flow of XML data and allow Visual Studio .NET developers to extend their skills to Office applications using everything from ASP.NET to Web services to network deployment.
8 a.m.

Microsoft.com Application Framework
Larry Jordan ,Microsoft.com Development Manager, Microsoft
This presentation will take a deep look at the .NET adoption on Microsoft.com that provides a centralized framework for content aggregation ,presentation and programmability. The presentation will focus on the use of various XML capabilities in .NET and net- work distribution model of Web Services that make up the architecture of Microsoft.com.
9 a.m.

Practical IL Primer: An Inside Look at Intermediate Language
Andrew Troelson, Intertech
There are practical benefits from knowing how — and when — to hand-code Common Intermediate Language (CIL). And knowing how .NET languages map their constructs to IL tokens can be incredibly useful towards getting more mileage out of a language tool. And if you're planning to use Reflection.Emit, you don't have any choice: an understanding of CIL is requisite. In this session, we'll discuss and explain these topics and how you can start mastering IL in your own applications.
10:30 a.m.

Using the CodeDom to Wrap, Extend, Generate, Assemble and Load New Code on the Fly
Josh Holmes
The CodeDom is perhaps one of the most powerful but least understood parts of the .NET Framework: it gives you the ability to quickly and easily create logical program constructs, emit that code in a supported .NET source language, compile it into an Assembly, and load and execute it using reflection. But the question remains: when should you use it — and when shouldn't you? An easy answer would be: to write tools that generate source code, but after all, how many of us do that? More realistically, you may have applications that need to create rule-based engines, or you may need to generate a type-safe collection — on-the-fly, while your program is running. In this session, we'll explore the CodeDom, and how you can harness it to create applications and components that are extensible and flexbile — even at runtime.
11:45 a.m.

.NET Message Queuing and Queued Components
Tom Barnaby, Intertech
With Microsoft's overwhelming focus on .NET's support for XML Web services, and attention in the developer community going to .NET Remoting, everyone seems to have forgotten an established, effective and robust means of distributed communication for applications and components: message queuing. While available to component-based systems since the advent of COM+, very few developers have discovered the power of asynchronous, disconnected operations via message-oriented middleware (MOM) solutions. In this presentation, we'll discuss when and where you should apply MOM, how to build queued components with the .NET Framework, and how to leverage MSMQ from managed code.
2 p.m.

Advanced Windows Forms: Threading, Performance, Exceptions and Resources
Richard Grimes, Author
If there's any part of the .NET Framework that appears to deliver the classic RAD experience, it's the Windows Forms library: it appears to be so simple, easy to use, and you get nearly instantaneous results! But even the simplest Forms application may hide more complex issues that only surface later, such as how properties are used, performance problems in forms, and threading issues. Just how do you create a multi-threaded GUI that's efficient and safe? How do you deal with components that use combinations of both managed and unmanaged resources in a Form? And just how should exceptions be handled? In this session, come find out how Advanced Windows Forms development should really be done.
3:15 p.m.

Leveraging the Power of Custom Attributes
Tom Barnaby, Intertech
Custom Attributes let you extend the metadata stored in an assembly so that you can build programs that dynamically load and instantiate new types or wrap new behavior around existing program components at runtime. The key: knowing how and when to build Custom Attributes, and where best to apply them. In this session, we'll briefly review the basics of Attributes (syntax, CIL representation) and then jump into creating your own Custom Attributes, as well as how to detect and retrieve them via reflection. You'll even learn how to wire attributes into other Framework facilities (such as Exceptions) to leverage Context and Interception and create powerful, self-diagnosing/notifying program components. Come to this session to learn to master Custom Attributes.
4:30 p.m.

.NET .Config Files De-Mystified
Richard Hale Shaw, Richard Hale Shaw Group
Config files don't seem to be complicated — until you start to use them. When should you use a config file and when shouldn't you? What is the relationship between Machine .config files and private application .config files, and what about components with their own .config files. How are configuration settings stored in an AppDomain and applied to your code? How do custom config file sections figure in; how do you apply them to your code? And how do config files in Remoting differ from ordinary application config files? In this session, we'll show how .config files can be powerful tools that can be routinely be applied to your applications and components, and how to get the most mileage out of them.
5:45 p.m.

C# Live Sessions — September 12

Data Access with Visual Studio .NET
Most mission-critical applications created with Visual Studio start with data access - from Oracle SQL Server,DB2,legacy data stores, From the impact of XML to the move from ADO to ADO how Visual Studio developers approach data access is being redefined. With native CLR-support promised in the Yukon release of SQL Server, more changes are afoot. Get a new perspective on where data access is today and how to architect your applications so they won ’t be made obsolete by the substantial changes on the horizon.
9 a.m.

Advanced Datagrid Programming: Pushing the Envelope of Advanced UIs
Josh Holmes
The Windows Forms Datagrid looks soooooo easy! Just drop it on a form, configure a few properties and wire up a data source! But in reality, that's only where your troubles begin: just try to configure the TableStyles collection and the GridColumnStyles of each one. Suppose you want to underline a grid row, or handle double-click events in a grid cell: as soon as you try something that the grid doesn't handle directly, there's quite a bit of work involved. You quickly find out that the Grid is great for slapping together a quick demo, but it falls short when you start using it in a production application. In this talk, we'll delve beneath the hood of the DataGrid to see how it works, and push it beyond the “out of the box” behavior.
10:30 a.m.

.NET Context and Interception — And Why You Should Care
Richard Grimes, Author
All .NET objects run in a context: an environment that's selected or created for them whenever they're activated. That said: why should you care? What's the point of contexts, and when do you use them, anyway? In this session we will answer these questions. He'll explain when you use contexts and why, and he'll cover the details of how to get information about them and manipulate them at runtime. He'll also explain why some objects don't care about context, others can move between contexts, and some are bound to their contexts, and he'll show how to configure contexts, how to get information about them and how to write context plug-in code to create your own contexts.
11:45 a.m.

The Common Language Infrastructure and Platform — Independent .NET
Andrew Troelson, Intertech
.NET Is platform-independence in .NET a reality? Is it really possible to build .NET assemblies with Visaul Studio .NET and run them unmodified on other platforms? If you really must modify them, what are the constraints and limitations? In this session, we'll discuss the reality of cross-platform assemblies via the Common Language Infrastructure (CLI): what it is, what it's used for, and how it makes cross-platform development possible. We'll also discuss the toolkit, the C# specifications, partition docs and the Mono project. And for grins, we'll write some programs using C# and run them via the FreeBSD on a Macintosh PowerBook.
2 p.m.

Practical .NET Security
Richard Hale Shaw, Richard Hale Shaw Group
Mention the word "security" and for many of us, our eyes glaze over: it's usually the domain of administrators and systems programmers. But .NET provides two excellent mechanisms — Code Access Security and Principal (or Role-Based) Security — that you can use to design and implement coherent security policies in your applications and components. Using these services, you can assign and enforce degrees of trust to your code (based on its origins and identity), specify what your code should be allowed to do (and never allowed to do!), and assign privileges to logical roles that control access to code elements and resources. In addition to looking at these issues, we’ll also review the new security impositions placed on you in .NET Framework 1.1 (which comes with VS.NET 2003).
3:15 p.m.

Top 10 Best Practices for .NET Development
Experts Panel including Tom Barnaby, Richard Grimes, Josh Holmes, Andrew Troelsen, and Richard Hale Shaw
When all's said and done, it's not just techniques that build an application, but how you apply the techniques. What makes for the best tools for .NET development? Should you package your components into multiple assemblies? When do you apply strong names to your assemblies — and why? In this no-holds-barred session, our expert speakers will give you their recommendations for Best Practices, and they'll answer the questions you may have based on their own development experiences with the .NET Framework.
4:30 p.m.