InterKnowlogy Bloggers

My blog has moved

Brad Cunningham — Wed, 22 Oct 2008 16:11:00 GMT

The new location is http://team.interknowlogy.com/blogs/bradcunningham/

Update your bookmarks and feed readers.

My Blog has Moved

Bill Sheldon — Tue, 07 Oct 2008 05:58:00 GMT

The InterKnowlogy copy of Bill Sheldon's blog has moved. The past posts have been maintained for historical and linking purposes please join us at the new Team InterKnowlogy blog site.

My New Blog address is: http://team.interknowlogy.com/blogs/BillSheldon

If you are not redirected automatically within a few seconds then please click on the link above.

New Blog Site

John Bowen — Wed, 01 Oct 2008 20:03:00 GMT

My blog has moved to team.interknowlogy.com/blogs/johnbowen/

Check it out for recent posts!

My Blog has moved

Scott Larson — Wed, 13 Aug 2008 20:46:00 GMT

http://team.interknowlogy.com/blogs/scottlarson/default.aspx

Blog Has Moved

Adam Calderon — Fri, 08 Aug 2008 04:10:00 GMT

My blog has moved to our new blog server http://team.interknowlogy.com/blogs/adamcalderon/default.aspx so please look there from now on for all of my blog posts.

Book Chapter Excerpt

Adam Calderon — Tue, 29 Jul 2008 00:57:00 GMT

CoDe magazine has an excerpt from Chapter 11 Adding Client Capabilities to Server Controls Using the ASP.NET AJAX Control Toolkit of our book.

Silverlight IE Pains on Windows 2008

Adam Calderon — Sat, 12 Jul 2008 19:20:00 GMT

So I got an environment up an running to do some work with Silverlight Beta 2 and also SP1 for VS 2008. I decided to do all of this on a VMWare image with Windows 2008. Man was this a headache. The extra super stringent security on Windows 2008 made this an absolute pain. Just so others don’t have to go through the same thing I documented what you have to do to get things to work.

1. Turn off IE Enhanced Security (ESC) for Administrators (this assumes your are developing as an admin). This will enable you to open websites without getting asked if it’s ok. To do this go to Administrative Tools and open Server Manager. Click the Configure IE ESC link as shown below in red. This opens the dialog that allows you to turn off ESC for administrators and for users. I just turned it off for administrators on my box since that is what I am developing as.

2. Now that you have that done run you application in debug mode (which won’t show the Silverlight control yet) and add “http://localhost” to your trusted sites. I did this so that all of the other websites I hit will still have the standard “bullet proof” security. To get to the security dialog shown double click the Internet icon. Then select the trusted sites icon and finally add “http://localhost” to the trusted sites.

Once I did this I was finally able to rock and roll with Silverlight. If I remember right you will get a little warning just below the toolbar that ESC is disabled. If you select it you can turn this warning off.

I hope this helps.

Book Sales on Amazon

Adam Calderon — Wed, 09 Jul 2008 22:18:00 GMT

The book Joel Rumerman and I wrote

Advanced ASP.NET AJAX Server Controls For .NET Framework 3.5

seems to be doing quite well wth only 4 days being on sale. Joel sent me an email earlier today with links to the latest statistics. I was quite suprised. Thanks to everyone!

Top AJAX Best Sellers

Top ASP.NET Best Sellers

So Cal Code Camp Slides and Code

Adam Calderon — Tue, 01 Jul 2008 00:39:00 GMT

Thanks to everyone who attended my sessions at code camp last weekend. Once again Woody and company did a great job.

Overview of the Composite Application Guidance for WPF

Power Point Slide

Composite Application Guidance for WPF

Building Control Extenders using the Ajax Control Toolkit

Power Point Slide
AJAX Version of Custom Control
Toolkit Version of Custom Control

San Diego Code Camp 2008 Resources

John Bowen — Sun, 29 Jun 2008 18:45:00 GMT

Thanks to everyone who attended my sessions!

Application Layout in XAML:

Handout | Code

Also look at this previous post for more on sharing sizing between Grids.

We didn't get to cover the FrameworkElement layout properties so check out the second application in the sample code to get a feel for how they work.

Building Controls for WPF:

Slides | Code

You can also download the full class library reference poster here.

WPF Data Binding:

Slides | Code

Also look at my other blog posts for more examples and explanations.

Creating Responsive Desktop Apps:

Code

Speaking at San Diego Code Camp

Adam Calderon — Tue, 24 Jun 2008 00:09:00 GMT

I will be presenting on two very different topics this year at the SoCal Code Camp in San Diego that reflect much of what I have been doing over the last 6 months or so. My first session Building Control Extenders using the Ajax Control Toolkit stems from the work I have been doing on my book and will be a fairly comprehensive look at creating controls using the Ajax Control Toolkit. My second session Overview of the Composite Application Guidance for WPF covers the work I have been doing with the Patterns and Practices Group on building composite applications in WPF.

ASP.NET AJAX Controls Book Done!

Adam Calderon — Mon, 23 Jun 2008 23:54:00 GMT

I thought this day would never come. Joel Rumerman and I have finally completed our book Advanced ASP.NET AJAX Server Controls For .NET Framework 3.5 that hits the book shelves the first part of next month. This has been a exciting experience for the both of us and we hope you enjoy reading it as much as we did writing it.

Getting to Know Your Resource Tree

John Bowen — Fri, 30 May 2008 15:48:00 GMT

The XAML Resources in WPF and Silverlight can be a powerful tool but are often misunderstood and can cause lots of problems if not managed properly. The first point of confusion with Resources is that the term "resources" already has so many other meanings, including:

Project items compiled as Resource
Linked and embedded resources (resx files)
Hardware resources, and specifically graphics in WPF

So first to clarify what we're talking about here: XAML Resources are any .NET object that is declared in a ResourceDictionary. This is generally done in XAML but objects can also be added to a ResourceDictionary in code. ResourceDictionaries can be found on any FrameworkElement derived object (and also on Application) in the form of the Resources DependencyProperty.

Resources are typically accessed with the StaticResource or DynamicResource MarkupExtensions in XAML. I won't get too much into the details of these except for a few key points. DynamicResource will update if the referenced Resource changes which can be useful but generally just causes extra overhead that can create performance and memory problems. StaticResource requires that the referenced Resource exist in the resource tree at load time. More on that later. StaticResource can cause compile-time errors for missing Resources while Dynamic will just use a default value until the Resource becomes available. StaticResource should always be your default choice unless you have a specific need for the behavior of Dynamic (Blend always uses Dynamic so be prepared to make lots of switches in what it generates).

Next, what is the Resource tree? WPF UI is inherently hierarchical. Each UI is made of a logical tree that is then used to render a visual tree. This means that each element in your UI has a clear parent structure with a single path up the hierarchy to the root Window element (or NavigationWindow, Page…) and then an Application object at the very top. The Resources property of each parent element is made available to every child element so that elements can access any Resource that is declared anywhere in its parent hierarchy. This makes it possible to share Resources between elements in specific areas while not requiring the memory and performance penalty of declaring them application-wide.

To get the maximum reuse benefits while not overly impacting performance, resources need to be carefully managed and organized. In addition to resources from the parent hierarchy, the MergedDictionary feature allows you to extract any Resource to a separate ResourceDictionary file that can then be imported to specific elements that need it. This can allow you to share XAML between elements at a lower level but it can also cause situations where multiple instances of a ResourceDictionary are created by elements under a common parent, consuming more memory and initialization time than if the ResourceDictionary were merged once into the parent.

<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="/Resources/Brushes.xaml"/>
<ResourceDictionary Source="/MyCompany.MyApplication;component/Resources/Styles.xaml"/>
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>

Once you've created and structured your Resources you can get to the important part: actually using them. The most compelling reason to use a Resource is reuse but even in cases where a resource is used once they can still provide value by simplifying your XAML's structure. Declaring things like templates and brushes as resources rather than inline can turn a deep hierarchy into a single line of XAML and can also introduce a descriptive name for a sub-section of XAML, making it more readable (it's no coincidence that this sounds like refactoring methods). There are also cases (ItemsControl ItemTemplates in particular) where declaring things in-line can actually break them but simply moving them to resources will fix the problem.

The primary method of accessing a Resource is by Key. Keys are specified by the x:Key attribute on the element that is declared as a Resource. Keys are a required attribute for most types of resources and will cause compiler errors if missing. Static and DynamicResource references rely on Keys to find resources.

The other method of accessing resources instead relies on a type that is associated with a Style (TargetType) or DataTemplate (DataType). When no x:Key is specified on one of these types they are assigned an implicit key that will cause them to be applied to any object of the specified type in whose Resource tree they exist. This can be very powerful but also cause problems that are very hard to locate. For example, if someone creates a Style with TargetType of Button that sets Width to 100 and puts it in App.xaml, suddenly all Buttons application-wide will be fixed at 100 unless they have some other explicit setting for Width. Now someone trying to figure out why their Button text is getting cropped needs to figure out where that fixed width is coming from but gets no clues from the settings on the Button itself. It's pretty easy to go check Window.Resources or App.xaml but now imagine the Style is located in one of 10 ResourceDictionary files that are merged into App.xaml. Implicit key resources should be used very carefully and be declared only in well known locations to avoid this sort of problem.

The first thing you should do when tracking down an issue with a named (explicit Key) Resource is to make sure the reference is using StaticResource rather than DynamicResource. This can often turn a mysterious run-time behavior into a compiler error, or in some cases a run-time exception, telling you immediately that the Resource doesn't exist in the current Resource tree. If this happens it can most often be fixed simply by merging in a ResourceDictionary or just moving the Resource declaration itself.

If you find yourself getting into problems with name collisions (i.e. 10 different people created "ButtonStyle1" in Blend and spread them all over the app) it can help to actually diagram out the resource tree for the element in question (on paper or in your head) to find out which one is really being used. It starts at the top with App.xaml, then the Window or Page, then local parent controls' resources, then the element itself. Inside each of these sections include any MergedDictionaries and anything in turn merged into those ResourceDictionaries. Once you can see the whole tree, whatever is declared last takes precedence: this goes for inside files as well as down the tree.

So if ButtonStyle1 is declared in Common.xaml (A) that is the first file merged into App.xaml but also as the last local Resource in App.xaml (B) and again in CustomStyles.xaml (C) merged into Window1.xaml then A and B are going to be ignored and C will be used. If you then rename C to ButtonStyle2, A will be ignored and B will be used. Using Visual Studio's Find in Files is usually the quickest way to find name collisions or just track down lost resources (use x:Key="MyResourceKey" to find declarations).

What I am reading

Brad Cunningham — Fri, 23 May 2008 17:54:00 GMT

Here is the current line up:

Born on A Blue Day : Inside the Extraordinary Mind of an Autistic Savant -I am only a 1/4 of the way into to this book but I am fascinated by it. I actually find myself comparing some of the author's autistic traits to my own behaviors and trying to figure out why I think the way I do. It is a very interesting exploration in the way the mind works and how people think and react. Very Highly recommended.

Designing Interactions - This is a monster of a read. 700 plus pages. It has been a long but interesting read. I am just about finished with it and I have really enjoyed the read. It can be read in chunks which is nice due to it's size. Short interviews with influential designers. This gives a nice way to see what a designer thinks about when creating a new product or interaction. It has given me good ideas to consider when building user interfaces.

Universal Principles of Design - Short sweet and to the point. I really like this book as a reference guide. Some of the principles are obvious but others aren't quite so easy to see. The book takes a design principle and devotes 2 pages to it. A short summary of the principle, a reason why you would use the principle, and a real world example of where to apply it. Then on the other page a visual representation of the principle and an explanation of why the visual represents the principle. This is a highly recommend reference book. Anyone designing user interfaces or user interactions should read this IMO.

Software Creativity 2.0 - This has a been a slow read for me. I haven't read much of it so I don't have much to say on it yet. I have liked what I read but it obviously wasn't as engaging as the other books because it is the last one of the set I pickup to read. Once I catch up on it more I will update my review.

I had this idea for a book review "corner" the other day so this is my first stab at it. I will be adding a new post every once in a while when I have a new set of books to read. Tell me what you think.

Silverlight 2 and DHTML

John Bowen — Fri, 23 May 2008 02:15:00 GMT

The purpose of Silverlight 2 in demo applications has so far primarily been to provide enhanced graphics to self contained applications. While the graphics capabilities are attention-grabbing, some of the other powerful features that are available seem to get overlooked. For example, Silverlight has the ability to interact with the HTML DOM and Javascript which allows you to use it to enhance existing web applications. To try out some of these features, I took a basic data entry form (in this case just plain HTML that's not actually hooked up to anything on the server) and added a toolbar that gives the user some editing features to help fill out the form.

The toolbar provides

Unlimited Undo/Redo
Clearing of all form data
Saving multiple sets of the entire contents of the form locally on the client
Reloading of any set of data that is saved on the client

The only javascript that is required for this functionality is some boilerplate to connect to the Silverlight C# code.

For the toolbar I used the DHTML-Silverlight connections in both directions. The DataCache class in the application is decorated with the ScriptableType attribute and has methods decorated with the ScriptableMember attribute. This is the first step in making code available to javascript. The next is to call HtmlPage.RegisterScriptableObject("objectName", theScriptableObjectInstance) from the Silverlight UserControl's code-behind. A good place to do this is in a handler for the Loaded event. These methods are now available to call from javascript by getting a reference to the Silverlight application like this:

var agEControl = document.getElementById("SilverlightElementId");
var content = agEControl.content;
var scriptableObject = content.objectName;

Here objectName is the string used above to register the object and "SilverlightElementId" is the HTML id of your Silverlight control ("Xaml1" by default in a VS generated project). Once you have scriptableObject you can just call any method on it just as you would in C#.

In the scriptable methods I use the connection in the other direction to go back to the calling HTML and retrieve values from the page's controls. This basically takes one step to get the current value of an element:

HtmlElement element = HtmlPage.Document.GetElementById("controlId");
string value = element.GetAttribute("value");

It looks just like what you would do in javascript with the exception of the HtmlElement and HtmlPage classes that provide the access to the DOM. HtmlElement allows you to do all sorts of manipulation including attaching event handlers and playing with the structure of elements on the page.

Another interesting thing I ran into when I decided to blog this is the simplicity of deployment with the current structure of a Silverlight application. If you're working in Visual Studio your application is compiled into a single file with a .xap extension. You probably also have a web project of some type to host the application. When running your application the built-in web server is spun up to serve up the page to the browser.

If you happen to be using a plain HTML host and not using server-side code you can also open the .htm directly in your browser as a file. This gave me the idea to try xcopy deploying my app to my blog's downloads folder, which is just a basic file share. Starting out with a minimum set of files I copied the .htm and .js files that make up my page (no generated files) and the .xap file in ClientBin. This didn't work at first due I think to extension filtering that disallowed the browser from pulling down the xap file. Fortunately zip files are allowed to download and (big secret) xap files are actually just zip files containing your assemblies and a manifest. If you rename your xap to zip you can just open it up and see your dlls inside. Once I did this and adjusted the reference in the HTML accordingly the entire page with toolbar loaded in my browser over http from a simple file share! Compare this to what you need to stand up a simple AJAX application and you can see the advantage.

Download the sample code HERE. Try out the functional page HERE. You'll need the Silverlight 2 Beta 1 runtime (it should ask to install itself). Sets of data are saved by Last Name and ID so you may notice the Save button being enabled/disabled as you change fields. The Load and Delete buttons will become enabled after you save a form. The set selector is kind of clunky because there's no ComboBox control yet in Beta 1 so I just squeezed in a small ListBox instead.

**UPDATE** - Silverlight 2 Beta 2 was just released and I've updated the functional version and put it alongside the original HERE. **

Photo Stackr (Silverlight goodness)

Brad Cunningham — Tue, 13 May 2008 03:34:00 GMT

So with the release of the Silverlight 2 beta bits I finally decided to see what all the talk was about. I suppose I would consider myself an ASP.NET guy by trade. Although I have been building WPF applications for the past year or so and generally I am enjoying NOT building web applications. However, I can't hide the fact that I spent the last seven odd years building mostly ASP.NET applications.

So when I first heard of Silverlight and it in the same vain as flash I was skeptical to say the least. I would say I was somewhere closer to outright disgust. I spend so much time focusing on a lightweight client that offloads it's work to a controlled and decidedly beefier web server. There is no way I want to push a plug-in to a client and THEN pay the price of shoving all the assest's down the pipe and hoping their machine can handle it. but alas, I will give it a fair shake. I do like WPF after all.

So with that said I wanted to see what the development experience is like and what kind of things I could do with the WPF skills I had amassed.

Cue PhotoStackr (note the gratuitous web 2.0 spelling)

One of the things I really like with WPF, and the main thing that makes WPF so compelling to me, is that it gives you the ability to focus on user interaction and user experience and less on implementation details. This allows you to build incredible applications with minimal effort (compared to building the equivalent in WinForms). So before I show the gory details of my Silverlight application I will say that I was trying to build an application that models a known collection of data (in this case a set of photos from the flickr website) in a new / interesting way.

To that end Silverlight, really XAML in general, gives you the tools to visual your data quickly. For the photo stackr application I wanted to give a interesting way to view and organize multiple search results on a single page.

What I like about Silverlight is it changes the development paradigm on the web. With the plug-in architecture you have a stateful environment to develop to. You can write fully managed code to do things previously done on the client in JavaScript (like drag and drop)

The basic design idea of PhotoStackr is to have a "Photo Table", which is the main canvas of the application. On the table you will have multiple "Photo Stacks." These stacks are the result of searching the Flickr web service for a specified tag. The application will give you the ability to "un-stack" your search results so you can view all results at once. You can then zoom in on any one of the results to view the photo in more detail.

There is a link at the bottom of this post where you can get the entire project to view the code in more detail so I will just focus on the main points.

The main canvas is pretty simple I put a text block to show the title in the top left and then two custom controls, one for the search box and one for the about window. I am toggling the visibility of these controls on the button click event of the respective buttons. This brings me to my first annoyance with Silverlight. The current build doesn't support triggers. Triggers are fundamental (IMHO) to WPF. Since I am approaching Silverlight with a WPF background the lack of triggers is painfully obvious. However, Sivlerlight is still in beta so some features just aren't there. I don't know if there is a plan to support triggers in Silverlight. Personally, I think they have to be supported if they want Silverlight to follow the "Do it in markup, not in code" mantra.

<Canvas Background="Black" x:Name="Table" Loaded="Table_Loaded" SizeChanged="Table_SizeChanged" >
    <TextBlock x:Name="Title" Text="Photo Stackr" FontSize="16" Foreground="#FF686868"  Canvas.Left="100" Canvas.Top="50" Opacity=".4"/>
    <Button x:Name="AddButton" Click="AddButton_Click" Template="{StaticResource AddStackButtonTemplate}"  Canvas.Left="100" Canvas.Top="650"/>
    <Button x:Name="AboutButton" Click="AboutButton_Click" Template="{StaticResource AboutButtonTemplate}"  Canvas.Left="125" Canvas.Top="650"/>
    <local:MessageControl x:Name="About" Canvas.Left="250" Visibility="Collapsed"/>
    <local:SearchPopup x:Name="SearchPopup" Canvas.Left="100" Visibility="Collapsed" />
</Canvas>

I like the control architecture that Silverlight drives you towards. I have built the SearchPopup and the MessageControl as separate UserControls in it's own XAML file. This is nothing revolutionary, you could do this in ASP.NET with custom controls, but with the stateful environment it makes managing multiple controls much easier. The controls are more aware of the application domain data and don't need state management code to work with the rest of the application. This gives you a development experience much closer to desktop development. This is a big plus to me.

When the user enters a search tag and clicks the search button I create a PolaroidStack control. This control is a canvas that has the logic to manage multiple Polaroid controls and perform the stack and un-stack behaviors. This brings me to the first programming feature that I really like about Silverlight. On the PolaroidStack control I added a static dependency property called SelectedTag

public static readonly DependencyProperty SelectedTagProperty = DependencyProperty.Register("SelectedTag", typeof(string), typeof(UserControl),OnSelectedTagChanged);

Dependency properties come from WPF and are a key component to control development. Since I have a dependency property on the PolaroidStack all I have to do in code is set the property and the change handler code in the stack control will take care of the rest.

PolaroidStack s = new PolaroidStack();

s.SetValue(PolaroidStack.SelectedTagProperty, SearchPhrase.Text);

Change handler for the PolaroidStack.SelectedTag property:

private static void OnSelectedTagChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    //Reload the Polaroid Stack
    ((PolaroidStack)d).LoadStack(e.NewValue.ToString());
}

The nice thing about the DependencyProperty is that it can also be set in markup. If I created the PolaroidStack in markup I could set the SelectedTag property in the markup as well which would cause the stack load itself when the control is loaded (and this is exactly what I did to test the LoadStack functionality)

In the LoadStack method I make a call the the Flickr Rest based Webservice passing the tag that the user passed in as the search term. The only thing to note here is that I am processing the result of the web service using LinqToXml which makes processing the XML document leaps and bounds easier then before.

XDocument doc = XDocument.Parse(e.Result);
var photos = from results in doc.Descendants("photo")
select new
{
    id = results.Attribute("id").Value.ToString(),
    farm = results.Attribute("farm").Value.ToString(),
    server = results.Attribute("server").Value.ToString(),
    secret = results.Attribute("secret").Value.ToString()
};

This snippet of code basically creates a dynamic collection and I am defining the members of the objects in the collection by selecting the attributes from the XML document. So I have a collection of Photos, the items in the collection are of type Photo. The Photo type (which is a dynamic type created by LINQ when I call select new) has string members id,farm,server, and secret. And this ends my LINQToXML lesson :), LinqToXML is really cool, for more info check here

After processing the web service response into a collection of Photo objects, I iterate the collection and build a new Polaroid control. The Polaroid control in a custom user control composed of an Image control, a button to control the zoom, and a border to give the look and feel of a Polaroid.

<Canvas Height="110" Width="91" Background="#FFFFFFFF" x:Name="PolariodCanvas">
    <Button x:Name="Zoomer" Canvas.Left="70" Canvas.Top="95.666" Click="Button_Click" />
    <Image x:Name="imageControl"  Height="75" Width="75" Stretch="Fill" Canvas.Top="8" Canvas.Left="8"/>
    <Border Height="75.75" Width="76.006" Canvas.Left="8" Canvas.Top="8" BorderBrush="#FF000000" BorderThickness="1,1,1,1"/>
</Canvas>

I am also creating a rotate transform in code to randomly set the angle of the Polaroid control to give it the messy look when stacked on top of each other. Again, the control development approach works nicely here because I can keep the logic to zoom the Polaroid in the Polaroid control.

The last thing to point out here is how I implemented drag and drop logic. I wanted to give the ability to drag and drop the PolaroidStack control so I hooked into the mouse button events of the Polaroid control. The actual drag and drop code is nothing new but the ability to do it all in managed code is the big difference. Previously this type of thing would have to be done in javascript. With Silverlight you can do it all in managed C# code

private void PolariodStack_MouseMove(object sender, MouseEventArgs e)
{
    // only execute this code when the user has started dragging
    if (startDrag)
    {
        Point movePos = e.GetPosition(null);
        double currentX = double.Parse(this.GetValue(Canvas.LeftProperty).ToString()) + (movePos.X - beginPos.X);
        double currentY = double.Parse(this.GetValue(Canvas.TopProperty).ToString()) + (movePos.Y - beginPos.Y)
        ...

        this.SetValue(Canvas.LeftProperty, currentX);
        this.SetValue(Canvas.TopProperty, currentY);
        beginPos = movePos;
    }
}

You can get the code for this project here. NOTE: you will have to sign up for a Flickr account and get your own API key to get this to work. I purposely forced a compile error to show you were to enter your API key.

So in the end, I like what Silverlight offers so far but it isn't all the way there yet. The lack of support for DataTemplates and Triggers are glaring issues. I am also still not sold on the plug-in approach. Solving the satefulness issue is huge and I think that is the overriding win with the plug-in approach but I am still concerned with pushing that much on to the client machine. The temptation to abuse the technology is high and pushing really intensive applications down the wire to the client can lead to bloated applications and serious support issues.

To see the application in action visit our Silverlight page silverlight.interknowlogy.com

Tell me what you think

As I wrote this I thought of clever way to use this same data visualization for another purpose....... So stay tuned for an update.

Debugging Blend Errors

John Bowen — Sun, 11 May 2008 21:13:00 GMT

Blend has been getting more stable with frequent releases including SP1, Blend 2 etc but it still can't render everything, even from an application that runs flawlessly at runtime. There are lots of things that can break the Blend renderer but tracking down exactly what broke your window/page/control can be difficult and time consuming. In some cases the location can be found by taking advantage of how Blend hosts applications. When Blend renders XAML it's running the code just like at runtime and the code can be debugged in the same way. In cases where non-XAML Exceptions are breaking the renderer Visual Studio can attach to Blend itself and break to the exact location that's causing the problem.

The primary reason errors occur in Blend that don't show up at runtime is that Blend acts as a host for the application. This causes things that are evaluated relative to the running application like config files and certain types of relative resource references to look in the wrong place. The pack:application syntax in particular causes invalid references. The ResourceDictionary hierarchy is also different when running in Blend. In versions prior to Blend 2 Feb Beta App.xaml resources aren't automatically resolved using StaticResource the way they are at compile time. Even the newest versions run into problems resolving references inside things like UserControls when rendered as part of a Window. XAML errors generally show up in the Blend errors window and can be linked to a specific line (with varying accuracy depending on the version) while errors deeper in code need Visual Studio debugging.

To debug an application inside Blend open the project in both Visual Studio and Blend at the same time. Before opening the broken component in Blend attach Visual Studio to the process with Debug->Attach To Process and select Blend.exe from the list. To make sure the Exception isn't just swallowed by Blend set Visual Studio to break on all CLR Exceptions by selecting Thrown in the Debug->Exceptions for Common Language Runtime Exceptions.

Once you've tracked down an Exception in code you have a few choices. You can fix the error if it's something that you determine shouldn't be happening. If it's due solely to the peculiarities of Blend and you want to leave the code as is, except when running in Blend, WPF provides a way to check whether Blend (or some other designer) is hosting the code. DesignerProperties.IsInDesignMode is set to True by Blend and can be accessed from anywhere in a WPF application with

(bool)DependencyPropertyDescriptor.FromProperty(DesignerProperties.IsInDesignModeProperty, typeof(DependencyObject)).Metadata.DefaultValue

Any code that breaks Blend can just be executed conditionally when this value is false.

One of the key advantages of using WPF is the promise of direct collaboration between designer and developer. Fixing Blend rendering errors will enable design and development of your application simultaneously without worrying about keeping application code and static designs from separate teams in sync.

WPFPerf and software rendering

Brad Cunningham — Fri, 09 May 2008 21:37:00 GMT

The WPFPerf tool that is included with the windows SDK can be a very useful tool in finding areas of your application that is being rendered using the WPF software pipeline.

Recently I was profiling an application looking for areas that could be improved, performance wise, at the WPF level. One thing I thought to do was use the WPFPerf tool and look for elements that were being software rendered and see if I could modify them to use the hardware pipeline and still get desired effect. See here for more information on the two pipelines.

To find the areas that are using software rendering the Perfortator plug-in gives a nice, albeit cheesy, visual cue. By enabling "Draw software rendering with purple tint"

Come on guys, really? Is that really what the option is called? I wonder what the property is called in code ShowSoftwareRenderingUsingPurpleShadeBecauseMyKidWasWatchingBarneyWhileIWasWritingThisFuction.

But I digress, The functionality works well.

So a discovery I made was that WPF is able to use the hardware rendering pipeline to render bitmap drop shadows (which is typically documented as being software rendered) but only if the drop shadow is rectangular. In my case I had a button template that was using a border element ad applying a drop shadow to the border element to give the drop shadow effect on the button

<Style x:Key="SoftwareRenderTemplate">
            <Setter Property="Control.Template">
                <Setter.Value>
                    <ControlTemplate TargetType="{x:Type Button}">
                        <Grid Height="22">
                            <Border Background="Gray" Height="22" Margin="0,0,0,0">
                                <Border.BitmapEffect>
                                    <DropShadowBitmapEffect Opacity="0.5" ShadowDepth="3" Softness="0.285"/>
                                </Border.BitmapEffect>
                                <ContentPresenter x:Name="ButtonContent" Width="Auto" Content="{TemplateBinding Content}" OpacityMask="{TemplateBinding Foreground}" HorizontalAlignment="Center" VerticalAlignment="Center" Height="Auto" Margin="10,0,10,0"/>
                            </Border>
                        </Grid>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>

When I built the template this way and ran Perforator it showed me that the button was using software rendering. Which is what I would have expected. However, if I modify the template to use a rectangle shape instead of a border element. Then apply the drop shadow effect to the the rectangle I noticed that Perforator no longer indicated (which means to remove the lovely purple tint) that the button was using software rendering. This is not what I would have expected.

<Style x:Key="HardwareRenderTemplate">
            <Setter Property="Control.Template">
                <Setter.Value>
                    <ControlTemplate TargetType="{x:Type Button}">
                        <Grid Height="22">
                            <Rectangle Fill="Gray" Height="22" Margin="0,0,0,0" Stroke="{x:Null}">
                                <Rectangle.BitmapEffect>
                                    <DropShadowBitmapEffect Opacity="0.5" ShadowDepth="3" Softness="0.285"/>
                                </Rectangle.BitmapEffect>
                            </Rectangle>
                            <ContentPresenter x:Name="ButtonContent" Width="Auto" Content="{TemplateBinding Content}" OpacityMask="{TemplateBinding Foreground}" HorizontalAlignment="Center" VerticalAlignment="Center" Height="Auto" Margin="10,0,10,0"/>
                        </Grid>
                    </ControlTemplate>
                </Setter.Value>
            </Setter>
        </Style>

I searched around a bit to try and determine what was going on here and the information is sparse (hence my blog entry) But I did find one source that hints to the fact that the underlying implementation of the drop shadow effect is optimized when sticking to rectangular shapes.

So there it is. If you really like drop shadows but don't want to get hammered by the performance this is one way to do it.

Generic or Specific

Bill Sheldon — Sat, 03 May 2008 06:46:00 GMT

This is one of those musing posts and comes from one of the challenges I have when teaching a feature that Microsoft chose to call 'Generics'. I think this name was picked by someone, who while reasonably familiar with English wasn't a native speaker of the English language. Thus they found a definition and thought it applied - allow me to elaborate.

What is a .NET Generic - well in short - under the original implementation of .NET collection classes contained a set of other objects. However, these classes didn't know specifically what kind of object they contained. Instead a given collection might contain more then one different type of object, for example numbers stored in a collection with strings and image objects. It wasn't possible to say thata given collection would contain only a specific type of class.

With the introduction of 'Generics' it was possible to indicate that a given collection would only contain a specific type of object. That's right the feature Generics describes a set of rules and syntax for ensuring a collection is of a specific type. Now the challenge comes from how the definition of generic is phrased in some dictionaries: "Relating to or descriptive of an entire group or class"

Notice that the preceding definition basically associates the definition of a generic with a class. Thus if you were searching the dictionary for a word that described a class - well there you have it. Unfortunately this use of the word "class" doesn't relate to the use of the word "class" in object oriented programming. In this use a class is more of a category of like items - not the definition of a single item.

Webster's Revised Unabridged Dictionary - Cite This Source - Share This

(http://dictionary.reference.com/help/web1913.html)

Generic

Ge*ner"ic\, Generical \Ge*ner"ic*al\, a. [L. genus, generis, race, kind: cf. F. g['e]n['e]rique. See Gender.]

1. (Biol.) Pertaining to a genus or kind; relating to a genus, as distinct from a species, or from another genus; as, a generic description; a generic difference; a generic name.

2. Very comprehensive; pertaining or appropriate to large classes or their characteristics; -- opposed to specific.

That's right the word I most frequently use to describe the feature Generic is the one which defines the opposite of the definition of the word generic....

I don't think Microsoft can really do much about this, it's just one of those things that make you wonder...

ROSARIO (cont'd) - Manual Test Runner

Randy Bergeron — Thu, 24 Apr 2008 18:22:00 GMT

In last weeks post I talked about the new tool "Camano" to define your test cases and create test suites. After we have our tests loaded into team system , we can now start to actually execute the test. The first thing we will do is open the new tool called the Manual Test Run tool:

We now can start recording the actual test, in this case we will be testing the Beer House Web site. As we can see we have three recording settings

Action - Records an action log of each action performed on the application under test

Background - Records actions which can later be played back in the application under test

Video - Records video in the WMV format

We will now run the test. The last step will fail. From here we can capture the screen to show exactly what we see when we executed the test step.

We then create a new bug. We see all the data collected already being pre-populated and placed in the bug report and loaded into Team System.

Now after the bug is fixed we can re-play the recording to re-test the application. We go back in the Test case and select the steps then select play. The steps that we used to test the web page are now re-executed automatically which is fantastic. Now the last really cool thing is we can go to VS 2008, Create a New Test choose a Coded UI Test. Now we create a BrowserWindow object and use the recording as the source. Then we right click and select Generate code from Existing recording. Now the code is generated and placed right into the test procedure. We now have an automated test that will execute the recording that we have made earlier.

Microsoft has made some great strides in assisting us on being able to execute our manual tests being able to convert these test to automated test. These tools will help us being able to create and execute these test in a timely way. I look forward to using these tools when ROSARIO is released. The test tools will allow us to manage and execute our tests in a much more efficient and effective way to ensure quality on our projects.

The Unofficial, still Plausably Deniable, Future Home of the "San Diego" Chargers

Bill Sheldon — Mon, 21 Apr 2008 21:05:00 GMT

So officially it's not yet an option, after all the San Diego Chargers are still working with the city (suburb) of Chula Vista to keep the Chargers football team in San Diego County. And of course the Chargers spokesman has officially denied it... http://www.sportsbusinessdaily.com/index.cfm?fuseaction=sbd.preview&articleID=120164 (account needed for full article - but the headline says it all)

However, if Chula Vista 'stumbles', one environmental suit or negative ruling in the next two years, and lets face it the Chargers are moving to Los Angeles and this brand new, very fancy stadium. Construction should be ready to begin in 4Q of this year and my guess is if it does and if the inevitable challenges to the Chula Vista site arise - "Los Angeles 'super' Chargers" will be the new theme song...

http://www.losangelesfootballstadium.com/

I easily could be wrong but let's face it if there wasn't already a sequence of events (or perhaps more than one) that would result in a team moving here, this idea would be crazy. Fact is, IMHO that's what you would have to be to think that this isn't the future home of the Chargers. BTW, check out the background color scheme - which NFL team has uniforms in Baby Blue? Heck another story even has Roski on the record as stating that the team moving could play in other LA venues for 2009, 2010 till this place opens in 2011.

The new phone books are here, the new phone books are here...

Bill Sheldon — Fri, 18 Apr 2008 00:27:00 GMT

This is one of those 'hey look at me' posts that always make me feel like... well if you recognize the title of the movie that the quote which is the title of this movie comes from - that pretty much sums it up.

Anyway a few 'ads'.

First off, I have a new article available over at SQL Magazine. It's a very introductory article to LINQ for SQL so if you are looking for a good starting point for just getting started with LINQ, here's a short article that might be of assistance: http://www.sqlmag.com/Article/ArticleID/98205/sql_server_98205.html

The second item fits the post a bit better. Back in the first Quarter I signed on to do another book - yes my wife is ready to kill me - which since she is pregnant get's the pregnancy multiplier (we're currently around 7 or 8 so the danger level is getting pretty high). At any rate if you are interested it's still way out in the future - like October 2008 - if "we" (me) make "our" (my) final due date - here is the page: http://www.amazon.com/o/ASIN/0470377313/105-1544171-6096430

As you can note on that page this next book is an Office Business Applications book. Of note, it will have both C# and VB samples (ok VB sample - but more on that later) and covers using WPF with Outlook Form Regions and Excel not to mention server side document generation. That's the good news - the bad news - well I'm late on my chapters - of course that's pretty typical for me - the question is can I catch up in the next few weeks - especially given the increasing pregnancy multiplier...

Finally, I thought I should mention that my last book is finally getting read to be available. At 1600 pages it pretty much is a phone book, and it should ship for the first week of May which apparently is fast approaching: http://www.amazon.com/Professional-Visual-Basic-2008-Evjen/dp/0470191368/ref=sr_1_1

"ROSARIO" TAP using "Camano" Tool

Randy Bergeron — Thu, 17 Apr 2008 19:51:00 GMT

I have been participating in the Microsoft TAP program using the new Team Foundation Server codename "ROSARIO". I have been very impressed with this version of the TFS server. I will be making several posts on the features since the functionality in ROSARIO is more than one post can accommodate.

Let me add the disclaimer that these are potential features that will be part of the new version of TFS wether these features will be part of the official release (I sure hope they are) has yet been determined. So today I'm going to concentrate on a new tool being introduced codename Camano.

Microsoft is creating tools to assist in manual testing. This is a great area that needs assitance and Camano is a great step in this direction. Currently here at InterKnowlogy all our test cases are written in word documents with only outbound references inside the document to link with the project requirements. Needless to say this creates issues when trying to run reports to confirm coverage of requirements.

Camano is a new tool that allows a tester to create and organize the test cases for a given project and link the cases back to to defined requirements that are stored in TFS.

Above is a screen snapshot of creating a test case in Camano. As we can see each of the steps of the test case are stored inside TFS as Test Case work item. From here we will add the test case to a Test Suite, and the we will create the Test Plan which will track the actually testing of the features. As we can see Camano allows us to consolidate our test cases and test planning tasks into a single utility, they are not buried inside of a word document, which will give us the ability to easily generate coverage reports. Now from here we will be able to use the Microsoft Test Runner tool to actually run the test suite. Which will be the topic of the next post.

WPF Now? Why should you?

Bill Sheldon — Thu, 20 Mar 2008 07:39:00 GMT

I'm in week 5 of teaching my Visual Basic I programming class at the University of California San Diego Extension. The week 5 class is going to focus in on WPF and helping students get a better feel for working with this new user interface paradigm, and it's custom 'script' language XAML. :-)

WPF comes with several new concepts and I think that for developers who are just getting started and or coming from a solid web application background many of these concepts feel very natural. On the other hand there are a host of developers out there who are coming from a Forms/Win32 based background. For these developers, even though most people think of WPF as a Forms replacement the new declarative model and in particular the new buzzwords leave them overwhelmed.

After all most people that show of WPF applications are busy making sure they've included as many graphical elements as they possibly can, for example one famous paraphrase of Tim Huckaby is "It's just not a WPF application without some form of gratouitous animation."

However, from my standpoint, in the way I approach introducing developers is to explain some elements on XAML and then focus on the similarities between WPF and Windows Forms development. For example in Chapter 17 of the soon to be released Professional Visual Basic 2008 which will ship this May, my approach is to literally have you start by designing what could easily be a Windows Forms application using WPF. Over the course of the chapter the application is migrated with the title bar being hidden, buttons being customized, etc as you introduce more and more concepts that are native to WPF.

In the beginning you start by working with the Visual Studio 2008 editor. This editor is well known to be VERY limited in comparison to Blend. However, if you are moving from Windows Forms to WPF then you'll feel much more comfortable in this environment. Start here and work towards the same type of applications, then introduce Blend. Blend not only provides several key examples that you can use to get a better feel for the WPF paradigm, but allows you to start to take that item which you feel comfortable with and migrate it to a WPF paradigm with routed events, complex styling and other elements that are much more in keeping with the declarative programming model. Of course this book isn't about WPF so I don't go deep on things like styling and databinding and other topics, but it will help you start so that those topics combined with everything else in WPF aren't quite so overwhelming.

Keep in mind that while there are rumored to be several WPF related updates coming in the next update to Visual Studio 2008 (I think I covered when to expect that to appear) even with these updates you as a developer are still going to need to start to transition to this new UI paradigm. Fortunately because WPF performs better on Vista then on XP, and has no backward compatability below XP there is still time for you to get up to speed... but that grace period won't last forever. More importantly those performance issues are primarily for heavy duty graphics, if you are working in a more Windows Forms paradigm you won't see much of a difference at all.

Which brings me to "Why do it now?" - Well we already have an announcement that Windows Forms 2.0 was the last of the new development on that model. By starting to work with WPF now, even though you might not create a gratouitous graphic, you are creating an application tier that as WPF takes over (and with it's relationship to Silverlight 2.0 the pace of adoption is imho going to accelerate) your code even though it still has the standard Windows Forms look will integrate and be able to be adapted much easier then people who are continuing to create new solutions using Windows Forms. So now is the time to take those existing designs and just start by implementing them in WPF with little or no leverage of the high end graphics - and then as you get more comfortable with just how much power WPF provides you can update them to leverage that power.

Knowing Who Executed a Custom Workflow Action

Bill Sheldon — Wed, 12 Mar 2008 05:43:00 GMT

As I noted in my last post I’ve been working with a State based custom MOSS workflow. I’ve actually reached the point where I’m into resolving minor issues during my unit tests. One of my tests involved having a user other then the assigned user take a pending task and resolve/address it. So for example a document waiting to be approved is recognized by a manager who is covering for the assigned manager. The covering manager has “permission” to complete the task but isn’t the assigned user. This is where I had what I consider to be unexpected behavior.

What happens in SharePoint is that when I start in the debugger (or after deploying my workflow outside the debugger) the workflow is run in the context of the administrator. Now before you read that as “administrator” let me clarify – it’s run under a fixed account. The context of the thread executing the workflow isn’t assigned based on the current user. So whether it’s the administrator account or the Guest account the point is that at runtime if a parameter containing the user who triggered a workflow event isn’t passed into the workflow there is no way to determine the actual identity of the person triggering that next step in the workflow. This is important because if you are planning a workflow, then like most you are planning to capture a history of events which occurred. The problem if you don’t explicitly pass the name of the current user triggering an event then the name available as part of your running context will not be correct. Thus your history can at best reflect the name of the user who was supposed to resolve/address that action. Lost is the identity of the user who actually accessed your site and did take action on that workflow item.

If someone actually has an answer for getting that user (aside from explicitly setting a parameter) that I'm not aware of please feel free to let me know?

I spent quite a while looking at the parameter and runtime environment data and created a new WindowsPrincipal.GetCurrent() instance to see if I could find the actual current user. I also checked for example the current user value in this.workflowproperties.web, and it also was the administrator. Of course it might turn out to be a setting within SharePoint that I'm not aware of. Not that I would have explicitly set it since I can only begin to guess at where the setting comes from when my workflow is deployed from Visual Studio 2008. (btw, the account I deploy from isn't the administrator account.)

I actually consider this to be a pretty major workflow failing… in theory there is a reduction in security since the process executing the workflow has the permissions associated with (in this case the administrator) the most privileged account that will need to run any workflow. Additionally it breaks down on tracking reliability since it is in theory possible to apply the wrong account name to some of the history data, or if you haven’t planned for it to not explicitly capture the actual user executing the workflow.

Keep in mind if you are building and testing your workflow under the administrator account you might not ever notice this. However, knowing about this issue you can set up an InfoPath form and at least capture the name of the user who actually acted on the associated workflow.

Thoughts on Microsoft Mix: The WideOpen Web

Tim Huckaby — Sat, 08 Mar 2008 16:21:00 GMT

The majority of my blog posts are not exposed externally, but when a group of folks asked me to do an external post on my thoughts about the Microsoft Mix conference in Las Vegas this week, I gladly said, “Sure!”. So here we go…Attending the conference was time well spent for me and consequently, I’m more confident than ever that not only is Microsoft building the platform, tools and plumbing for the next generation of applications, but that InterKnowlogy is perfectly aligned as experts in these technologies - specifically WPF and Silverlight.

I have been a strong advocate and evangelist for “the smart client revolution” for many years. When .NET Windows Forms 2.0 shipped ~ 5 years ago, the deployment and maintenance nightmare of COM was nearing an end. And finally people started seeing that in most cases building browser based applications inside the firewall was just silly – especially when you consider the developer productivity achieved. Let’s face it. It simply is much easier to build windows apps than it is to build browser based apps. I call this the Winform phase of the Smart Client Revolution.

In 2005, WPF shipped and took client apps to the next level. WPF allows us to do things in design, usability, and UX that we never speculated would come so quickly. In all honesty, WPF took me totally by surprise. The paradigm was different, and difficult. But the results were so compelling. I call this Phase II.

In my opinion, we are in the 3rd phase of the smart client revolution: The Silverlight phase. Silverlight gives us the ability to build rich client applications and manifest them in the browser…cross platform! It’s basically WPF for the browser. Sure it’s a light version of the .NET framework, but at a 4.3 mb download there are tough choices to be made on what goes in and stays out.

I am speculating here, but in phase 4 we are headed for a world where:

· The rich clients of WPF are going to collide with applications delivered in the browser.

· There will be no delineation between web and windows. The tool (Visual Studio) will not delineate between the two types.

· Issues of cross platform will be overcome – at least for platforms and devices that have an SDK.

· We’ll have a full blown framework / next generation version of Silverlight where the technical and security challenges of access to the entire .NET framework over the web delivered in a browser will be overcome.

That’s a world I want to live in and it’s happening a lot quicker than I thought it would. For now, the next 18 months of building WPF and Silverlight applications is going to be really fun.