Ray Houston

Fluent Silverlight - Auto Wiring INotifyPropertyChanged

Ray Houston — Wed, 03 Jun 2009 03:13:58 GMT

In Gabriel's introductory post for Fluent Silverlight, he showed that the code typically associated with implementing INotifyPropertyChanged can be reduced to a simple auto property. This can really improve the clarity of a large class as well as save some typing. I'm going to show you how to get it setup.

INotifyPropertyChanged

First lets talk a little about normal INotifyPropertyChanged. This is an interface that is typically implemented on a ViewModel that you wish to participate in two way data binding between itself and some sort of DependencyProperty which typically lives on a control. The interface declaration looks like:

public interface INotifyPropertyChanged
{
    event PropertyChangedEventHandler PropertyChanged;
}

The PropertyChanged event on this interface is used to notify the control of any updates of properties that happen in your ViewModel so that the control can be refreshed with any updated data. Without the use of this interface, your updates will end up only being one way. Which means that the ViewModel will be updated with any changes from the control, but the control will not be updated with the changes from the ViewModel. A typical implementation may look like:

public class MyViewModel : INotifyPropertyChanged
{
    private string name;
    public string Name
    {
        get { return name; }
        set
        {
            if (value == name) return; 
            name = value;
            OnPropertyChanged("Name");
        }
    }

    private int age;
    public int Age
    {
        get { return age; }
        set
        {
            if (value == age) return;
            age = value;
            OnPropertyChanged("Age");
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

As you can see, it makes for a lot of noise. Also make note of the "Name" and "Age" strings which are not very refactor friendly.

IAutoNotifyPropertyChanged

We got to thinking that if we could intercept the changes to the properties (AOP), then we could automatically throw the PropertyChanged event. One way to do this is to use Castle.DynamicProxy (the Silverlight edition). DynamicProxy allows us to create a runtime generated subclass of our ViewModel. The generated subclass allows interception of any virtual member where we can chose to do what we please. To get it all started, we needed an interface that would allow us to trigger the event:

public interface IAutoNotifyPropertyChanged : INotifyPropertyChanged
{
    void OnPropertyChanged(string propertyName);
}

Next we updated our ViewModel to implement the new IAutoNotifyPropertyChanged interface and removed all the extras:

public class MyViewModel : IAutoNotifyPropertyChanged
{
    public virtual string Name { get; set; }
    public virtual int Age { get; set; }

    public event PropertyChangedEventHandler PropertyChanged;

    public void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

As you can see, there is a lot less noise here and we don't have the magic strings for the property names laying around. Also note that we made the properties virtual so that they can be intercepted. To actually make the auto wiring work, we have to create an instance of the ViewModel class (actually it's a generated subclass) using our AutoNotifyPropertyChangedProxyCreator. I'm not sure if we'll stick with that name, but it will do for now. Take a look at the following little test:

[TestFixture]
public class when_creating_viewmodel_with_creator
{
    private MyViewModel model;
    private string lastPropChanged;

    [SetUp]
    public void SetUp()
    {
        model = new AutoNotifyPropertyChangedProxyCreator().Create<MyViewModel>();

        model.PropertyChanged += (s, e) => lastPropChanged = e.PropertyName;

        lastPropChanged = null;
    }

    [Test]
    public void should_send_property_changed_for_given_property()
    {
        model.Name = "test";

        Assert.That(lastPropChanged, Is.EqualTo("Name"));
        Assert.That(model.Name, Is.EqualTo("test"));
    }
}

Because the proxy is a subclass, we can treat it as it's original type MyViewModel. As the Name property changes, it fires the PropertyChanged event which is wired to update the lastPropChanged field.

Summary

INotifyPropertyChanged is a handy interface for doing two way data binding but it causes a lot of extra noise in your classes. In Fluent Silverlight, we have introduced the IAutoNotifyPropertyChanged interface which is used in conjunction with AutoNotifyPropertyChangedProxyCreator which uses Dynamic Proxy to intercept the calls and auto throw the PropertyChanged event. This allowed us to reduce the noise and completely remove the magic strings typically associated with standard INotifyPropertyChanged.

In a future post I'll demonstrate how you can do other things with this such as ignore certain properties, tap into the interception to execute methods and have an IoC container handle the proxy creation.

Technorati Tags: Fluent Silverlight,INotifyPropertyChanged,Silverlight

Simple Code Navigation with ReSharper

Ray Houston — Sat, 11 Apr 2009 01:20:37 GMT

Here's a quick 5 minute screen cast that demonstrates how you can use ReSharper to get where you want to be in your code. If you haven't tried ReSharper yet, I highly recommend that you download the free trial and give it a spin.

Technorati Tags: ReSharper,PabloTV

Don't Waste The Time We Have Now

Ray Houston — Sun, 15 Mar 2009 22:47:56 GMT

I almost titled this "Get Things Done" but this post is not about how to do things. This post is about minimizing waste associated with distractions from non work related activities. I'm talking about things like Instant Messenger, Twitter, Skype, Facebook, personal phone calls, texting or anything else that is a distraction.

Some of the online tools can be used for work related activities (and I do used them), but they can also be major productivity killers. I bet that 90% of what happens on these things is noise. I don't have any statistics to back that up, but from my own experiences, what happens on there is mostly waste. For myself, I have enough work related distractions without piling on extras. You don't notice how much time you actually waste until you get so busy that any unnecessary distraction becomes a painful thing.

If you've had the opportunity to do some real pair programming, then you can appreciate minimizing distractions. One of the reason pair programming works, is that it keeps both parties engaged in the work. Even a simple phone call or text message to either party is a distraction. It actually even feels rude. After a good day of pairing, you feel exhausted because you put in a real day's work. You were engaged the entire time. Why don't we hold ourselves to the same standards when we are programming solo?

Don't get me wrong. I'm not saying that we shouldn't take breaks and have our minds think about other things once in awhile. The fact is that we're going to have non worked related distractions. The real point of this post is to remind everyone that in economic times like these, we cannot afford to waste the time we have now. If a company of 100 people waste 20 minutes a day on non worked related activities, then that is over a man week that has been wasted within that day. Wasted, gone, vanished, can't get it back. The time you waste today, may mean someone's job tomorrow (if not your own).

Pablo welcomes Gabriel Schenker

Ray Houston — Sat, 10 Jan 2009 17:00:52 GMT

I'm happy to announce that Gabriel Schenker has accepted an invitation to join Los Techies. You may know Gabriel as the man behind the NHibernate FAQ Blog or contributor to many of the software related community lists. He is an expert in didactics and methodology. He is very passionate about software development and the software community.

Look for his LosTechies posts at http://gabrielschenker.lostechies.com

Welcome Gabriel!!!

PTOM: The Composite Design Pattern

Ray Houston — Tue, 18 Nov 2008 02:07:28 GMT

The Composite Design Pattern

This post talks about the Composite Design Pattern and is part of Pablo's Topic of the Month - November: Design Patterns. A Composite is a tree structure where each node can be represented as a common type so that they can be acted on in a consistent manner, regardless of their concrete implementations. This allows a consumer of the composite to avoid the complexity of having to distinguish the objects individually. I believe that the posts for PTOM are going to centered around a coffee shop, but I'm having a difficult time thinking of a good composite example around that, so let's say I'm building coffee machines instead.

Lets pretend that I have a model of a coffee machine and all of its parts. Many of the parts are logical and are made up of only child parts. I might have a class that looks something like the following (simplistically implemented for example purposes):

public class CoffeeMachine
{
    public FluxCapacitor FluxCapacitor { get; set; }
    public PowerCord PowerCord { get; set; }
}

Lets say FluxCapacitor is a composite part made up of child parts and those child parts may have their own child parts. I want to build a class that allows me to output all the given parts for a machine, but I don't want my part list generator to know about each specific details of the machine or any of its specific parts. If I did couple the list generator to those implementations, that would force me to modify the list generator every time we added or changed a part, which would be a violation of OCP. We can solve this problem by creating an interface that lets us traverse our structure as a composite.

public interface IPart
{
    IEnumerable<IPart> GetChildParts();
}

You will notice that the IPart returns child instances of other IParts. This gives us a recursive structure and lets us act on that structure as a composite. By implementing this interface on all of our parts, when can then walk the hierarchy and perform operations without knowing the details of each implementation. We can implement this on our CoffeeMachine and our other parts like the following:

public class CoffeeMachine : IPart
{
    public FluxCapacitor FluxCapacitor { get; set; }
    public PowerCord PowerCord { get; set; }

    public IEnumerable<IPart> GetChildParts()
    {
        yield return FluxCapacitor;
        yield return PowerCord;
    }
}

public class FluxCapacitor : IPart
{
    public Switch Switch { get; set; }
    public PowerBooster PowerBooster { get; set; }

    public IEnumerable<IPart> GetChildParts()
    {
        yield return Switch;
        yield return PowerBooster;
    } 
}

public class PowerCord : IPart
{
    public IEnumerable<IPart> GetChildParts()
    {
        yield break;
    }        
}

Now we can easily build a part list generator that uses a recursive method to walk through the hierarchy and outputs the names of the parts.

public class PartListGenerator
{
    public void OutpAllParts(IPart part, TextWriter textWriter)
    {
        OuputAllPartsByLevel(part, textWriter, 0);    
    }

    private static void OuputAllPartsByLevel(IPart part, TextWriter textWriter, int level)
    {
        textWriter.WriteLine("{0}{1}", new string('\t', level), part.GetType().Name);

        foreach (var childPart in part.GetChildParts())
        {
            OuputAllPartsByLevel(childPart, textWriter, level + 1);
        }
    }
}

By running our CoffeeMachine through this class, we end up with something similar to the following output:

CoffeeMachine
    FluxCapacitor
        Switch
        PowerBooster
    PowerCord

You may have noticed that we have the GetChildParts() method implemented on the leaf parts as well (see PowerCord). This may be a slight violation of ISP, but it is side effect free and it does not violate LSP therefor it does not bother me too much. In the real world, IPart would probably have other functionality and you could split out the GetChildParts() into a separate interface such as ICompositePart which would only be implemented by non leafs. This would require the PartListGenerator to know about IParts and ICompositeParts which may or may not be desirable. It's really a trade off here as to what makes the most sense for your needs.

There are several variations of the Composite Design Pattern and my example can probably be considered one of them. The Composite can also be combined with other patterns such as the Specification or Command patterns. You can find lots of other examples on the web and in Design Patterns : Elements of Reusable Object-Oriented Software. I recommend picking up that book for more information on the Composite and many other must know patterns.

Pablo's Topic of the Month - November: Design Patterns

Ray Houston — Wed, 05 Nov 2008 10:57:13 GMT

Pablo's Topic of the Month - November: Design Patterns

Back in April, we announced we would be doing a PTOM on Design Patterns. It turned out that April was a busy month for all of us and we didn't live up to our announcement. I think we're going to claim it as a sad April fools joke. During the course of this month we will revisit our previous topic with the exception that the patterns will not just be patterns from 'Design Patterns: Elements of Reusable Object-Oriented Software' (Addison-Wesley. ISBN 0-201-63361-2) , but from various sources which we believe are relevant to the types of programs being written today.

If you haven't already, please consider subscribing to the Los Techies Main Feed so that you can see the various post from all the Los Techies bloggers.

The main feed is here: http://feeds.feedburner.com/lostechies

What is a Design Pattern?

A Design Pattern is exactly what it sounds like. It's a design that can be applied over and over again, forming a pattern. The Wikipedia page for Design Patterns describes one as

a general reusable solution to a commonly occurring problem in software design. A design pattern is not a finished design that can be transformed directly into code. It is a description or template for how to solve a problem that can be used in many different situations.

By using Design Patterns, we can better standardize our designs makes them easier to understand. Design Patterns give us a common vocabulary in which to use in communicating software designs. Without them, we would have a difficult time in explaining and documenting our ideas.

Posts on Design Patterns

We will update this area with links to the posts as they happen.

PTOM: The Decorator Pattern by Sean Chambers

PTOM: The Composite Pattern by Ray Houston

PTOM: Command and Conquer Your UI Coupling Problems by Derick Bailey

PTOM: Bend 3rd Party Libraries to Your Will With the Adapter Pattern by John Teague

PTOM: Descriptive State Enumeration by Derick Bailey

PTOM: Visitor Design Pattern by Jason Meridth

Technorati Tags: PTOM,Design Patterns

Udi's SOA Class Made Me Smart

Ray Houston — Sun, 26 Oct 2008 16:07:41 GMT

Chris challenged me to write a post showing how smart I am after taking the class. ;) While I know that "made me smart" is completely unbelievable, I did manage learn a great deal.

I'm slow to getting around to this post, but little over a week ago I finished up Udi Dahan's week long class called "Advanced Distributed Systems Design using SOA & DDD". As Aaron has already stated, it was awesome. The class was very well put together. The materials were clear and concise and Udi did a fantastic job presenting it. It was a good mixture of lecture, coding, and question and answer. I fully expected that I would be taking notes like crazy, but it was so well laid out that the only thing I wrote down the entire course was what I wanted for lunch. Udi provided us with all the lecture materials and everyone has access to all of the samples which are in the nServiceBus trunk.

Now I know why Udi is the "Software Simplist." I was amazed to find that all the code and solutions were indeed very simple. Your day to day DDD code doesn't change (if you're doing it well). All the hard stuff is dealt with at the bus level. You as the architect need to know what's going on so that you can apply the patterns appropriately, but a developer in the domain should not be writing code that deals with things like threading. If you are, you're doing it wrong. The patterns that Udi presented keep things simple by isolating complexity so that it doesn't creep into your day to day code. The domain code looks the same if it's running in a single process or if it's running in 100 processes.

Udi kept saying that the code is simple, but defining the right boundaries is the hard part. Often the questions we gave Udi were solved by diving deeper into the real business requirement and giving the business choices as to what their requirements really mean in terms of performance, latency, durability, etc. You get into trouble when you try to make a technical problem out of what should be a business decision.

Two great quotes from the lecture materials:

Best practices have yet to catch up to "best thinking"

Technology cannot solve all problems

Good SOA is not about applying one single thing over and over again. It's about knowing your requirements, your options, and planning accordingly. I feel lucky that I got to spend a week with Udi and absorb some of this. I highly recommend that you attend his class if your doing or thinking of doing distributed systems.

In the coming months, I plan to start working on some SOA projects at TOPAZ and applying what I have learned. I hope to be able to blog about my experience and that Udi will correct me when I say something incorrect. ;)

Senior Developer Opportunity in Austin

Ray Houston — Sat, 25 Oct 2008 13:26:40 GMT

TOPAZ Technologies is currently looking for a Senior Developer who loves to write .NET code. We're a product company that builds software solutions for the medical research industry. Here are some of the details for the position:

If you are pragmatic and passionate about software development and enjoy delivering real value to customers, then we may be a good match for you. We are currently looking for a full‐time Senior Developer who does A+ work and who can contribute to the continued success of our team. We are looking for someone with humility who is enthusiastic about sharing knowledge and who believes in continuous improvement. If this describes you and you are interested in working for an exciting company focused on building quality software, we would love to hear from you. Contact us at humanresources@topazti.com.

Requirements

Strong development experience with OO languages
Broad knowledge of .NET and C#
Strong knowledge of building applications for the web
Strong knowledge of design patterns, DDD, refactoring, and TDD
Experience with Agile methodologies such as SCRUM and XP
Experience with ORMs such as NHibernate
Experience as a leader and mentor
Silverlight knowledge a plus
Windows Mobile knowledge a plus

Responsibilities

Report to the Director of Development
Provide technical analysis and designs for features
Incrementally estimate and implement features from feature backlog using TDD/BDD
Identify and mitigate risks
Mentor other team members and lead by example
Bring new ideas to the team
Keep up to date on the latest technologies

TOPAZ Technologies is an established leader in the development and support of software solutions for medical research. We have solid foundation of clients including leaders in the pharmaceutical, biotech, university, government, and private research organizations. We are privately owned and offers excellent benefits to employees. TOPAZ is also a supporter of the development community.

I should probably add that this is not a work from home position.

Single-Responsibility Versus Needless Complexity

Ray Houston — Sun, 05 Oct 2008 22:07:10 GMT

At Pablo's Day of TDD, we were discussing the Single-Responsibility Principle (SRP) while working through one of the labs and a question came up about a piece of code. The code in question looked something like the following (warning: this is over simplified code to show a point):

public bool Login(string username, string password)
{
    var user = userRepo.GetUserByUsername(username);

    if(user == null)
        return false;

    if (loginValidator.IsValid(user, password))
        return true;

    user.FailedLoginAttempts++;

    if (user.FailedLoginAttempts >= 3)
        user.LockedOut = true;

    return false;
}

This was from the a LoginService class and this was its only method. The question was whether or not this violates SRP because it's in charge of incrementing FailLoginAttempts as well as locking the user out after 3 failed attempts. I believe we answered the question with a "depends", but it bothered me that we didn't have a better answer. Personally, I wouldn't have busted this up into another class, but I didn't have a good argument to stand on.

Today I went searching through Agile Principle, Patterns, and Practices in C# looking for a better answer. In the chapter on SRP, the book gives an example of an interface of a modem that can Dial/Hang-up and Send/Receive. The former is connection management and the later is data communication. The book asks the question as to whether or not these responsibilities should be separated. The answer is

"That depends on how the application is changing."

It then gives an example to how a change might violate SRP, but then states:

"If, on the other hand, the application is not changing in ways that cause the two responsibilities to change at different times, there is no need to separate them. Indeed, separating them would smell of needless complexity."

Ah, there's the backup wisdom that I needed to validate my gut feeling. Here's one final quote from the book:

"There is a corollary here. An axis of change is an axis of change only if the changes occur. It is not wise to apply SRP (or any other principle, for that matter) if there is no symptom."

I think applying SRP is about applying good judgement. You certainly don't want to wait until you have to make a change before you think about SRP, but you don't want to over do it either and end up with classes with one method with each having only a couple lines of code.

Technorati Tags: Principles

Learning TDD

Ray Houston — Wed, 24 Sep 2008 01:22:19 GMT

Learning TDD takes time and can be especially tough if you don't have an opportunity to work with folks that are already doing TDD. It requires you to think and work differently and there are many pitfalls along the way. I know that I've made a ton of mistakes.

When I started working with automated testing, I was writing tests that hit the database. They were big, slow and complex and required a lot of maintenance to keep the data population scripts in check. The tests were very fragile and it seemed like it was almost a full time job to keep them going. At the time, I thought that doing TDD was just about writing your tests first so I tried doing it, but it was just too hard because I wasn't writing my code in a manner that could be tested easily.

Next I learned about dependency injection and IoC containers which allowed me to decouple my classes and test them in isolation. I learned how to create a mock instance of an interface and pass it into the classes that I was testing to see if they interacted with it properly. This was a million times better than the tests that ran against the database, but I still wasn't doing it right. I wrote all my tests as interaction tests (versus state base tests) and I ended up with a big mess of fragile unreadable tests that gave me very little feed back to the source of problems when they occurred. Refactoring was painful because I'd have to go fix a ton of tests that I could no longer understand what they were trying to test in the first place.

There are a lot of other mistakes that I'm forgetting right now (or just too embarrassed to mention) and I'm sure there are tons of other people who have made the same ones. As Jimmy pointed out, hiring a good coach can be well worth it in avoiding some of the mistakes like I made.

If you're interested in talking with other folks about TDD, Los Techies is hosting a free event in Austin, TX called "Pablo's Days of TDD" (PDoTDD). It will be held on Friday October 3rd, 2008 from 2PM-5PM and Saturday, October 4th, 2008 from 9AM to 5PM. This event is for all levels from beginners to masters and will include workshops, discussion, practice, and training around automated unit testing, specifically the practice of TDD. For more information, please see Chad's post here.

Technorati Tags: TDD

How Mr. Buford got me started in software development

Ray Houston — Sun, 21 Sep 2008 00:50:26 GMT

Jason tagged me awhile back for a "How did I get started in software development?" post and I'm just now getting around to it, but I'm going to change the format a little.

One morning back in 1982/83 when I was in the 6th grade, I was hanging out in the side of the school building trying to look cool (but not) when my science teacher, Mr. Buford, came up and saw me standing there picking my nose and said "Hey kid, you want to learn something?" Mr. Buford was a real big guy and was a bit intimidating. He was one of those teachers we didn't play around with. I said meekly "ok" and he told me to come with him. He took me into his classroom where he had a TI 99-4A which he used to record our grades. I remember him placing a cartridge in the machine and telling me that it was a program that teaches you the BASIC programming language and that I was to sit there and go through the tutorial. Of course I was extremely excited to be playing with the computer since I had never messed with one before. The tutorial was interactive and you could write code as you followed along with lessons. I can't remember exactly how long the tutorial was, but it took me several mornings to go through the whole thing. Then after completing it, I started writing my own programs. Each morning, I would wait for Mr. Buford to get to school so I could play with his computer. I was fascinated by being able to make images and sounds with the machine so I wrote a lot of little programs around those topics. I showed the programs I wrote to Mr. Buford and I clearly remember him being amazed that I could make the computer do those things (I don't think Mr. Buford ever did the tutorial himself). It was a lot of fun.

When school let out for the summer, I was forced to take a break from the computer. In the late summer of 1983, hurricane Alicia came and tore a lot of things up. I worked cutting and splitting wood of fallen trees and saved enough money to buy my own first computer which was a Commodore VIC-20. This was the first of the many I was to own over the years.

So that's it. If it hadn't been for Mr. Buford, I wouldn't have learned BASIC when I did (or maybe never) and I wouldn't have spent my hard earned money on my first computer. Instead I probably would have bought a bag of Super Bubble and a fishing reel or some firecrackers or something. It's amazing how a little encouragement from my 6th grade science teacher helped me get into something which I would end up doing professionally. It's amazing how such a small thing can be so powerful. Keep that in mind when you have the opportunity to mentor someone. The old saying is true; a little bit goes a long way.

Thanks Mr. Buford.

Technorati Tags: Mentoring

Creating a Silverlight Layout Panel

Ray Houston — Sun, 14 Sep 2008 16:21:04 GMT

On our current project, we came across the need to build some custom layout panels in Silverlight to achieve some complex fluid layouts that we could not get from the built in controls. I was amazed to see how easy it was to create your own. This panel that I'm going to show is nothing fancy, but it shows how simple it really is. It will layout it's children in a diagonal direction from upper left to lower right.

The first thing we need to do is create a new class and inherit from Panel. Panel is the base class for the built-in layout controls such as Grid and StackPanel.

public class DiagonalStackPanel : Panel
{
}

The next thing is to override the MeasureOverride() method. In this method you should iterate through the Children collection and call the Measure() method on each child. After Measure() is called, the DesiredSize property of the child will be populated with the size in which the child wants to be rendered.

protected override Size MeasureOverride(Size availableSize)
{
    double totalWidth = 0;
    double totalHeight = 0;

    foreach (var child in Children)
    {
        child.Measure(availableSize);

        totalWidth += child.DesiredSize.Width;
        totalHeight += child.DesiredSize.Height;
    }

    return new Size(totalWidth, totalHeight);
}

You can see that we're adding up all the widths and heights of each child and returning the size (desired) for our Panel.

Next we override the ArrangeOverride() method. This is where we actually layout the children in the diagonal pattern. We do that by calculating the running total sizes of the child controls and calling Arrange() on each child with the appropriate sizing Rect object.

protected override Size ArrangeOverride(Size finalSize)
{
    double runningWidth = 0;
    double runningHeight = 0;

    foreach (var child in Children)
    {
        var width = child.DesiredSize.Width;
        var height = child.DesiredSize.Width;

        var finalRect = new Rect(runningWidth, runningHeight, width, height);
        child.Arrange(finalRect);

        runningWidth += width;
        runningHeight += height;
    }

    return new Size(runningWidth, runningHeight);
}

Now we can use our panel like so:

<UserControl x:Class="LayoutPanelExample.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:c="clr-namespace:LayoutPanelExample">
    <Grid x:Name="LayoutRoot" Background="White">
        <c:DiagonalStackPanel>
            <Button Content="Button"/>
            <Button Content="Button"/>
            <Button Content="Button"/>
            <Button Content="Button"/>
            <Button Content="Button"/>
            <Button Content="Button"/>
        </c:DiagonalStackPanel>
    </Grid>
</UserControl>

and we'll get something that looks like:

You could extend this by added Dependency Properties to the panel so that you can customize how each child reacts in the layout. This is how the Grid works. It looks at the properties set on the child elements and figures out what row and column to place them in.

Technorati Tags: Silverlight,.NET

From Flex to Silverlight

Ray Houston — Sat, 13 Sep 2008 14:52:06 GMT

A couple of years ago my company started development on a web product that had designs for a very rich user interface. We started out building a AJAX HTML based application and realized very soon that we were having to work really hard to make HTML and CSS do what we wanted it to do and in many cases it just wasn't happening.

Our UI designer was doing prototypes in Flex (which I didn't know what it was at the time) but his stuff was really cool and we starting talking about it. I was skeptical about Flex at first, but it turned out to be a real platform for developing rich Internet applications. Anyway, to make a very long story short, we chose Flex as the front end of our .NET web application.

In the beginning Flex was cool. It gave us a strongly typed object oriented language (ActionScript 3) and IDE support in Eclipse. We were able to develop some really slick things in a fraction of the effort if we would have done them using DHTML/CSS. It was good, but working in Flex did have its negatives as well. Some of the things that we struggled with were

We're .NET folks, so there was a learning curve
Extra time in working with two IDE's to develop in (Eclipse and Visual Studio for Flex and .NET respectfully)
The IDE plug-in was very buggy
No refactoring support
No real testing support
Compiles painfully slow on large projects
Not a lot of support from Adobe when we would have problems

I had been keeping my eye on Silverlight waiting to see how it was all going to play out. When the first beta of 2.0 came out, we started looking at it hard. Then in April at ALT.NET Seattle, I had the opportunity to steal a few moments of Scott Guthrie's time and ask him about what to expect from Silverlight in the future. The guy's enthusiasm about what they were doing completely sold me. We started our Silverlight project that following week and haven't looked back.

I'm truly digging Silverlight. It is amazing to be able to write .NET code that runs in the browsers. I even forget that I'm working in a browser sometimes. There are a few things we miss from Flex, but nothing we couldn't create ourselves without too much effort. Some of the things we now get to take advantage of are

All the C# language features
Passing .NET types to and from the server
Reflection
Testing Tools
We able to use Resharper (can I get a "heck yeah" for this one?)
Support of Microsoft

That last point is really important. Microsoft made us part of their early adopters program and we so have good channels of communication with the team. We tried to do something like that with Adobe, but I guess we never talked to the right person.

I think the Silverlight team has done a great job and I'm looking forward to the future releases.

Technorati Tags: Silverlight,.NET,Flex

Do Anonymous Methods Prevent Declaring Types from Being GC'd?

Ray Houston — Thu, 22 May 2008 01:57:02 GMT

It seems that they do if they reference members of the declaring type. This makes perfect sense now that I think about it, but I didn't think about it earlier and wrote some code that caused a memory leak. I had an object acting as a singleton and referencing a delegate instance that was created from an object acting as a non singleton. Bam! Memory Leak.

I setup a little test to demonstrate. Here is a class that has two methods which return delegate instances:

public class TestSource
{
    private string internalValue = "test";

    public Func<bool> GetFunc1()
    {
        return () => 1 == 1;
    }

    public Func<string> GetFunc2()
    {
        return () => internalValue;
    }
}

Notice that GetFunc1() doesn't have any references to internal members, but GetFunc2() does. Here's the test class:

class Program
{
    static void Main(string[] args)
    {
        // hold no references to TestSource
        TestFuncInstance(new TestSource().GetFunc1());
        TestFuncInstance(new TestSource().GetFunc2());

        Console.WriteLine("Press Enter to continue.");
        Console.ReadLine();
    }

    private static void TestFuncInstance(Delegate func)
    {
        Thread.Sleep(1000);// give some time for GC

        Console.WriteLine(string.Format("Method: {0}",func.Method));
        Console.WriteLine(string.Format("DeclaringType: {0}", func.Method.DeclaringType));
        Console.WriteLine(string.Format("Target: {0}", func.Target ?? "null"));

        Console.WriteLine();
    }
}

This creates two separate instances of TestSource and passes the result of the two GetFunc methods to a test method. Notice that there are no declared variable references to the TestSource object. Here's the output of the test:

Method: Boolean <GetFunc1>b__0()
DeclaringType: TestingDelegates.TestSource
Target: null 

Method: System.String <GetFunc2>b__2()
DeclaringType: TestingDelegates.TestSource
Target: TestingDelegates.TestSource 

Press Enter to continue.

I know this test isn't very scientific, but you'll see that Func1's target is null while Func2's target is not. Func2 has to hold a reference to the declaring object so that it can do it's job when invoked. Func1 does not need a reference, and seems to free up the declaring object to be garbage collected. This is definitely something to keep in mind when passing around delegates.

Technorati Tags: .NET,delegates,GC

Synchronizing UI Operations with Asynchronous Dependencies

Ray Houston — Thu, 15 May 2008 02:14:21 GMT

When working with asynchronous data access such as using a Silverlight client to access data from a server side service, you will inevitably run into the situation where you have two or more calls which have results that need to be processed in a synchronous manner. A simple example is populating a list box from server side data and then making a second call to get the value that needs to be selected. You could wait until the list is populated before making the second call, but that would be a waste.

I built a little helper object that allows you to define Action delegates that will get executed in a specific order once all pending operations have completed. Below is a snippet of how it can be used.

private ILoginService loginService;
private ILoginView loginView;
private OperationSync localeOpSync = 
        new OperationSync(LocaleOps.GetLocales, LocaleOps.GetDefaultLocale);

private void PopulateLocales()
{
    loginService.GetLocales(HandleGetLocalesResult);
    loginService.GetDefaultLocale(HandleGetDefaultLocaleResult);
}

private void HandleGetDefaultLocaleResult(string result)
{
    localeOpSync.OpCompleted(LocaleOps.GetDefaultLocale, GetSetSelectedLocaleAction(result));
}

private void HandleGetLocalesResult(string[] result)
{
    localeOpSync.OpCompleted(LocaleOps.GetLocales, GetSetLocaleSelectionAction(result));
}

private Action GetSetSelectedLocaleAction(string result)
{
    return () => loginView.SetSelectedLocale(result);
}

private Action GetSetLocaleSelectionAction(string[] result)
{
    return ()=> loginView.SetLocaleSelections(result);
}

In this example, there are two asynchronous service methods which get called. Their results are passed to handler methods where they are processed by Actions, but those Actions don't execute until both OpComplete methods have fired (actually the last OpComplete triggers the execution of all the Actions. It doesn't matter which call returns first. Their associated Actions will execute in the order defined by the keys in the creation of the OperationSync object. There are a million different ways to put this together with lambdas and anonymous methods, but I tried to bust it up here so it would be easier to follow.

To show how it works I've included a subset of the unit tests (with extension methods and other goodies stripped out). The setup for all the specs is at the bottom of the code snippet.

[TestFixture]
public class when_not_completing_all_ops 
    : behaves_like_setting_up_operation_actions
{
    [Test]
    public void should_not_execute_actions()
    {
        OpSync.OpCompleted(OpKey.One, Action1);
        OpSync.OpCompleted(OpKey.Two, Action2);

        CollectionAssert.IsEmpty(ActionResults);
    }
}

[TestFixture]
public class when_completing_all_ops_in_key_order 
    : behaves_like_setting_up_operation_actions
{
    [Test]
    public void should_execute_actions_in_key_order()
    {
        OpSync.OpCompleted(OpKey.One, Action1);
        OpSync.OpCompleted(OpKey.Two, Action2);
        OpSync.OpCompleted(OpKey.Three, Action3);

        Assert_That_ActionResults_Fire_In_Correct_Order();
    }
}

[TestFixture]
public class when_completing_all_ops_not_in_key_order 
    : behaves_like_setting_up_operation_actions
{
    [Test]
    public void should_execute_actions_in_key_order()
    {
        OpSync.OpCompleted(OpKey.Two, Action2);
        OpSync.OpCompleted(OpKey.Three, Action3);
        OpSync.OpCompleted(OpKey.One, Action1);

        Assert_That_ActionResults_Fire_In_Correct_Order();
    }
}

public abstract class behaves_like_setting_up_operation_actions
{
    protected OperationSync OpSync { get; set; }
    protected Action Action1 { get; set; }
    protected Action Action2 { get; set; }
    protected Action Action3 { get; set; }
    protected List<OpKey> ActionResults { get; set; }

    [SetUp]
    public void Before_Each_Spec()
    {
        OpSync = new OperationSync(OpKey.One, OpKey.Two, OpKey.Three);

        Action1 = () => ActionResults.Add(OpKey.One);
        Action2 = () => ActionResults.Add(OpKey.Two);
        Action3 = () => ActionResults.Add(OpKey.Three);

        ActionResults = new List<OpKey>();
    }

    protected void Assert_That_ActionResults_Fire_In_Correct_Order()
    {
        Assert.That(ActionResults.Count, Is.EqualTo(3));
        Assert.That(ActionResults[0], Is.EqualTo(OpKey.One));
        Assert.That(ActionResults[1], Is.EqualTo(OpKey.Two));
        Assert.That(ActionResults[2], Is.EqualTo(OpKey.Three));
    }

    protected enum OpKey
    {
        One,
        Two,
        Three
    }
}

The keys can be anything. I have just been creating a private enum in the class where I need them. Here's the OperationSync class that handles it all:

public class OperationSync
{
    private static readonly object syncRoot = new object();

    private readonly object[] keys;
    private readonly Dictionary<object, bool> keyKeepActionAfterExecute = 
        new Dictionary<object, bool>();

    private readonly Dictionary<object, Action> keyActions = 
        new Dictionary<object, Action>();

    public OperationSync(params object[] operationKeys)
    {
        keys = operationKeys;

        foreach (var o in operationKeys)
        {
            keyActions.Add(o, null);
        }
    }

    public void OpCompleted(object key, Action action)
    {
        OpCompleted(key, action, false);
    }

    public void OpCompleted(object key, Action action, bool keepActionAfterExecute)
    {
        lock (syncRoot)
        {
            if (!keyActions.ContainsKey(key))
                throw new UIException("Key '{0}' not found.");

            keyActions[key] = action;
            keyKeepActionAfterExecute[key] = keepActionAfterExecute;

            if (AllOpsComplete())
                ProcessActions();
        }
    }

    private void ProcessActions()
    {
        ExecuteEachAction();

        ClearActionsIfIndicated();
    }

    private void ExecuteEachAction()
    {
        foreach (var key in keys)
        {
            keyActions[key]();
        }
    }

    private void ClearActionsIfIndicated()
    {
        foreach (var key in keys)
        {
            if (!keyKeepActionAfterExecute[key])
                keyActions[key] = null;
        }
    }

    private bool AllOpsComplete()
    {
        return keyActions.All(pair => pair.Value != null);
    }
}

There's probably a fancy smancy AJAX pattern name for this sort of thing. Let me know if you come across one.

Technorati Tags: C#,Silverlight,AJAX,UI