Elegant Code » Brian Lagunas

Windows 8 Unleashed–Boise

Brian Lagunas — Mon, 20 Aug 2012 22:56:14 +0000

Have you heard about Windows 8 Unleashed yet? “Windows 8 Unleashed” is a series of FREE events run by your local community friends and leaders, and are great whether you are an experienced .NET developer, or even if you are just getting started. I am excited to announce that Boise will be hosting its very own Windows 8 Unleashed event. Yeah, that’s right. You heard me! A full day of hands on training for FREE!

B.Y.O. Laptop!

Come join me and spend the morning in lecture and hands on labs. Half way through, you’ll get a chance to take what you learned in the morning and compete in a friendly contest with a chance to win some great prizes! More on that in a minute.

When and Where

The event is being held on Friday, Sept 28 starting at 8 a.m and goes to 8 p.m. My friends at URS Energy and Construction have kindly let us use their awesome facility located at:

720 Park Blvd
Boise, ID 83704
see the map

The auditorium can be found in the basement of Plaza 1.

Feed Me

Feed them, and they will come. Breakfast, lunch, and dinner (if necessary) will be provided to you to help fuel all the keystrokes that will be unleashed.

Required Software and Downloads

Please make sure to get the required software and downloads BEFORE coming to the event. You can find everything you need on the “Windows 8 Unleashed Installs” page.

Agenda

Session I – Overview

Metro Style Apps Overview
Developing Metro Style Apps
Working with Controls
Implementing Navigation

Session II – Location and Data

Working with Location
Data Binding
Roaming
App Bar

Session III – Metro Principals

Live Tiles & Toast
Contracts
Full, Fill, Snap and Portrait Views
Advertising

Build an App and Win Money and Prizes!

Our sponsors have stepped up with some awesome prizes. Not only do you get a ton of information for FREE, but you have an opportunity to win some awesome stuff! You can’t afford to miss this!

DAY-OF prizes will be awarded (sponsored by PDSA):

1st Place: $500 Gift Card
2nd Place: $200 Gift Card
3rd Place: $100 Gift Card

“Best Overall App” Prizes will be awarded to the best app from ALL unleashed events:

$10,000 from ComponentArt
Windows 8 Tablet from PDSA, Inc.

In addition all attendees will receive a FREE eBook from O’Reilly

REGISTER NOW

Building IG Outlook Part 4 – Creating Custom Region Adapters

Brian Lagunas — Fri, 01 Jun 2012 19:00:00 +0000

This is the fourth video in a series that will take you step-by-step on building a Prism application that mimics Microsoft Outlook. In this video we create custom region adapters for the Infragistics XamRibbon and XamOutlookBar controls that are defined as regions in our application’s shell.

The code you really care about are the two region adapters.

XamRibbon

#if !SILVERLIGHT
using Infragistics.Windows.Ribbon;
#else
using Infragistics.Controls.Menus;
#endif
 namespace IgOutlook.Infrastructure.Prism
 {
     public class XamRibbonRegionAdapter : RegionAdapterBase<XamRibbon>
     {
         public XamRibbonRegionAdapter(IRegionBehaviorFactory regionBehaviorFactory)
             : base(regionBehaviorFactory)
         {
         }
         protected override void Adapt(IRegion region, XamRibbon regionTarget)
         {
             if (region == null) throw new ArgumentNullException("region");
             if (regionTarget == null) throw new ArgumentNullException("regionTarget");
             region.ActiveViews.CollectionChanged += (s, args) =>
             {
                 switch (args.Action)
                 {
                     case NotifyCollectionChangedAction.Add:
                         {
                             foreach (Object view in args.NewItems)
                             {
                                 AddViewToRegion(view, regionTarget);
                             }
                             break;
                         }
                     case NotifyCollectionChangedAction.Remove:
                         {
                             foreach (Object view in args.OldItems)
                             {
                                 RemoveViewFromRegion(view, regionTarget);
                             }
                             break;
                         }
                     default:
                         {
                             // Do nothing.
                             break;
                         }
                 }
             };
         }
         protected override IRegion CreateRegion()
         {
             return new AllActiveRegion();
         }
         static void AddViewToRegion(Object view, XamRibbon xamRibbon)
         {
             //TODO: implement in later video
         }
         static void RemoveViewFromRegion(Object view, XamRibbon xamRibbon)
         {
             //TODO: implement in later video
         }
     }
 }

XamOutlookBar

#if SILVERLIGHT
using Infragistics.Controls.Menus;
#else
using Infragistics.Windows.OutlookBar;
#endif
 namespace IgOutlook.Infrastructure.Prism
 {
     public class XamOutlookBarRegionAdapter : RegionAdapterBase<XamOutlookBar>
     {
         public XamOutlookBarRegionAdapter(IRegionBehaviorFactory factory)
             : base (factory)
         {
         }
         protected override void Adapt(IRegion region, XamOutlookBar regionTarget)
         {
             region.ActiveViews.CollectionChanged += ((x, y) =>
                 {
                     switch (y.Action)
                     {
                         case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
                             {
                                 foreach (OutlookBarGroup group in y.NewItems)
                                 {
                                     regionTarget.Groups.Add(group);
 #if !SILVERLIGHT
                                 //The WPF XamOutlookBar does not automatically select the first group in it's collection.
                                 //So we must manually select the group if it is the first one in the collection, but we don't
                                 //want to excute this code every time a new group is added, only if the first group is the current group being added.
                                 if (regionTarget.Groups[0] == group)
                                 {
                                     regionTarget.SelectedGroup = group;
                                 }
 #endif
                                 }
                                 break;
                             }
                         case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
                             {
                                 foreach (OutlookBarGroup group in y.NewItems)
                                 {
                                     regionTarget.Groups.Remove(group);
                                 }
                                 break;
                             }
                     }
                 });
         }
         protected override IRegion CreateRegion()
         {
             return new AllActiveRegion();
         }
     }
 }

Of course don’t forget to register your mappings in your bootstrapper.

protected override Microsoft.Practices.Prism.Regions.RegionAdapterMappings ConfigureRegionAdapterMappings()
 {
     RegionAdapterMappings mappings = base.ConfigureRegionAdapterMappings();
     mappings.RegisterMapping(typeof(XamOutlookBar), Container.Resolve<XamOutlookBarRegionAdapter>());
     mappings.RegisterMapping(typeof(XamRibbon), Container.Resolve<XamRibbonRegionAdapter>());
     return mappings;

Watch the video on Xaml TV

Building IG Outlook Part 3 – Creating the Mail Module

Brian Lagunas — Thu, 31 May 2012 19:00:00 +0000

This is the third video in a series that will take you step-by-step on building a Prism application that mimics Microsoft Outlook. In this video we will create the first module in the application called the Mail module. We concentrate on just stubbing out the module project, creating a module catalog, adding the Mail module to it in the bootstrapper. We also inject our first navigation view, in the form of an Infragistics OutlookBarGroup, into our OutlookBar region defined in our shell. We do this for both the WPF and Silverlight platforms.

Watch the video on Xaml TV.

Building IG Outlook Part 2 – Creating the Shell

Brian Lagunas — Wed, 30 May 2012 19:43:57 +0000

This is the second video in a series that will take you step-by-step on building a Prism application that mimics Microsoft Outlook. In this video, I walk you through creating a shell for both the WPF and Silverlight platforms. This is a relatively short video, because shells are just so stinking easy. The only concept introduced in this video is a Region. A Region basically defines elements within your shell as containers for views that will be composed at runtime. We also start utilizing controls from Infragistics NetAdvantage for WPF and Silverlight, such as the XamOutlookBar and XamRibbon.

Watch the video on Xaml TV.

If you have any questions feel free to leave a comment or contact me on twitter (@BrianLagunas).

Building IG Outlook Part 1–Setting up the Prism Application

Brian Lagunas — Wed, 25 Apr 2012 20:03:18 +0000

This is the first video in a series that will take you step-by-step on building a Prism application that mimics Microsoft Outlook. This video covers how to setup a multi-platform Prism application that targets WPF and Silverlight. I show you how to setup your directory structure, as well as the solution/project structure inside Visual Studio. We also create a functional Silverlight and WPF shell application and see our first glimpse of code sharing with the bootstrapper.

Watch the video on Xaml TV.

Building IG Outlook– Introduction to a Prism App

Brian Lagunas — Tue, 24 Apr 2012 01:41:57 +0000

Often when learning a technology you start by searching the web. You look for videos, blogs, articles, samples, and examples. What you start to realize is that everything you find is very simple “demo” code. That’s code that shows how to implement a simple feature in a non-realistic demo. Then you start looking for “production” code examples. That’s code that represents a more realistic implementation of an application in a production environment. This type of resource is very difficult to find. Why? Mainly, because it is very time consuming to create such examples.

This scenario is no different when trying to learn Prism. You probably first start by reading though the documentation. Next, you head on over to Pluralsight and watch my Introduction to Prism course. Now that you know all the basics you start searching the web for examples for specific scenarios. How do I do “x” and “y”? How do I apply this sample code to my application? Hopefully I can help you answer those questions.

I am starting a new video series called Building IG Outlook. I will take you step-by-step on building a Prism application that mimics Microsoft Outlook. We will be discussing the following key areas in no specific order:

Application architecture/structure
Multi-platform support (WPF and Silverlight)
Commanding
Event aggregation
Custom RegionAdapters
Custom RegionBehaviors
Navigation (OutlookBar, Ribbon, and View interaction)
MVVM (no frameworks needed)

Like most production applications we will have a dependency on a 3rd party toolset. I will be using Infragistics NetAdvantage for WPF and Silverlight. If you don’t own Infragistics you can download the trial or purchase the suite so you can compile and run all the sample code. Otherwise, you will have to modify the code to work with your vendor of choice.

I hope this series will help you gain a better understanding of how you can use the various aspects of Prism to build your applications. This will be a long series and I plan to record at least one a week depending on my traveling schedule. If you have any questions or would like to see something specific be sure to let me know, and I will see if I can squeeze an example in the application.

Create a Custom Prism RegionAdapter

Brian Lagunas — Wed, 18 Apr 2012 19:26:48 +0000

Don’t want to read the article? Watch the video tutorial on Xaml TV.

Prism provides 4 region adapters out of the box for you:

ContentControlRegionAdapter
SelectorRegionAdaptor
ItemsControlRegionAdapter
TabControlRegionAdapter (Silverlight only)

Well, what happens when you want to use a different control as a region host? Simple. You need to write a custom region adapter for it. Is it hard you ask? No it is quite easy. Let’s write one for the StackPanel.

Start by creating a class the derive from and implements the base abstract class RegionAdapterBase.

publicclassStackPanelRegionAdapter : RegionAdapterBase<StackPanel>
 {
public StackPanelRegionAdapter(IRegionBehaviorFactory factory)
         : base(factory)
     {
     }
     protected override void Adapt(IRegion region, StackPanel regionTarget)
     {
         region.Views.CollectionChanged += (s, e) =>
             {
                 if (e.Action == NotifyCollectionChangedAction.Add)
                 {
                     foreach (FrameworkElement element in e.NewItems)
                     {
                         regionTarget.Children.Add(element);
                     }
                 }
                 //implement remove
             };
     }
     protected override IRegion CreateRegion()
     {
         return new AllActiveRegion();
     }
 }

Notice that there are two methods we need to implement. Adapt and CreateRegion. CreateRegion return the type of region we will need. In our case we want to support multiple views so we need to return an instance of an AllActiveRegion. If we only needed support for one view at a time we would return a SingleActiveRegion. The Adapt method is responsible for adapting the region to our control. This is where we will add and remove the views to or host control.

Now we simply have to tell Prism about our new RegionAdapter. We do this in the bootstrapper. Simply override the ConfigureRegionAdapterMappings method as follows:

protected override Microsoft.Practices.Prism.Regions.RegionAdapterMappings ConfigureRegionAdapterMappings()
 {
     RegionAdapterMappings mappings = base.ConfigureRegionAdapterMappings();
     mappings.RegisterMapping(typeof(StackPanel), Container.Resolve<StackPanelRegionAdapter>());
     return mappings;
 }

That’s it. Now you can use a StackPanel as a region host:

<StackPanel Orientation="Horizontal"
             prism:RegionManager.RegionName="MyRegion" />

Download the sample application.

Validate a Property Against a Parent Collection

Brian Lagunas — Thu, 12 Apr 2012 00:34:53 +0000

I was monitoring my Twitter feed, like I always do, and saw a tweet come through asking about how to validate an object’s property against it’s parent ObservableCollection in the Infragistics XamDataGrid. What this person was trying to accomplish was to validate a duplicate item in his data source. They have a POCO object the implements the IDataErrorInfo interface, and an ObservableColletion as the data source. They want to check the ObservableCollection for a pre-existing item whenever a property value in a POCO changes. Obviously this is not a XamDataGrid issue, but rather an object design issue. So I decided to whip up a quick and dirty solution to solve this particular issue.

The approach I am going to take is to simply keep track of the parent collection from within the POCO object itself. I really like interfaces, so I started out by defining a simple interface my POCOs will implement.

public interface IHasParent
 {
     object Parent { get; set; }
 }

Now let’s take a look at the simple POCO I will be using in this example.

publicclassPerson : INotifyPropertyChanged, IDataErrorInfo
 {
privatestring _firstName;
publicstring FirstName
     {
get { return _firstName; }
set
         {
             _firstName = value;
             OnPropertyChanged("FirstName");
         }
     }
     private string _lastName;
     public string LastName
     {
         get { return _lastName; }
         set
         {
             _lastName = value;
             OnPropertyChanged("LastName");
         }
     }
     public event PropertyChangedEventHandler PropertyChanged;
     protected void OnPropertyChanged(string propertyName)
     {
         var handler = PropertyChanged;
         if (handler != null)
             handler(this, new PropertyChangedEventArgs(propertyName));
     }
     public string this[string columnName]
     {
         get
         {
             if (columnName == "FirstName")
             {
                 if (String.IsNullOrWhiteSpace(FirstName))
                     return "First name cannot be empty";
             }
             if (columnName == "LastName")
             {
                 if (String.IsNullOrWhiteSpace(LastName))
                     return "Last name cannot be empty";
             }
             return String.Empty;
         }
     }
     public string Error
     {
         get { return String.Empty; }
     }
 }

Notice that we implement both the INotifyPropertyChanged interfaces as well as the IDataErrorInfo interface. The Next thing we need is a custom ObservableCollection to use as our data source.

public class HasParentObservableCollection : ObservableCollection
 {
protectedoverridevoid InsertItem(int index, T item)
     {
//set the parent object when a new item is added to our collection
if (item != null && item isIHasParent)
             (item asIHasParent).Parent = this;
         base.InsertItem(index, item);
     }
 }

Notice that we are casting our item as the IHasParent interface and setting the Parent property accordingly. The next thing we need to do is have our POCO class implement the IHasPerson interface.

publicclassPerson : INotifyPropertyChanged, IDataErrorInfo, IHasParent
 {
publicobject Parent { get; set; }
     private string _firstName;
     public string FirstName
     {
         get { return _firstName; }
         set
         {
             _firstName = value;
             OnPropertyChanged("FirstName");
         }
     }
     private string _lastName;
     public string LastName
     {
         get { return _lastName; }
         set
         {
             _lastName = value;
             OnPropertyChanged("LastName");
         }
     }
     public event PropertyChangedEventHandler PropertyChanged;
     protected void OnPropertyChanged(string propertyName)
     {
         var handler = PropertyChanged;
         if (handler != null)
             handler(this, new PropertyChangedEventArgs(propertyName));
     }
     public string this[string columnName]
     {
         get
         {
             if (columnName == "FirstName")
             {
                 if (String.IsNullOrWhiteSpace(FirstName))
                     return "First name cannot be empty";
             }
             if (columnName == "LastName")
             {
                 if (String.IsNullOrWhiteSpace(LastName))
                     return "Last name cannot be empty";
                 if (Parent != null && Parent is IList<Person>)
                 {
                     var list = (IList<Person>) Parent;
                     if (list.Count(x => x.LastName == LastName) > 1)
                         return "This last name already exists.  Please use a different last name.";
                 }
             }
             return String.Empty;
         }
     }
     public string Error
     {
         get { return String.Empty; }
     }
 }

Notice how we implemented the check for a duplicate last name. We simply checked to make sure we are dealing with the LastName property. Then we cast the Parent as an IList so that we can perform a simply LINQ query against it. We check the parent collection for any results that match the LastName property. If more than one is returned we have a duplicate.

So let’s test this baby using the XamDataGrid as the original poster was attempting to do. First create our UI.

<igDP:XamDataGrid Name="xamDataGrid1">
     <igDP:XamDataGrid.FieldLayouts>
         <igDP:FieldLayout>
             <igDP:Field Name="FirstName" Label="First Name" />
             <igDP:Field Name="LastName" Label="Last Name" />
         igDP:FieldLayout>
     igDP:XamDataGrid.FieldLayouts>
     <igDP:XamDataGrid.FieldLayoutSettings>
         <igDP:FieldLayoutSettings AddNewRecordLocation="OnTop"
                                   AllowAddNew="True" 
                                   AutoGenerateFields="False" 
                                   SupportDataErrorInfo="RecordsAndCells" 
                                   DataErrorDisplayMode="Highlight" />
     igDP:XamDataGrid.FieldLayoutSettings>
 igDP:XamDataGrid>

Next let’s hook up some data to this bad boy:

public MainWindow()
 {
     InitializeComponent();
     var people = new HasParentObservableCollection<Person>();
     people.Add(new Person(){ FirstName = "Brian", LastName = "Lagunas"});
     xamDataGrid1.DataSource = people;
 }

Now let’s run the app, type a duplicate last name, and see what we get.

Cool. Works as expected. Now there are a number of ways to accomplish this task. There are even frameworks out there that have already solved this problem for you such as CSLA. I hope this simple approach helps you find a solution that works for you.

Download the Source.

Victor Gaudioso–Preserving his Contributions

Brian Lagunas — Fri, 06 Apr 2012 19:55:39 +0000

It was Sunday night. Victor and I were having a video call on Skype finalizing our plans to host his 70+ Silverlight video tutorials on Xaml TV. He was late to our meeting because he said he didn’t feel well. He said that he was recovering from a week long illness, but he quickly assured me he was feeling better. We chatted for awhile and then ended the meeting with some friendly banter like we always have in the past.

Sadly the next day, on the morning of Monday April 2, 2012, Victor Gaudioso passed away. You didn’t have to know Victor long to know that he was passionate about his work and about his community. He always went the extra mile to help his fellow developer. I can write pages about all the good things he has done for his family, friends, and community, but instead I would like encourage you to share your memories of Victor. Think of how he has influenced you in your life.

The Sunday before he passed, Victor gave me 73 of his videos that we would be posting on Xaml TV. That night he posted 10 of his Microsoft Starter Kit videos. Unfortunately he passed before he could finish his effort. With the blessing of his family and the help of his community, we will be posting all 73 of Victor Gaudioso’s Silverlight video tutorials on Xaml TV. We will preserve his work and contributions that he made to the community. They will live on and not disappear with an expiring domain or hosting plan. His legacy will continue to grow as you remember the fond memories you have of him.

If you would like to help by donating to Victor’s memorial fund or to volunteer, please visit the Los Angeles Silverlight User Group site.

Rest in peace my friend.

Awarded – Microsoft Community Contributor Award 2012

Brian Lagunas — Fri, 30 Mar 2012 23:03:17 +0000

Today I received an email informing me that I have been awarded the Microsoft Community Contributor Award. This is the second time I have been awarded this particular award and it feels just as good this time as it did last time. I’m not sure how you go about getting nominated for this award, but apparently I am doing something right.

I would like to thank whoever nominated me for this award and Microsoft for listening to that person. I would most of all like to thank the community. Without the support of the community I would probably still be a cop. Oh, you probably didn’t know that about me.