It will definitely be a busy TechEd for me this year. I'll be giving six sessions at TechEd Developers Orlando in June, as well as spending a lot of time in the TLCs and at the RD booth..

The sessions are as follows:

Tue, 3 June, 11:30-12:30 AM: Vista Ask the Experts area

Doing Q&A on selecting the right client technology.

Tue, 3 June, 1:15-2:30 PM: WIN315 - Data Binding in WPF

This talk will cover the A-Z of data binding capabilities in WPF. I'll start by talking about the different kinds of data sources you can bind to and the interfaces those data sources need to support to have high fidelity data binding. Then I'll go through what data contexts are and how they allow you to flow data into you UI in a more decoupled fashion. Then I'll get into Binding objects and how you use them to hook up the data binding to your controls, and the many capabilities they expose. Then I cover navigating and filtering your data with collection views, and finally finish up with data validation.

Tue, 3 June, 4:00-5:00 PM: Vista Ask the Experts area

Doing Q&A on WPF Data Binding

Wed, 4 June, 10:15-11:30 AM: ARC304 - Selecting the Right Client Technology

This talk covers the spectrum of options that exist for building client UI applications today, helping you to make the right choice when getting started with a new UI application. I start by talking about the decision between smart client and browser based applications, drawing out the pros and cons of each approach. Then I get into each of the current technologies including WPF, Windows Forms, ASP.NET, ASP.NET AJAX, and Silverlight, and talk about the pros/cons, differences/similarities between each of those technologies.

Thu, 5 June, 4:30-5:45 PM: WIN301 - Windows Presentation Foundation in Windows Forms and Vice Versa

This talk covers the interoperability story between Windows Forms and WPF, which is a great one. I start with the motivations of why you would want to use interop as opposed to building a homogenous application in one or the other technology. Then I show how to embed WPF controls in a Windows Forms application, and Windows Forms controls in a WPF application. If it were just about the code required to do those things, I could give this talk in about 10 minutes. But of course, there are always other considerations and hazards to be aware of when doing interop between technology stacks, so I then let you know what those hazards are and how to address them.

Fri, 6 Jun, 8:30-9:45 AM: WIN306 Building Differentiated UI Applications Using Composite Windows Presentation Foundation

I'll be joining Glenn Block from p&p to code monkey for this session on using Prism to build composite WPF solutions. I've been working with the team part time building this, so Glenn was nice enough to invite me to help present.

Fri, 6 June, 1:00-2:15 PM: SOA305 - Getting Workflows Running and Talking in Your Applications

This talk covers the hosting and communications aspects of Windows Workflow Foundation (WF). You will learn how to set up the host environment for running workflows, how to leverage persistence and tracking, how to pass parameters into a workflow and get them back out when it completes, and how to make calls from the host application into the workflow. I'll also briefly discuss making service calls into and out from a workflow, but don't demo those in details because my TLC session (listed next) covers doing that in detail.

Fri, 6 June, 2:45-4:00 PM: SOA08-TLC - Developing Service Oriented Workflows

This talk shows you how to leverage the new WCF related capabilities in WF 3.5 to build workflows that particpate directly in your service oriented architecture. You'll see how to use the Receive and Send activities, the context bindings that take care of automatically routing incoming messages to the right workflow instance, and the WorkflowServiceHost class to host your workflows. This is a TLC session down on the show floor, and the rule of the game there is max interaction, and minimum if any PowerPoint. I in fact have only two slides planned, a couple architecture diagrams to couch the discussion, and the rest will be all code demos showing you how to really leverage this stuff.

I also plan to spend an hour after each session in the associated TLC area, and then most of the rest in the RD booth.

If you are going to be at TechEd, I hope to see you at one of my sessions. If so, stop by and say hi and let me know you are one of the few who actually read my blog. :)

A little late to the game, but I have been struggling with some blog configuration issues that were preventing me from posting, and have finally found time to tackle those.

I gave two talks at VS Live! San Francisco.

Here are the slides and demos:

Exploit WPF Graphics without Wounding the Eyes   Slides    Demos

Build Composite UI Applications with CAB and SCSF    Slides    Demos

 

To create the database for the music data demos, you have two choices.

1) Follow the instructions in this post to create your own music library database based on your own collection:
http://briannoyes.net/2008/02/13/BuildYourOwnMusicDatabaseForDemosAndSamples.aspx

2) Download a database backup (29MB) from here: http://www.softinsight.com/downloads/MusicLibrary.bak and restore it.

I spoke this week at DevConnections in Orlando. As always a great time and a good show. For those that attended my talks, thanks for the great participation and questions! For those that didn't, you really need to work harder on convincing your boss to send you to a DevConnections conference. The line up of speakers is amazing and the venue is always great.

 

The three talks I gave were on building custom activities in WF, WPF Tools, and Service Oriented workflows.

 

You can grab the slides and demos from the links below.

 

Custom WF Activities:   Slides    Demos

WPF Tools:    Slides

SO Workflows:   Slides     Demos

Enjoy!

I'll  be speaking at VSLive! San Francisco this year after quite a few years since doing a VSLive! conference. I'm looking forward to it.

The two talks I'll be giving are:

Exploit WPF Graphics without Wounding the Eyes

Build Composite UI Applications with CAB and SCSF

If you haven’t already registered for VSLive San Francisco, you can receive a $695 discount on the Gold Passport if you register using priority code SPNOY. More at www.vslive.com/sf

Hope to see you there!

I did another .NET Rocks! interview with Carl and Richard last week and it has gone live. You can find it here. We discussed a lot of tangential aspects of WPF including adoption rates, UI patterns, the WPF Composite (codename Prism) work I am doing with Microsoft patterns and practices, and a lot more.

Check it out if you have an hour to kill away from the keyboard.

I recorded a DNR TV episode back in December that took a little while to hit the site, but is up now. This episode walks through the data binding features of WPF and shows how to set up basic data binding, converters, work with data contexts and more.

http://www.dnrtv.com/default.aspx?showNum=101

I gave a talk on WPF for ASP.NET developers this evening at the .NET SIG in Cleveland. Good size crowd and great questions. It was a challenging talk because of trying to cover all of WPF and Silverlight for ASP.NET developers and for those in the crowd who were Windows Forms developers.

I covered the various deployment models of WPF including:

- Windows Application

- XAML Browser Application (XBAP)

- Plain Old XAML Page (POXP?)

- Silverlight App

Whenever I present this stuff, the overwhelming reaction is: Stop giving us so many choices!!! We can't figure out what to use when!

There is also often a desire for a conclusion to be drawn that one of these will be the end state and all UI will be written in it. I just don't think that will be the case. I think that maybe 5 years from now, if the tools come along a lot farther than they are now, and if the control suite grows, the list of options could shorten to just WPF Windows App, Silverlight App, and ASP.NET AJAX app. But I don't think it will shrink beyond that. Windows Apps make sense when you control the desktop to take maximum advantage of the client platform and give the best user experience. Silverlight makes sense for broader reach while sticking to the same tools and programming models. ASP.NET AJAX will be broader still and will address the platforms that Silverlight can't reach, and will also (like Windows Forms) be more evolved for data over forms apps for a while to come.

Anyway, here are the slides and demos for those who are interested:

Slides    Demos

I've arrived in Orlando and am looking forward to giving my sessions tomorrow and Wed in the Visual Studio connections track. I'll be presenting the following sessions:

- WPF in Windows Forms and vice versa: This talk will cover the interop story for containing WPF controls in Windows Forms applications and Windows Forms controls in WPF applications. Quite a compelling story for migrating incrementally to WPF, but not without its share of pain points.

- Real World .NET 3.0 Smart Client Deployment: This is a modification of my Real World ClickOnce talk, covering the key aspects of ClickOnce deployment but with a slant towards the special considerations introduced by .NET 3.0 for security and WPF deployment models.

- Encapsulate Business Processes in Custom WF Activities: This talk covers how to create custom simple and composite WF activities and all the many things you need to take into consideration to make a robust, reusable activity.

This year the conferences is at the World Center Marriott, a change from the Hyatt Grand Regency of the last few years. Verdict is still out whether this is an improvement...

Wow, is this really my first blog post this year? The year has started off busy busy busy.

But enough about me... this is about you! YOU need to come to the NOVA Code Camp on 14 April! YOU need to volunteer to speak if you have some knowledge you are willing to share with your fellow developers.

I hope to see you there.

Details: http://novacodecamp.org/

 

Another great conference complete. Around 5000 showed up and we had great feedback from the crowd that it was a good show. If you haven't been to connections before, you really should check it out.

I gave three talks this week. You can get the slides and demos for each below.

Real World ClickOnce:  Slides   Demos
Workflow Driven Windows Applications:  Slides   Demos
Implement a Data Layer with the VS 2005 DataSet Designer:  Slides   Demos

We (at IDesign (http://www.idesign.net)) are currently in the middle of a .NET 3.0 Roadshow (http://www.net3roadshow.com) across six cities in the U.S.

In the show, we cover a full day + 1 session of WCF, 2 sessions of WF, 1 session of CardSpace, and 1 session of WPF. I am doing the WF and WPF sessions.

A common question that is coming up is why this weighted mix instead of a more even spread of coverage?

It has nothing to do with the complexity of the topics. WF is equally as complex and capable for what it is designed to address as WCF is for its purposes. WPF is also very complex and capable. CardSpace has a much narrower focus than the others, but has a fair amount of complexity surrounding it as well.

The mix we came up with has a number of reasons behind it, but one of the most important factors was considering how many development organizations should be considering adoption of each technology at this point in time.

WCF is a remote communications platform that is rock solid, easy to use for simple scenarios, yet has a million knobs and dials that you can twiddle to address almost any remote communications needs. My perspective on WCF is that if you are writing any application from this day forward (even though WCF won't release until next month) that needs to make remote calls, you should be using WCF and forget that .NET Remoting, ASP.NET Web Services, and Enterprise Services exist. Obviously that has to be tempered with your ability to get .NET 3.0 deployed to the target platforms. But unless there is an unmovable roadblock to you doing that, it is worth your while to make the switch to WCF as soon as possible. Every application of any significant scale has at least a cross process hop to deal with somewhere in its architecture, and WCF works great for addressing those simple scenarios as well as full enterprise scale SOA apps. So I feel WCF should be adopted by most development organizations as soon as possible.

WF is an extremely capable platform for developing workflow driven processing in your enterprise applications. It is very stable and ready for adoption by those who need it. The only downside to WF is that because of some the capabilities that are built in to WF to address enterprise requirements (persistence, tracking, and scheduling to name a few), I don't think you can really say that simple scenarios are easy to implement with WF. So it takes fairly complex enterprise application requirements to justify the adoption of WF in your application. Additionally, not every application out there really has workflows of any significance (there are a lot of pure CRUD apps still out there). As a result, I think the number of development organizations that should be adopting WF at this time is smaller by at least 1/2 than those who should be looking at WCF.

WPF is a harder one to nail down, and my opinions are likely to incite some flames. I think that there are a lot fewer development organizations that should be bothering with WPF for the near future. The reason mainly has to do with productivity. Even though the runtime bits for WPF will be part of the .NET 3.0 release, the development tools for designing WPF UIs will not. Microsoft is hard at work on a WPF designer for Visual Studio that will hopefully release sometime next year. Alongside that effort is the Expression Suite that includes the Interactive Designer product for allowing designers to put together WPF UIs that they can hand over to developers to complete the hook up of the dynamic behaviors of the application from code. At this point in time and for at least the next 6 months, those products will only be available in a Beta form.

Even with the Visual Studio WPF designer, there is an awful lot missing at this point when compared to the Windows Forms or ASP.NET designers for rapidly designing and implementing UI applications. Even once they release next year, I suspect they will still feel like a v 1.0 designer. Think about how the Windows Forms designer in VS 2002 compares with the VS 2005 designer. Night and day in terms of productivity and producing good maintainable code. Hopefully the gap will not be that large. At the current time, if you want to write WPF apps, you will mostly be banging out XAML markup by hand (thankfully at least with some great intellisense assistance). The current CTP of the Visual Studio Orcas WPF designer does at least work pretty well for visualizing the result of your markup, but it is not really useful for doing a graphical drag/drop layout of your form nor for getting things like data bindings, styles, and resources hooked up.

You also have to consider how bad do you need/want what WPF offers. One of the biggest draws of WPF is that it allows you to write UI applications that are more visually compelling. In short, you could say WPF allows you to create eye-candy that you either couldn't do before or that was orders of magnitude harder to do. What you have to ask yourself is how bad you really need eye candy? If you are building consumer applications, then definitely eye candy is important. The difference between someone buying/using your app instead of your competitors is often a simple matter of whether they look at it, get a glazed look in their eye, and say "Keewwlll....." But if you are building internal enterprise business applications that show and manipulate data, do you really need pulsating 3D bar charts? Maybe, but it is a lot harder to sell that as a "requirement" than "I need my web server to be separated from my application server for security/scalability reasons" (i.e. I need WCF).

Don't get me wrong - I would love to incorporate many WPF features into every Windows app I build from today forward. Using things like styling and subtle opacity animations can make any application look better and more intuitive. Once you have adopted WPF, some of the other features of WPF such as the ability to use Style, Data, and Control Templates is very powerful and will be a welcome new model compared to Windows Forms. But the relative number of apps out there that really need embedded 3D modeling or video I think you can say is considerably less than the number of applications that need to do a cross process, machine, or network hop.

Compounding the problem is the fact that adopting WPF implies that you think you can get .NET 3.0 deployed to all of your client desktop machines to support your application. For an enterprise, that may be true if your organization is savvy about the benefits of adopting new technology and not overly paranoid about the risks of deploying a new version of the .NET Framework. For the open consumer market (yes, the primary ones who would drive you to want to incorporate eye-candy), that is going to be a much tougher nut to crack. For a back end server that you want to run WCF or WF on, having the control to deploy .NET 3.0 to that machine should be a lot easier to satisfy.

So as a result of the current maturity of the tools (equating directly to productivity), the relative importance of the completely new capabilities WPF provides compared to Windows Forms or ASP.NET, and the ability to guarantee that .NET 3.0 is installed on the client machine, I would say that a lot less people should be jumping on WPF for the near term. Once we have a good, near production designer for WPF apps in Visual Studio, my tune will change. Also, for those that really need some aspects of WPF now, by all means go for it. But my primary strategy for most smart client apps at this point would be to build it as a Windows Forms application to address the bulk of your requirements (and complete them in a reasonable timeframe), and then incorporate things like 3D, video, animations, etc. as needed using WPF controls embedded in the Windows application through interop (WPF controls can be hosted in a Windows Forms application and vice versa).

CardSpace's role in the mix is easier to address because it only really addresses one set of requirements: authentication and identity management. It does it well and provides a great new model for identity management that you should definitely be getting familiar with and thinking about how to incorporate it into your applications. CardSpace too faces some adoption challenges since it requires both a service or site that supports CardSpace and a client that has IE 7 or a smart client app designed to work with CardSpace. It definitely warranted coverage in the roadshow and Michele does an awesome session on it. But it definitely did not warrant more than one session compared to overall complexity and capabilities of the technology compared to WCF, WF, and WPF.

These were some of the considerations that drive the mix of sessions we are offering in the roadshow.

I'd be very interested in some comments on other perspectives on WCF, WPF, or WF adoption.

This week and next my colleagues Juval Lowy and Michele Leroux Bustamante (http://dasblonde.com) and I are conducting a two day seminar on .NET 3.0 development as a roadshow in 6 cities across the country (LA, San Jose, Chicago, DC, New York, and Boston). We have completed LA and San Jose with great feedback from the crowd and are in the middle of the Chicago show.

You can grab the slides and demos for my WF and WPF sessions here:   Slides    Demos
http://www.softinsight.com/downloads/NET30RoadShow/Slides.zip
http://www.softinsight.com/downloads/NET30RoadShow/democode.zip

In the WPF talk, I demonstrated several apps others have written that do a good job of displaying some of the awesome graphics capabilities of WPF. Those apps can be found through the links below. I also mentioned a great document for getting up to speed on WPF when you know Windows Forms 2.0 capabilities well. That link is below as well.

Enjoy!

Cine.View: A WPF viewing application that exposes the NetFlix catalog and ordering capabilities created by the thirteen23 company. They also have a great viewer for Flickr.
http://www.thirteen23.com/

New York Times Reader: A WPF content application that provides a rich browsing and reading experience for the paper's news content online in a Windows application.
http://firstlook.nytimes.com
 
Karen Corby's Woodgrove Finance application: This is a WPF XAML Browser application that provides rich visualization of stock market data in a multi-paned WPF app that runs in the browser.
http://scorbs.com/

Keep an eye on http://wpf.netfx3.com for some more upcoming samples that will wow your eyes.

The WPF for Windows Developers document from Mark Boulter and Jessica Fosler can be found on Jessica Fosler's blog:
http://blogs.msdn.com/jfoscoding/articles/765135.aspx

I gave a talk at the Greensville Spartanburg Developers Guild last night on Windows Workflow Foundation. The talk covers the basics of WF, including the fact that WF is not basic at all, it has a lot of complexities that have to be mastered to build real applications. There is a lot of power there and it makes sense to use it for workflow oriented enterprise applications, but this is not something you decide to adopt for a couple of conditionals and a loop in your business processing layer.

 

You can get the slides and demos here:  Slides    Demos

 

The more I work with WF, the more comfortable I get with it, but also the more I become convinced that they need a WF-Lite version. There are several key things I highlight in this talk that seem much more complex than they need to be. I understand the reasoning of some of these things, mostly tied to the fact that:

-          WF manages workflow scheduling and execution using threads from the thread pool

-          WF supports dehydrating your workflow when it is idle, persisting it to a persistence provider (SQL Server supported out of the box), and unloading it from memory

-          WF supports logging tracking information to a persistent store to know what workflows/activities are running when and what their state is.

 

The thing is that not all systems that could benefit from the abstracted design model of WF need these things. But by having these things, it means that certain aspects, particularly communicating with the executing workflow, are much harder than calling from one chunk of code to another in a standard .NET application. If we had a WF-Lite that provided the design time experience (with improvements… see below), but let the app control workflow instantiation and synchronous execution, this technology could apply to even more applications than it will in its current incarnation.

 

Some of the things that I find people have the hardest time groking are:

 

1. Presentation of workflow constructs as "Properties". A property is a first class construct of a type in .NET. It has a very precise meaning, as compared to events and methods. In WF, there are a lot of things that are exposed in the designer through the Properties window that are not really properties. They are events or event handler methods that are in your workflow or activities that you are hooking up. Event handlers should show up in the events view to be consistent with other design experiences in VS, and because that is where they belong. Instead, they show up in both the properties view and sometimes in the events view and it makes it confusing as a coder what the heck the designer is creating for you. WF is for developers, so speak the developers lingo dammit.

 

2. Code Conditions - a bool is just a bool. If you need to hook up an activity that depends on a condition (i.e. IfElse, While, ConditionalActivityGroup, etc.), you should be able to define either a method that returns a bool and point to it, or you should be able to define a bool property and point to it. The model of having to have an event defined that takes a ConditionalEventArgs, hooking up an event handler to that event, and then setting the event argument Result property to true/false just leaves people going "Whahuhhhh????"

 

3. HandleExternalEvent/CallExternalMethod - The number of things you have to do to conceptually just make a simple method call from the host to the workflow or vice versa is just way too high. I like the fact that the communications are based on interfaces. That part I like from a design perspective – the workflow is sort of a layer unto itself and communicating through an interface is a good way to enforce that separation. However, the number of steps you have to go through to hook up host communication scenarios is just way too high. The calls from the workflow into the host are not too bad, because those just get defined as methods. But the extra steps for the events that provide calls into the workflow just pushes it over the edge.

 

If you are not familiar with this model, the steps include:

- Define an event argument type to carry parameters (only needed because of the chosen event model - this should change in my opinion) that derives from ExternalDataEventArgs

- Define an interface marked with the ExternalDataExchange attribute

- Define an event on that interface of the type EventHandler<T>, where T is your event argument type

- Hook up the interface and the event to the HandleExternalEvent activity in your workflow that you want to be the call point for the call from the host into the workflow

- Define a class in the host application that implements the interface

- Have a way to fire the event in that class when you want to call into the workflow (a trigger/fire method)

- Register the ExternalDataExchangeService with the runtime when you start it up

- Register an instance of the class that implements the interface with the ExternalDataExchangeService instance that you registered with the runtime

- Finally, trigger the event from the host application at the point where you want to call into the workflow

 

All of this amounts to what? A simple method call with parameters into the workflow. This is where the attendees jaws usually hit the floor.

 

Am I wrong here? Isn't this a little more complex than it needs to be for most apps?

 

 

If you are looking to bootstrap your knowledge on .NET 3.0 (WCF, WF, WPF, and WCS specifically), then a great opportunity is coming to a city near you (well, hopefully reachable from where you are) in October. My colleagues and I from IDesign will be presenting a .NET 3.0 Roadshow in conjunction with CMP media. This event will provide a full day of WCF presented by Juval Lowy and the second day will be split between WF, WPF, and WCF and will be presented by myself and Michele Leroux Bustamante.

You can find more details and registration info here:

http://www.net3roadshow.com/

 

Here are the slides and demos from last week's webcast. Keep in mind that you will need to add a Modified DateTime column and respective stored procedures to your database to be able to run the code as it was demo'ed in the webcast. The demo code includes my CodeSmith templates for generating those stored procedures and also one for making the coumn modification scripts for you if you want to do it to all the tables in your database that are transactional. There is also a SQL script just for doing the Employees table in Northwind, which was all I used in the demos.

Slides

Demos

For those who attended, or those who just want the materials, here are the slides and demos from today's MSDN Webcast:

Slides: http://www.softinsight.com/downloads/MSDNWebcasts/SmartClientDataApplications_Jul06.pdf

Demos:http://www.softinsight.com/downloads/MSDNWebcasts/SmartClientDataAppsDemos_Jul06.zip

 

For my students in Linkoping Sweden this week, thanks for attending!

Here are the demos and labs: Download Here

It was a crazy week at TechEd last week. So crazy, no time to write or consume blogs. I gave two breakout sessions (Real World ClickOnce and Windows Forms: Build Enterprise Ready Forms Applications) and a Birds of Feather session (Windows Workflow Foundation).

You can get the slides and demos from the sessions here:

Real World ClickOnce:  Slides   Demos

Windows Forms: Build Enterprise Ready Forms Applications:  Slides   Demos

 

For the students from my 3 day WCF course and 2 Day WF course this week, or for anyone else who wants the code with out the supporting delivery, here you go.

For those who attended, it was good working with you this week!

WCF Course Demos and Lab Code

WF Course Demos and Lab Code

The schedule for our upcoming DC area / Mid-Atlantic Region code camp on 10 June in Reston VA is up:

http://www.madcodecamp.com/schedule/codecampmain.htm

The event is being held at the Microsoft Technology Center at:

Microsoft Technology Center
12012 Sunset Hills Rd
Reston, VA 20190

You can find directions at:

http://www.microsoft.com/mscorp/info/usaoffices/midatlantic/mtc_reston.mspx

We are currently filled up on registration, but are taking waitlist people to fill in for no-shows.

If you are planning on attending and would be willing to volunteer to help out, please send me a note at brian.noyes(AT)idesign.net. (Change the (AT) to @)

We need volunteers for:

Registration - Help check people in off the registration lists.

Room monitors: All this means is you sit in on a session and make sure that if the speaker needs any help, you can help go and find someone so the speaker doesn't leave the room. You will also prompt the speaker when there is 15 minutes remaining and at completion time so that we can stay on schedule.

Food/drink - Just need a couple of folks to hang out in the food area for the morning break and at lunch to help out if anything is needed.

I gave four talks at the Software Developers Conference in Netherlands this week. This is a very fun and interesting conference that is put on by a large user group organization called Software Developers Network, run by Remi Caron and Joop Pecht.

This conference is one of the most enjoyable conferences I get to do anywhere in the world. It is amazing how professional and well run this conference is, especially when you consider that it is being put on by a user group organization and it is better run than many U.S. conferences put on by companies that are supposed to specialize in this kind of event. All of the user group members that run the conference are volunteers, and yet the quality and professionalism that comes out of that is outstanding.

The attendees are hard core, ask great questions, and make the event fun for the speakers as well. For those of you who attended and find your way to this post for the slides and demos - thanks!

You can grab the slides and demos here:

Build Smart Client Data Apps with Windows Forms 2.0:  Slides   Demos
Build Custom Data Bound Objects and Collections:  Slides   Demos
Present Rich Tabular Data with the DataGridView Control:  Slides   Demos
Drive Application Behavior with Application and User Settings:  Slides   Demos

I spoke at DevTeach  in Montreal Tue-Thu of this week and had a great time as always. If you haven't checked out this conference, you should plan on signing up next year. Great location, great speakers, very well done conference with lots of hard core sessions.

If you attended one of my sessions and want to get the slides and demos, here you go:

NET371 - Drive App Behavior with Application and User Settings:  Slides   Demos

NET391 - Custom Bound Objects and Collections:  Slides   Demos

NET463 - Advanced ClickOnce:  Slides   Demos

MusicLibrary Database Creation Script:   Script

Make sure you sign up and come to the DC Code Camp in Reston VA on 10 June. You can find all the details at http://www.madcodecamp.com. We have a great line up of speakers with 4 concurrent tracks to pick from. Details will be out soon on the session schedules.

It's free!! You can't beat that price!

I taught a public Advanced .NET Master Class in Reston VA last week. Had a great time, great bunch of students. One of the things that makes teaching the most fun is answering questions, and this was a lively group with the questions. Thanks to all of the students who attended.

A lot of the demos that I give during class are part of the downloads available on our site at http://www.idesign.net. If you want the live demos that I did on the fly, you can download them here:

Live Demos

We will be running a Code Camp at the Microsoft Reston training center on 10 June all day. This is a great FREE event with great speakers teaching you hard core topics on .NET coding. We are looking for speakers, so if you are interested in sharing your knowledge with the local community, you can find the call for speakers here as well as registration information if you just want to attend and soak up knowledge.

Come on out and participate in the DC area developer community!

 

I presented four sessions at DevConnections last week and have been a little remiss on getting the slides and demos posted, but here they are:

Secure ClickOnce Deployments:  Slides   Demos

Connecting Smart Clients with WCF: Slides   Demos

Drive Application Behavior with User and Application Settings:  Slides   Demos

Build a Data Access Layer with Enterprise Library Data Access Block:  Slides  Demos

I gave a talk on Data Binding with Windows Forms 2.0 at the San Diego .NET Developers Group on Tuesday 7 Mar.

Here are the slides and demos:  Slides   Demos

I gave a talk on Connecting Smart Clients at the Microsoft Integration and Connected Systems User Group (MICSUG) last night. I discussed and demoed the basics of using Windows Communication Foundation (WCF) to connect applications, using the newly released Feb CTP.

You can get the slides and demos here:  Slides   Demos

In jumping through the hoops yesterday to get my demos running on the Feb CTP, there were a number of changes that I had to get used to compared to previous builds.

The biggest is that if you run svcutil against a service that uses wsHttpBinding to generate a proxy, you get a proxy service contract that uses custom message contracts to wrap the parameters and return values from each operation contract. XXXRequest and XXXResponse classes are defined in the proxy file for each operation, along with an XXXBody class that actually contains the raw parameter/DataContract types.

If you program against the service contract interface like so:

IAccountsManager mgrProxy = new AccountsManagerProxy();

You will have to create the XXXRequest message contract types to wrap all the parameters you pass into the methods, and unwrap any return values from the XXXResponse types. However, they also expose a public method on the proxy class directly that encapsulates these details so that you can deal directly with the underlying parameters and return values.

So instead of calling IAccountsManager.GetAllAccounts for example, you will have an easier time calling AccountsManagerProxy.GetAllAccounts.

This is true for wsHttpBinding because of the message level security involved in the default binding. If you use basicHttpBinding, or turn down the security on the wsHttpBinding, then you will get more straightforward service contract interface definitions on the client side proxy.

The resulting proxy and service contract look like the following:

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

[System.ServiceModel.ServiceContractAttribute()]

public interface IAccountsManager

{

// CODEGEN: Generating message contract since message part accountNo requires protection.

[System.ServiceModel.OperationContractAttribute(Action="http://tempuri.org/IAccountsManager/CreateAccount", ReplyAction="http://tempuri.org/IAccountsManager/CreateAccountResponse")]

CreateAccountResponse CreateAccount(CreateAccountRequest request);

// CODEGEN: Generating message contract since message part GetAllAccountsResult requires protection.

[System.ServiceModel.OperationContractAttribute(Action="http://tempuri.org/IAccountsManager/GetAllAccounts", ReplyAction="http://tempuri.org/IAccountsManager/GetAllAccountsResponse")]

GetAllAccountsResponse GetAllAccounts(GetAllAccountsRequest request);

// CODEGEN: Generating message contract since message part fromAccountNo requires protection.

[System.ServiceModel.OperationContractAttribute(Action="http://tempuri.org/IAccountsManager/Transfer", ReplyAction="http://tempuri.org/IAccountsManager/TransferResponse")]

TransferResponse Transfer(TransferRequest request);

}

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

public interface IAccountsManagerChannel : IAccountsManager, System.ServiceModel.IClientChannel

{

}

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]

public partial class AccountsManagerProxy : System.ServiceModel.ClientBase<IAccountsManager>, IAccountsManager

{

public AccountsManagerProxy()

{

}

public AccountsManagerProxy(string endpointConfigurationName) :

base(endpointConfigurationName)

{

}

public AccountsManagerProxy(string endpointConfigurationName, string remoteAddress) :

base(endpointConfigurationName, remoteAddress)

{

}

public AccountsManagerProxy(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) :

base(endpointConfigurationName, remoteAddress)

{

}

public AccountsManagerProxy(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) :

base(binding, remoteAddress)

{

}

CreateAccountResponse IAccountsManager.CreateAccount(CreateAccountRequest request)

{

return base.InnerProxy.CreateAccount(request);

}

public void CreateAccount(int accountNo, string name, decimal initialBalance)

{

CreateAccountRequest inValue = new CreateAccountRequest();

inValue.Body = new CreateAccountRequestBody();

inValue.Body.accountNo = accountNo;

inValue.Body.name = name;

inValue.Body.initialBalance = initialBalance;

CreateAccountResponse retVal = ((IAccountsManager)(this)).CreateAccount(inValue);

}

GetAllAccountsResponse IAccountsManager.GetAllAccounts(GetAllAccountsRequest request)

{

return base.InnerProxy.GetAllAccounts(request);

}

public BankingBusinessLayer.Account[] GetAllAccounts()

{

GetAllAccountsRequest inValue = new GetAllAccountsRequest();

inValue.Body = new GetAllAccountsRequestBody();

GetAllAccountsResponse retVal = ((IAccountsManager)(this)).GetAllAccounts(inValue);

return retVal.Body.GetAllAccountsResult;

}

TransferResponse IAccountsManager.Transfer(TransferRequest request)

{

return base.InnerProxy.Transfer(request);

}

public void Transfer(int fromAccountNo, int toAccountNo, decimal amount)

{

TransferRequest inValue = new TransferRequest();

inValue.Body = new TransferRequestBody();

inValue.Body.fromAccountNo = fromAccountNo;

inValue.Body.toAccountNo = toAccountNo;

inValue.Body.amount = amount;

TransferResponse retVal = ((IAccountsManager)(this)).Transfer(inValue);

}

}

I recorded a DNR and DNRtv last week in New London and they are already up on the site.

You can download/listen to the .NET Rocks! epsidode here: http://www.dotnetrocks.com

And the DNRtv here: http://www.dnrtv.com

In the DNR episode, we talk about data binding, ClickOnce and a few other related topics.

This DNRtv shows how to do some of the data binding stuff in the designer. Keep your eyes out for another episode in a week or so on ClickOnce deployment.

Come on out for the inaugural meeting of the Microsoft Integration and Connected Systems User Group (MICSUG) at the Microsoft Reston offices tomorrow night at 7 pm. I'll be giving a presentation on using WCF to connect smart clients in a distributed environment.

Should be a great time!

I went up to New London this week and taped two episodes of DNRtv and one DNR with Carl and Richard. The DNRtv episodes should go up in the next two weeks, one on data binding and one on ClickOnce deployment. The DNR will air on 22 March. Check them out!

I gave a talk on data binding in NYC this Thu night. Had a great time. Lively crowd as always, lots of good questions and interaction.

Here are the slides and demos:

Slides    Demos

For the folks from my Master class in CA this week, here are the live demos. Anyone's welcome to grab them, most have project names that indicate what was being demoed.

I gave a presentation on WPF last night in Orlando to ONETUG. Great group, lots of good questions, had a lot of fun.

Here are the slides and demos:  Slides   Demos

I gave a talk on data binding at the Sarasota FL .NEt Users Group last night. Had a great time, and it was especially fun to present this topic this time since it was the first time presenting on data binding since my book came out. Gave away a couple copies. It was also great to go have some beers with the group members afterwards, including fellow MVPs Stan Schultes and David Hayden.

You can grab the slides and demos here:  Slides   Demos

I co-presented the Smart Client session at the DC Launch event yesterday at the Washington Convention Center with Marc Schweigert, a Microsoft Developer Evangelist for the Federal Sector. We covered a lot of good material on Windows Forms 2.0 capabilities including data binding and ClickOnce, two topics close to my heart since I have written/am writing books on them. I also spent most of the day in the Ask the Experts booth along with other local DC area experts like Sahil Malik, Randy Hayes, G. Andrew Duthie, Darrell Norton, Jonathan Cogley and Vishwas Lele. Besides being a great opportunity to catch up with all these guys and exchange ideas, it was a great day talking to developers from the area and seeing how much enthusiasm there is around the availability of VS 2005 and .NET 2.0. Most of the people there had spent little to no time looking at the new stuff, so there was the usual "wow!" reaction when they saw all the great features and capabilities that are now available to them.

I think we ended up with over 2000 attendees at the event, with about a thousand or so sticking around to the bitter end for our session, which was last up at 4:30-5:45.

The folks at Microsoft that put together the event (Darryl Schaffer in particular) did a great job organizing and running the event.

I am the vice president of the Capital Area .NET Users Group, and help coordinate our speakers and sponsors. If you are interested in speaking at CapArea, or know someone who might be, I am trying to get our speaker line up for 2006 rolling. We need a speaker for Feb 2006, and April-Dec.

Like most user groups, we have no budget for paying speakers or covering travel expenses. This is just a chance for you to share your expertise with fellow community members and teaching them something new about .NET development.

If you are interested, please contact me at brian.noyes(AT)idesign.net.

Thanks

The question came up from several attendees at my MSDN Webcast on ClickOnce yesterday:

"Can I launch a XXX application using ClickOnce?" (fill in XXX with VB6, MFC, etc. - non-.NET applications)

The answer is yes, you will just have to employ a little trick.

What you need is a simple little launcher application that IS a Windows .NET application. So do the following:

1. Create a new Windows Application project with VS 2005.
2. Delete the Form1 from the project.
3. Add the unmanaged EXE and any supporting files to the VS 2005 project, which makes them part of this application from a ClickOnce perspective. As a result, they will get deployed with this application to its cache folder and can be executed by this launcher app.
4. Edit the Program.cs file Main method and delete the current method body (which launches the application and the form) and replace it with code to launch the unmanaged executable. This just requires a single line of code: Process.Start("MyUnamangedApp.exe");

Note: You will need to give the launcher app full trust in the ClickOnce security settings.

Note2: If the unmanaged app relies on ActiveX or COM objects, those need to be added to the project as well, and you will need to add a reference to the COM DLL's to the project to get their reg-free COM information added to the manifest. See this article for more details.

You can download a sample implementation here.

For those who attended or are interested, here are the demos from my MSDN Webcast on ClickOnce yesterday.

You can find the webcast link for on-demand viewing here.

For the demo that went awry demonstrating on-demand updates, the little mistake I made was that I said that if you turn off automatic updates (Check for updates option at top of Updates dialog), then you need to put in an Update location, which is true. But what I was doing was fully qualifying the path to the deployment manifest, which is incorrect. What you need to put is just the URL to the root folder where the deployment manifest resides. VS will automatically append the deployment manifest file name. So when I was putting in:

http://localhost/ClickOnceOnDemand/ClickOnceOnDemand.application

I should have just been putting

http://localhost/ClickOnceOnDemand/

Another little tidbit I didn't mention is that you will need Full Trust for on-demand updates, which is unfortunate because it means the app has to request full trust even though it may not be doing anything privileged beyond on-demand updates.

Here are the demos from my MSDN Webcast today on the DataGridView control.

You can find the sample DataGridView chapter for my book here.

You can view the webcast on demand through the links here.

I gave a talk on connecting smart clients with WCF on Tuesday at Boulder .NET. Had a good turnout desipte the proximity to the holiday and had a good time.

The talk covered the fundamentals of connecting applications with WCF since most of the people there had never seen anything on WCF. Then I moved into some of the specific client concerns when using WCF, similar to my talk at VSConnections.

You can get the slides and demos here:  Slides   Demos

When I demonstrate the use of interface-based programming in a class, I always give a demo of using interface-based programming combined with a factory pattern to add dynamic behaviors to an application. This is basically a scaled down version of what the provider model in ASP.NET 2.0 and the Enterprise Library do to allow you to externally configure components that will be called by the framework at runtime. ASP.NET actually uses abstract base classes instead of interfaces because they also provide some shared implementation, but the concepts are basically the same.

 

I use a simple little example of a client that defines an IDog interface (in a separate interface only assembly that it can share with component providers) that specifies the contract that providers are expected to implement. I then show how to build components separately that the client has no specific type information about, and load and invoke the behavior defined in those components dynamically through a factory and based on the interface definition that is the contract for how those components expose their behavior and some configuration file entries that the factory can use to load and instantiate the types. The client is able to do this without requiring any code modifications to accept new components, and can even have new behaviors added at runtime without needing to restart the application.

 

I have repacked the demo I normally give in class to:

Make it a little cleaner

Separate out the factory into a generic factory in a separate assembly that could be reused for any project

Use the new Settings features in the .NET 2.0 framework to enter the type information into a configuration file instead of using a separate XML file like I used to.

 

The factory method looks like the following:

 

public static T[] ConstructType<T>() where T : class

{

   // Refresh the config cache in case the config file has been edited at runtime

   Settings.Default.Reload();

   // Load the collection of components from the string collection in config

   StringCollection componentTypeInfoColl = Settings.Default.Components;

   // Create a list to add the components to as they are created

   List<T> components = new List<T>();

   // Loop through the config strings trying to create instances of the appropriate type

   foreach (string componentTypeInfo in componentTypeInfoColl)

   {

      try

      {

         // Config entries should be in the form:

         // Fully.Qualified.TypeName, AssemblyName

         // Split into its two parts

         string[] typeInfo = componentTypeInfo.Split(',');

         // Dynamic load the assembly

         Assembly assem = Assembly.Load(typeInfo[1].Trim());

         // Dynamic instance creation

         T instance = assem.CreateInstance(typeInfo[0].Trim()) as T;

         if (instance != null)

         {

            components.Add(instance);

         }

      }

      catch { } // Just ignore invalid types

   }

   return components.ToArray();

}

 

So the only things you need to know to use this as a factory for other purposes than this demo is that it expects the type information to be entered in the client configuration file with an application settings section like the following:

 

<configuration>

    <configSections>

        <sectionGroup name="applicationSettings" type="System.Configuration.ApplicationSettingsGroup, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >

            <section name="DynamicFactoryLibrary.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />

        </sectionGroup>

    </configSections>

    <applicationSettings>

        <DynamicFactoryLibrary.Properties.Settings>

            <setting name="Components" serializeAs="Xml">

                <value>

                    <ArrayOfString xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

                        xmlns:xsd="http://www.w3.org/2001/XMLSchema">

                        <string>Animals.Dog, Animals</string>

                      <!--

                        <string>Animals.GermanShepherd, Animals</string>

                        <string>Animals2.Shitzu, Animals2</string>

                        -->

                    </ArrayOfString>

                </value>

            </setting>

        </DynamicFactoryLibrary.Properties.Settings>

    </applicationSettings>

</configuration>

 

I’m just using a StringCollection as the type for the component type collection, so each component that you want to add to the collection should be added to the section in the form:

 

<string>Animals.Dog, Animals</string>

 

You can see a couple of additional components commented out for dynamically adding them into the application (even while it is running). The type information uses a standard convention for specifying type information through a config file: specifically the fully qualified type name of the type, followed by a comma, followed by an Assembly name to load it from.

 

You can grab the whole sample here.

 

To demonstrate the example in action:

• First build the InterfaceBasedProgramming solution, which builds the interface contract assembly, the factory library, and the client application. The default client config file has all of the type information for available components commented out.
• Open the build output folder of the client (InterfaceBasedClient\bin\debug) and run the client by double clicking on InterfaceBasedClient.exe.
• Push the button and observe that you get nothing because no types have been provided or plugged in though the config file yet. Leave the client running.
• Next open the Animals solution, build it, and copy the build output (Animals.dll) from the bin\Debug folder into the client’s bin\Debug folder.
• Edit the InterfaceBasedClient.exe.config file through an editor, and uncomment the Dog type information as shown in the snippet of config file above, save the file.
• Hit the button in the client again, you should see a standard Dog Bark (through a message box).
• Edit the config file again, uncommenting the type information for a GermanShepherd (which is also defined in the Animals assembly), and save.
• Push the button again and you will see that type is dynamically used from the already loaded assembly.
• Go open the Animals2 solution and build it.
• Copy the Animals2.dll from its bin\Debug folder into the bin\Debug folder for the client.
• Edit the config file for the client again to uncomment the type information for the Shitzu type, and save.
• Click the button in the client again and you should see all three types of dogs bark. 

For the students from my recent class in Sweden, you can download all the demos I did dynamically (as opposed to the ones you already have in your demos folder and available on our site at www.idesign.net) from the following link:

http://www.softinsight.com/downloads/Linsoft05ClassDemos.zip

 

I gave two WCF (Indigo) talks at DevConnections today:

Build Event Driven Applications with Indigo:   Slides   Demos

Connecting Smart Client Applications with Indigo:  Slides   Demos

In the Event Driven Applications session I cover creating list based subscription services with direct callback services in the clients, using duplex channels to set up callbacks, and a Pub-Sub implementation that gives loosely coupled events that I will have more information on here in the near future.

In the smart client session, I covered client concerns with respect to channel selection, asynchronous calls, sessions, transactions, callbacks, security, and peer-to-peer.

Good time!

My second session of the day yesterday at DevConnections was on ClickOnce deployments, and specifically the various security protections and options that ClickOnce offers for preventing unauthorized applications from being able to run through a ClickOnce launch.

You can grab the slides and demos here:  Slides   Demos

Some of the key takeaways from this session were the following:

• ClickOnce provides a simple, powerful, and easy to use mechanism for deploying smart client applications with minimal maintenance effort and IT Admin involvement
• ClickOnce provides runtime security protections through the Code Access Security (CAS) infrastructure of .NET to prevent applications launched from ClickOnce from being granted permissions to perform any operations or access any resources that the application was not specifically allowed to do.
• ClickOnce app default permissions are determined by the launch URL and how it maps to built-in CAS location-based code groups (MyComputer, LocalIntranet, Internet, TrustedSites, UntrustedSites).
• If the application manifest requests permissions greater than those that would be granted based on the CAS location-based code groups, permission elevation needs to occur.
• By default, permissions can be elevated in one of two ways: user prompting or trusted publishers.
• If an application is launched through a link to a deployment manifest that is signed by a publisher certificate that is not in the Trusted Publishers certificate store on the client machine, the user will be prompted by default and can accept or reject the application. If they accept it, the permissions for that application will be elevated to whatever permissions the application manifest has requested.
• If an application is launched that was signed with a publisher certificate that is in the client machine's Trusted Publishers certificate store, then no user prompting will occur and the application permissions will be automatically elevated to whatever the application manifest requests because it is coming from a trusted source identified implicitly by IT admin when they installed the publisher certificate in the Trusted Publishers store.

If you want to prevent the user from ever being prompted and only allow applications from trusted publishers to be launched through ClickOnce (a good idea in an enterprise environment), then you should create the registry key discussed in the slides from the session and set the string values to Disabled for all the zones.

I just got finished doing my first talk here at DevConnections in Vegas and I think it went pretty well. Great crowd, good questions, fun topic.

You can grab the slides and demos here: Slides   Demos

The talk highlighted how to define custom objects and collections to make them suitable for data binding, mostly for Windows Forms, but some of it is applicable to ASP.NET as well.

The key takeaways from the talk are:

• Implement INotifyPropertyChanged on any business entitity type you define that you expect to use in data binding scenarios. This interface defines a contract for the objects to raise PropertyChanged events whenever a property is set on the object. It allows containing collections or bound controls to be notified when the contents of the data object change, which helps with keeping controls synchronized in a form.
• Use BindingList<T> to create strongly typed collections of objects that support rich data binding. It provides full implementation of IList, ICollection, IEnumerable and their generic strongly typed counterparts for whatever type parameter you provide, and it provides a partial implementation of the IBindingList interface. The part that it implements is firing ListChanged events when items are added or removed from the collection. It also looks at the objects type that you provide as a type parameter, and if it implements INotifyPropertyChanged, the collection will subscribe to the PropertyChanged event on each object and raise ListChanged events with a change type of PropertyChanged whenever the contents of an object in the collection change. These features make BindingList<T> collections work seamlessly with data binding to multiple controls and keeps the controls all in sync.
• Use my BindingListView<T> class (in the demos and in my book) to get a generic container that supports sorting (both IBindingList based single property sorts and IBindingListView multi-property sorts), searching, and filtering.

If you were there at the end and saw the on-the-fly demo where I didn't see the saving behavior that I thought I had just implemented, I tracked down the problem. the changes were actually being saved. It was just the way I hooked up the data binding I wasn't seeing those changes.

In the demo, I used the data sources window to generate a Details view (control collection) bound to a collection of Album data. I changed one of the controls in the collection which was bound to a GenreID property on the Album objects to a ComboBox. I then used the Data Sources window to add data binidng to a Genre object collection to populate the list of Genres in the combo box. This sets up the ComboBox to have its contents determined by the Genre collection, but its SelectedValue property is bound to the GenreID property on the current item in the Album collection - generally exactly what you want to be able to edit a property on one object collection item through a lookup list of values in another collection of objects. The problem was that after I selected a new value in the combo box and saved the changes, then restarted the app, I wasn't seeing the modified value set for the Album I was viewing in the other controls.

It turns out the problem was just the order that I did the initial binding of the control collection and the combobox BindingSources. In the form load I had added the following two lines of code to bind the control collection and the combo box binding sources:

albumBindingSource.DataSource = Album.GetAlbums();
genreBindingSource.DataSource = Genre.GetGenres();

The problem is that when you set the DataSource, that is when it intializes the bound controls. So I was initializing the data bindings for all of the controls based on the album data, then intializing the combo box of Genres with a new set of data. That set the SelectedIndex of the ComboBox back to zero, so I wasn't seeing the actual value of the Genre for the current Album, I was just seeing the first Genre value in the Genre collection. The fix is simply to do the initial binding in the reverse order:

genreBindingSource.DataSource = Genre.GetGenres();
albumBindingSource.DataSource = Album.GetAlbums();

Then it works as expected.

Some resources I mentioned in the talk, as well as some additional ones I gave related to after-session questions:

My Book: Data Binding in Windows Forms 2.0, Addison Wesley, January 2006
http://www.amazon.com/exec/obidos/ASIN/032126892X/qid%3D1124482085/sr%3D11-1/ref%3Dsr%5F11%5F1/102-3039504-6850510
Rocky Lhotka binding refresh problem post:
http://www.lhotka.net/WeBlog/PermaLink.aspx?guid=d8306469-7e76-4734-9811-777498808b85
Rocky Lhotka article on binding to business objects: Windows Forms Object Data Binding in .NET 2.0, 15seconds.com, http://www.15seconds.com/issue/040614.htm
My recent article on The Server Side .NET: Build a Data Access Layer with the Visual Studio DataSet Designer, The Server Side .NET, Oct 2005, http://www.theserverside.net/articles/showarticle.tss?id=DataSetDesigner
My recent article in CoDe magazine: Tackle Complex Data Binding in Windows Forms 2.0, CoDe Magazine, July/Aug 2005, http://www.code-magazine.com/Article.aspx?quickid=0507051

Enjoy!

I'm catching a flight early tomorrow morning to Vegas for VS Connections and am really looking forward to it. VS Connections in particular, and DevConnections in general (the overall conference event) is well run, in great locations, and always has a lot of great content that I can benefit from as well.

I've been spending most of my recent prep time fine tuning the demos for my two WCF sessions, Build Event Driven Applications with Indigo and Connecting Smart Client Applications with Indigo. The more I work with Windows Communications Foundation (aka "Indigo"), I am struck by a number of things:

• I am impressed by how capable Indigo is.
• I am awed by how elegant and simple solutions are to complex aspects like security, transactions, queuing, callbacks, and so on.
• I am dumbfounded by how hard it is to figure out how to get to those elegant and simple solutions.

The last bullet is not really a criticism of what they have come up with, it is just the nature of the beast. I would draw on an analogy from my flying days to explain why this is so. Imagine the cockpit of a WW I fighter aircraft. You probably have half a dozen or less simple dials and gauges, and a stick and throttle. Imagine trying to use that set of controls on an aircraft that can fly at high subsonic speeds at high altitude carrying hundreds of passengers for 12 hour transoceanic flights. Not going to work too well. This is basically where you were at with past technologies to build complex, distributed, heterogenous, connected enterprise systems. It could be done, but the end result was not going to be pretty and it was going to take you a long time to get there.

Now with WCF, it is more like climbing into the cockpit of a 777. There is a technological elegance to everything that is there. But there are still hundreds (if not thousands) of individual switches, controls, displays, electronic gages and dials, menu driven control panels, etc. A great deal of human engineering has gone into everything that is in there so that for any given common task, there are only a couple of relevant controls that you have to touch and put into place to get the job done. The challenge is in knowing which one of those hundreds of knobs and dials to tweak.

The same is true for WCF. Microsoft has created an incredibly powerful and technologically advanced platform that is well adapted to building large distributed enterprise systems. In order to do that, there needs to be hundreds of switches and knobs that you can throw to address different scenarios. The downside to that is bullet number three above - you have to learn which switches and knobs are relevant for a given task, and in what order to throw them.

This is somewhat aggravated right now in that we are only at Beta 1 of WinFx (and its parts WCF, WPF, and WinWF), and the names, shapes, and locations of all the knobs and switches is constantly changing as they work on that human engineering task of trying to make it easier to use. Meanwhile the documentation and samples are seriously lagging, so working with it right now is a little like stepping into that 777 cockpit without any labels on the controls. When you say to yourself, "I just need transactions and certificate based security", it is kind of like saying "I just need to call the flight attendant at the second aft flight station". Simple to describe, but God help you in figuring out which switches and knobs to throw. At least there are not really any destructive ones that you can throw by accident. If you get it wrong, your app may not work, but you would have to go out of your way to write some code that would do bad things when WCF fails to let you communicate.

I'm looking forward to continuing to work with this technology and learn what all those knobs and buttons are for. Learning all the controls of the aft cockpit of the F-14 to run the weapons system, navigation systems, communications systems, and other tasks was one of the funnest things I have done in my life. The fact that we got to do that while strapped to a couple of 50K lb + of thrust zorching through the sky pulling G's and landing on the carrier certainly helped make it interesting. Sitting at a computer leaves a little to be desired in that department, but the learning challenge is still just as fun.

I'll be speaking at Visual Studio Connections (part of DevConnections) in Las Vegas from 5-8 November. This is a great and growing conference that happens twice annually in the US, usually Orlando in the spring and Las Vegas in the fall, that I have been privileged to speak at for the last couple years. If you haven't been to one yet, you ought to be hammering your boss for permisson/funding to attend for the following reasons:

• It will rapidly and time-effectively expose you to new solution technologies you might not get a chance to explore on your own
• You will get concentrated advanced training in current and future technologies, getting you up to speed on them in far less time than you can achieve on your own
• You will get presentations from the top speakers in the business
• You will get a chance to network with peers in the industry, learn from others experiences employing .NET technologies, which will make you more effective at employing them yourself
• You will have a lot of fun (OK, maybe don't tell your boss this...)

You can learn a lot peripherally from the conference too by reading the DevConnections blog here. There are posts from other speakers as they develop their talks and their own observations and experiences at the conference.

I'll be presenting the following sessions:

VSM356: Build Custom Data Bound Business Objects and Collections
VSM351: Secure Smart Client ClickOnce Deployments
VID306: Build Event-Driven Applications with Indigo
VID309: Connect Smart Client Applications with Indigo

If you make it to the show (and you should!!), stop by and say hi!

 

I've got two MSDN Webcasts coming up at the end of November, both part of the "Best Of" series that they are doing surrounding the launch of VS 2005 for those Webcasts focused on .NET 2.0 and VS 2005 that got the highest scores in the last year.

You can click through here to get to the webcasts:

The two I am giving will both be on 29 November:

Presenting Rich Rich Tabular Data with the DataGridView Control
Tuesday, November 29, 2005
10:00 A.M.–11:00 A.M. Pacific Time

Deploy Smart Client Applications with ClickOnce
Tuesday, November 29, 2005
1:00 P.M.–2:00 P.M. Pacific Time

Check them out!!

We just got a new site up and running for IDesign. You can check it out at http://www.idesign.net. Much nicer look and feel, and a lot easier to access the many resources we have available there, such as our download library, articles, events on the homepage, and RSS feeds for dynamic content like events.

I gave a talk on ClickOnce in both St. Louis and Kansas City Monday and Tuesday evening this week and had a really good time. After the St. Louis talk I was able to go out for a beer with Bill Evjan, Scott Spradlin, and some of the other group members, which is always a great chance to network while I am there. KC was more of a quick strike since I had to fly out first thing in the morning to head to the MVP summit in Seattle.

The code samples and slides can be downloaded here.

I'll take the opportunity here for some shameless self-promotion...

If you are an intermediate to advanced developer who already has some .NET experience and are looking to take it to the next level, you might want to check out our Advanced .NET Master Class, which I will be teaching in Reston, VA from 17-21 Oct. This is a public offering of a high-demand course that we normally only offer onsite for larger development teams. You can find the full class description here. This will be a well-timed, comprehensive, in-depth coverage of developing enterprise applications in .NET 2.0. I cover a huge amount of material including advanced language features in C#, assemblies and versioning, serialization, multi-threading, transactions, security, Enterprise Services, and Remoting.

If you are interested, contact us through this link to obtain more information.

I had a great time speaking at the TampaBay .NET Users Group last night. We had a great turn out and it was a fun crowd. About 20 of us retired to a nearby bar afterwards for some suds and good conversation. Apparently they do that fairly regularly at their group. That is definitely the largest interactive mass of people I have encountered at a user group that goes out and really networks and has a good time together after the meeting on a regular basis.

Thanks for having me down guys and gals!!

The talk was on ASP.NET 2.0 Data Binding, and was a little rough since it was the first time I had given this talk. But hopefully people still got a lot out of it. I did all the demos on the fly, and as a result, a few of them didn't work out because I decided to take a few little side trips that I had not practiced, which is never a good idea on stage with new material.

If you are interested, here are the slides and outcome of the demos.

Here are the demos from today's talk. Enjoy!

Here are the demos from my session today on In Depth Windows Forms. Thanks to the Windows Client team in Redmond for provided such great demo code and instructions that you can follow on your own.

Get them here.

For those who want the demos from my session on data binding in Windows Forms 2.0 at TechEd Europe today, here they are.

I arrived in Amsterdam yesterday to speak here at TechEd Europe. I am giving four sessions:

WCD221 - Deploying Applications with ClickOnce

WCD322 - Making the Most of Windows Forms 2.0 Data Binding

WCD324 - An In-Depth Look at Windows Forms in Visual Studio 2005

WCD440 - Smart Client Offline Data Caching and Synchronization

Should be a good time, this is my first time to TechEd Europe, and only my second time to Holland. The last time was in May for the SDC 2005 conference, but we were out in Arnhem and the schedule was packed, so I didn't get to see much. Hopefully I will have a chance to do a little more sightseeing in Amsterdam while I am here. People in old town Alexandria where I live like to brag about our 200 year old homes and buildings, but some of the structures here dating back to the 1600s or even 1400s kind of put old town to shame.

And yes, I did wander through the red light district last night to see what all the hubbub was about. Holy crap, talk about sensory overload. The laws are quite liberal here indeed. I didn't imbibe in any of the carnal pleasures available. It was enough of a shock to the system just wandering through. And Las Vegas calls itself sin city? Hah! Las Vegas is like a friggin bible camp compared to this place. :)

It does make an interesting contrast to the puritanical approach to everything that is the default in the US. Here, they just allow it, tax it, regulate it, and a lot less people get hurt in the process (both from the indulgences themselves, and especially from the lack of crime that surrounds the industries).

Roy and I had a great long interview/discussion on a myriad of .NET topics back a couple of months, and he has it all edited and posted now. You can find it here.

I gave my session on extending ASP.NET with custom handlers and modules at DevTeach in Montreal yesterday. If you attended or want the slides and demos, here you go:

Slides

Demos

Here are the demos I gave in my TechEd session on Friday of last week. Sorry it took me a bit to get them posted. Call it post-conference-traumatic-stress-letdown-syndrome that made me go stupid.

Smart Client Offline Demos

This is pretty cool. Hopefully by now you have heard that Microsoft officially announced the release date for Visual Studio 2005 and SQL Server 2005 as 7 November. What you may not have noticed is that is the opening day of the DevConnections conference in Vegas. Well, if you were not sure whether you should come to this outstanding conference before, maybe this will change your mind: you will get a free fully licensed copy of Visual Studio 2005 and of SQL Server 2005. The specific versions they are going to give out has not yet been determined, but hopefully they will be generous and go with Pro/Standard at least. They will also have a live broadcast of the Microsoft launch event in San Francisco, at which either Bill Gates or Steve Balmer will be speaking.

And if you happen to come to the show, come check out the talks I'll be giving, which include:

- Connect Smart Client Applications with Indigo

- Build Event Driven Applications with Indigo

- Secure Smart Client ClickOnce Deployments

I just got back from Holland Thursday after speaking at SDC there, and now I am in Orlando to speak at TechEd. These things are nothing but fun, but man, the travel can get crazy.

I had a great time last night joining in with the crowd at the Party with Palermo, which evolved from a loosely organized geek dinner into a great gathering of speakers, RDs, MVPs, and attendees in the Peabody hotel restaurant and bar. Today there are a collection of overlapping events that I plan to try to attend portions of, including some MVP events, the INETA summit, and some of the pre-con sessions.

The rest of the week is already pretty packed. My breakout session is not until Friday, but I have a bunch of other things I am participating in / presenting as well:

Tuesday 7 Jun:

3:15-6:15 PM- proctoring Juval Lowy's Instructor Led Lab (ILL) on Generics (DEV20/DEV20R)

9:00 - 10:00 PM - Preparing for Indigo Birds of a Feather (BoF) given by Juval

Wednesday 8 June:

8:30 AM-11:30 AM- proctoring Michele Leroux Bustamante's ILL on Iterators (DEV23/DEV23R)

7:00-11:00 PM Influencer Party

9:00-10:00PM Leading BoF session on Smart Client Deployment (BOF051)

Thursday 9 June:

3:15 - 6:15 PM - Giving System.Transactions ILL (DEV 22/22R)

Friday 10 June:

10:15 AM -12:00 PM - Answering Q&A questions through LiveMeeting for Juval Lowy's Simulcast session Being More Productive with the .NET Framework (DEV325)

1:00 - 2:15 PM - Presenting CLI440 Smart Client Offline Data Caching and Synchronization

 

Those are just the items that warrant an unchallenged block on my calendar. There are a ton of other events mixed in there as well to keep the week packed. I also need to get some more work done on my book this week getting the second half of the book up to date with Beta 2 and ready for Tech review, and also want to try to blog a few technical posts about stuff I am working on. Hmm, when is thattime expansion device going to be on the market??

I gave 4 sessions at the Software Developers Conference 2005 in Arnhem, Netherlands yesterday and today. Great little conference and a lot of fun to get to speak at.

Here are the slides and demos from the sessions:

Smart Client Offline Data Caching and Synchronization:  slides   demos

Extending ASP.NET with Custom Handlers and Modules:  slides   demos

Smart Client Communications with the Middle Tier: slides   demos

Tackle Complex Data Binding with Windows Forms 2.0:  slides   demos

For those who attended, I hope you had a good time! Andrew did a great job putting the code camp together, and it seemed to go well all day.

Here are the slides and demos I gave:

Smart Client Offline Data Caching and Synchronization: Slides   Demos

Secure Smart Client Deployment with ClickOnce:  Slides   Demos

Complex Data Binding in Windows Forms 2.0: Slides    Demos

I gave a talk at Tulsa .NET Users Group on Monday 25 Apr on Windows Forms 2.0 Data Bining and had a great time. The group is large and growing, standing room only with over 40 folks. The group is well led by Caleb Jenkins, he is a great MC and keeps the group very dynamic and motivated.

Here are the slides and demos.

It took me a few days to get to it, but here are the slides and demos from Sunday's talks at Philly Code Camp:

Smart Client Offline Data Caching and Synchronization: Slides   Demos

Secure Smart Client Deployment with ClickOnce:  Slides   Demos

I'm speaking at the Philly Code Camp this weekend, and gave three talks today, and two tomorrow.

As promised to the attendees, here are the slides and demos from today for:

DataGridView Control: Slides   Demos

Complex Data Binding in Windows Forms 2.0: Slides    Demos

Extending ASP.NET with Custom Handlers and Modules: Slides   Demos

 

I had a great time speaking at the Austin .NET Users Group and Texas A&M .NET User Group last night and today, giving my talk on Extending ASP.NET with Custom Handlers and Modules

For those that attended, or others that are interested, here are the slides and demos that I gave. If you have grabbed earlier versions of these from when I have given the talk in the past, you may want to grab the demos again since I added a custom handler demo that does watermarking of images that I wrote on the plane ride to Texas monday.

If you are a Texan and live in the Austin or College Station area, come on out to the Austin .NET Users Group on 11 April or the Texas A&M .NET Users Group on 12 April to see my Extending ASP.NET with Custom HTTP Handlers and Modules talk. I will be covering the ASP.NET processing pipeline, how/why to create custom handlers as endpoints for ASP.NET requests, and how to create custom modules to perform per-request processing across your application.

Hopefully them Aggies won't throw a lynching party afterwards since I am a boat school graduate...

Michele Leroux Bustamante and I presented a full day tutorial on advanced fundamentals of the .NET Framework on Thursday. Here are the slides and demo code.

Michele has posted her demos here.

Here are my slides and demos from today's session on ClickOnce security. Within the next couple days I'll write some posts to address the scenarios discussed. If anyone had any complex questions that I deferred, ping me so that I can get them answered here.

Slides    Demos

If you attended my sessions today at Visual Studio Connections in Orlando, thanks! It was a lot of fun.

 

Here are links to the slides and demos for each session:

Smart Client Communications with the middle tier: Slides     Demos

Smart Client Offline Data Caching and Synchronization: Slides      Demos

Enjoy!

I'm doing a lot of talks at various conferences, user groups, and code camps over the next few months, mostly on smart client topics. Here is the line up:

Visual Studio Connections - 20-24 March - Orlando, FL:
http://www.vsconnections.com
Smart Client Offline Data Caching and Synchronization
Smart Client Communications with the Middle Tier
Secure Smart Client Deployment with ClickOnce
Advanced .NET Fundamentals Full Day Tutorial

Philly .NET Code Camp - 23-24 April - Philidelphia, PA
http://www.phillydotnet.org/Default.aspx?alias=www.phillydotnet.org/codecamp
Smart Client Offline Data Caching and Synchronization
Secure Smart Client Deployments with ClickOnce
Tackle Complex Data Binding with Windows Forms 2.0
Present Rich Data Interfaces with the DataGridView Control

Tulsa .NET Users Group - 25 April - Tulsa OK
http://www.tulsadnug.org/DesktopDefault.aspx
Tackle Complex Data Binding in Windows Forms 2.0

Mid-Atlantic MSDN Code Camp - 7 May - Reston VA
http://blogs.msdn.com/gduthie/articles/383561.aspx
Secure Smart Client Deployment with ClickOnce
Smart Client Offline Data Caching and Synchronization
Microsoft Application Blocks Chalk Talk

Software Developers Conference - 30-31 May - Arnhem Netherlands
http://www.sdc.nl/default.asp@a1pid=12338pdwl&a1sid=29101225200420.htm
Smart Client Offline Data Caching and Synchronization
Smart Client Communications with the Middle Tier
Tackle Complex Data Binding with Windows Forms 2.0
Extending ASP.NET with Custom Handlers and Modules

Microsoft TechEd - 5-10 June - Orlando, FL
http://www.microsoft.com/teched
Smart Client Offline Data Caching and Synchronization

DevTeach - 19-21 June - Montreal Canada
http://www.devteach.com
Secure Smart Client Deployments with ClickOnce
Tackle Complex Data Binding in Windows Forms 2.0
Extending ASP.NET with Custom Handlers and Modules

 

Last night I gave a talk on Visual Studio Extensibility to the BaltoMSDN User Group in Hunt Valley Maryland. Great group, had a lot of fun. If you attended or would like to check out the slides and demos, here is a link:

http://www.softinsight.com/downloads/VisualStudioExtensibility.zip

Just to actually put a little technical content on my blog for a change, I thought I would summarize a few key points from the talk.

Extensibility Options:
You have several options for adding functionality to Visual Studio. The first and simplest are Macros. Visual Studio Macros are code that you can either generate with the Macro recorder (similar to recording macros in Office applications) or write yourself through the Macros IDE, a scaled down version of Visual Studio for macro development that you access through the Tools > Macros menu. Macros are a good way to automate simple repetitive tasks to save yourself keystrokes and mouse clicks that you do over and over for a given development task.

The next step up the pyramid are Visual Studio Add-ins, which were the focus of my talk. Add-ins allow you to write .NET components that plug into Visual Studio and can run in the background and handle events fired by VS as the developer interacts with it, and/or invoke custom code based on user keystrokes or command bar/menu button clicks. You can add custom UIs to Visual studio as dialogs, docking windows, or options panes. There are a bunch of good examples available from MSDN at:

http://www.microsoft.com/downloads/details.aspx?FamilyId=3FF9C915-30E5-430E-95B3-621DCCD25150&displaylang=en

To get really rich functionality like you may have experienced from retail developer tools that integrate into Visual Studio, you will need to tap into the Visual Studio Integration Partner (VSIP) SDK. You can download and use the SDK for free, but if you ship any products to customers that you developed with VSIP, licensing fees and restrictions can apply.

I was just made aware of another option that I have not yet explored in depth, but that looks very promising and intriguing. Developer Express, who produce CodeRush and soon Refactor! for Visual Studio .NET, have packaged their core framework for developing add-ins as a reusable class library that you can use to develop extensions to Visual Studio. Basically they hide all the arcane details of the VS object model and the COM interop layers you have to go through for programming straight add-ins and VSIP code, and instead give you a cleaner, managed object model to program against. It is called DXCore and you can get it here:

http://www.devexpress.com/Downloads/NET/DXCore/

I am a huge and vocal fan of CodeRush and now Refactor!, which not only save me a lot of time writing code, they make great motivational demos of the kinds of things you can achieve with extensibility in VS.NET. The fact that DevExpress has made the engine that they build these tools on for other to use is just another great example of the .NET community and I thank them for doing so. I'm looking forward to playing with these capabilities.

Add-in Gotchas:
Some things to be aware of when building Add-ins (not using DXCore)...
- When you create an Add-in project through the wizard, make sure you compile right away before doing anything. This is because the project wizard adds the registry settings to try and load your Add-in the next time VS starts up. If you don't build your project, those reg keys are pointing to a non-existent DLL, and you will get an error message that if you say Yes to, will kill all the reg settings you need to build/debug your Add-in. You can get them back by building and running the setup project that is created by the wizard, but it is a better practice to just do a quick build to get something there for VS to refer to after completing the wizard.
- If you move your project to another machine, those reg keys will not be there to allow you to debug the add-in. The easiest way to get them in place is to build the Add-in project, build the setup project that is part of the solution, run the install, and then rebuild the Add-in project. Running the install will install a copy of the original DLL to the path you specify (typically under Program Files), will reg the DLL for COM interop, and will create the necessary reg settings. Rebuilding the Add-in project after that re-does the COM interop registration, pointing the CLSID in the reg back to your debug version of the DLL, allowing you to proceed with further development and debug.
- When you create an Add-in project it sets up the debugger to launch another instance of Visual Studio in the debugger so that you can try out your add in and hit breakpoints and do debugging in the original instance you ran the debug session from. If you are working out bugs and your add-in is failing to catch all exceptions or is not unsubscribing from events, you can get some weird behaviors because your object may remain in memory in the live VS instance. If you get anything unexpected, shut down all instances of VS and re-open your Add-in solution to make sure all objects get killed and you are working with an uncorrupted instance of VS.
- The code injected by the project wizard when you say you want a Tools menu item only creates that item one time, the first time your add-in is loaded. If the tools menu item is removed or exceptions get thrown in loading your add-in, you will never get your tools menu item loaded. This is because the code that creates in the OnConnection method is contained in a conditional block that checks for the enumerated value ext_ConnectMode.ext_cm_UISetup. If you want to make sure your tools menu item is recreated if it fails the first time, change this to be an || (Or) of the values ext_cm_Startup and ext_cm_AfterStartup. The downside of doing this is that there will be a minor perf hit in loading your add in because an exception will be thrown and caught when it tries to create the command if it already exists, so you may want to revert to the original check for production. But in development environments this will ensure your command gets created and is present repeatably in the face of errors and weird development startup paths.
- The objects and collections in the automation object model are COM components that you are accessing through interop. In many cases to get to the underlying object and get back a valid .NET reference, you have to use the .Object property for objects and the .Item property to access items in a collection. For example, there is an ActiveWindow and ActiveDocument property on the DTE root object of the model that let you get quickly to these items in the environment. However, to get a Window reference or a Document reference variable back from these (respectively), you will need to access DTE.ActiveWindow.Object, not just DTE.ActiveWindow. Likewise, to get into a collection, you will need to index into Item with a 1-based index, such as DTE.Solution.Projects.Item(1).Object to get to the Project object for the first project in the current solution.

The last month and a half has bascially flown by. I have had to keep myself from doing anything that was not of critical priority, because I had too many events stacked up that were of critical priority.

In the last month and a half, I have:

• Bought a house
• Moved
• Had a baby (Nathan).. Holy crap, I'm a dad! :)
• Helped my wife recover and care for our son after some complications with her that required every other day visits to the hospital for weeks
• Sold my old house (twice, but that is another story)
• Finalized a title for my upcoming book (Data Binding in Windows Forms 2.0: Programming Smart Client Data Applications with .NET 2.0).
• Completed another chapter for that book
• Completely neglected the remaining three chapters of the book for over a month (Sorry Joan!!!)
• Agreed to start another book very soon (details to follow) that I will complete within about 6 months
• Agreed to write another book soon after that to make sure I am overcommitted for all of 2005
• Wrote an article for The Server Side .NET that will be up soon on Smart Client Deployment and Update.
• Wrote an article for CoDe Magazine that will be in the April issue.
• Wrote a lengthy research paper as my “comprehensive exam“ for an M.E. degree in CS that I have been working on at University of Colorado Boulder remotely for about 5 years.
• Continued with my last class toward that degree with non-trivial weekly homeworks.
• Completed the slides for 3 talks and a full day tutorial I am giving at Visual Studio Connections in Orlando 20-24 March.
• Wrote proposals and got invited to speak at Microsoft TechEd in Orlando in June, SDC in the Netherlands in May, and DevTeach in Montreal in June.
• Wrote some other proposals for some other conferences further out in the year (fingers crossed).
• Spoke at the Charlottesville .NET Users Group (thanks Eric!!, it was great!)
• And a few other little things in there as well.

Things are starting to settle down now, I am getting a few hours of sleep a night in between feedings and diaper changes, and I am hoping to do a better job managing my calendar for the rest of the year. The one thing notably missing from the list above is anything that generates any significant income, which does not go well with the new house with a much bigger mortgage and impending child care when my wife Robin goes back to work in a couple months. Sigh.

Of course I probably still won't find time to blog about much other than pointers to all the other writing and speaking I am doing for publications and conferences... I don't know how guys like Scott and Chris and Sam and many others do it. I haven't even found time to read blogs for the last month, let alone write any meaningful ones...

 

I had a great time presenting at the Little Rock .NET Users Group last night on my way back to DC from VS Connections in Vegas. I was very impressed with this group. They had a good sized crowd (30-40) in a good little meeting room that was actually inside a Pizza Hut, and are led by a great group of guys. One of the most energetic groups I have seen, and when you consider the population and industry presence in Little Rock compared to the group size, you'll realize these guys are doing a great job of running a user group! There are a lot of times we don't get many more attendees at CapArea.NET, even though we meet in the heart of the tech sector of DC.

I want to thank the group for having me out to speak and pass along the slides and demos.

Here are the slides and demos from today's sessions:

Smart Client Disconnected Data slides

Smart Client Disconnected Data slides

ClickOnce Deployment slides

ClickOnce Deployment demos

Intro to .NET Deployment slides

Intro to .NET Deployment demos

Enjoy!

I'm out at Visual Studio Connections in Las Vegas at the Mandalay Bay hotel and casino. Great show so far, runs through Wed. I have three talks on Wed: Synchronize Smart Client Data and Offline Data, Deploy Smart Client Applications with ClickOnce, and Introduction to .NET Deployment (Fundamentals track).

This is a great location for a conference, good hotel, lots to do and see, when you can tear yourself away from the conference facilities, which are top notch.

If you could not make this one, you should definitely consider picking up the spring 2005 show, which should be on the east coast. Keep your eyes on the site to see when it gets announced (very soon).

Had a great time talking to the folks at DelMarva.NET on Thursday night. The topic was querying XML with .NET, and you can get the slides here and the demos here.

If there are any follow up questions, you have my email.

In case you live out on the DelMarva peninsula, or feel like making a drive out to the eastern shore from DC or Norfolk area, I'll be giving a talk to the DelMarva.NET users group on Querying XML with XPath in .NET. Their site is down right now, but the location is at Wor Wic College in Henderson Hall HH105 at 5pm.

Here are the demos I gave in today's session on Smart Client Communications with the middle tier.

Here is the demo code from today's session on HTTP Handlers, Modules, and applications.

UPDATE: Here is the demo code from today's session on the DataGridView control.

Thanks to Joe Stegman from the Windows Client team at Microsoft for the real estate sample that showcases all of the different modes of the app.