| 
September 11
Microsoft-Sponsored Breakfast Session:
Development Opportunities with the New Microsoft Office System
KEYNOTE: Microsoft.com Application Framework
Practical IL Primer: An Inside Look at Intermediate Language
Using the CodeDom to Wrap, Extend, Generate, Assemble and
Load New Code on the Fly
.NET Message Queuing and Queued Components
Advanced Windows Forms: Threading, Performance, Exceptions
and Resources
Leveraging the Power of Custom Attributes
.NET .Config Files De-Mystified 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.
|
