Designed for .NET developers “in the trenches”, our Core .NET conference at VSLive! focuses on day-to-day development with the .NET Framework. To this end, Richard and Rocky have selected content that lets you implement the Best Practices in .NET 2.0 (specifically, Generics, Windows Form, and ADO.NET), while showing you how to leverage newer technologies like .NET 3.x and Linq.
This is all the more challenging with the release of VS2008 and .NET 3.5. We view these as an evolution of the .NET Platform, as VS2008 now integrates support for .NET 3.0 (WPF, WCF and Workflow) into a single IDE (without the requirement of installing additional tools). Plus, VS2008 brings Language Integrated Query (LINQ) into the picture for use in all 3 (or more) tiers. And VS2008 gives developers the option of targeting specific Framework versions whether developing libraries or applications, meaning only one version of VS is required for .NET 2.0, 3.0 or 3.5.
Whether you’re using .NET 1.x, 2.0 or 3.x, we know that you need to make the most of the technologies you’re using today. At the same time, we appreciate that you need to plan for the future so you can most effectively extend your current capabilities with those provided by Linq, Visual Studio 2008, Silverlight and other new or future technologies.
To this end, Rocky and Richard have created a track that strives to make sense of what otherwise might seem to be a daunting set of disparate technologies, and answer questions like:
- How do I incorporate WPF into my existing WinForms application?
- What are the Best Practices for leveraging .NET 2.0 features like Generics?
- Should I replace my .ASMX or Remoting Services with WCF? If I do, will I break my clients?
- What are the consequences of using the SQL Server-specific provider in ADO.NET 2.0?
- If my applications are still .NET 2.0-specific, should I bother to upgrade to VS2008?
- I don’t write data access or even business layer code: should I even bother with Linq?
If these sound like questions you’re asking, don’t look elsewhere: come to the Core .NET track and get answers!
| CORE .NET LIVE! | ||
|---|---|---|
| 9:00a | Keynote: Achieving Dynamic IT with Windows Server 2008 | |
| 10:15a- 11:30a |
V C7
Introduction to Windows Workflow Foundation |
V C8
Using and Extending the Typed DataSet and TableAdapter  |
| 11:45a- 1:00p |
V C15
Windows Presentation Foundation (WPF): Build a WPF Application in an Hour |
V C16
Data Enhancements in Visual Studio 2008 |
| 12:45p- 3:00p |
Lunch and Exhibit Hall Open | |
| 3:00p- 4:15p |
V C23
Investigating LINQ over XML |
V C24
VS Tools and Techniques for Distributed Data Access in VS 2008 |
| 4:30p- 5:45p |
V C31
Introduction to Silverlight Programming |
V C32
Creating Advanced Custom Windows Forms Controls  |
| 5:30p- 7:30 |
Exhibit Hall Reception - Sponsored by Kaseya | |
| CORE .NET LIVE! | ||
|---|---|---|
| 9:00a- 10:15a |
V C39
Creating Custom WCF Behaviors |
V C40
More Best Kept Secrets in .NET |
| 10:30a- 11:45a |
V C47
LINQ to SQL (DLINQ) for ADO.NET Developers |
V C48
Generics, Anonymous Methods, and Delegates |
| 12:00p- 1:15p |
V C55
Exploit WPF Graphics without Wounding the Eyes |
V C56
Doing Something Useful with Enterprise Library 3.0 |
| 1:00p- 3:00p |
Lunch and Exhibit Hall Open | |
| 3:00p- 4:15p |
V C63
Workflow Services Using WCF and WWF |
V C64
Build Composite UI Applications with CAB and SCSF |
| 4:30p- 5:45p |
V C71
Asynchronous Messaging Patterns with WCF |
V C72
Reflection in .NET: Hacking and Futzing With IL |
| 6:00p- 8:00p |
Wild Wednesday – Special Guests The Code Trip | |
Virtual Tracks:
= Black Belt Virtual Track
= Best Practices Virtual Track
Track Chairs
Rockford Lhotka, Magenic Technologies
Rockford Lhotka is the author of the Expert VB 2005 Business Objects and Expert C# 2005 Business Objects books from Apress. He is a contributing author for Visual Studio Magazine and he speaks at major conferences around the world. Rockford is the Principal Technology Evangelist for Magenic Technologies, one of the nation's premiere Microsoft Gold Certified Partners.
Richard Hale Shaw, Richard Hale Shaw Group
Richard Hale Shaw is the founder of the Richard Hale Shaw Group, which has consulted and trained software developers since 1993. He's created and chaired numerous technical conferences, including C# Live! and the Black Belt tracks of the VSLive! conference series. An articulate writer and speaker on topics dear to the hearts of software developers and an outspoken critic of broken devtools, Richard specializes in consulting and training on .NET programming in C# and Managed C++. Richard is a member of the INETA (http://www.ineta.org/) speakers bureau, and for his work supporting C#/.NET software developers, he's been recognized by Microsoft as a C# MVP since 2004. You can reach him at www.RichardHaleShawGroup.com.
Core.NETLive!: Track 1 – Tuesday, April 1, 2008
Introduction to Windows Workflow Foundation, Introductory
Michael Stiefel
10:15 a.m.
What do email, meeting planning, document approval, budgeting, manufacturing processes, resource planning, and product lifecycle management have in common? Work flow: long running, complex business processes that interact with human decision making. But traditional, conventional programming techniques require you to spend an enormous amount of time building your workflow infrastructure before you write a line of application code. Fortunately, there’s a solution: Microsoft Windows Workflow Foundation (WF) arrived with .NET Framework 3.0, and offers a programming solution that lets you focus on writing business workflows immediately, without having to solve the difficult problems of workflow plumbing. In this session, I will introduce the fundamentals of building workflow applications.
Using an example of a simple business process, I will show you how to build a simple workflow application. I will also explain the fundamental parts of WF such as hosts, workflow, the activities and the basic workflow patterns.
Windows Presentation Foundation (WPF): Build a WPF Application in an Hour, Introductory
Ken Getz
11:45 a.m.
WPF makes it possible to build rich graphical user interfaces, but it doesn't necessarily make it easy. Getting your head around where to start, and how to display information, can be a daunting task. This session gets you started with WPF, and demonstrates creating a working video-player application, using data binding, templates, and more. Not the typical first introduction to WPF, this session actually shows you features you can use now to get started building WPF applications.
Investigating LINQ over XML, Introductory
Kenneth Getz
3:00 p.m.
LINQ adds many new features for Visual Studio 2008 developers, including strong support for working with XML data. In this session, you'll learn about working with XML data using LINQ, including creating, querying, modifying, and validating XML data, for both Visual Basic and C#. You'll also learn to use LINQ over XML to transform XML data (without using XSLT). Working with XML data could be a real pain before the addition of LINQ over XML, and this session gets you started using this powerful new technology.
Introduction to Silverlight Programming, Introductory
Jesse Liberty
4:30 p.m.
A complete introduction to coding Silverlight applications using Visual Studio 2008, including declarative programming, storyboards, XAML, event handling, drag and drop, media and so forth. This presentation is very focused on demonstrations of creating simple but illustrative examples.
Core.NETLive!: Track 2 – Tuesday, April 1, 2008
Using and Extending the Typed DataSet and TableAdapter, Intermediate
Jackie Goldstein
10:15 a.m.
Are you using the VS 2005 DataSet designer to design your data access code usign Typed DataSets and Table Adapters? You should be - because doing so allows you to build better data access code much faster. This session will be mainly demos that cover both the basic uses of these tools and objects, as well as techniques to extend the standard classes to meet your own specific needs. We will also take a look at some of the improvements in Visual Studio 2008.
Data Enhancements in Visual Studio 2008, Intermediate
Robert Green
11:45 a.m.
Visual Studio 2008 offers a number of features that make it easier to build both 2-tier and n-tier data applications. You can use the new TableAdapterManager to manage updating of related table. No more having to write the code make sure child rows are deleted before parent rows. Now, it’s automatic. With ADO.NET Synchronization Services you can maintain a local copy of data that doesn’t change often, such as lookup tables, and then synching that data with the server version. You can now automatically separate DataSet code from TableAdapter code. In VS 2005, you must do this by hand if you want to use the DataSet Designer and build an n-tier application. Or you can have VS 2008 do it for you. You can use the LINQ to SQL classes and the Object Relational Designer to build your data middle tier. The LINQ to SQL classes provide a way to map a database model to an object model. You can write the code yourself, or you can use the Object Relation Designer and drag and drop tables and stored procedures from the Server Explorer.
VS Tools and Techniques for Distributed Data Access in VS 2008, Intermediate
Jackie Goldstein
3:00 p.m.
This session will discuss several challenges facing developers developing distributed data access applications. These issues include hierarchical updates, use of VS tools/wizards to generate truly N-tier applications, and separation of data entity and data access objects. We will demonstrate what tools and techniques can be used and take a look at what new solutions are offered in Visual Studio 2008.
Creating Advanced Custom Windows Forms Controls, Intermediate
Walt Ritscher
4:30 p.m.
Creating your own controls is a great way to augment your UI development. There's more to creating user controls however than dropping a few constituent controls on a designer and crafting a few properties or methods. This session illustrates the techniques you need to elevate your user controls to the next level. Since other developers use your control, you need a firm grasp on how to make your control interact with the Visual Studio Forms designer. Learn how to decorate your control with design time adornments (example: sizing and rotation handles). We'll look at several powerful tools - Property Browser integration, Extender Property Providers, Type Converters, Designer Verbs, Custom Designers and UI Type Editors - that make your control easy to use, work effectively in the Visual Studio IDE and also look professional. In addition you'll see you to support data-binding to your control and learn how to debug your control effectively.
Core.NETLive!: Track 1 – Wednesday, April 2, 2008
Creating Custom WCF Behaviors, Advanced
Rob Daigneau
9:00 a.m.
Custom behaviors provide a mechanism to modify the WCF runtime execution at the proxy (i.e. client) or dispatcher (i.e. service) via attributes, configurations, and even programmatic means. This powerful technique may be used to inject common and “cross-cutting” logic upon Services, Contracts, Endpoints, and Operations, which in turn yields limitless possibilities.
In this session we will explore how WCF custom behaviors might be leveraged to implement a concept similar to Aspects. You'll learn how this powerful feature can be used to apply cross-cutting logic to your services in a manner that is both simple to understand and implement. You'll also see that the concepts of SOA, OOP, and AOP (i.e. Aspect-Oriented Programming) should be thought of as being complementary rather than competing.
LINQ to SQL (DLINQ) for ADO.NET Developers, Intermediate
Richard Hale Shaw
10:30 a.m.
ADO.NET Developers have long faced an unfair set of choices: use the DataReader -- equally known for its speed as for the cumbersome ways in which you have to write code to use it -- or use the Typed DataSet, which offers strong type-safety but can be a performance sloth and memory hog. Not any more: DLinq (also known by its official name, Linq to SQL) offers you strong typing, great performance and the ability to access your data in a far more intuitive, Object-Oriented fashion that you could with the DataReader or the DataSet. Will you find that DLinq is a Better DataSet -- but without performance issues? How do you get started with it, and what are the Best Practices for using it? In this session, Richard will show you how. We'll start with a brief overview of DLinq mechanics and quickly move under-the-covers, calling Stored Procedures, creating wrapper classes and more. If you're largely targeting Microsoft SQL Server or SQL Express (now Compact Edition), you'll find this may be the Data Access method to invest in from now on.
Exploit WPF Graphics without Wounding the Eyes, Intermediate
Brian Noyes
12:00 p.m.
WPF has a lot of powerful capabilities for styling and animation that if used uncontrolled can leave you with a UI that looks like it was designed by someone on an overdose of psychotic drugs. This session will demonstrate how to leverage the power of the styling and animation features of WPF to create pleasing UI experiences that make your application more intuitive and visually pleasing for your users, instead of making them seek therapy. You’ll learn how to apply styles, control template, and subtle uses of animation and transparency to give a great UI experience that catches the eye and sells your product to your customers or project sponsors.
Workflow Services Using WCF and WWF, Intermediate
Michael Stiefel
3:00 p.m.
Using workflow to build services is one of the fundamental building blocks of service-oriented systems. Version 3.5 (”Orcas”) of the .NET Framework simplifies the building of workflow enabled services using Windows Workflow Foundation (WF) and Windows Communication Foundation (WCF). The new framework classes reduce the amount of plumbing code that has to be written as well as providing new templates to help build these kinds of scenarios. This talk will not only illustrate the new features, but demonstrate them with a realistic scenario.
Asynchronous Messaging Patterns with WCF, Introductory
Rob Daigneau
4:30 p.m.
A client program calls a service and must wait for it to finish before moving on to do more work. We all know how to do synchronous calls; it’s as easy as writing a “Hello World” program. But how does one design a system where lots of work can be done in parallel?
In this session you’ll see how to use WCF to do just that. You’ll learn about several patterns used in the world of asynchronous messaging including callbacks, store and forward, and conversations. This session will provide you an introduction to some of the fundamental concepts required to build distributed Event Driven Architectures.
Core.NETLive!: Track 2 – Wednesday, April 2, 2008
More Best Kept Secrets in .NET, Intermediate
Deborah Kurata
9:00 a.m.
Deborah Kurata has been sharing her Visual Studio and .NET Framework secrets with developers for the past several years. In this new installment, she covers more lesser-known features to help you become more productive with your development tools, including some VS 2008 features.
This session covers how to improve your productivity by building your own project and project item templates. It covers lesser known code navigation features and keywords such as Using and IsNullOrEmpty. It provides details on using nullable types and on building queries from within Visual Studio. Finally, it covers how to perform unit testing directly from within Visual Studio.
Generics, Anonymous Methods, and Delegates, Intermediate
Deborah Kurata
10:30 a.m.
Generics, anonymous methods, and delegates, oh my! Come and learn all about these very important concepts. This session is both for developers who don’t know what these things are and for those who want to expand their use of these techniques.
This session begins with a brief introduction to generics. It then dives deep into using generics in both VB and in C#, including use of anonymous methods, lambda expressions and delegates to expand on generic functionality. Finally, it covers how to use reflection with generic types.
Doing Something Useful with Enterprise Library 3.0, Advanced
Benjamin Day
12:00 p.m.
There are so many common problems that we run in to when we write applications – logging, exception handling, validation, data access, etc. Unfortunately, many of us end up writing and re-writing the same code over and over again in each application. Sure it might be fun to write this code but if someone’s already done it, should we keep re-writing it? Enter P&P’s Enterprise Library. Enterprise Library aims to solve these common problems with standardized code so that you can focus on implementing your “real business problem”. There so much stuff in Enterprise Library and it can be difficult to know how and where to start using it.
In this session, Ben will show you what some of the big pieces are and how to incorporate them into your application’s architecture including what “Policy Injection” is and why you should care.
Build Composite UI Applications with CAB and SCSF, Intermediate
Brian Noyes
3:00 p.m.
When you build complex smart client applications, especially with distributed teams all working on parts of the application at the same time, things can get messy in your presentation layer code pretty quickly because of all the tight coupling that evolves for navigating and coordinating between forms. The Composite UI Application Block (CAB) and Smart Client Software Factory provide a rich framework for addressing that complexity and minimizing the coupling in your application. This session will get you up to speed on using CAB and SCSF to improve your UI architecture. You will learn how to use its capabilities to partition functionality in your application into modules, use Model-View-Controller and Model-View-Presenter patterns to decouple the navigation and logic in your presentation layer, services to provide shared functionality, dependency injection patterns for loosely coupled construction of dependent objects, and loosely coupled events between modules and views to coordinate different portions of your UI.
Reflection in .NET: Hacking and Futzing with IL, Advanced
Jason Bock
4:30 p.m.
Reflection is a powerful way to dynamically inspect assembies at run-time to determine the structure of its contents, invoke methods, and change private field values (among other interesting tricks). But it doesn't stop there - .NET gives you the power to create code at run-time via its reflection infrastructure as well.
In this presentation, I'll cover the essentials of the System.Reflection namespace, how to emit code at run-time, and other libraries that go far beyond what .NET can currently provide (FxCop's CCI library for introspection and Mono.Cecil for full assembly reading/writing).
