To find out what the real problem was I’ve built a test application that basically does the same thing as the complex window that is giving me such a headache. So here goes:

I have a class like this:

public class Base {
    public string Property1 { get; set; }
    public Sub SubItem { get; set; }

    public Base() {
        Property1 = "Base Property1";
        SubItem = new Sub();
}
public class Sub {
    public string Property1 { get; set; }

    public Sub() {
        Property1 = "Sub Property1";
    }
}

Which is bound to a TextBox:

private void buttonBind_Click(object sender, EventArgs e) {
    Base b = new Base();

    // This works
    textBox1.DataBindings.Add("Text", b.SubItem, "Property1");

    // This doesn't work
    textBox2.DataBindings.Add("Text", b, "SubItem.Property1");
}

Now the first binding will work but the second one will throw a TargetException. I have no clue why this happens but the message of the exception and the stack trace give some hints that this is a reflection problem. However the binding specifies to bind a string property to a string property so that shouldn’t be a problem.

A workaround for this problem is to use a BindingSource:

private void buttonBind_Click(object sender, EventArgs e) {
    Base b = new Base();
    BindingSource bs = new BindingSource(b, null); // Use a empty datamember

    // Now it will work
    textBox2.DataBindings.Add("Text", bs, "SubItem.Property1");
}

But it’s quite a lot of work to replace this in the current application so I hope this gets fixed soon.

In the meanwhile I’ve filed a bug report at Microsoft Connect (see here) with sample code that demonstrates the behavior so you can test for yourself. If you do, please vote on Microsoft Connect to get it under their attention!

Are you using Twitter? Do you like it or absolutely loathe it? I do like it but one thing I don’t like is constantly checking twitter.com to see if someone tweeted something interesting. So a new idea was born and the wasting of time began.

The idea

Actually it’s pretty simple, I wanted an application that showed a pop-up of some kind that shows me the latest tweet for a minute or so and then disappear, similar to the new e-mail popup of Outlook. Another feature I wanted to make is that when I mouse over on the pop-up the app shows me the last 10 tweets from my timeline.

Problem #1

First things first, how to get the last tweets from Twitter? As all programmers are lazy (see http://blogoscoped.com/archive/2005-08-24-n14.html) I’ve started looking for a library that could do this for me. Lo’ and behold: LINQ To Twitter. A wrapper around the Twitter web services written by Joe Mayo (Microsoft MVP) in C#.

So, problem #1 was solved.

Problem #2

The next problem was one of UI. How to display a nice pop-up that gives access to the rest of the application? What I wanted to do is create a window that slides in from the top of the screen when a new Tweet is posted and when the mouse is over it, expand to show the last 10 tweets. Because a default window border doesn’t look all that nice I’ve decided to use a transparent window:

XAML: <Window Background="Transparent" AllowsTransparency="True"> <Grid> <Border> <ScrollViewer> <ItemsControl /> </ScrollViewer> </Border> </Grid> </Window>

As you can see it’s a pretty simple UI but that’s exactly what I wanted. What you see is a transparent Window with a Border and ScrollViewer (the green bit) that hosts an ItemsControl, nothing fancy so far. The next step was to set the initial position of the window. A simple RenderTransform took care of that:

XAML:

<Border.RenderTransform>
<TranslateTransform Y="-360"  />
</Border.RenderTransform>

The ItemTemplate of the tweets is also quite straightforward:

XAML:

<DataTemplate>
  <Border>
    <StackPanel Orientation="Vertical">
      <StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
        <TextBlock Text="{Binding Path=User.Name}" />
        <TextBlock Text=" at " />
        <TextBlock Text="{Binding Path=CreatedAt}" />
      </StackPanel>
      <TextBlock Text="{Binding Path=Text}" TextWrapping="Wrap" />
    </StackPanel>
  </Border>
</DataTemplate>

The result looks like this:

Fancy UI

The important part of the application was to “popup” (or down actually) when a new tweet is available and when the mouse enters the application so all tweets are shown. To do this three storyboards are needed:

1.       Animate to the new tweet view

2.       Animate to the full view

3.       Animate to the hidden view

The storyboards all animate the RenderTransform of the Border that hosts the controls.

XAML:

<Storyboard  x:Key="Hidden">
  <DoubleAnimation
    Storyboard.TargetProperty="Opacity"
    To="0.4"
    Duration="0:0:0.2" />
  <DoubleAnimation Storyboard.TargetProperty="(Border.RenderTransform).(TranslateTransform.Y)"
    To="-370"
    Duration="0:0:0.2"
    BeginTime="0:0:0.2" />
</Storyboard>
<Storyboard x:Key="NewTweet">
  <DoubleAnimation Storyboard.TargetProperty="(Border.RenderTransform).(TranslateTransform.Y)"
    To="-295"
    Duration="0:0:0.2" />
   <DoubleAnimation
    Storyboard.TargetProperty="Opacity"
    To="1"
    Duration="0:0:0.2" />
</Storyboard>
<Storyboard x:Key"AllTweets">
  <DoubleAnimation Storyboard.TargetProperty="(Border.RenderTransform).(TranslateTransform.Y)"
    To="-20"
    Duration="0:0:0.2" />
  <DoubleAnimation
    Storyboard.TargetProperty="Opacity"
    To="1"
    Duration="0:0:0.2" />
</Storyboard>

These storyboards are started by various events in the application. For example: MouseEnter and MouseLeave on the Border trigger the AllTweets and Hidden Storyboards.

Timeline

So far so good, the UI is basically finished and all that remains is to fill the application with the tweets from my timeline. For this I’ve created a Timeline class that contains the TwitterContext and a simple timer for the refresh action. The grunt of this class is the following LINQ statement:

LINQ:

var statusTweets =
from tweet in  this.context.Status
where tweet.Type == statusType
            && tweet.ScreenName == this.screenName
            && tweet.Count == maximumTweetsPerRefresh
            && tweet.CreatedAt > lastTweetDate
select tweet;

This statement will retrieve all tweets from the timeline specified with screenName that have been created since the last refresh.  If this results in 1 or more tweets the Timeline class will raise the NewTweetsAvailable event to notify the application that new tweets are available to display.

The event handler simply pushes the new tweets to the ItemsControl and starts the NewTweet storyboard to pop-down the window so the latest tweet is visible.

Wrap up

As you can see it’s really simple to build an application that shows the latest tweets in your Twitter timeline. Of course there are a few features that are missing, for example the storyboards, but I’ll blog about them a bit later. Be sure to check #TwitCast for updates

Update:

TwitCast is now listed on Codeplex at http://twitcast.codeplex.com/

Unfortunately when I decided it was time to move our Visual Source Safe database to TFS all went sour. The analysis of the VSS database with the VSSConverter tool worked but when I tried to migrate it just sat there and told me:

TF60070: Unable to connect to the Team Foundation Server: ‘http://ts01:8080/’. Please ensure that the Team Foundation Server exists and try again.

At first it seemed logical as the TFS is at http://ts01:8080/tfs so no worries there, just a bad config. Unfortunately there is no option in the configuration file to specify a full URL so basically I’m stuck. (small update: I tried to be clever and use URL redirection but it doesn’t work)

I’ve filed a bug on the Microsoft Connect site so if you’re having the same problem please vote for it so they’ll start to fix it.

Update 1: It seems that in Beta 1 the VSSConverter tool is unsupported. See the blog post from granth here, about half-way on the page

Update 2: Someone has been successful but with the VS2008 version of VSSConverter Nope, he was not.

Update 3: Matthew Mitrick (from Microsoft) has a good answer to this. You can read about it here.

The answer is that in the TFS 2010 Beta 2 there is a new feature called Collections. Unfortunately the documentation of VSSConverter has not been updated as there is a new configuration option to specify in which collection the projects should be migrated. So the solution is to add the option “collection” to the TeamFoundationServer element in the options.xml so it looks something like this:

<TeamFoundationServer name="myserver" port="8080" protocol="http"
collection="tfs/DefaultCollection"></TeamFoundationServer>

If you’ve installed TFS in another virtual directory than tfs you should modify the collection option accordingly. (Goes for the collection as well )

var voyages = from voyage in entities.Voyage
              select new { Number = voyage.Number, ETA = voyage.StartTime };

dataGridTest.ItemsSource = voyages;

XAML

<DataGrid Name="dataGridTest">
    <DataGrid.Columns>
        <DataGridTextColumn Header="Number" Binding="{Binding Path=Number}" />
        <DataGridTextColumn Header="ETA" Binding="{Binding Path=ETA}" />
    </DataGrid.Columns>
</DataGrid>

Seems straightforward enough, doesn’t it? Well it does but when you try to run it, it’ll crash and burn with the following exception:

InvalidOperationException: A TwoWay or OneWayToSource binding cannot work on the read-only property ‘Number’

The reason that the InvalidOperationException gets thrown is that the Binding used to bind the column to a property is a TwoWay binding, by default!

But why should (and is) this be a problem? Well, because the result from the LINQ is a new class that contains only get-properties. This is by design because an anonymous type can only contain get-only properties as is written on MSDN:

Anonymous types provide a convenient way to encapsulate a set of read-only properties into a single object without having to first explicitly define a type.

There are two workarounds for this problem, one is simply to add Mode=OneWay to the Binding property of the DataGridTextColumn. This will tell the DataGrid (ultimately the Binding) that it should not attempt to write data back to the bound object.

The other workaround is not to use an anonymous type. If you need to be able to change data in the result set this is probably the way to go. By defining a type that contains the properties you want to bind on you can tell LINQ to return that specific type and not an anonymous one.

For example:

C#

public class VoyageResult {
    public int Number { get; set; }
    public DateTime ETA { get; set; }
}
var voyages = from voyage in entities.Voyage
              select new VoyageResult()
              {
                   Number = voyage.Number,
                   ETA = voyage.StartTime
              };

voyages will now contain a list of VoyageResults instead of a generated anonymous type (with exactly the same properties!) If you bind this list to the DataGrid it will use the default TwoWay binding without complaints.