Shawn Wildermuth's Blog

AgiliTrain and Rachel Appel Announce New Classes

shawn@wildermuth.com (Shawn Wildermuth) — Thu, 02 Jul 2009 17:31:03 GMT

We are very proud to announce that AgiliTrain and Rachel Appel are partnering to present a series of public classes on the next generation of web development. Rachel will be teaching two new courses for AgiliTrain on web development:

The MVC Tour: A 3-day training session that features an in depth look at MVC – the Model/View/Controller pattern as implemented in ASP.NET.
The jQuery Tour: A 3-day jQuery workshop that enables developers new to jQuery development to increase their knowledge and gain familiarity with the jQuery libraries, plug-ins and ecosystem.

For those not in the know, Rachel has been working as a mentor, instructor, software developer, architect and DBA for nearly 20 years. During her career, Rachel has worked with a variety of languages, technologies and systems and has contributed to projects of all sizes including large scale enterprise applications at some of the world’s leading companies. Rachel’s expertise lies within developing solutions that align business and technology using the Microsoft .NET family of products, particularly ASP.NET & SQL Server. She is also an ASP.NET MVP, ASPInsider and holds the Microsoft Certified Trainer, MCAD & MCSD certifications.

The workshops will be held in several cities including:

The MVC Tour (http://mvctour.com):

Sep 14-16, 2009 in Seattle, WA
Nov 2-4, 2009 in Philadelphia, PA
Jan 11-13, 2010 in Dallas, TX

The jQuery Tour (http://jquerytour.com):

Aug 24-26, 2009 in Philadelphia, PA
Oct 5-7, 2009 in Dallas, TX
Dec 7-9, 2009 in Seattle, WA

Get your seats while they last. Only sixteen students per date will be accepted.

[advertisement]
The Silverlight Tour is a three-day workshop covering topics from XAML and Blend to data access and server scenarios. For more information, see our website at http://silverlight-tour.com.

Erik Mork's Prism for Silverlight Resources

shawn@wildermuth.com (Shawn Wildermuth) — Thu, 02 Jul 2009 17:25:36 GMT

URL: http://www.sparklingclient.com/prism-silverlight/

Erik Mork, Silverlight MVP, host of the SparkingClient Podcast and an instructor for The Silverlight Tour, has compiled a new set of Prism for Silverlight Resources. He recently completed a number of podcasts and videos on how to use Prism in Silverlight. This blog post enumerates the ten things every developer should know about Prism and links over to resources that explain each point. If you're new to Silverlight and have heard a lot about Prism and/or MVVM, this list is worth reading and following.

Only Four Seats Left for Silverlight Tour Atlanta

shawn@wildermuth.com (Shawn Wildermuth) — Tue, 30 Jun 2009 21:59:13 GMT

UPDATE: Now only 3 Seats Left!

With nearly three weeks left, we are starting to run out of seats for the Silverlight Tour in Atlanta. This stop of the Tour will be the first using all Silverlight 3 materials. The seats are going quickly, get yours while they last. You can sign up on the AgiliTrain website here:

https://agilitrain.com/Workshop/Info/Silverlight_Tour_Workshop

If you miss out on Atlanta, the Tour next stops in Dallas on August 17-19th.

My Sillveright-Prism Article is Live!

shawn@wildermuth.com (Shawn Wildermuth) — Fri, 26 Jun 2009 02:53:37 GMT

URL: http://msdn.microsoft.com/en-us/magazine/dd9430...

The new MSDN Magazine is out and my article on creating composite Silverlight applications using Prism is finally available. If you're building large scale Silverlight applications and need to learn how to compose pieces of your application together, go read the article!

Hear me on Deep Fried Bytes talk about Oslo!

shawn@wildermuth.com (Shawn Wildermuth) — Tue, 23 Jun 2009 20:15:49 GMT

URL: http://deepfriedbytes.com/podcast/episode-33-ge...

I have a chance to sit down with Keith and Woody of the Deep Fried Bytes podcast to give them my long elevator pitch for Oslo and Domain Specific Languages. If you haven't heard me tell the Oslo story, grab some headphones...

About Deep Fried Bytes

Deep Fried Bytes is an audio talk show with a Southern flavor hosted by technologists and developers Keith Elder and Chris Woodruff. The show discusses a wide range of topics including application development, operating systems and technology in general. Anything is fair game if it plugs into the wall or takes a battery.

Announcing "Agile Database Techniques" Workshop

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 22 Jun 2009 00:56:59 GMT

URL: https://agilitrain.com/Workshop/Info/Agile_Data...

In cooperation with Accentient, AgiliTrain is now bringing Richard Hundhausen's Agile Database Techniques workshop to a city near you. This three-day course will give students a deep dive into managing SQL Server database development in an agile environment. From understanding how VSTS supports an agile database development lifecycle, to creating and configuring database projects, as well as automating the building and deploying of SQL Server databases, you’ll walk away knowing how to do it all.

The dates for the workshop are coming up soon. The workshop will take place:

July 20-22nd, 2009 - Seattle WA
August 3-5th, 2009 - Atlanta, GA
September 7-9th, 2009 - Chicago, IL

The workshop is limited to the first sixteen students so register before the seats are gone!

Join me in DC for a Nerd Dinner Tonight! CANCELLED

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 17 Jun 2009 16:00:00 GMT

URL: http://nerddinner.com/633

UPDATE: Due to lots of conflicts I am cancelling this event. Sorry everyone who planned on coming.

Listen to me on Deep Fried Bytes!

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 17 Jun 2009 10:17:52 GMT

URL: http://deepfriedbytes.com/podcast/episode-33-ge...

I had the pleasure recently to sit down with Keith and Woody on their Deep Fried Bytes Podcast and talk about Oslo and DSLs in general. If you have a chance, go listen to it and let me know what you think!

Blend and Visual Studio - Why Two Tools?

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 10 Jun 2009 20:22:51 GMT

I am here at DevTeach and having a great time. I got in a discussion with several of the speakers about the common complaint of some Silverlight/WPF folks that they want Blend to be in Visual Studio; or why Cider has always been disabled by most dev's.

I hear the complaint a lot that developers want the functionality of Blend hosted in Visual Studio. While I understand the desire, I've never been bothered by the dual programs. In fact, I think its better. Blend needs to be separate because its primarily for a Designer/UX role that isn't comfortable with the breadth of Visual Studio.

We have plenty of other solutions that have two overlapping tools: I can insert an Excel spreadsheet in Word but when I need to do an if/then analysis I use excel. A single Office App would be silly. Finally (I think the most compelling example) is SQL Server. When I am in Visual Studio, I can open a database connection and run queries, create stored proces and more. But if I want to manage users, create backup plans or other DBA-like tasks, I go to SQL Server Management Studio. I can do many of the same tasks in both, but developers never ask for Microsoft to remove SQL Server Management Studio and fold it all into Visual Studio. Different roles mean different tools (roles != people btw).

What do you think?

DevTeach Silverlight+MVVM=Easy Demo

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 10 Jun 2009 03:16:09 GMT

URL: http://wildermuth.com/downloads/DevTeachGameSto...

Fun first day here at DevTeach. I a talk showing creating a MVVM application from scratch (using ADO.NET Data Services 1.5 CTP). Kathleen Dollard had introduced the concept earlier that day, but we teach it a lot differently so it was fun to show off building a full MVVM application in the span of 75 minutes.

The project we built in the talk is now available here at:

http://wildermuth.com/downloads/DevTeachGameStore.zip

I the demo is a little big because I included the database (that includes some additional information). You will need Silverlight 3, ADO.NET Data Services 1.5 CTP and to attach the database (as XBoxStore) to SQL Server Express to get the demo to work. I introduced the topic of separation and isolation of contract with interfaces. Hope it helps!

My Oslo DSL Article Part 1 is Updated for May 2009 CTP

shawn@wildermuth.com (Shawn Wildermuth) — Tue, 09 Jun 2009 04:49:05 GMT

URL: http://msdn.microsoft.com/en-us/library/dd44170...

UPDATE: All Three Are Available Now!

Since the Oslo May 2009 CTP came out last month, i've had a chance to update my article and samples to the new CTP. If you haven't had a chance to read the three articles on Oslo's Textual DSL's, this is your chance to learn why I think Oslo and the M Grammar stack matters. The first article can be found here:

RIA Services RoadMap

shawn@wildermuth.com (Shawn Wildermuth) — Tue, 09 Jun 2009 02:51:58 GMT

URL: http://silverlight.net/forums/p/101160/230835.aspx

Looks like RIA Services finally has a roadmap. Wahoo:

July 2009 CTP: Still listening to lots of changes and perhaps a golive license (but not firm yet).
PDC 2009 Beta: Feature Complete but bug fixes are coming.
First part of 2010: RTW (my guess is MIX 10 but who knows)

Hopefully the July 2009 CTP will have lots of changes I love. Stay tuned for what I think when it releases.

Still Room Left for the Silverlight Tour - Washington, DC

shawn@wildermuth.com (Shawn Wildermuth) — Thu, 04 Jun 2009 15:54:02 GMT

Two weeks left before the Silverilght Tour hits Washington, DC for Silverlight 2 and 3! If you want to be ready for the next version of Silverlight, this is the place to be.

On June 16-18th in Washington, DC our three-day Silverlight workshop is going to teach the latest features of Silverlight 3 as well as the complete Silverlight 2 stack.

The new features we are covering include:

Out of the Browser Support
Pixel Shaders
Hardware Graphic Accelleration
Behaviors
Navigation Framework
Blend 3
Binding Improvements
Secure Web Services
Binary XML Transport
RIA Services Client Controls
Text Rendering Improvements
Render Caching
And more...

To sign up for the class or hold a seat, visit the registration site:

http://silverlight-tour.com

Running ADO.NET Data Services 1.5 CTP1 on Windows 7

shawn@wildermuth.com (Shawn Wildermuth) — Fri, 29 May 2009 19:26:40 GMT

URL: http://blogs.msdn.com/astoriateam/archive/2009/...

I've been running Windows 7 as my primary machine now for a couple of months (first the Beta and now the RC). I love the OS but there have been a couple of frameworks that didn't work right. The one that perplexes me the most is ADO.NET Data Services 1.5 CTP1.

When you are on a Windows 7 box, running the installer will complain about a problem and point you to the readme file.

The problem is that the "%PROGFILES%/Reference Assemblies\Microsoft\Framework\v3.5" folder on Windows 7 is protected as a part of the operating system. Specifically only "Trusted Installer" has rights to update the files and the ADO.NET Data Services 1.5 installer doesn't have those rights so it doesn't update the crucial assembly. To address this, you have to take over ownership of the System.Data.Services.Design.dll assembly in that folder and give yourself full access to the file. If you're not familiar with how to do this, i'll cover it further down in the blog post.

Once you have ownership of the assembly, re-run the installer (choose Repair if you already installed once with the error). You will get the same error again, but this time it replaced the crucial file.

In order to use the new bits, there are some small hoops to jump through, but Mike Flasko explains these really well in a video on the Astoria Team blog:

http://blogs.msdn.com/astoriateam/archive/2009/03/16/ado-net-data-services-v1-5-ctp1-now-available-for-download.aspx

Changing Ownership/Permissions to the Assembly

For the uninitiated, taking ownership and assigning permissions can be done like so:

Open the "%PROGFILES%/Reference Assemblies\Microsoft\Framework\v3.5" folder and find the assembly:

Next, right-click the assembly and pick Properties to show the property window for the assembly. On the Security tab, click on the "Advanced" button near the bottom:

Next, select the "Owner" tab and click on the "Edit" button:

Next pick a new owner (probably your user name or your machine's Administrator group) and press OK:

Close all the dialogs and return to the Explorer window again (changing owner requries you re-open the property window). Right-click the assembly again and pick "Properties. In the Security Tab, click the "Edit" button to change permissions for you user name (or group):

Lastly, in the Permissions dialog, click the "Full control" checkbox to give you full control of the assembly.

You've now got the full permissions requried.

Giving Up Chrome as My Default Browser

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 27 May 2009 04:44:20 GMT

URL: http://www.youtube.com/watch?v=GuPoASZ5wiw

UPDATE: I killed off all the Chrome windows on my machine and this behavior stopped...very very wierd.

For the past few months, I've been using Chrome as my primary browser since its ridiculously fast. It starts up fast and renders fast. I was never a FireFox Addin addict, so I never missed them.

But I've noticed that the 'AddressBar' on Chrome doesn't allow me to type in an address. It only issues search. I've tried to change this behavior to no avail. I don't want every address I type in to become a search (and hint Google at what I care about) so I am giving up Chrome as a browser (except to test my sites against it). Here's a video where I show different ways of using the AddressBar that always does a search:

UPDATE: Most people on 2.0.172.28 (I think the non-dev Channel) are not seeing this. Perhaps its my use of the Development Channel. Let's see once the Dev Channel updates.

May Oslo SDK Available - Now with Quadrant

shawn@wildermuth.com (Shawn Wildermuth) — Tue, 26 May 2009 22:51:30 GMT

URL: http://www.microsoft.com/downloads/details.aspx...

The newest CTP of the Oslo SDK is available and lots of changes are included:

IntelliPad with DSL Authoring Mode built-in (No more 'samples included' needed).
Quadrant! (The Model Editor Piece of the Platform)
The CLR and UML domains added to the Repository
Unified Tooling (instead of lots of individual command-line tools)

The things to be aware of that have changed are:

Setup is now unified.
Lots of M-Language changes, read the readme.
None of the whitepapers or docs are included. They are all included on the DevCenter.

For more information on this release, check out Chris Sells' blog:

http://www.sellsbrothers.com/news/showTopic.aspx?ixTopic=2277

For a full write up of the changes, check out this post from the Oslo Team:

http://blogs.msdn.com/modelcitizen/archive/2009/05/27/about-the-oslo-may-2009-ctp.aspx

I will be updating my three part series for the new bits in the next week or so.

DataForm Templates

shawn@wildermuth.com (Shawn Wildermuth) — Mon, 25 May 2009 16:15:37 GMT

URL: http://wildermuth.com/downloads/funwithdataform...

It is great to see that Tim Heuer and I are thinking about the same thing. In his recent article on DataForm helpers, he explained how to use the Validation Attributes to hint the DataForm with additional information. These attributes are used extensively in the validation model in RIA Services but I'll be covering that later.

Instead of that, I've been digging into how you can customize the look the DataForm while still getting the benefit of paging functionality. As Tim mentioned you can specify the rows of the DataForm in a similar way to who the DataGrid works;

<df:DataForm x:Name="theForm"
             AutoGenerateFields="False">
  <df:DataForm.Fields>
    <df:DataFormTextField Binding="{Binding Name}"
                          FieldLabelPosition="Top" />
  </df:DataForm.Fields>
</df:DataForm>

While specifying the fields to use is interesting, I wanted more control. That's where DataForm templates come in. In the DataForm control, there are three templates:

DisplayTemplate: The DataTemplate for showing the 'read-only' view of a bound item.
EditTemplate: The DataTemplate for editing an item.
InsertTemplate: The DataTemplate for a new item.

Specifying these Templates is as simple as using a DataTemplate like so:

<df:DataForm x:Name="theForm"
             AutoGenerateFields="True">

  <df:DataForm.DisplayTemplate>
    <DataTemplate>
      <StackPanel>
        <TextBlock Text="{Binding Name}" />
        <TextBlock Text="{Binding Title}" />
      </StackPanel>
    </DataTemplate>
  </df:DataForm.DisplayTemplate>

  <df:DataForm.InsertTemplate>
    <DataTemplate>
      <StackPanel>
        <TextBox Text="{Binding Name, Mode=TwoWay}" />
        <TextBox Text="{Binding Title, Mode=TwoWay}" />
      </StackPanel>
    </DataTemplate>
  </df:DataForm.InsertTemplate>

  <df:DataForm.EditTemplate>
    <DataTemplate>
      <StackPanel>
        <TextBlock Text="{Binding Name, Mode=TwoWay}" />
        <TextBox Text="{Binding Title, Mode=TwoWay}" />
      </StackPanel>
    </DataTemplate>
  </df:DataForm.EditTemplate>

</df:DataForm>

This gives you the full power of controlling the look of the individual items in the DataForm. Of course, to get the full power, you will often want to use the other new controls as well (like the FieldLabel):

<df:DataForm.EditTemplate>
  <DataTemplate>
    <StackPanel>
      <df:FieldLabel PropertyPath="Name" />
      <TextBox Text="{Binding Name, Mode=TwoWay, 
                      NotifyOnValidationError=true, 
                      ValidatesOnExceptions=true}"
               HorizontalContentAlignment="Stretch" />
      <df:FieldLabel PropertyPath="Title" />
      <TextBox Text="{Binding Title, Mode=TwoWay, 
                      NotifyOnValidationError=true, 
                      ValidatesOnExceptions=true}"
               HorizontalContentAlignment="Stretch" />
      <df:ErrorSummary />
    </StackPanel>
  </DataTemplate>
</df:DataForm.EditTemplate>

In this way the DataForm gives you full control over how the individual items are displayed. This allows you to use all the services of the DataForm without having to deal with the look of the DataForm.

What do you think?

Which came first, the View or the Model?

shawn@wildermuth.com (Shawn Wildermuth) — Fri, 22 May 2009 17:48:59 GMT

As I wrote and subsequently taught the Silverlight Tour workshop, I've had a number of discussions with students, clients and the community-at-large about how to architect Silverlight applications.

The momentum behind the Model-View-ViewModel (MVVM) design pattern makes a lot of sense to me, especially with declarative views (as seen in Silverlight and WPF). Most of my thinking around this was covered in my MSDN article about it:

http://tinyurl.com/slmvvm

One topic that the article is thin on is how the View and the ViewModel are related. After the article shipped, I had some lengthy conversations with lots of people about this from John Papa, Laurent Bugnion, Glenn Block, et al. It occurred to me that some of the nomenclature was confusing. The three parts of the MVVM are:

Model: Responsibile for managing and delivering data.
ViewModel: Responsible for shaping, sorting and filtering data for a view(s).
View: Responsible for formatting and displaying data.

The three elements have a clear separation of responsibilities. Typically a small number (or one) model exists in my projects with Views and ViewModels being built in pairs. Though it is not uncommon to build more than one view for a single ViewModel. As long as the separation is there, having two views that show the same data but in very different ways is in keeping with the pattern in my opinion. This can be seen in this simple illustration:

Most what I've mentioned in the article and so far in this blog post is what most of the community seems to agree on. The last part of the contention is how do you create Views and ViewModels. The two approaches I hear most often are:

View-First: The View has a relationship to its ViewModel(usually through data binding).
ViewModel-First: The ViewModel creates the view (usually through an IoC container).

In View-First, it is usually is exemplified in XAML like so (as I showed in my article):

<UserControl x:Class="MVVM.Client.Views.GameView"
             ...
             xmlns:data="clr-namespace:MVVM.Client.Data;assembly=MVVM.Client.Data">
  <UserControl.Resources>
    <data:GamesViewModel x:Key="TheViewModel" />
  </UserControl.Resources>
  <Grid DataContext="{Binding Path=Games, 
                      Source={StaticResource TheViewModel}}">
  ...
  </Grid>
</UserControl>

In ViewModel-First, it is usually implemented using a Inversion of Control container (e.g. Unity, Ninject, Spring, etc.). This way the ViewModel can request the interface (in the constructor) for the View it expects:

public MyViewModel
{
  public MyViewModel(IMyView view)
  {
  }
}

In both of these methods I tend not to like the sticky-ness of the view to the view-model. Also, both of these imply a one-to-one relationship which while the common case, is not the always case.

I have come up with another pattern that I am tentatively calling a "Marriage". (I don't love this name but its the closest, non-technobabble name I've found for it).

Marrying the View and ViewModel

In my design, I want the View and the ViewModel to be ignorant of each other so that I could mock either side of the equation without impacting the other. In practice, mocking the View-Model is common, but mocking (and testing) the View is not common at all. But by not tying them tightly, it does allow us to move to a one View-Model to multiple Views without any real pain.

In a Marriage, you would simply apply the ViewModel to the View at runtime. This may be done with a class that handles and isolated this or simply with some simple code. For example, I typically have an IView interface that requires a method to do this applicaiton like so:

public interface IView
{
  void ApplyViewModel(object viewModel);
}

Then in the module declaration for a module (or assembly) holding the View and ViewModel, I simply use the IoC container to create them (either using Interfaces or class names depending on the complexity of the project) then apply the ViewModel to the View via the interface:

IView view = theContainer.Resolve<IGameView>();
IViewModel vm = theContainer.Resolve<IGameViewModel>();
view.ApplyViewModel(vm);

The magic of this code is that you retain the anonymity while perserving the functionality. It becomes the user of the View/ViewModel's responsibility to determine how they are related.

I explain this pattern in my article on the Prism Framework and Silverlight coming in next month's MSDN magazine. Using this pattern with an overall Composition pattern for building your applications has a number of benefits beyond separation of responsibilities and testing.

Just to throw a plug in as well, I also teach this pattern (and Prism) in our Advanced Silverlight Workshop coming to Seattle in August.

Let me know what you think of this versus the View-First or ViewModel-First patterns.

Entity Framework Samples now in Visual Basic

shawn@wildermuth.com (Shawn Wildermuth) — Fri, 22 May 2009 17:29:56 GMT

URL: http://thinqlinq.com/Default/Entity-Framework-S...

My friend Jim Wooley has been doing some work with the Entity Framework team to help them get their examples into Visual Basic. The first of the fruits of these labors is now available! Hop on over to his blog to see all the details:

http://thinqlinq.com/Default/Entity-Framework-Samples-in-Visual-Basic.aspx

I, for one, am glad that this is finally happening. I would so prefer that the examples will be in both languages. As much pain as that is pre-VB10 its always my goal!

M Language Changes Coming in Next CTP

shawn@wildermuth.com (Shawn Wildermuth) — Fri, 22 May 2009 14:46:20 GMT

If you haven't been following the new Specification for the M Language that the Oslo team has been cooking up, they have been making changes in response to feedback about the language. These changes will come to light in the next CTP. These changes are;

'=>' as label binding operator

The label binding operator has changed from '=' to '=>'.

@[] as escape for verbatim identifier names

Identifier names that need to be escaped use '@[]' instead of '[]'

'about' operator

about' is an operator that returns data for M identifiers (e.g., extents, type declarations, computed value declarations)

'item' removed

'item' is no longer a keyword used to iterate over a collection of collection of values. Instead, use 'value' to iterate over a collection, and 'value' plus parenthesis to iterate over a collection of collection.

'into' removed

'into' has been removed as a keyword with the 'join' and 'group by' query clauses.

'this' removed

'this' has been removed as a keyword that refers to all of the members of an entity type declaration. Instead, constraints now must be written after the member declarations and use 'value' to reference members.

Decimal without preceding 0

Decimals of the form '0.xxx' no longer require the preceding 0.

DateTimeOffset type and literal value added

A new data type, DateTimeOffset, has been added. In addition, a new literal kind, DateTimeOffset, has been added to write literals of the type DateTimeOffset

# undef removed

'#undef' has been removed from the supported set of preprocessor directives

Preprocessor scope changes

'#define' must occur before any conditional operator '#define' is scoped to a compilation unit, not a source file

Text patterns defined

Text value patterns are now defining including literals, character classes/ranges, repitition operators, 'any', 'empty' and 'error' keywords, and text pattern operators difference, intersect and inverse.

Productions defined

Productions are defining including pattern and token declarations, constructors, precedence rules, and constructor operators.

Rules defined

Rules are defining including token rules, syntax rules, interleave rules, and parameterized rules

Language defined

Language is defined

Binary literal syntax change

The literal syntax for binary has changed from \xNNNN to 0xNNNN.

binary shift operators removed

The binary shift operators (<< and >>) have been removed from the language.

Entity type computed value declarations removed

Entity types can no longer have computed value declarations

where/select become Where/Select

Where and Select query expression clauses now have the first character capitalized

Identity selector supports multiple fields

The identity selector now supports using more than 1 field as the identity to select an instance

extern

Extern is now supported for computed values and extent declarations

name overloaded changes

Now, within a module, computed values, extents and types must not have same names, where as before only computed values and extents could not have same names.

'.' leading dot identifier

A leading dot identifier '.' can be used to scope the remaining dotted identifiers to the current module rather than the current lexical scope

'::' scope identifier

The scope identifier '::' constructs a fully qualified identifier name with the module name to the left of the operator, and the module's member name to the right.

Attributes defined

Attributes as used by Mgrammar declarations is defined

Catalog definitions

The M catalog written in M is defined

SQL mapping

The M-to-SQL mapping is defined

Silverlight Tour and Silverlight Firestarter both coming to Washington, DC

shawn@wildermuth.com (Shawn Wildermuth) — Fri, 22 May 2009 01:17:06 GMT

URL: http://silverlight-tour.com

A few weeks left before the Silverilght Tour hits Washington, DC for Silverlight 2 and 3! If you want to be ready for the next version of Silverlight, this is the place to be.

On June 16-18th in Washington, DC our three-day Silverlight workshop is going to teach the latest features of Silverlight 3 as well as the complete Silverlight 2 stack.

The new features we are covering include:

Out of the Browser Support
Pixel Shaders
Hardware Graphic Accelleration
Behaviors
Navigation Framework
Blend 3
Binding Improvements
Secure Web Services
Binary XML Transport
RIA Services Client Controls
Text Rendering Improvements
Render Caching
And more...

To sign up for the class or hold a seat, visit the registration site:

http://silverlight-tour.com

On June 6th, the Cap Area Silverlight SIG will be holding a Silverlight Firestarter in Washington, DC as well (free). The Silverlight Firestarter is "A Silverlight Fire Starter is a one-day event providing developers and designers information on the concept behind Silverlight as a technology, what tools are useful in development and the knowledge in order to start building their own applications."

Their agenda includes:

Keynote and Intro
Building a basic Silverlight Application (with Databinding)
Using Expression Blend
Lightning Talks at Lunch
Intro to Silverlight 3
Lessons Learned - Bringing your existing skills to Silverlight
Open Panel / Q&A

We will be giving away a free seat to the class at that free event. You can register for the event here:

https://www.clicktoattend.com/invitation.aspx?code=138392

My Netbook Experience

shawn@wildermuth.com (Shawn Wildermuth) — Wed, 20 May 2009 23:48:31 GMT

URL: http://eeepc.asus.com/global/product1008ha.html...

As I am heading to another large round of airline trips, I decided I finally needed a laptop I could write on during a flight. While I really love my HP dv7t, its a full sized laptop and (with no thanks to my girth) I needed something smaller to work on in an airline seat. In comes the Netbook.

I was a bit late to this party but decided to dive in. I had read Scott Hanselman's great article on the Dell Mini 9 and liked the upgrading to 2GB which seemed doable for my limited needs on a plane.

Of course, I was impatient so I headed out to my close retailer to see if I liked the keyboard or not. As I've said here before, my shrek sized hands need a comfortable keyboard. I looked at several netbooks including 9" and 10" varieties from Dell, HP and ASUS. I settled on the Dell Mini 10 because the keyboard looked roomy.

I took it home and tried to cram the 2GB memory that Scott mentioned. Of course I didn't do my homework. In the Dell Mini 10 the memory is soldered in so no upgrade was possible. So I bit the bullet this morning and traded it in for an ASUS Eee 1000. The specs were similar but the ASUS has a faster Atom chip (1.6GHz vs. 1.3GHz) and of course the ASUS let me upgrade the memory. One tiny note was that the Dell's video size was 1024x592 whereas the ASUS is 1024x600. Yeah, 8 pixels. I wonder why.

While 2GB is a lot of memory these days (ok, not a lot, but enough) the Atom processor is the real performance problem. But of course you're giving up performance for battery. The promise is for 7 hours of battery with the ASUS Eee 1000, but we'll see soon when I head across the country from Atlanta to Vancouver Canada.

I'd seen a lot of Netbooks but I was still surprised by the relative size between my normal laptop and the netbook:

Now I wanted to see it run some of my favorite apps. First I paved it with Win7 RC. The installation was easy as cake. The Windows drivers worked for everything out of the box, though I installed the chipset and touchpad drivers just in case. Of interest, the touchpad drivers included a lot of multi-touch capabilities like the Mac touchpad. Nice, but still getting used to it. Here's the netbook screen running Windows 7:

While not eactly snappy, its good enough. I don't plan on doing much more than browse and write so it works. But I wanted to take it to the next level so I used the Web Platform Installer 2.0 to install Visual Studio Web Express and the Silverlight 2 Tools:

That worked pretty well (sure, a bit slugish but better than nothing). So I figured I'd take it the whole way. As many of you know lots of Delta flights are now including Internet connections...so maybe I don't want to get work done:

Getting World of Warcraft working was a surprise. I was sure that the Atom processor would just bust under the weight but it wasn't too bad. I had to turn down most of the visual settings, but it runs pretty well as long as your outside a city.

Overall I am very impressed by what the Atom can do. The proof will be in the battery life. After I get back from all my trips in June, i'll follow this up with some observations.

Writing Behaviors for Silverlight 3 - Part 2

shawn@wildermuth.com (Shawn Wildermuth) — Sat, 16 May 2009 17:14:02 GMT

URL: http://wildermuth.com/downloads/BehaviorDemo.zip

In the first part of this article, I showed you how to build a very simple behavior using the Behavior<T> class. That class is useful for creating simple behaviors that just require that the behavior know about attaching and detaching of the item.

In this 2nd part of the series, I'll show off the TriggerAction<T> class which expands on this by supporting an Invoke method which is called once an event trigger happens. This is a much more common case than the simple behavior.

For example, let's create a behavior that shivers an object when an event is fired. I start out with a behavior that derives from TriggerAction<T> like so:

public class ShiverBehavior : TriggerAction<UIElement>
{
}

Note that I use UIElement again as the generic parameter. This is because I should be able to make any UIElement shiver with my behavior. This parameter determines what types of objects I can attach the behavior to.

I decided to implement the behavior by using a DoubleAnimation with a ElasticEase (easing function). To make the shiver happen, I am going to animate a TranslateTransform so I can move it around vertically or horizontally. So my behavior is going to need to reference and create the storyboard (and related objects) to do the actual shivering:

TranslateTransform shiverTransform = new TranslateTransform();
Storyboard shiverStory = new Storyboard();
ElasticEase ease = new ElasticEase();
DoubleAnimation shiverAnimation = new DoubleAnimation();

public ShiverBehavior()
  : base()
{
  // Set up ease
  ease.Springiness = 2;

  // Create the Animation
  shiverAnimation.EasingFunction = ease;
  Storyboard.SetTarget(shiverAnimation, shiverTransform);

  // Setup Variable Properties
  SetupProperties();

  // Attach it to the story
  shiverStory.Children.Add(shiverAnimation);
}

The trick to making this work is to use the OnAttached to insert our TranslateTransform into the object itself. (We won't work on objects that already have a TranslateTransform but that's a small price for getting the behavior):

protected override void OnAttached()
{
  base.OnAttached();

  // Attach the transform
  if (this.AssociatedObject.RenderTransform == null)
  {
    this.AssociatedObject.RenderTransform = shiverTransform;
  }
  else if (this.AssociatedObject.RenderTransform is TransformGroup)
  {
    TransformGroup group = (TransformGroup)AssociatedObject.RenderTransform);
    group.Children.Add(shiverTransform);
  }
  else
  {
    var tx = AssociatedObject.RenderTransform;
    var group = new TransformGroup();
    group.Children.Add(tx);
    group.Children.Add(shiverTransform);
    AssociatedObject.RenderTransform = group;
  }
}

The OnAttached adds the transformation to the object (or inside a TransformGroup if it exists). In the OnDetaching we need to reverse this as well (you can see that code by downloading the sample since its not especially relevant to our explanation).

At this point we have a Storyboard that contains our animation of the TranslateTransform. The TranslateTransform is now added to the object. We're all ready for the last part of the code. When the Invoke method is called, we simply need to start the animation:

protected override void Invoke(object parameter)
{
  shiverStory.Begin();
}

This Invoke method is the only required override that you need in your behavior, but in practice (as you've seen here), you will override several other parts of the class.

In order to make our shivering configurable, we can just add dependency properties and they show up in Blend automatically. For example, the Oscillations property was created like so:

public int Oscillations
{
  get { return (int)GetValue(OscillationsProperty); }
  set { SetValue(OscillationsProperty, value); }
}
public static readonly DependencyProperty OscillationsProperty =
    DependencyProperty.Register("Oscillations", 
                                typeof(int), 
                                typeof(ShiverBehavior),
    new PropertyMetadata(25, 
      new PropertyChangedCallback(OnOscillationsChanged)));

private static void OnOscillationsChanged(DependencyObject d, 
                                          DependencyPropertyChangedEventArgs e)
{
  ((ShiverBehavior)d).OnOscillationsChanged(e);
}

protected virtual void OnOscillationsChanged(DependencyPropertyChangedEventArgs e)
{
  SetupProperties();
}

Creating the dependency properties is fairly simple (especially since I am using the dependency property snippets from the Silverlight Contrib project).

Using a TriggerAction based behavior is similar to using a simple Behavior. You can see the behaviors in the Asset Library as shown below:

Once added, the behavior becomes nested inside the object in the "Objects and Timeline":

In the Property pane, you can see the event that will trigger this behavior and change it (as well as behavior specific properties in the Miscellaneous section):

If you are using behaviors for your own projects, you just need to reference the assembly in your Silverlight project and they'll show up in Blend 3's Asset Library. But if you want to build behaviors that are listed in all Blend 3's projects (and make it add the assembly automatically), you will need to register your assembly in the registry:

HKEY_CURRENT_USER\Software\Microsoft\Expression\Blend\v3.0\Toolbox\Silverlight\v3.0\{Friendly Name

With the default key pointing to the directory with behaviors.

Grab the source code and take a look at the behaviors:

http://wildermuth.com/downloads/BehaviorDemo.zip

Writing Behaviors for Silverlight 3 - Part 1

shawn@wildermuth.com (Shawn Wildermuth) — Sat, 16 May 2009 02:03:26 GMT

URL: http://wildermuth.com/downloads/BehaviorDemo.zip

One of my favorite features of Silverlight 3 (and by extension Blend 3) is the new support for Behaviors. Behaviors are a way to allow designers to add functionality to XAML elements without code. In Blend 3, a couple of built-in behaviors are included (ShowMessageBox and ExecuteMethod). But of course I wanted to write my own behavior.

To start out you need to have a reference to a Blend assembly (for some reason its not part of the Silverlight SDK, at least at this point). The assembly is called Microsoft.Expression.Interactivity.dll and its located in

{ProgramFiles}\Microsoft Expression\Blend 3 Preview\Libraries\Silverlight\

Once you have a reference to the Interactivity assembly, you can use one of the base classes to create a behavior. There are several base classes of interest, but I will focus on three that are the most interesting:

Behavior<T>: Simple behaviors
TriggerAction<T>: Behavior tied to an event
TargettedTriggerAction<T>: TriggerAction that affects a separate object (e.g. the Target)

The class diagram looks like this:

For simple Behaviors, the Behavior<T> class is perfect. This class simply has overridable methods for notifying the Behavior when an object is attached or detached from the behavior. For my first behavior, I decided to create a behavior that blurs an element when the mouse hovers. To do this I started by creating a simply deriving from the Behavior<T> class:

public class BlurHoverBehavior : Behavior<UIElement>
{
}

I choose UIElement as the template parameter since Bluring had to be applied to elements that were part of the UI.

The Behavior class supplies an OnAttached and OnDetaching virtual methods that you can use to wire up your behavior. In my case, I wanted to handle the MouseEnter and MouseLeave event to enable and disable the blurring. First I needed the behavior to have a BlurEffect then on the OnAttached, I registered for the two events then OnDetaching I removed the events (so I wouldn't leak the handlers):

  BlurEffect effect = null;

  public BlurHoverBehavior()
    : base()
  {
    effect = new BlurEffect() { Radius = 20 };
  }

  protected override void OnAttached()
  {
    base.OnAttached();

    this.AssociatedObject.MouseEnter += 
      new MouseEventHandler(AssociatedObject_MouseEnter);
    this.AssociatedObject.MouseLeave += 
      new MouseEventHandler(AssociatedObject_MouseLeave);
  }

  protected override void OnDetaching()
  {
    base.OnDetaching();

    this.AssociatedObject.MouseEnter -= 
      new MouseEventHandler(AssociatedObject_MouseEnter);
    this.AssociatedObject.MouseLeave -= 
      new MouseEventHandler(AssociatedObject_MouseLeave);
  }

In the mouse event handlers, I simply added and removed the blur event as necessary:

  void AssociatedObject_MouseLeave(object sender, MouseEventArgs e)
  {
    this.AssociatedObject.Effect = null;
  }

  void AssociatedObject_MouseEnter(object sender, MouseEventArgs e)
  {
    this.AssociatedObject.Effect = effect;
  }

Once this class is written, we can add it via Blend 3 or directly in XAML:

<Ellipse Fill="Green"
         Width="200"
         Height="200"
         VerticalAlignment="Top">
  <i:Interaction.Behaviors>
    <beh:BlurHoverBehavior BlurRadius="25" />
  </i:Interaction.Behaviors>
</Ellipse>

The Interaction.Behaviors is an attached behavior that is part of the Interaction assembly that you added from the Blend assemblies. The beh namespace is from your new class (whatever namespace it belongs in).

You can play with this behavior by downloading the source code here:

http://wildermuth.com/downloads/BehaviorDemo.zip

In the next part of this article, I will create a Trigger-based behavior...look for it this weekend!

Sample Code from GGMUG Talk

shawn@wildermuth.com (Shawn Wildermuth) — Fri, 15 May 2009 18:33:07 GMT

URL: http://wildermuth.com/talks#Speaking_at_Gwinnet...

Last night I attended and spoke to the GGMUG (Gwinett Georgia Microsoft User Group) meeting to talk about everything new Silverlight 3. It was a good event and the people were great. There were good questions and the facility is great. If you attended the event, thanks for coming! You had some great questions.

You can get the slides and sample code on my site here:

http://wildermuth.com/talks#Speaking_at_Gwinnett,_Georgia_Microsoft_User_Group_