Ian T. Lackey (ITLackey)

What's Wrong with this Picture? - St. Louis Day of .Net Presentation Info

webmaster@openlightgroup.net — Tue, 09 Aug 2011 02:41:00 GMT

First of all, thank all of you that attended this session at the conference. I had a great time talking with you all and hope everyone got something out of the session. I have posted the slide deck, links to the articles I referenced in the talk and a link to the example code below.

What’s wrong with this picture - STL DODN

View more presentations from Ian Lackey

Here are the links and contact information from the presentation (for easy access):

MSDN documentation on Health Monitoring: http://msdn.microsoft.com/en-us/library/bb398933.aspx
Health Monitoring FAQ article: http://forums.asp.net/t/1027461.aspx
Example code: http://olgcommon.codeplex.com/releases/view/71454
My twitter account: @itlackey
OpenLight Group Common CodePlex project: http://olgcommon.codeplex.com

An audience member raised a question regarding providing event log output to SNMP. I have looked around for a bit and found this open source library for using SNMP in .Net. (http://sharpsnmplib.codeplex.com/) This library should help you build a custom provider to route the events to SNMP. Information on how to build a custom provider can be found here: http://msdn.microsoft.com/en-us/library/ms178718.aspx I hope this information points you in the right direction.

If you have any questions, comments, concerns (or I have forgotten to follow up on your question) please feel free to post a comment below.

More ...

Prism BootStrapper Load ModuleCatalog Ansyc

webmaster@openlightgroup.net — Thu, 10 Mar 2011 07:05:55 GMT

Prism gives you two options on how to configure the ModuleCatalog, typically in the BootStrapper, these include programmatically or from a XAML file that is embedded in the XAP file. This is a quick post to shown a very simple example of loading the ModuleCatalog for in an asynchronous fashion. This example will load the ModuleCatalog from an XML file located on the web server. The example will be abstract in implementation, but consider the scenario that you allow Administrators to upload modules into the application. When a new module is installed the catalog needs to be updated so that the Silverlight application will see them the next time it reloads the ModuleCatalog.

1. Create a Bootstrapper that inherits from your choice of a BootStrapper base class.

public class AsyncBootstrapper
        : MefBootstrapper

Here we are using the MefBootstrapper but there is no reason you could not use Unity or any DI framework that you choose to integrate with Prism.

2. Implement the required abstract method CreateShell. Here we return null here because we do not want to load a UI until the catalog is downloaded.

       protected override DependencyObject CreateShell()
        {
            return null;
        }

Delaying the creation of the shell may not always be necessary. However, given that Async processes can throw error and do not always complete it would be nice to be able to display a different UI to handle any exceptions gracefully.

3. Override the base class CreateModuleCatalog method and in this method we are going to request the xml file from the server.

        protected override IModuleCatalog CreateModuleCatalog()
        {
            ModuleCatalog catalog = new ModuleCatalog();
            WebClient client = new WebClient();
            client.OpenReadCompleted += new OpenReadCompletedEventHandler(client_OpenReadCompleted);
            client.OpenReadAsync(new Uri(http://localhost:6639/ModuleCatalog.xml, UriKind.RelativeOrAbsolute), catalog);
            return catalog;
        }

To keep this example as simple as possible we are just hard coding a path to an XML file. Imagine pointing this to a REST service that could construct the response from a database possibly event based authorization rules etc. You could also use any other async process in place of this web get request, such as a RIA Services DomainContext or a standard WCF service call.

4. In the event handler for the OpenReadCompleted we take the response and load it into the ModuleCatalog and set the RootVisual to the Shell for our application.

        private void client_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
        {
            var catalog = Microsoft.Practices.Prism.Modularity.ModuleCatalog.CreateFromXaml(e.Result);
            foreach (var item in catalog.Modules)
                this.ModuleCatalog.AddModule(item);
            App.Current.RootVisual = this.Container.GetExportedValue();
        }

Continuing the comments about step 3, if you were using a different way of requesting the catalog this code could be very different. For example, instead of using the CreateFromXaml method you may enumerate through a collection returned from WCF and programmatically configure the catalog. Also, if you did not delay the creation of the Shell, you would not need to set the RootVisual here.

I tried to keep this example short and to the point. However, the simplicity of the example keep you from considering this solution in more complicated scenarios. A complete solution would probably include caching a copy of the catalog in IsolatedStorage and loading from cache if the application is offline. It should be able to be applied in many scenarios that included updating the available modules without redeploying the main XAP file.

As always, I hope this helps and look forward to your feedback!

-Updated – Modified how we handled the creation of the Shell due to an issue I discovered after publishing this article. Instead of loading a custom view we are no simply delaying the creation of the Shell. If you wanted a custom UI to display during the loading of the catalog you would create the Shell in the CreateShell method and handle the different displays inside of the Shell.

More ...

Simple RadioButtonList and / or CheckBoxList in Silverlight Using a Behavior

webmaster@openlightgroup.net — Wed, 23 Feb 2011 05:47:09 GMT

A problem I have encountered frequently on recent projects is needing an ASP.Net style RadioButtonList or CheckBoxList inside on a Silverlight application. I have tried several approaches and had moderate success given the varying scenarios of each attempt. It finally came to a point that the problem had to be solved once and for all. So after discussing it with a few of the guys on my team and doing some extra reading tonight, I have found a solution that I feel is worth sharing. This post will be a step-by-step guide to using the ToogleButtonListBoxBehavior that I have created inside of the OpenLightGroup.Common Library.

To follow this tutorial you will need to download the latest version of the OpenLightGroup.Common Library and add a reference to the included dll file. We will also be using Microsoft Blend; however, the behavior can be added in Visual Studio just as other behaviors.

Drop a ToggleButtonListBoxBehavior onto the ListBox.
Bind the ListBox ItemsSource property to a ViewModel (You may also us a DomainDataSource or any way you would like to populate the Items of the ListBox).
Create a new template for the ListBox ItemTemplate.
Create the template as a resource.
Create a StackPanel in the template and place a TextBlock and RadioButton in it (You may also use a CheckBox or any other control that inherits from ToggleButton, see the notes at the end of the article).
Bind the Text property of the TextBlock to the property that you would like displayed.

That is all there is too it! Since this is still just a ListBox, you can customize it any way you like (at least any way you could any other ListBox). There are a few things to keep in mind documented in the following notes section.

Notes:

The ItemTemplate must contain a ToggleButton (this includes both RadioButton and CheckBox).

This means you cannot use the DisplayMemberPath on your ListBox.

Currently this behavior only uses the first ToggleButton it finds inside of the template.
Each item in the ListBox will have at least two event handlers attached to it to handle Checking and Unchecking etc. This may have a negative impact on performance in long lists.
If you are not finding the ToggleButtonListBoxBehavior in your assets lists, make you you have downloaded and added a reference to the latest OpenLightGroup.Common release.
If you are interested in how this behavior works you can view the source code here.

More ...

Getting the right behaviors in your Phone 7 App – Part 3 Email ‘em

webmaster@openlightgroup.net — Wed, 22 Dec 2010 13:45:26 GMT

This example will cover how to package a EmailComposeTask as a reusable behavior that can be dropped into any given Phone 7 app. The EmailComposeTask has a few properties that are used to pass data to the email you are launching / preparing to send.

These include the following:

Body
Cc
Subject
To

Due to the fact that there are four properties included with this task, as opposed to the one property we dealt with in Part 1 and Part 2, we will not be able to use the Tag property of the associated control in the same way as in those examples. With that said, we will in fact use the Tag property but we will have to do a little extra magic to get it to work. Thankfully that Tag property is of type object which gives us the flexibility we will need to make this work. In order to make this solution as reusable as possible I decided to use an interface that can be used in any project referencing this code. Before I loose you, give me one more moment of your time to see how simple this really is. Here is the interface:

public interface IEmailComposeData
{
        string Body { get; set; }
        string Cc { get; set; }
        string Subject { get; set; }    
        string To { get; set; }
}

Whoa, ok so it just mimics the properties exposed by the EmailComposeTask! Why in the world would I do something like this?!? We the answer is actually pretty simple, to leverage the powerful binding framework baked into Silverlight. An example is probably the easiest way to explain this, so here is a class that I used in a recent project.

    public partial class Submission
        : IEmailComposeData
    {
        public Submission()
        {
        }
        #region IEmailComposeData Members
        public string Body
        {
            get { return string.Empty; }
            set { }  //No op
        }
        public string Cc
        {
            get { return string.Empty; }
            set { }  //No op
        }
        public string Subject
        {
            get { return "Thank you for your feedback of " + this.ApplicationName; }
            set { }  //No op
        }
        public string To
        {
            get { return this.EmailAddress; }          
            set { }  //No op
        }
        #endregion
    }

What I did here is I created a partial class of a class generated by a service reference and wrapped a few properties into the IEmailComposeData interface. I also included a little prefix text to the subject and a property from the generated class. The point this should illustrate is that you can implement this interface in any class and provide the expected properties to the behavior, which I will show here:

public class LaunchEmailComposeAction : TriggerAction
{
    public bool UseDataObject { get; set; }
    protected override void Invoke(object o)
    {
        EmailComposeTask task = new EmailComposeTask();
        if (this.UseDataObject)
        {
            var data = this.AssociatedObject.Tag as IEmailComposeData;
            task.Body = data.Body;
            task.Cc = data.Cc;                
            task.Subject = data.Subject;
            task.To = data.To;
        }
        else
        {
            task.To = this.AssociatedObject.Tag.ToString();
        }
        task.Show();
    }
}

As you can see, the behavior includes a property UseDataObject to tell the Invoke method if it should try to cast the AssociatedObject’s Tag to the provided interface and pull the data out of it for the properties of EmailComposeTask. If the UseDataObject is set to false then it tries to grab a To string out of the Tag property. I included this just for simple situation when you simply want to launch an email with the To field filled out automatically. However, using the data object allows you to create XAML that looks like this:

<HyperlinkButton
	 Content="{Binding EmailAddress, Mode=OneWay}"
	 Tag="{Binding Mode=OneWay}">
	<Custom:Interaction.Triggers>
		<Custom:EventTrigger EventName="Click">
			<ITLackey_Phone7_Common_Behaviors:LaunchEmailComposeAction  UseDataObject="True" />
		Custom:EventTrigger>
	Custom:Interaction.Triggers>
HyperlinkButton>

In this XAML the EmailAddress from the Submission class (shown above) is used as the content and the Submission object itself is bound to the Tag property. Since we implemented the IEmailComposeData interface in the Submission class it will be successfully parsed by the behavior and the email will be prepopulated with the information provided by the properties of the Submission class. In this case the To field will be filled in with the EmailAddress and the Subject will be filled in with “Thank you for your feedback of “ + ApplicationName.

I completely understand and acknowledge that this example includes additional complexity compared to the examples shown in Part 1 & 2; however, I hope that the power of repackaging this task for reusability can be seen and will out weigh the little bit of extra complexity. Obviously, you can trim this down to support only a single field or however you see fit. This solution worked for me and allowed me to pass in all of the data the task supports and is open to add data if the task is expanded to include some additional properties such as ATTACHMENT (hint hint Windows Phone 7 Team! ).

Hope this helps!

More ...

Getting the right behaviors in your Phone 7 App – Part 2 Binding & Browsing

webmaster@openlightgroup.net — Wed, 22 Dec 2010 13:43:54 GMT

In this example we will look at the WebBrowserTask and how a little bit of code can create a great design time experience for the times that you need to launch a browser in a Phone 7 app. Like the PhoneCallTask, the WebBrowserTask only contains one property. So, this example will look very similar to the one we looked at in Part 1. I will jump straight to the code as the concept will be identical to our previous example.

using System.Windows.Controls;
using System.Windows.Interactivity;
using Microsoft.Phone.Tasks;
namespace ITLackey.Phone7.Common.Behaviors
{
    public class LaunchBrowserAction : TriggerAction
    {
        protected override void Invoke(object parameter)
        {
            WebBrowserTask task = new WebBrowserTask();
            task.URL = this.AssociatedObject.Tag.ToString();
            task.Show();
        }
    }
}

Again, we are simply using the Tag property of the associated control to pass in the data we need for our task. In this case it is the URL that we would like to direct the browser to when it is launched. Here is an example of using this behavior on a button:

<Button x:Name="FeedbackUrl"
     Content="You may also submit feedback via the web" 
     Tag="{Binding SubmitFeedbackUrl}" >
	<Custom:Interaction.Triggers>
		<Custom:EventTrigger EventName="Click">
			<ITLackey_Phone7_Common_Behaviors:LaunchBrowserAction/>
		Custom:EventTrigger>
	Custom:Interaction.Triggers>
Button>

Here we are just bound the SubmitFeedbackUrl to the Tag property of the button and dropped the behavior on. Done. That is all there is too it. Pretty simple example but now you can launch a browser session straight to the URL you want from any control in your Phone 7 app.

Enjoy!

More ...

Getting the right behaviors in your Phone 7 App – Part 1 Phone Home

webmaster@openlightgroup.net — Tue, 21 Dec 2010 06:01:19 GMT

This multiple part series will focus on packaging up a few common “tasks” into reusable behaviors. I hope to cover tasks for phone calls, sending emails, launching the browser etc. Most of the articles in this series will be short and typically will contain only a few lines of code. The majority of the code will deal with the objects contained in the Microsoft.Phone.Tasks namespace which contains several classes used to launch a task or choose a piece of data from the phone.

In this post (part 1) will we tackle what I consider to be the most obvious task to use on a phone… making a phone call. Again this will require only a few lines of code, so I will go ahead and drop it all right here and then run through what it does and how to use it.

using Microsoft.Phone.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Interactivity;
namespace ITLackey.Phone7.Common.Behaviors
{
     public class LaunchPhoneDialerAction : TriggerAction
    {
        public LaunchPhoneDialerAction()
        {
           
        }
        protected override void Invoke(object o)
        {
            PhoneCallTask task = new PhoneCallTask();
            
	   task.PhoneNumber = this.AssociatedObject.Tag.ToString(); 
            
            task.Show();
        }
    }
}

What we have here is a standard “Action” (as you would see in any Silverlight application) that can be dropped onto any object that derives from the Control base class (For a refresher on behaviors check out this article by Michael http://openlightgroup.nethttp://www.openlightgroup.net/Blog/tabid/58/EntryId/17/Creating-a-simple-Silverlight-3-Behavior.aspx and now there is a handy template available in Blend). The real work for this example is done inside of the Invoke method and by the majority of work I am referring to the three lines of code.

The Phone 7 team has done a fine job providing and easy way to launch the phone dialer prepopulated with a phone number. In this example, we are pulling the phone number out of the Tag property of the control this action is associated with. This allows us to bind the Tag property to some dynamically loaded data so that this action could be used inside of a ListBox ItemTemplate for example. That would look something like this:

<ListBox x:Name="listBox">
	<ListBox.ItemTemplate>
		<DataTemplate>
			<HyperlinkButton Tag="{Binding PhoneNumber}" Content=”{Binding PhoneNumber}”>
				<Custom:Interaction.Triggers>
					<Custom:EventTrigger EventName="Click">
						<ITLackey_Phone7_Common_Behaviors:LaunchPhoneDialerAction/>
					Custom:EventTrigger>
				Custom:Interaction.Triggers>
			HyperlinkButton>
		DataTemplate>
	ListBox.ItemTemplate>
ListBox>

This would only display a list of phone numbers, obviously you would typically want to include a more useful item template, but hopefully this illustrates the point. Anytime you click on one of the phone numbers the phone dialer will launch preloaded with that phone number.

Well there you have it, a reusable phone dialer launching action that can be dropped onto any control in your phone app. Unfortunately, sine Phone 7 uses Silverlight 3 we cannot bind the phone number data directly to a property on the action due to the lack of support in Silverlight 3 to bind to objects that do not inherit from FrameworkElement. (This article shows the announcement of this feature being added to Silverlight 4 http://timheuer.com/blog/archive/2009/11/18/whats-new-in-silverlight-4-complete-guide-new-features.aspx#dobind ). This is why we have to use the Tag property of the associated object. I feel that is a small price to pay for the reusability of this commonly used action.

As always any feedback, improvements, questions etc. are appreciated!

More ...

Phone 7 Back Button and the ListPicker control

webmaster@openlightgroup.net — Sat, 04 Dec 2010 18:55:46 GMT

I had disappeared once again for far too long; however the time has been well spent. I have been heads down coding apps for Phone7 and learning the nuances of the platform. I have also learned much about the certification process in which your apps must go through before making it to the marketplace. I hope to share a few tips & tricks with you from what I have learned in this and upcoming articles.

This post will focus on the requirement stated in the certification documentation regarding back button navigation when menus or dialog boxes are present on the current page. Over the last few days I have had two separate apps fail certification due to an oversight in this area. I decided I would post what I have learned and hopefully help prevent others from encountering the same issues when they submit their apps.

While developing my first Phone 7 app I was stumped momentarily at the absence of a ComboBox in the phone controls. I use this control so often in Silverlight that I had to wonder what I would do without it. I quickly found that we are supposed to use a ListPicker control from the control toolkit in place of the traditional ComboBox. Great! So off I went dropping them into my app and chugging along ignorant to what this meant in regards to navigation through the app. I wasn’t until recently that I was pointed to the section of the certification requirements document that says:

“If the current page displays a context menu or a dialog, the pressing of the Back button
must close the menu or dialog and cancel the backward navigation to the previous page.”

– Windows Phone 7 Application Certification Requirements.pdf Section 5.2.4

* Link to the document as of 12/04/10: direct link to the PDF file

Apparently, this includes ListPicker controls that are in the expanded mode (waiting for a selection to be made). This caused me to rework some pieces of apps I was currently developing. Then I decided instead of writing the same code in each page code-behind, I would just write a behavior I could drop on each ListPicker to handle the back button press event.

The main piece of code that takes care of the issue is simple and only takes a few lines of code:

private void page_BackKeyPress(object sender, System.ComponentModel.CancelEventArgs e)
{
      if (this.AssociatedObject.ListPickerMode == ListPickerMode.Expanded)
      {
          this.AssociatedObject.ListPickerMode = ListPickerMode.Normal;
          e.Cancel = true;
                
      }
}

First check to see if the ListPicker is expanded and if so set it back to the normal mode and cancel the navigation by setting the Cancel property of the event args to true. That’s is all there is too it. So simple it is easy to forget and cause your app to fail certification. Now that I have packaged this logic into a behavior, I just have to remember to drop it on my ListPicker controls that will not use the FullMode. For more information on the ListPicker check out the toolkit page on CodePlex: http://silverlight.codeplex.com/

To make it easy, here is the code for the in its entirety behavior:

public class CancelBackButtonListPickerBehavior : Behavior
{
    private PhoneApplicationPage _page;
    protected override void OnAttached()
    {
        base.OnAttached();
        this.AssociatedObject.Loaded += new RoutedEventHandler(AssociatedObject_Loaded);
          
    }
    void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
    {
        _page = FindParentOfType(this.AssociatedObject);
        _page.BackKeyPress += new EventHandler(page_BackKeyPress);
                       
    }
    protected override void OnDetaching()
    {
        base.OnDetaching();
        _page.BackKeyPress -= new EventHandler(page_BackKeyPress);
        this.AssociatedObject.Loaded -= new RoutedEventHandler(AssociatedObject_Loaded);
    }
    void page_BackKeyPress(object sender, System.ComponentModel.CancelEventArgs e)
    {
        if (this.AssociatedObject.ListPickerMode == ListPickerMode.Expanded)
        {
            this.AssociatedObject.ListPickerMode = ListPickerMode.Normal;
            e.Cancel = true;
                
        }
    }
    public static T FindParentOfType(FrameworkElement element)
    {
        var parent = VisualTreeHelper.GetParent(element) as FrameworkElement;
        while (parent != null)
        {
            if (parent is T)
                return (T)(object)parent;
            parent = VisualTreeHelper.GetParent(parent) as FrameworkElement;
        }
        return default(T);
    }
}

I hope this helps!

More ...

Embrace your designer!

webmaster@openlightgroup.net — Fri, 03 Sep 2010 04:29:06 GMT

Now before you go run off and start hugging the graphic artist down the hall, please finish reading this post. We don’t want any HR issues, now do we?

I tend to agree with what Michael is saying in his post (Silverlight: Why I feel “Design Is The Most Important Thing”), and think that it deserves some serious consideration by any professional developer. Far too long have we (developers) under valued how much a good “design” plays a part in good software. However, the designer I am referring to in this article spans graphic artists, UI designers, developers, machinist, architects, civil engineers… and on and on. This “designer” is the one that lives in all of us (yes you can now hug yourself if you like, but still not exactly what I’m talking about either). What I am trying to illustrate in this article is that we all have the ability to evaluate a good design or a poor design, granted this ability has varying degrees. Additionally, a lot of us are able to say “something about this just isn’t right” or “I love this… but I can’t say why exactly” but have not sharpened the skills to what our intuition is telling us.

(Image taken from the book The Design of Everyday Things which illustrates the idea that many times throughout history people have not listened or acknowledged their inner designer and in turn have caused poor design to take root in our world)

Now this is where a few feathers are going to get ruffled, and honestly I kind of hope they do because I feel that they need to be. We developers are some of the biggest offenders when it comes to introducing poor design into the world and therefore the lives of others. Let’s be honest (this includes me and maybe this article is a form of confession), we know that our grey squares and white backgrounds are hideous! We know that the “Save Changes” button that is enabled even though there are no changes(!!!) confuses and frustrates users. We know that sticking the cool little animated gif on the page to tell the user something is “Loading” or even better the one that lets the user know that something is “Processing” (seriously do we even know what is processing?) for minutes doesn’t really cut it. The only feature that these poor designs provide is user frustration and calls to our typically over worked support teams. The list could go on and on, and we can come up for an excuse for each example. Like “when I started doing development it was so hard to make things look pretty” or “it takes too long to style an entire application and clients really don’t want to pay for that.”

While some of these excuses may contain a bit of truth, they no longer provide the shelter we used to hide under. The truth is clients no longer care if the software simply works. It must provide an intuitive and enjoyable experience! I believe the world is transitioning from the “Information Age” into the “Innovation Age” and we have to grab a board and surf the wave or be swallowed by the undertow. Technology has moved us past the “wow I can actually get real-time stock information from the web” to “this has to feel like we are really interacting with this data.” Things like multi-touch and accelerometers have given us the ability to “get our hands” into the digital world! Seriously, who doesn’t want that awesome interface from Minority Report?!?!

Each day brings us closer to that reality in our homes, offices and even pockets. However, it is up to us the developers, architects and designers to make this reality happen. So, I suppose this is a call to arms of sorts. It is time for us to tear down the wall between the technological specialties (developers, graphic designers, interactive designers, solution architects, etc.) and realize we ALL play a part in the overall design of our digital world. Each of us needs to open our eyes a little wider and look around. We need to focus on questions like: What in our world is enjoyable to use? Why does it feel that way? What can we do to make our software/solutions feel this way?

The revolution begun in my mind thanks to a series of books that I have read over the last few months. I credit my director for starting me on this journey by discussing the innovation firm IDEO with our team at work and showing us the television special showing how the successfully redesign the shopping cart is a week. Below is part one of the special, there are three parts to the episode. The other two videos should show up in the related videos once part one completes. I highly recommend watching the entire series!

One of the interesting pieces of information in these videos is that their “design team” is made up of people from drastically different backgrounds. For example, there is a anthropologist, a biologist, an engineer, a linguist etc. Each of these individuals provide a unique perspective to the concepts explored by the team allowing for a more holistic vision of the “problem domain” or “design challenge.” The idea that we are all designers started here for me and the was further affirmed while reading the Purple Cow book recommended to me by my teammate Ken. This book as well as the book Innovate the Pixar Way really started the process of questioning my internal design processes and the way I view innovation and what is remarkable. Another great book that helped to inspire and clarify a refinement of the design process I will be using from now on is Dynamic Prototyping with SketchFlow in Expression Blend: Sketch Your Ideas...And Bring Them to Life! This book made me realize that I was insulting SketchFlow with my half hearted attempts to use the tool. It is so much more powerful than I gave it credit for! However, the power is not the tool in and of itself but how the tool allows us to change the way we design our applications. The relationship and feedback that is created when it is used properly is priceless!

So I know this post may seem a bit too abstract and/or sporadic when compared to other content on this site that focuses on “how to” do things. However, I have found a new way of seeing the world and feel inspired to make better designs and encourage you to do so. Michael has definitely caught the design bug and is learning to surf the new wave. Many of the topics he discussed in his article are the more practical examples of the underlying concepts I have been trying to bring to light. Believe me, I agree 100% that we need the artistic folks ( I AM NOT ONE OF THEM NO MATTER HOW MUCH I WISH I WAS ) such as the graphic designers and UI specialists! We are not all that kind of designer, but we all design what we are specialists at. For example, the graphic artist that make the amazing visual artifacts for the application typically has no idea how to “design” the service that the application is going to need to fill that visual with useful data. For a developer or application architect it is our job to design a great experience by building a great service to return that data in a way that allows the visual designers work to really be appreciated. No more three minutes of watching a progress bar as we retrieve data! Design your service to be responsive, otherwise no matter how great the application looks it will still “feel” clunky. (Michael has another post that give some good information about new tools to help design a more responsive application: Simple Silverlight 4 Example Using oData and RX Extensions)

To wrap up this rant, there are a lot of resources out about what good design is, processes used to create good designs and tools to help you implement the designs. I encourage, maybe even beg, you to check out some of the books, videos and articles I mentioned here. I truly hope you find inspiration to take your “designing” to the next level and to push those around you to do the same. We are all victims of bad design, but we have the power to change that… it is our world that we are creating.

So now that you have read this, there is only one question that needs to be answered to determine the direction of our collective future:

“You take the blue pill - the story ends, you wake up in your bed and believe whatever you want to believe. You take the red pill - you stay in Wonderland and I show you how deep the rabbit-hole goes.”

More ...

St. Louis Day of .Net Review

webmaster@openlightgroup.net — Sun, 22 Aug 2010 16:53:28 GMT

AWESOME!

If you live anywhere near St. Louis, you have to attend this event next year! If you live further out and can still make it, it is definitely worth your time and money. Speaking of money, the registration fee was only $200 for two full days of learning. That is an amazing price! The value is incredible compared to the cost of attending TechEd or PDC or the other big conferences. I was privileged enough to attend TechEd in 2009 and had a great time, learned some cool stuff (and got to meet Michael in person for the first time). To compare the two conferences: Ounce for ounce STLDODN is either equal to or greater than the value I experienced at TechEd.

The speakers were great, the topics were on point and the atmosphere was charged with excitement and passion… or maybe that was just all the free coffee I pounded down. Seriously, you could tell that the attendees where enjoying the sessions and excited about what they were learning. The caliber of speakers, again, was on par with one of the major conferences and brought with them some great knowledge and experience to share.

I also feel that part of the increased value is due to the fact that most of the attendees and a fair amount of the speakers live and work in the area. This allows for some great “networking” (though I kind of dislike that term – prefer “relationship building”) and general socializing with others that are familiar with the local industry. I am convinced that St. Louis must have one of the greatest .Net communities in the country.

And of course, there was schwag and prize giveaways. Some of the prizes included a laptop, a Wii, 1TB External HD (which I won!!! Thanks STLDODN!), software licenses and more!

I just wanted to write a little blurb about my experience with the St. Louis Day of .Net and encourage anyone that can attend to definitely do so next year! Check out the St. Louis Day of .Net website for more information, and I will be sure and post something here and on Twitter (@itlackey) when registration for next year opens.

Before I wrap up I wanted to say thanks to all the individuals that went the extra mile to make this happen and volunteered your time to make this event possible and the sponsors that contributed to keep the costs down.

Special thanks to Kevin Grossnicklaus, Scott Spradlin, Chris Deweese, Dru Sellers, Jeff Fattic, Brad Nunnally for taking the time after and between session to answer questions and help myself and my team become better at what we do!

P.S. I did not write this just because I won the HD :P

More ...

How to show a ChildWindow from a ViewModel using a custom Action

webmaster@openlightgroup.net — Sat, 14 Aug 2010 00:23:49 GMT

We this is a classic example of “the early bird gets the worm.” I have been on hiatus for far too long, but have not been idle. I have actually been planning this blog entry for a few weeks, along with another one (more on this in a minute). As it turns out, Michael and Haruhiro where working on pretty much the same concept. They beat me to the finish line with there solution as you can see here: Using the “Hisowa Simple PopUp Behavior” in a DataGrid. Since I took a slightly different approach, I decided to go ahead and post this article.

Additionally, I believe that the more information is examined the best solution will be formed based on pieces of all the information. I want to be very clear, I think the solution described in Haruhiro’s article is great! This article is not being posted to “one up” or discredit Haruhiro’s work in any way and I suggest that if you have not read his post, you should.

Side Note:
The other blog entry I planned on posting is titled “Embrace your Designer” and is along some of the same topics as Michael’s post Silverlight: Why I feel “Design Is The Most Important Thing”. After seeing the articles that Michael and Haruhiro put together, I had to tell Michael to “stop stealing my ideas!” I am seriously starting to wonder if he “chipped” me when I met up with him in Cali.

With that said, “now for something completely different” … well kind of.

I have seen many example and questions regarding how to use a childwindow control when using MVVM. Most examples have either been highly criticized as not “pure MVVM” or overly complicated for a majority of applications. To me, one of the main benefits of MVVM is the simplicity that comes with the pattern. Why then would you want to implement an entire “Childwindow Service Layer” or something equally as complicated? So I started thinking “there has to be an easy way to do this in a MVVM purest fashion.” That lead to the idea of building a behavior (or action to be specific) that could show a childwindow control. Thanks to the selection of triggers built into Silverlight, the action could be invoked several different ways with no code necessary.

For example, here is a button that is wired to a command on a ViewModel.

   <Button x:Name="button"
     Content="Use Command"
     Command="{Binding RequestResponseCommand}" 
     />

The command on the ViewModel simply raises an event:

        public void RequestResponse(object param)
        {
            if (this.RequestingResponse != null)
                this.RequestingResponse(this, new EventArgs());
        }

Which is handled by an EventTrigger that has the ShowChildWindowAction associated with it:

<i:EventTrigger SourceObject="{Binding}"
                EventName="RequestingResponse">
    <behaviors:ShowChildWindowAction>
        <behaviors:ShowChildWindowAction.ChildWindow>
            <controls:ResponseWindow x:Name="CommandWindow" />
        behaviors:ShowChildWindowAction.ChildWindow>
    behaviors:ShowChildWindowAction>
i:EventTrigger>

So that is all that is needed to display a childwindow; however, that is not very useful in and of itself. Typically we want to know if the window was “cancelled” or “confirmed” and be able to response accordingly. We sometimes also want to have a custom childwindow and to know if any data was changed in the childwindow. This action allows for those scenarios through a set of five properties.

AttachDataContext: If set to true, attaches the DataContext of the control the EventTrigger is associated with. This is useful if you want to send the ViewModel (or any other DataContext) to the childwindow for binding purposes etc.
- Note: If you attach the DataContext to the childwindow, any properties changed on that DataContext will change immediately and will not be undone if the window is cancelled.
ClosedCommand: The ICommand to be executed when the childwindow is closed.
CommandParameterProperty: The property name of the childwindow control that is used as the parameter of the ClosedCommand when executed.
ExecuteCommandOnCancel: Specifies if the ClosedCommand should be executed if the DialogResult of the window is “cancelled” or closed.
ChildWindow: Is a nested childwindow control that is created and shown when the action is invoked. This allows you to build and customize a control that inherits from ChildWindow and use it as the window to be shown.

Here is an example of what the XAML might look like for a button that calls a command only with the DialogResult of a custom ChildWindow control is true and pass the value of the Response property of the ChildWindow to the command:

<behaviors:ShowChildWindowAction
                                    CommandParameterProperty="Response"
                                    ClosedCommand="{Binding UpdateResponseCommand}">
    <behaviors:ShowChildWindowAction.ChildWindow>
        <controls:ResponseWindow x:Name="CommandWindow" />
    behaviors:ShowChildWindowAction.ChildWindow>
behaviors:ShowChildWindowAction>

Hopefully you are thinking, “Wow this is the greatest thing I have ever seen!” No? Okay, how about something more realistic like, “This seems useful, but how does it work?”

Well, the action was actually fairly simple to build. All of the properties except for ClosedCommand and ChildWindow are standard properties. ClosedCommand is a dependency property that allows for the command to be bound to an ICommand property of your ViewModel.

Note: I have included the source code for an example project so I will not show all of the code here. However, feel free to download the code and browse\use\modify it as you see fit.

In the overridden OnAttached method we handle attaching the DataContext of the associated control and wiring up an event handler to the Closed event of the childwindow if needed.

protected override void OnAttached()
{
    base.OnAttached();
    if (this.AttachDataContext)
        ChildWindow.DataContext = this.AssociatedObject.DataContext;
    if (this.ClosedCommand != null)
        ChildWindow.Closed += new EventHandler(window_Closed);
}

The window_Closed method is where we determine if we need to call the ClosedCommand based on the DialogResult and the ExecuteCommandOnCancel values. If so, we create the parameter for the command using reflection (This ones for you Ken! :) ), if a CommandParameter value is specified. Finally we execute the ClosedCommand. Hopefully my C# is clearer than my English:

void window_Closed(object sender, EventArgs e)
{
    ChildWindow window = (ChildWindow)sender;
    if (this.ClosedCommand != null &&
        (this.ExecuteCommandOnCancel ||
            (window.DialogResult.HasValue && window.DialogResult.Value == true)))
    {
        object param = null;
        if (!String.IsNullOrEmpty(this.CommandParameterProperty))
            param = sender.GetType().GetProperty(this.CommandParameterProperty).GetValue(sender, null);
        this.ClosedCommand.Execute(param);
    }
}

The rest of the behavior is pretty straightforward. In the Invoke method we simply call Show on the childwindow and in the OnDetaching method we remove the Closed event handler.

That about wraps it up. I intentionally chose the simplest way to provide the functionality that I required and I am sure there are MANY enhancements that can me made to this behavior. Some of which can probably be found in the HisowaSimplePopUpBehavior. Please do check out that article as well and use the foundations that have been laid here to make something awesome!

I plan on included this control in the OLGCommon project so keep your eye on that, and feel free to submit enhancements.

As always, we value your feedback!

Here is the source code for the example project and behavior: ShowChildWindowExample.zip

Updated 8/14/2010: I have upload a new example project that removed the reference to the OLGCommon assembly and changed the ChildWindow property of the behavior to be a dependency property to allow for binding.

More ...