Dennis van der Stelt : Silverlight

Bing Maps on WPF and custom PushPin tutorial for PixelSense

Dennis van der Stelt — Wed, 17 Oct 2012 21:17:14 GMT

I’ve just came back from a trip to Washington DC, where I’ve been at the 50th IAM International Moving Annual Meeting. This was for my employer TellUs, who’s into lead generation for international removal companies. A lot of people asked for the reason why I went to the states, this is it. And of course because we bought a Microsoft PixelSense table which we used to visualize our data on.

The table had to ship however a little before we could finish the applications. After installing them at the convention, everything worked flawlessly. Well, until our sales representatives started working with it. We build a map with thousands of clustered pushpins on it. But there was a problem.

The push pins did not rotate when sales reps rotated the map!!!
For some reason we did not test rotation of the map on our desktop monitors. Go figure! ;-)

This blogpost is how I solved this issue.

Creating the map and adding pushpins
At the convention, we loaded data and placed push pins on the map. For this tutorial we’ll add them via the double-click event of your mouse. Rotation of the map will occur via clicking on the push pins. The push pins will rotate themselves according to rotation of the map. This tutorial was writing in Visual Studio 2010, because Visual Studio 2012 doesn’t support development for PixelSense (yet). If you are completely unfamiliar with adding push pins to a WPF Bing map, check out this tutorial on MSDN.

First, create a new project by pressing CTRL+SHIFT+N and select “WPF Application” under the “Windows” category. You should end up with an almost empty XAML file with a grid in it. Let’s first add the map to it. First add a reference to the Bing assembly that has all the controls. It should be located in one of the following folders

C:\Program Files\Bing Maps WPF Control\V1\Libraries\Microsoft.Maps.MapControl.WPF.dll
C:\Program Files (x86)\Bing Maps WPF Control\V1\Libraries\Microsoft.Maps.MapControl.WPF.dll

After having added the reference, add the namespace to the MainWindow.xaml and add the map. You should end up with the following code.

<Window x:Class="WpfApplication2.MainWindow"
                xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                xmlns:m="clr-namespace:Microsoft.Maps.MapControl.WPF;assembly=Microsoft.Maps.MapControl.WPF"
                Title="MainWindow" Height="350" Width="525">
    <Grid>
        <m:Map x:Name="myMap" CredentialsProvider="PutYourOwnKeyHere-ItShouldBeVeryLong" />
    </Grid>
</Window>

The CredentialsProvider should have a key that you’ve requested on this page or follow the short tutorial on this page. After adding the key you can already run the application and be able to zoom and pan the map.

Adding PushPins from code
As you can see in the above code, I’ve already given my map a name via x:Name attribute. This way I can access my map from code-behind. This way I can set up my code for the double-click event on the map so I can add a PushPin on every double-click by the user. We’ll quickly run through the code, which shouldn’t be very complex.

public partial class MainWindow : Window
{
    int counter = 0;

    public MainWindow()
    {
        InitializeComponent();

        myMap.MouseDoubleClick += new MouseButtonEventHandler(myMap_MouseDoubleClick);
    }

    private void myMap_MouseDoubleClick(object sender, MouseButtonEventArgs e)
    {
        e.Handled = true;

        Point mousePosition = e.GetPosition(this);
        Location pinLocation = myMap.ViewportPointToLocation(mousePosition);

        Pushpin pin = new Pushpin();
        pin.Location = pinLocation;
        pin.Content = counter += 10;
        pin.MouseDown += new MouseButtonEventHandler(pin_MouseDown);

        myMap.Children.Add(pin);
    }

    private void pin_MouseDown(object sender, MouseButtonEventArgs e)
    {
    }
}

On line 3 you see a counter variable, which we’ll use to add unique push pins to our map. In the constructor MainWindow() you can see that we set up the handler for the double-click event. This is standard .NET code. In the myMap_MouseDoubleClick event handler, we first set e.Handled to true. Otherwise the map control will try to handle the click itself as well, making it zoom-in every time we add a push pin.

In the next two lines we try to retrieve the exact location where we clicked. This can all be viewed in the MSDN documentation and is standard behavior. Then we instantiate a new Pushpin object, give it the location we just ‘calculated’ and add the value of the counter variable to it as content. As you can see we’ve also already set up the event handler for when we press the pushpin itself.

At line 24 we add the Pushpin to the map so that it will be shown. You can now run this application and start double clicking on the map yourself.

Rotating the map & Pushpins
We will now rotate the map as a reaction of the Pushpin that is being clicked by the user. Edit the event handler for the Pushpin click as follows

private void pin_MouseDown(object sender, MouseButtonEventArgs e)
{
    e.Handled = true;

    var pushPinContent = 0;
    var pushPin = sender as Pushpin;
    if (pushPin != null && pushPin.GetType() == typeof(Pushpin))
        pushPinContent = Convert.ToInt32(pushPin.Content);

    myMap.Heading = (double)pushPinContent;
}

As you can see we set the event as being handled again at line 3. The sender of the event should be a Pushpin, so we verify this first and then try to obtain the value of the content of the pin itself. After that, we set the heading of the map, which is the rotation. If you now run the application and start clicking the Pushpins (after adding a few), the map should rotate, but the Pushpins should not.

We can easily fix this by binding the heading property of the Pushpin itself, to the heading of the map control. This can be done by the following code, which should be placed directly before we add the Pushpin to the map control.

Binding binding = new Binding();
binding.Source = myMap;
binding.Path = new PropertyPath("Heading");
binding.Mode = BindingMode.OneWay;
pin.SetBinding(Pushpin.HeadingProperty, binding);

myMap.Children.Add(pin);

Customizing the Pushpin
We will now start customizing the Pushpin to make it show completely different from the default Pushpins. For this we need to create a ControlTemplate in the xaml file. First add a section for static resources in the root object, the Window. Then add the template for the Pushpin. In your existing xaml file, just place the following code directly before the <grid> element.

<Window.Resources>
    <ControlTemplate x:Key="CutomPushpinTemplate" TargetType="m:Pushpin">
        <Grid x:Name="ContentGrid" HorizontalAlignment="Center" VerticalAlignment="Center">
            <StackPanel>
                <Grid Margin="0" Width="33" Height="33">
                    <Rectangle HorizontalAlignment="Left" Margin="-0.208,13.238,0,-0.146" Width="10.555" Fill="#FF005167" RenderTransformOrigin="0.5,0.5">
                        <Rectangle.RenderTransform>
                            <TransformGroup>
                                <ScaleTransform/>
                                <SkewTransform AngleX="-23"/>
                                <RotateTransform Angle="-12.944"/>
                                <TranslateTransform/>
                            </TransformGroup>
                        </Rectangle.RenderTransform>
                    </Rectangle>

                    <Rectangle Fill="White" Stroke="#FF005167" RadiusX="5" RadiusY="5"/>

                    <ContentPresenter HorizontalAlignment="Center"
                                                                VerticalAlignment="Center"
                                                                Content="{TemplateBinding Content}"
                                                                ContentTemplate="{TemplateBinding ContentTemplate}"
                                                                Margin="0" TextBlock.FontFamily="Segoe UI" TextBlock.FontWeight="Bold" TextBlock.Foreground="#FFB8D30B">
                    </ContentPresenter>
                </Grid>
            </StackPanel>
        </Grid>
    </ControlTemplate>
</Window.Resources>

You can see we added a ControlTemplate which has a TargetType for our Pushpin objects. This we will bind to our Pushpins later. I’ve made the Pushpins look a bit like our TellUs logo and for this I needed a rectangle with rounded corners. Directly behind it I placed another rectangle that I skewed and rotated a bit to make it look a bit like a balloon. Then I added a ContentPresenter that should show the numerical value and I’ve also added some font settings to it. Nothing spectacular, but it’s nice if you know how to do it! ;-)

Now we move back to our code again and we need to do three things.

Locate the control template for our Pushpin
Bind it to our Pushpin
Set the PositionOrigin of our PushPin.

This setting of the PositionOrigin is important to us, because our customized Pushpin should be placed to the top and to the right of where we click. I’ve included some code that we already had for additional clarity of where to put the code.

ControlTemplate template = (ControlTemplate)this.FindResource("CutomPushpinTemplate");

Pushpin pin = new Pushpin();
pin.Template = template;
pin.PositionOrigin = PositionOrigin.BottomLeft;
pin.Location = pinLocation;
pin.Content = counter += 10;
pin.MouseDown += new MouseButtonEventHandler(pin_MouseDown);

If we run our application again it should look like this after adding a few Pushpins and rotating them.

Adding custom styling based on content of the Pushpin
Now one really interesting thing to do is setting the size of the content/text of the Pushpin based on the number. If we start adding a lot of Pushpins this way and we start adding pins that have a numerical value of higher than 999, the font is too big so the value will fall outside of the boundaries of the pin.

For this we need a ValueConverter first. Based on the value that is inside the content of the Pushpin, we’ll return the FontSize. This FontSize then needs to be set to the style of the ContentPresenter. First let’s have a look at the ValueConverter. Add this directly beneath your MainWindow class, so that (in this tutorial) we don’t have the additional hassle of namespace problems.

public class PushPinContentConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        int pushPinContentValue;
        if (int.TryParse(value.ToString(), out pushPinContentValue))
        {
            if (pushPinContentValue >= 1000)
                return 12;
            else
                return 15;
        }

        // If convert fails!
        return 14;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

As you can see we try to extract the content from the Pushpin and if the value is higher than (or equally to) a 1000, we’ll lower the FontSize. Now we need to add this converter to the static resources of the Window in the xaml. First add a namespace reference (as seen in line 5) and then add it as a resource itself (as seen in line 9).

<Window x:Class="WpfApplication1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:m="clr-namespace:Microsoft.Maps.MapControl.WPF;assembly=Microsoft.Maps.MapControl.WPF"
        xmlns:local="clr-namespace:WpfApplication1"
        Title="MainWindow" Width="700" Height="500">
    <Window.Resources>

        <local:PushPinContentConverter x:Key="MyContentConverter" />

Finally we need to add the styling to the ContentPresenter. The only thing changed is the element <ContentPresenter.Style> and the elements within it.

<ContentPresenter HorizontalAlignment="Center"
                                            VerticalAlignment="Center"
                                            Content="{TemplateBinding Content}"
                                            ContentTemplate="{TemplateBinding ContentTemplate}"
                                            Margin="0" TextBlock.FontFamily="Segoe UI" TextBlock.FontWeight="Bold" TextBlock.Foreground="#FFB8D30B">
    <ContentPresenter.Style>
        <Style>
            <Setter Property="TextBlock.FontSize" Value="{Binding Path=Content, RelativeSource={RelativeSource TemplatedParent}, Converter={StaticResource MyContentConverter}}" />
        </Style>
    </ContentPresenter.Style>
</ContentPresenter>

I advise you to no start the counter variable at 0, but at 970, for your own testing pleasure. It’d be a whole lot of clicks if you started at 0 to see the results at Pushpin 1000 and higher.

Conclusion
All in all it is not so difficult to add a custom Pushpin, rotate it according to the map rotation and have the content sized based on its value. But information is fragmented and (for example) setting a ControlTemplate is mostly only shown in code if you start searching for it. I hope it’s beneficial for you to see it all in one place.

Download the entire solution here.

If this was usable, leave a comment and tell me your problems and/or results. Thanks!

Silverlight vs. Windows Forms or ASP.NET

Dennis van der Stelt — Sat, 04 Dec 2010 22:15:56 GMT

Some time ago I went to a great presentation, organized by DotNed, held at Vicrea and given by Dennis Vroegop and Thomas Huijer. At some point Dennis Vroegop mentioned that he saw a lot of old Windows Forms developers, create WPF applications like they were still developing Windows Forms applications. What Dennis meant was that these developers were handling click events the same way they did before. At first I thought that he was talking about boring line of business (LOB) applications with just textboxes and buttons in them, without a cool design or something different in user experience (UX). In a series of posts I’ll see if I can lighten up both of our points. So this is not really a one versus the other, but more on showing you how Silverlight can help you create a better user interface and have more powerful databinding.

First I’m going to explain what I meant by creating a normal ListBox with layout that’s extremely hard to accomplish in Windows Forms. We’ll keep it extremely simple. After that I’ll show how you can do this with Master-Detail as well, very easily. And later I’ll show you how to do this with an MVVM implementation.

1. Creating a class and repository
We need some data and we normally get this from a database using webservices. In this example I’ll create a repository class, as I said I’m going to keep it extremely simple. Building webservices via WCF is discussed extensively throughout this weblog elsewhere.

We’ll take on of my favorite subjects, games. Let’s create a class that contains our data.

public class Game
{
    public string Name { get; set; }
    public int YearOfRelease { get; set; }
    public string Developer { get; set; }
    public string ImageUrl { get; set; }
}

Now let’s create our repository.

public class Repository
{
    public static ObservableCollection<Game> GetAllGames()
    {
        return new ObservableCollection<Game>()
        {
            new Game() { Name = "Assassin's Creed : Brotherhood", Developer = "Ubisoft", YearOfRelease = 2010, ImageUrl = @"http://upload.wikimedia.org/wikipedia/en/2/2a/Assassins_Creed_brotherhood_cover.jpg" },
            new Game() { Name = "Call of Duty: Modern Warfare 2", Developer = "Infinity Ward", YearOfRelease = 2009, ImageUrl = @"http://upload.wikimedia.org/wikipedia/en/d/db/Modern_Warfare_2_cover.PNG" },
            new Game() { Name = "FIFA 11", Developer="Electronic Arts", YearOfRelease = 2010, ImageUrl = @"http://upload.wikimedia.org/wikipedia/en/9/97/Fifa11_keyart_uk-492x600.jpg" },
            new Game() { Name = "Quake", Developer = "id Software", YearOfRelease = 1996, ImageUrl = @"http://upload.wikimedia.org/wikipedia/en/4/4c/Quake1cover.jpg" },
            new Game() { Name = "Half-Life", Developer = "Valve", YearOfRelease = 1998, ImageUrl = @"http://upload.wikimedia.org/wikipedia/en/f/fa/Half-Life_Cover_Art.jpg" }
        };
    }
}

I’ve put these two classes inside the Silverlight Application I’ve created. Now that we’ve got our data, let’s first create some layout that can present our games.

<UserControl x:Class="BindingExample.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">
    <StackPanel Orientation="Horizontal" VerticalAlignment="Top" Margin="10">
        <ListBox x:Name="gamesListBox" ItemsSource="{Binding}" Width="300" Height="300">
        </ListBox>
    </StackPanel>
</UserControl>

This is very basic and it doesn’t even show the right results as you can see in the first image below. Let’s change the XAML so that it’ll show the results we’d normally expect.

<StackPanel Orientation="Horizontal" VerticalAlignment="Top" Margin="10">
    <ListBox x:Name="gamesListBox" ItemsSource="{Binding}" DisplayMemberPath="Name" Width="300" Height="300">
    </ListBox>
</StackPanel>

As you can see, the only thing changed is the added DisplayMemberPath attribute. But we can do this in Windows Forms as well. Let’s do some magic.

<ListBox x:Name="gamesListBox" ItemsSource="{Binding}" Width="300" Height="300">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <StackPanel Grid.Column="1" Margin="3,0,0,0">
                <TextBlock Text="{Binding Path=Name}" FontWeight="Bold" Margin="0" Padding="0"/>
                <StackPanel Orientation="Horizontal" Margin="3,0,0,0">
                    <TextBlock Text="Released" Width="80" />
                    <TextBlock Text=": " />
                    <TextBlock Text="{Binding Path=YearOfRelease}" Width="50" Margin="0" Padding="0"/>
                </StackPanel>
                <StackPanel Orientation="Horizontal" Margin="3,0,0,0">
                    <TextBlock Text="Developer" Width="80" />
                    <TextBlock Text=": " />
                    <TextBlock Text="{Binding Path=Developer}" />
                </StackPanel>
            </StackPanel>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

Now this is nice. What’s happening here?

We removed the DisplayMemberPath attribute, as we are going to very specifically define how we want to see the data.
We’ve added a DataTemplate, which describes the visual structure of a data object, according to MSDN :-)
Next we’ve defined some StackPanels and TextBlocks to define where and how to show the data.
We’ve used more than one property from our Game class, some bold text and margins to make it more attractive.

I think this is very user friendly. Imagine a lot of customers in your database, some of them with names very alike or with offices in different locations. Instead of just seeing the name of the customer, you also get presented the location, etc. Now as these are games, there’s probably a little box art available somewhere on the web. Let’s show this as well. Imagine that instead of box art, you present photos of your customers their faces! ;-)

<ListBox x:Name="gamesListBox" ItemsSource="{Binding}" Width="300" Height="300">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition />
                    <ColumnDefinition />
                </Grid.ColumnDefinitions>
                <Image Source="{Binding Path=ImageUrl}" Width="50" Stretch="UniformToFill" Grid.Column="0" />
                <StackPanel Grid.Column="1" Margin="3,0,0,0">
                    <TextBlock Text="{Binding Path=Name}" FontWeight="Bold" Margin="0" Padding="0"/>
                    <StackPanel Orientation="Horizontal" Margin="3,0,0,0">
                        <TextBlock Text="Released" Width="80" />
                        <TextBlock Text=": " />
                        <TextBlock Text="{Binding Path=YearOfRelease}" Width="50" Margin="0" Padding="0"/>
                    </StackPanel>
                    <StackPanel Orientation="Horizontal" Margin="3,0,0,0">
                        <TextBlock Text="Developer" Width="80" />
                        <TextBlock Text=": " />
                        <TextBlock Text="{Binding Path=Developer}" />
                    </StackPanel>
                </StackPanel>
            </Grid>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

And this results in a very simple but very nice ListBox with very usable items. And the best part is that you can still use gamesListBox.SelectedItem to get the complete Game object, as you’d expect.

Of course it’s even better to add the DataTemplate to a resource, which will result in the following XAML.

<UserControl.Resources>
    <DataTemplate x:Key="gameDataTemplate">
        <Grid>
            ...
        </Grid>
    </DataTemplate>
</UserControl.Resources>
<StackPanel Orientation="Horizontal" VerticalAlignment="Top" Margin="10">
    <ListBox x:Name="gamesListBox" ItemsSource="{Binding}" Width="300" Height="300"
             ItemTemplate="{StaticResource gameDataTemplate}" />
</StackPanel>

I hope this clarifies my point on how you can enhance your boring Line of Business (LOB) application with better usability for your end users.

SDN Event June 2009

Dennis van der Stelt — Sat, 27 Jun 2009 13:52:41 GMT

Yesterday was a great day as the SDN Event took place in Houten. The location was really great and the food never has been better. The poll on the website shows others agree with me. Thanks to those who attended my sessions. Sorry to those who wanted to know more about SQL Data Services, but know that all I demoed yesterday in Silverlight 3 and .NET Ria Services should be (almost) immediately be transportable to Azure and SQL Data Services in the near future. I included scripts to generate the database for the Silverlight demo.

I have uploaded the slides and demos to the media section on BloggingAbout.NET.

Windows Azure (slides and demo)
Met Windows Azure kunnen we applicaties hosten in de cloud. Maar wat betekent dat voor onze applicaties? En wat is het verschil tussen de web-role en worker-role? En hoe communiceren deze? Hoe slaan ze data op? Wat betekent dit voor development en deployment? Deze vragen zullen beantwoord worden in een sessie met weinig slides maar veel code om een WCF service te bouwen waarmee we informatie over mobiele flitsers beschikbaar maken.
SQL Data Services and Silverlight 3 (slides and demo)
Silverlight 3 heeft nieuwe mogelijkheden om eenvoudiger met een backend systeem te communiceren en gegevens uit een database te bewerken. Met SQL Data Services kun je een database 'in the cloud' plaatsen waarna je geen zorgen meer hebt over infrastructuur. Maar wat zijn de mogelijkheden en wat is er anders dan bij een lokale database? Nog interessanter wordt het als we deze twee technologieën gaan combineren. In deze sessie zal getoond worden hoe met Silverlight een LOB applicatie is te realiseren met het door Windows Azure gehoste SQL Data Services als storage model.

If you have questions about Azure, Azure Storage, .NET Services, Silverlight or anything else, don’t hesitate to contact me. And know that we give courses about all these subjects as well at Class-A! :-)

Silverlight 3 SDK Beta 1

Dennis van der Stelt — Wed, 18 Mar 2009 15:06:55 GMT

Via Twitter @MarcelMeijer and SDN site, that Silverlight 3 SDK Beta 1 was just released, a few hours before Mix09.

PDC 2008 : Keynote 2

Dennis van der Stelt — Tue, 28 Oct 2008 17:07:04 GMT

Scott Guthrie is talking… Very fast what he’s talking about…

WPF 4.0 has touch
.NET 4.0 can be loaded in the same process as .NET 2.0
Visual Studio 2010 is build in WPF
Ability to create awesome visualizers in Vsual Studio 2010
Scott just shows us a 200 line code visualizer that replaces the normal /// comments with a nice box with much richer presentation
This runs on MEF
MVC will be released in upcoming months
jQuery intellisense support for Visual Studio 2008 right now.
ASP.NET news
- Better deployment options, like having multiple web.config files (or deltas) under the normal web.config
IIS smooth streaming for (amongst others) Silverlight streaming video will be released
Silverlight
- 1 in 4 machines have Silverlight installed, according to ScottGu
- New controls like Charting, TreeView, Dock Panel, etc.
  Full access to source code, of course
- Updated Silverlight designer in Visual Studio 2010, based on WPF work done for VS2010
- Run Silverlight inside and outside the browser

Strange, nothing about Silverlight 2.0 on mobile. There is a session about it though, but I’m going to “Oslo” sessions.

Silverlight 2.0 on mobile announced today

Dennis van der Stelt — Tue, 28 Oct 2008 16:58:46 GMT

Yesterday Alex and I spoke to some people and from two resources we got to learn that Silverlight for mobile devices will most likely be revealed today at the keynote by Scott Guthrie.

The best is, it’s already able to run managed code. So that means Microsoft is skipping the first version and is immediately releasing Silverlight 2.0 for mobile devices.

More on this today, most likely on many weblogs!

Silverlight 2 released!

Dennis van der Stelt — Tue, 14 Oct 2008 11:52:14 GMT

Silverlight 2.0 was just released a few hours ago! Awesome news! If you look at Scott Guthrie’s website, it was released a 3:07 AM. Some sick people over there! The first comment is more than three hours later, when people turned up for work! :-)

At Class-A we’re definitely going to provide training in Silverlight 2.0 so keep a watch on our site for more info. If you want to be mailed about it, get in contact with us and we’ll notify you.

If you want to get started with Silverlight 2, go get it here.

Silverlight and clearing its isolated storage

Dennis van der Stelt — Fri, 14 Mar 2008 14:07:45 GMT

I've been looking all around for information about Silverlight its Isolated Storage. I was doing some tests with storing files and wanted to clear the isolated storage. I'll repeat the same words for SEO purposes : clear silverlight isolated storage. :-)

After I finally found the folder myself, using Sysinternals ProcessMonitor, I searched again on the internet if anyone had referenced the folder yet. Of course the one and only Mike Taulty did. How come these three English chaps do so much great work?

The word is that the isolated storage for Silverlight is cleared when the browser cache is flushed, and perhaps it's because of the beta, but this wasn't my experience. If you want to clear the cache, go to the folder below, find the specific file(s) and delete them there.

C:\Users\Dennis\AppData\LocalLow\Microsoft\Silverlight\is

If you want more information about Isolated Storage in Silverlight 2, check out this page.

"How Do I?" Videos

Dennis van der Stelt — Wed, 12 Mar 2008 19:59:14 GMT

When people want start learning about .NET in general or a specific subject like Silverlight or security, can be send to the "How Do I?" videos. I do this myself a lot of times, because a lot of videos aren't 60+ minutes.

Just as a reminder to myself, the root url is this one.

Getting started with Silverlight 2

Dennis van der Stelt — Tue, 11 Mar 2008 07:21:36 GMT

If you're ready for Silverlight 2, here are some links to help you get started.

Guy Burstein has a complete list with all the downloads.
If you're running into troubles, here's a list that might help you.
Scott Guthrie has a bunch of tutorials online here.
Scott's tutorials can also be viewed in Silverlight video at Dan Wahlin's site.

And of course the regular sites like silverlight.net.

MIX08 announcements

Dennis van der Stelt — Wed, 05 Mar 2008 20:03:55 GMT

Last year was a surprise to developers that so much new technology was announced at MIX07. I was there and had a blast. This year I have to read the news from behind my pc. But I'm gathering all news for you and myself.

Silverlight 2 with GoLive license.
It's downloadable!
Silverlight 2 Beta 1 for Windows
Silverlight 2 Beta 1 for Mac
Silverlight 2 now has controls.
But that's not just it, you get source code and a lot (!) of unit tests for the controls. Always nice to have a look at.
Silverlight on Nokia phones
Microsoft announced that with the help of Nokia they're porting Silverlight to the Nokia S60. The plan is to show it during the keynote.
Read more...
Silverlight 2 for Windows Mobile
Yeah! All my dreams coming true! First .NET Compact Framework, then WCF and now Silverlight?! What could I want more?!
See the first mobile app in Silverlight here. This is IE though! :)
Silverlight 2 and Seadragon
Zooming in on extreme large images.
Silverlight and Sharepoint
Read about it here.
WPF & Shading support
Support for some cool hardware accelerated shaders! Do I hear WPF games?! :)
Internet Explorer 8 Beta 1
It's released, download here for Vista, download for WinXP here.

Awesome!

Silverlight 2.0

Dennis van der Stelt — Thu, 29 Nov 2007 22:48:53 GMT

You probably all read Scott Guthries weblog, so I don't even have to create a link to it! ;-)

But he just announced Silverlight 2.0. It's basically 1.1 with too many features to call it a point release. And while the list below isn't the final list, it's a cool list to see what's coming in 2.0. A beta with GoLive license will be released Q1 2008. Hopefully sooner than later. And instead of just playing around with it, I'll try to write some blog entries for it. One of my wishes is to build the Class-A WinterClass banner in Silverlight with snow that'll stick on the ground or even on the Class-A logo or so.

Here's Scott's list of new features in Silverlight 2.0

WPF UI Framework: The current Silverlight Alpha release only includes basic controls support and a managed API for UI drawing. The next public Silverlight preview will add support for the higher level features of the WPF UI framework. These include: the extensible control framework model, layout manager support, two-way data-binding support, and control template and skinning support. The WPF UI Framework features in Silverlight will be a compatible subset of the WPF UI Framework features in last week's .NET Framework 3.5 release.

Rich Controls: Silverlight will deliver a rich set of controls that make building Rich Internet Applications much easier. The next Silverlight preview release will add support for core form controls (textbox, checkbox, radiobutton, etc), built-in layout management controls (StackPanel, Grid, etc), common functionality controls (TabControl, Slider, ScrollViewer, ProgressBar, etc) and data manipulation controls (DataGrid, etc).

Rich Networking Support: Silverlight will deliver rich networking support. The next Silverlight preview release will add support for REST, POX, RSS, and WS* communication. It will also add support for cross domain network access (so that Silverlight clients can access resources and data from any trusted source on the web).

Rich Base Class Library Support: Silverlight will include a rich .NET base class library of functionality (collections, IO, generics, threading, globalization, XML, local storage, etc). The next Silverlight preview release will also add built-in support for LINQ to XML and richer HTML DOM API integration.

Technorati Tags: Silverlight

Mobile development

Dennis van der Stelt — Wed, 24 Oct 2007 10:13:20 GMT

Two weeks ago Mike Schroepfer, a Mozilla developer, announced that they'll launch a version of Firefox that can be run mobile devices. If you own a Windows Mobile device, you're probably craving for a better browsing experience, just like I am. I've seen Deepfish, a new browser by Microsoft, but it's in early betas.

The interesting part however is that, according to Mike Schroepfer, mobile devices currently outsell computers 20 to 1. I remember Microsoft saying in some article or at some conference that by 2010 a total of 1 billion people will be accessing the internet using mobile devices. These numbers hopefully make you consider if the mobile market is worth investing in, especially being a developer.

At Class-A we're busy with our own mobile development training. We're not using standard Microsoft (MOC) material, but creating our own, so we can incorporate best practices and use .NET Compact Framework 3.5, which Microsoft probably won't have material for, for a long time. This features LINQ and WCF which are great enhancements. I've just blogged about the .NETCF 2.0 application I've been building, and the next step is to build it again in .NETCF 3.5.

If you experience the Compact Framework for the first time, it might be a though start. But once you get it, it's a really fun experience building on an entirely different platform. It's not the C# that's difficult, it's the new challenges like the user interface, different screen resolutions, connections and synchronizing data between your device and the server, performance considerations that are completely different from the full .NET Framework, etc. But when you put some time in it, it's really rewarding to see your application running on a mobile device and having other people enthusiastic about it.

Although LINQ is the 'expected' next evolution in programming, I think people can't even start to wonder what will happen in the mobile world. How it will advance on both hardware and software. Will we keep small screens or walk around with large origami like pc's? What will be possible on your mobile, especially with Silverlight mobile on the way.

The mobile platform is sure something that has my attention and I hope more people will join me. Together we can create a great future.
Wow, does that sound like a dull marketing line! ;-)

Technorati Tags: Windows Mobile, Compact Framework

Class-A Summer Classes become Winter Classes

Dennis van der Stelt — Thu, 04 Oct 2007 07:08:16 GMT

As I really enjoyed giving the Summer Classes a few weeks ago, the first ever real .NET 3.5 class world wide, I'm really pleased to announce the Winter Classes. Although the date hasn't even been set, we're planning it around the end of January or start of February. The classes will be the same as last time

.NET 3.5 Summer Class
Business Intelligence Summer Class

The location to be will again be the Badhotel Domburg. We really enjoyed it there last time with great facilities and a great bar to hang out and reflect on the things learned that day.

We'll redo the subjects from the last time, but update everything for the then expected to be released .NET Framework 3.5, with perhaps some new stuff that'll be released by then. Subjects we covered in our .NET 3.5 class last time are:

Language enhancements in C# 3.0 and VB 9.0
Visual Studio 2008 enhancements
ASP.NET AJAX extensions
LINQ and LINQ to XML
LINQ to SQL
Where does LINQ (and LINQ to SQL) fit in my architecture?
WCF and WF integration
Programming the web with WCF v2
.NET Compact Framework 3.5
Silverlight
Entity Framework
What else is new in .NET 3.5 (for everything we didn't cover yet)

This means a complete coverage of everything new in .NET Framework 3.5. So when you've visited our class, you'll know everything there is to know in a weeks time! And of course with the Class-A labs that make you think about the solution, instead of bothering you with setting colors on buttons and div's! ;-)

We'll also have enough discussion about everything new and you can ask questions just about anything. We'll also prepare a few games so we can have some fun if you enjoy this!

For the Business Intelligence class and more info about the .NET 3.5 class you can visit the Class-A website. It's currently not updated yet for the Winter Class, but it soon will be.

Technorati Tags: WCF, Silverlight, .NET Framework 3.5, .NET Compact Framework 3.5, Mobile Development, LINQ, LINQ to SQL

.NET 3.5 Summer Class was... awesome!

Dennis van der Stelt — Mon, 17 Sep 2007 14:07:21 GMT

The weekend-after has passed and I've slept through most of it. Man did we use up some hours (some nights we went on with the training until 23:00 hours) and especially the last night when we drank past the bar its closing hours and went on in a local pub in Domburg!

But of course it wasn't about partying, but about .NET 3.5. And I really think we discussed everything there is in .NET 3.5 and even more. On the last day, we discussed Silverlight and the Entity Framework even.

The evaluations were great, with most of them replying that it was so much. But as expected, still one step ahead. Both students and us still need to think about how we are going to write our software in the future, especially when you start to realize that LINQ and the other new features is so much more then just querying a database.

Thing is, we at Class-A had a great time organizing it, preparing for it and finally presenting it. I know the students had a great time and I really hope they get the opportunity to use .NET 3.5 in their daily lives.

This week it's up to Mike, Anko and Astrid and their Business Intelligence Summer Class, going through everything that's SQL Server and accompanying products.