Today I went to the WP7 boot camp in Minneapolis. Not many people have actually seen a Windows Phone 7 yet. I was hoping to see the real thing but it wasn’t available. Although, the dev tools are ready and very robust.

Getting started is easy using the developer tools and developer training kit. After downloading and playing around I really hope WP7 is a success. The development experience is slick if you are willing to embrace XAML or XNA.

A note about the install. If you have a full version of Visual Studio it will integrate with that. Otherwise it will install Visual Studio express. A few people in the group were confused when they opened express and the tools were not available as they already had VS2010 installed. (Note, it might be safer to use VS Express for now with this beta if you can. The presenter was having issues adding service references with VS Pro but it works in express.)

Since the first part of the conversation was about marketing information I ported over a Silverlight 3 test application which uses data binding and notifications to draw lines onto a canvas. All I had to do was copy the code verbatim and it ran on the phone. It took me 5 minutes. The ease of portability was impressive. Although, Silverlight is at a 60 – 65% adoption rate so portability is relative depending on market conditions.

Below are a list of notes that caught my attention during the talk. This is all based on a beta product so some of this may change. For the latest information download the WP7 Training Kit and visit the wp7 developer site.

Basics

• $100 fee to upload apps to market place. You get paid after you make the first $100 but Microsoft will take a cut for each sale.
• Has ability to upload app in trial mode
• Silverlight capabilities is basically Silverlight 3 plus additional features.

Known Issues with Emulator:

• Sometimes Emulator will not change from portrait to landscape if keyboard is enabled to be used. Hit PageDown to disable it
• When using VS Pro some users have not been able to add service references correctly. They didn’t generate the full proxy.

Tips and Tricks:

• Use PageUp and PageDown keys to enable keyboard in emulator.
• Emulator can be kept running and will store all opened apps.
• Blend can be used to test light and dark template available to phone users.

Tooling

• Code from Silverlight 3 should work on the phone with maybe only small tweaks for things like navigation and UI sizes.
• List Application (list and details page paradigm)
• Binding works just like in Silverlight
• DataContext works like Silverlight
• Input scopes “TelephoneAreaCode” and “EmailSMTPAdress”  allow you to change keyboard layout. Developer Note: You can use Verbose XAML syntax for intellisense. You can’t create your own input scopes right now. Demo in SDK uses reflection to explore input scopes.
• Accelerometer – can be used with emulator if laptop that has one built one in. Otherwise you can use accelerometer emulator using RX.
• Audio – leverage raw data override BufferReady event at regular intervals save and manipulate audio. About a 10ms delay. All available in SDK.
• Video elements – Media support is on the hardware – video decoding is down on the hardware. Only one media element on the page at the time. No video media brush. DRM
• XNA API can be used to bring in sounds and background sounds.
• JavaScript can talk to Silverlight in control – Silverlight to script wb.InvokeScript  – script to Silverlight wb_ScriptNotify. Window.external.Notify(string)

3rd Party Tools and Links

• MVVM light for wp7. Design Pattern.
•  Developer Note: Bing Maps Control not yet available but being developed.

Design

• All elements can be animated
• Elements can be projected onto 3d plane
• Templating – taking a control and laying a XAML rendering over the code base. Microsoft encourages using the metro theme but they did show a puzzle application that used templating to change buttons and panels.
• Styling can be set in the Application XAML resources or page resources.
• Two screen resolutions will be available.
• User can change the Theme
• Blend can be used to test dark and light themes available to users. Would only need to be done if you go off and build your own template. But if you use the metro theme you get the changes for free. For example, your applications buttons and backgrounds would be updated.
• App bar should be used to create consistent navigation and controls. How to: Add an Application Bar to Your Application on MSDN.
• App bar Icon set can be downloaded here.

Application Components

• Host (TaskHost)
• XAP file
• Pages (Silverlight)
• Content (Silverlight)
• Games (XNA)

Application Structure

• Apps are built like web sites
• Functionality is split into pages
• Forward navigation via links
• Backward navigation via Back (should use hardware button).
• Users can navigate across different applications
• Previous app (pages) are in the back stack. No multi tasking for third party apps. The back stack means your app is shut down.

Hardware buttons

• Back (only one you can inject into when it fires right now)
• Start
• Search
• Volume
• Camera

Feels like web design.

• Application state can be passed between pages by querystring and frame context.
• hyperlinks can be used to navigate to other pages.
• UriMapping which is similar to MVC URL routing.

Push Notification Service via the cloud (Microsoft Notification service)

• Developer Note: When the emulator starts it takes 30 seconds to instantiate notification service.
• Phones subscribe to a service on your server for events via a Uri.
• All communication pushed to phone is via Microsoft.
• Events are sent from a server to Microsoft push service.

Location Service:

• Developer Note: No Emulator Support – MSDN RX emulator can be created.
• Cell Tower, Satellite GPS, or WIFI can be used
• Developer Note: Use cell tower to save battery but less accurate

Types of Notifications on the Phone

• Tile Notifications –  Tile on homepage which has an image, number, and simple text.
• Toast – pop-up will link back to app.
• If the app is running raw data can be accessed and displayed.

Handling Life Time Events: Obscure VS Deactivated

Hidden By Shell UI: Obscured

• On Obscure you need to handle it gracefully then when un obscure you need to start.

Moved to background: Deactivated

• Deactivate event fires
• Your app becomes suspended (you have a limited time to handle but not specified yet)
• State will be destroyed eventually if user doesn’t go back. Assume your app is killed.
• If user goes back to application Activate event will be fired
• You can load state via isolated storage and resume where you left off

Interesting Questions asked during the presentation:

• Question: Are ODBC drivers available or ported? Answer: Someone suggested using isolated storage for this instead.
• Question: Does page Navigation come with default animation? Answer: It doesn’t come with a default animation. But you can add them in by intercepting the navigation event.
• Question: How is back stack clean up done and can it be prioritized? Answer: Presenter guessed that it might be resource based but not sure yet.
• Question: Can you control the Antenna for GPS? Can you turn it off or on and receive notifications when it is ready? Answer: Start and Stop service might be used for this but not sure. It looks like the API only tries to use it if available. Look at Location example in SDK.

Links

• http://www.silverlight.net/
• http://developer.windowsphone.com/
• http://slickthought.net/ Jeff Brand’s Site
• Programming Windows 7 Phone 

The latest release of Entity Framework CTP4 has some nice but unexpected changes. They introduced DbContext and DbSet to simplify model caching, database provisioning, schema creation and connection management. Here are my top 5 favorite features of the release.

1. Less code and fewer Concepts. The coolest part is the use of convention over configuration. See the Productivity Improvements walk through and Conventions for code first. I like the extra touch that DbContext  will create the database for you if you want. No code to write. Just use the default CreateDatabaseOnlyIfNotExists.
2. Simplified Database Experience. With the introduction of DbContext and DbSet. EF now takes care of database provisioning, schema creation and connection management. Nice! My favorite part is the Interface IDbConnectionFactory to allow creation of your own conventions.
3. Backwards Compatible. Yes, this is a feature when it comes to CTP’s and Betas. Some projects might just throw stuff away or completely change things on you. EF allows you to still use ObjectContext or Data Annotations for advanced scenarios where common conventions don’t work for you.
4. Simplified Configuration Experience. As I mentioned you can use annotations for this but you also have another cool option. DbContext includes a virtual method that can be overridden to do configuration right in the class. This means no need for separate configuration classes now. I definitely like having it all in one place. Much cleaner and easy to read.
5. Testability IDbSet<TEntity> allows you to define an interface that can be implemented by your derived context. This allows the context to be replaced with an in-memory test double for testing.

In addition, I added Inversion of Control (IOC) using Castle Windsor and implemented a repository pattern.

My database generation script and test data now look like this.

databasefactory.Create();
var repository = new HolidayRepository(databasefactory);

//... build up test data for xmas and newyear

repository.Add(xmas);
repository.Add(newYear);

//commit changes
var unitOfWork = new UnitOfWork(databasefactory);
unitOfWork.Commit();

The other interesting part of this sample project is using WCF and EF together and WCF dependency injection using Castle Windsor.

First I setup my interfaces and configuration files for EF and WCF.

[DataContract]
public class Holiday : IEntity
{
    public long Id { get; set; }

    [DataMember]
    public string HolidayName { get; set; }

    [DataMember]
    public DateTime HolidayDate { get; set; }

    [DataMember]
    public ICollection<holidayevent> HolidayEvents {get; set;}
}

[DataContract]
public class HolidayEvent : IEntity
{
    public long Id { get; set; }

    [DataMember]
    public string EventName { get; set; }

    [DataMember]
    public Holiday Holiday { get; set; }

    [DataMember]
    public long HolidayId { get; set; }
}

public HolidayConfiguration()
{
    Property(h => h.Id).IsIdentity();
    Property(h => h.HolidayName).HasMaxLength(1000).IsRequired();

    Relationship(e => e.HolidayEvents).FromProperty(h => h.Holiday);
}

public HolidayEventConfiguration()
{
    Property(e => e.Id).IsIdentity();
    Property(e => e.EventName).HasMaxLength(1000).IsRequired();

    //HolidayId is a FK property and Holiday is a navigation property backed by this FK
    Relationship(e => e.Holiday).FromProperty(h => h.HolidayEvents).HasConstraint((e, h) => e.HolidayId == h.Id);
}

In my .svc file I use a custom factory to do dependency injection

Factory="Castle.Facilities.WcfIntegration.WindsorServiceHostFactory, Castle.Facilities.WcfIntegration"

On startup, I add my HolidayService as a component and add the DatabaseFactory as a parameter. The DatabaseFactory is used to setup my EF Object Context.

container.Register(Component.For<iholidayservice>().ImplementedBy<holidayservices>().DependsOn
    (Property.ForKey("databaseFactory").Eq(databaseFactory)));

A great resource for seeing many of the new features in EF CTP3 is the shrinker project. This is where I found many great examples of property facets and relationships using Entity Framework.

MemoryIndex, contributed by Wolfgang Hoschek, is a fast RAM-only index designed to test whether a single document matches a query. InstantiatedIndex, contributed by Karl Wettin, is similar, except it’s able to index and search multiple documents. Unfortunately, neither of these are yet ported to .Net. I thought about trying to port these but figured I would see if I could build a simple reverse search using the slower built in RamDirectory in Lucene and Lucene.net.

So what I want to create is a reverse search or on-the-fly matchmaking for documents. A simpler way to say that is I take a list of queries and check if they match a data object each time a data object is created. For simplicity sake I’m only working with the already ported Lucene code.

One cool features in Lucene version 2.9 was the addition of Near Real Time (NRT) searching. This seemed like a good fit for my scenario of trying to create a faster reverse search. It provides a way to search for documents that have not been committed yet. This helps take some of the overhead off when I need to add the one document to the index before running all the queries to test for matches. The explanation from the book says NRT enables you to rapidly search changes made to the index with an open IndexWriter, without having to first close or commit changes to that writer.

The NRT features allows me to do something like this:

It seems to be a big memory hog though so I made it disposable.

 public class QueryProcessor : IDisposable
    {
        private readonly RAMDirectory _directory;
        private readonly IndexWriter _writer;

        public MetaQueryProcessor()
        {
            _directory = new RAMDirectory();
            _writer = new IndexWriter(_directory, new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_CURRENT), IndexWriter.MaxFieldLength.UNLIMITED);
            _writer.SetMergeFactor(2);
        }

        public void Optimize()
        {
            _writer.Optimize();
        }

        public List<string> Search(List<metaqueryrequest> requests, Document doc)
        {
            _writer.AddDocument(doc);

            var results = new List<string>();

            foreach (var request in requests)
            {
                var reader = _writer.GetReader();//Near-real-time search not commited

                var indexSearcher = new IndexSearcher(reader);

                var primitiveQuery = request.LuceneQuery.Rewrite(reader);

                var hits = indexSearcher.Search(primitiveQuery, 1);

                if (hits.totalHits > 0)
                {
                    results.Add(request.QueryName);
                }
            }

            _writer.DeleteAll();

            return results;
        }

        #region IDisposable Members

        public void Dispose()
        {
            _directory.Close();
        }

        #endregion
    }

If you know of a faster way to accomplish this please let me know. For more background information on this topic see these resources.

• MemoryIndex contrib project Lucene
• InstantiatedIndex contrib project Lucene

I started reading Lucene in Action by Otis Gospodnetic´ and Erik Hatcher.  Lucene is a high performance, scalable Information Retrieval (IR) library. The library is in Java but I’m using the book to understand the Lucene .Net port.

Why buy a Java book to learn a .net Library? I couldn’t find a book specifically for the .Net version. Also, I wanted a 1000 foot level view of search technologies and because this is my first time working with IR. I was pleased to find the .net version is akin to the Java version presented in the book.

In some ways, learning from a different language has been beneficial. I invested more time converting the presented samples to C#. I’ve also read Mathematics and Physics for Programmers which was completely written in a pseudo language. Again, lots of fun to convert the presented samples to a language I was more comfortable with.

It was also nice to find that the open source project Subtext is using Lucene .Net. They’ve worked out some locking issue recently and seem to be getting things setup in a nice way. Also, my co workers Kevin and Tim put together a nice library for Lucene .Net called ActiveLucene.Net – Attributed Lucene.Net. The largest project seems to be Linq to Lucene but I haven’t looked at it yet. It was helpful to see how others are integrating Lucene into the Microsoft Web Platform.

Anyway, here are the indexer and searcher in my C# interpretation. These are the first snippets presented in the book. These are a great way to get a jump start into understanding the basics.

Indexer

readonly static SimpleFSLockFactory _LockFactory = new SimpleFSLockFactory();

static void Main(string[] args)
{

    var dataPath = ConfigurationManager.AppSettings["DataDirectory"];

    var indexPath = ConfigurationManager.AppSettings["IndexDirectory"];

    if (!System.IO.Directory.Exists(dataPath))
    {
        throw new IOException(dataPath + " directory does not exist");
    }

    DirectoryInfo indexInfo = new DirectoryInfo(indexPath);

    DirectoryInfo dataInfo = new DirectoryInfo(dataPath);

    Lucene.Net.Store.Directory indexDir = Lucene.Net.Store.FSDirectory.Open(indexInfo, _LockFactory);

    var start = DateTime.Now.TimeOfDay;
    var numIndexed = Index(indexDir, dataInfo);
    var end = DateTime.Now.TimeOfDay;

    var delta = end.TotalMilliseconds - start.TotalMilliseconds;

    Console.WriteLine("Indexing " + numIndexed + " files took " + delta.ToString() + " milliseconds");
}

public static int Index(Lucene.Net.Store.Directory indexDir, DirectoryInfo dataInfo)
{
    var writer = new IndexWriter(indexDir, new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29), IndexWriter.MaxFieldLength.UNLIMITED);
    writer.SetMergePolicy(new LogDocMergePolicy(writer));
    writer.SetMergeFactor(5);

    try
    {
        var paths = dataInfo.EnumerateFiles("*.txt");

        foreach (var path in paths)
        {
            IndexFile(writer, path);
        }
    }
    catch (Exception ex)
    {
        writer.Close();
        throw ex;
    }

    var numIndexed = writer.MaxDoc();
    writer.Optimize();
    writer.Close();

    return numIndexed;
}

private static void IndexFile(IndexWriter writer, FileInfo file)
{
    if (!file.Exists)
    {
        return;
    }

    Console.WriteLine("Indexing " + file.Name);

    Document doc = new Document();

    var path = file.FullName;

    System.IO.TextReader readFile = new StreamReader(path);

    doc.Add(new Field("contents", readFile));

    doc.Add(new Field("filename", file.Name,
        Field.Store.YES,
        Field.Index.ANALYZED,
        Field.TermVector.YES));

    writer.AddDocument(doc);
}

Searcher

public static SimpleFSLockFactory _LockFactory = new SimpleFSLockFactory();

static void Main(string[] args)
{
    if (args.Length < 2)
    {
        Console.WriteLine("Searcher takes two parameters");
        Console.WriteLine("Usage: ConsoleSearcher <index dir> <query>");
    }

    var indexInfo = new DirectoryInfo(args[0]);
    var query = args[1];

    if (!System.IO.Directory.Exists(args[0]))
    {
        throw new IOException(args[0] + " directory does not exist");
    }

    SearchOption(indexInfo, query);
}

private static void SearchOption(DirectoryInfo indexInfo, string query)
{
    Lucene.Net.Store.Directory indexDir = Lucene.Net.Store.FSDirectory.Open(indexInfo, _LockFactory);

    IndexSearcher indexSearcher = new IndexSearcher(indexDir, true);

    QueryParser parser = BuildQueryParser();
    var luceneQuery = parser.Parse(query);

    var start = DateTime.Now.TimeOfDay;

    var hits = indexSearcher.Search(luceneQuery);
    var end = DateTime.Now.TimeOfDay;

    var delta = end.TotalMilliseconds - start.TotalMilliseconds;

    Console.WriteLine("Found " + hits.Length() + " document (s) (in " + delta.ToString() + " milliseconds) that matched query '" + query + "':");

    for (int i = 0; i < hits.Length(); i++)
    {
        Document doc = hits.Doc(i);

        Console.WriteLine(doc.Get("filename"));
    }
}

private static QueryParser BuildQueryParser()
{
    var parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_29, "contents", new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29));
    parser.SetDefaultOperator(QueryParser.Operator.AND);
    return parser;
}

My head is spinning from looking at Odata tonight. I keep going back and forth on if this is the coolest thing in the world or just a way to browse data via the URI. Either way it’s fun. Below are my notes and examples showing some limitations and features of Odata.

The first area I had some misunderstandings was when working with collections. Take a look at this question on StackOverflow “use linq to query nested odata collection“. This pretty much sums up the issue I was stuck on for awhile. How do relationships work and how can I query collections. This blog post helped me start to understand how keys and collections work.

Then, I find this post and this collection of resources. Now, I’m back to being sold on oData. The ease of filtering data is amazing. Filters also support functions if needed. Thanks to this tip for pointing that out.

Here is a set of examples for the Odata Netflix feed. I’ve listed the URI with the corresponding C# expression below.

http://odata.netflix.com/Catalog/Titles?$filter=Name eq ‘The Name of The Rose’

(from t in Titles
where t.Name == "The Name of The Rose"
select t)

http://odata.netflix.com/Catalog/Titles?$filter=AverageRating lt 2 and Instant/Available eq true

(from t in Titles
where t.AverageRating < 2 && t.Instant.Available == true
select t)

http://odata.netflix.com/Catalog/Titles?$filter=ReleaseYear le 1989 and ReleaseYear ge 1980 and AverageRating gt 4&$expand=Awards

(from t in Titles.Expand("Awards")
where t.ReleaseYear < 1989 && t.ReleaseYear > 1980 && t.AverageRating > 4
select t)

http://odata.netflix.com/Catalog/Titles?$filter=Type eq ‘Movie’ and Instant/Available eq true and (Rating eq ‘G’ or Rating eq ‘PG-13′)

(from t in Titles
where t.Type == "Movie" && t.Instant.Available == true && (t.Rating == "G" || t.Rating == "PG-13")
select t)

http://odata.netflix.com/Catalog/Titles?$filter=Type eq ‘Movie’ and Instant/Available eq true and (Rating ne ‘R’ and Rating ne ‘NC-17′ and Rating ne ‘UR’ and Rating ne ‘NR’)

(from t in Titles
where t.Type == "Movie" && t.Instant.Available == true && (t.Rating != "R" && t.Rating != "NC-17" && t.Rating != "UR" && t.Rating != "NR")
select t)

http://odata.netflix.com/Catalog/People?$filter=Name eq ‘James Cameron’&$expand=Awards,TitlesDirected

(from p in People.Expand("Awards").Expand("TitlesDirected")
where p.Name == "James Cameron"
select p)

http://odata.netflix.com/Catalog/Languages(‘Japanese’)/Titles?$filter=Type eq ‘Movie’”

(from l in Languages
from t in l.Titles
where l.Name == "Japanese" && t.Type == "Movie"
select t)

http://odata.netflix.com/Catalog/Languages(‘French’)/Titles?$filter=Type eq ‘Movie’ and Rating eq ‘UR’

(from l in Languages
from t in l.Titles
where l.Name == "French" && t.Type == "Movie" && t.Rating == "UR"
select t)

http://odata.netflix.com/Catalog/Genres(‘Horror’)/Titles/$count?$filter=Type eq ‘Movie’

(from g in Genres
from t in g.Titles
where g.Name == "Horror" && t.Type == "Movie"
select t).Count();

http://odata.netflix.com/Catalog/Genres(‘Horror’)/Titles?$filter=ReleaseYear le 1979 and ReleaseYear ge 1970

(from g in Genres
from t in g.Titles
where g.Name == "Horror" && t.ReleaseYear < 1979 && t.ReleaseYear > 1970
select t)

http://odata.netflix.com/Catalog/Titles(‘BVIuO’))

(from t in Titles
where t.Id == "BVIuO"
select t)

http://odata.netflix.com/Catalog/Genres(‘Romantic Comedies’)/Titles?$filter=Type%20eq%20′Movie’ and round(AverageRating) ge 5&$orderby=year(Instant/AvailableFrom)

(from g in Genres
from t in g.Titles
where g.Name == "Romantic Comedies" && t.Type == "Movie" && Math.Round(t.AverageRating.Value) > 5
orderby t.Instant.AvailableFrom
select t)

This weekend I drove to Chicago for Microsoft Web Camps not knowing what to expect. I definitely didn’t think I would win a purse and a cool t-shirt. So how did this happen?

Web Camps is a two day event. The first day is all learning and was presented by James Senior and Jon Galloway who did an excellent job.

The second day was a build day. You get into groups and build an application. Then at the end of the day all the teams got to demo. Thanks to my team members Mark Greenway and Tim McManemy, we got first place!

Our application was called Fact or Crap. Basically you could submit a statement and others could vote if it is true or false. We used MVC2, JQuery templating, and Entity Framework.

Hopefully Microsoft will do this again next year. This was probably the most fun I have had programming in awhile. Everyone learned a ton and made some new friends.

Binding is a fundamental part of Silverlight and allows developers to create a relationship between a UI property and a CLR object. Unfortunately, it can be a little confusing at first. Is it worth the trouble getting use to the syntax?

<object property=”{Binding}” …/>

It’s entirely possible to update the Silverlight presentation layer without using binding. Although with the use of binding you can make your code more reusable and easier to extend. Especially if you have multiple web requests that update the view. I’m not saying binding is a silver bullet. It can be very frustrating to track down issues and getting the syntax correct. But used in the right situations it can be very useful.

I’m not a Silverlight expert and I won’t be able to cover every detail of binding. I’ll start by covering some basic syntax. Then give an example using notification properties and dependencies properties. Then I will finish with a list of links and resources to find more information about MVVM and Silverlight 4.

Basic Binding Syntax

Let’s look at an example using an object named Cat and we will bind to the Speak property.

namespace BindingPatterns.ViewModel
{
    public class Cat
    {
        public string Speak { get; set; }
    }
}

From now on I won’t include this much XAML detail but I wanted to be clear on the first example. Notice the name space of where the Cat class is located is added.

<usercontrol x:Class="BindingPatterns.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"
    xmlns:data="clr-namespace:BindingPatterns.ViewModel"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">

    </usercontrol><usercontrol .Resources>
        <data :Cat x:Key="ViewModel" Speak="meow" />
    </usercontrol>

    <grid x:Name="LayoutRoot">
        <textblock x:Name="CatSound" Text="{Binding Path=Speak, Source={StaticResource ViewModel}}"></textblock>
    </grid>

I know this isn’t very useful but it’s only to demonstrate the binding. What happens first in this example is the Cat class is instantiate as a static Resource. Then we set the Speak property to “meow”. Finally we bind the TextBlock to the Speak property of that class. We have to include the Source attribute to tell where the CLR binding is located.

Another way we could do this is using the data context. Once “ViewModel” (which is the Cat class) is added to the DataContext we can reference directly in the TextBlock via the public property “Speak”.

<grid x:Name="LayoutRoot" DataContext="{Binding Source={StaticResource ViewModel}}">
    <textblock x:Name="CatSound" Text="{Binding Path=Speak}"></textblock>
</grid>

To simplify more you can leave off the Path and just use the following.

<textblock x:Name="CatSound" Text="{Binding Speak}"></textblock>

Notice the TextBlock no longer needs a Source extension because it looks in the DataContext by default. A reason to use the DataContext is child controls can also access this. When you add a binding to that control first it will check the current UserControl and if it can’t be found it will check the parents DataContext. For example, let’s move the TextBlock into a separate user control called CatControl. Then we could get the same result as above using this.

<grid x:Name="LayoutRoot" DataContext="{Binding Source={StaticResource ViewModel}}">
        <control :CatControl></control>
</grid>

Instead of using the Static Resource you can set the DataContext in C# as long as the control is initialized by doing the following.

public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();
            DataContext = new Cat { Speak = "meow in C#" };
        }
    }

The binding syntax also supports drilling into properties of properties using dot notation.

<textblock x:Name="CatActivity" Text="{Binding CatActivity.Scratch}"></textblock>

var activity = new CatActivity(){Scratch="scratchy"};
DataContext = new Cat { Speak = "meow in C#", CatActivity = activity };

Binding with Notification and Dependency Properties

An example where binding, notifications, and dependency properties show their power is when you need to make multiple Async web requests which have dependencies.

To use notifications you need to inherit from INotifyPropertyChanged. Then you can setup properties that will notify a binding when they change. For example, to update the quote we could have a notification property setup that would get updated by the request callback.

        private Quote _quote;
        public Quote Quote
        {
            get { return _quote; }
            set
            {
                _quote = value;
                NotifyPropertyChanged("Quote");
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }

<textblock x:Name="Price" Text="{Binding Quote.Price}"/>
<textblock x:Name="Price" Text="{Binding Quote.PercentChange }"/>

For the Chart State we can setup a dependency property that will change the chart user control as needed. In this case we do some drawing and background changes.

public static readonly DependencyProperty ChartStateProperty = DependencyProperty.Register(
            "ChartState",
            typeof(StateIndicator),
            typeof(LineChartControl),
            new PropertyMetadata(StateIndicator.NoChange, OnChartStateChanged));

        private static void OnChartStateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var lineChart = (LineChartControl)d;
            lineChart.CreateStateBackground((StateIndicator)e.NewValue);
            lineChart.ChangeLineColor((StateIndicator)e.NewValue);
        }

For a simpler example of notification binding we can go back to the cat example. Let’s setup the notification.

  public class Cat : INotifyPropertyChanged
    {
        public string Speak { get; set; }

        private CatActivity _catActivity;
        public CatActivity CatActivity
        {
            get { return _catActivity; }
            set
            {
                _catActivity = value;
                NotifyPropertyChanged("CatActivity");
            }
        }

        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }

         public event PropertyChangedEventHandler PropertyChanged;

     }

Then let’s make a button and a few fields to bind to the CatActivity property. Don’t take this as good coding practice. This is just a simplistic example to show how the notifications can be triggered.

        public Cat MyCat { get; set; }
        public MainPage()
        {
            InitializeComponent();

            var activity = new CatActivity(){Scratch="scratchy", Run="scramble"};
            MyCat = new Cat { Speak = "meow in C#", CatActivity = activity };
            DataContext = MyCat;
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            var newActivity = new CatActivity() { Scratch = "scratchy again", Run = "scramble again too" };
            MyCat.CatActivity = newActivity;
        }

When you click the button the following bindings will show “scratch again” and “scramble again too”.

<stackpanel>
    <button Click="Button_Click"></button>
    <textblock x:Name="CatSound" Text="{Binding Speak}"></textblock>

    <textblock x:Name="CatActivityScratch" Text="{Binding CatActivity.Scratch}"></textblock>

    <textblock x:Name="CatActivityRun" Text="{Binding CatActivity.Run}"></textblock>
</stackpanel>

SL4 and MVVM Links

• An early approach to MVVM on MSDN (http://msdn.microsoft.com/en-us/magazine/dd458800.aspx)
• Prism MVVM SL and WPF http://compositewpf.codeplex.com/
• SL4 Command Binding MVVM http://www.silverlight.net/community/samples/silverlight-samples/command-binding-in-silverlight-4-35238/

The major differences are the Mouse event names are different and you need to use a dispatcher to avoid cross thread issues. Check the Rx forums for more recent and efficient ways to do this for use in production code.

You will also need to add the System.CoreEx, System.Observable, and System.Reactive .Net references.

[raw]

// Observe MouseMove Events <!--

var mouseMove = from evt in Observable.FromEvent<mouseeventargs>(this, "MouseMove")
select evt.EventArgs.GetPosition(this);

// Observe Mouse LeftButtonUp Event --> // <!--

var mouseUp = from evt in Observable.FromEvent<mousebuttoneventargs>(this, "MouseLeftButtonUp")
select evt.EventArgs.GetPosition(this);

// Observe MouseLeftButtonDown Event --> <!--

var mouseDown = from evt in Observable.FromEvent<mousebuttoneventargs>(this, "MouseLeftButtonDown")
select evt.EventArgs.GetPosition(this);

// Calculate Movement and Display -->

var q = from start in mouseDown
        from delta in mouseMove.StartWith(start).TakeUntil(mouseUp)
            .Let(mm => mm.Zip(mm.Skip(1), (prev, cur) =>
                new { X = cur.X - prev.X, Y = cur.Y - prev.Y }))
        select delta;

q.Subscribe(value => textblock.Dispatcher.BeginInvoke(() =>
{
  Canvas.SetLeft(image,Canvas.GetLeft(image) + value.X);
  Canvas.SetTop(image,Canvas.GetTop(image) + value.Y);
}));

[/raw]

For a better explanation of this code check out John Skeets RX video at NDC 2010.

The act of sending mail is also incredibly complicated because spammers have abused the infrastructure for a decade. There are a few immune responses that are still effective, such as DKIM and Reverse PTR records. SenderID is another method, also based on DNS records, but it’s less well regarded. If you’re going to send email and you want it to arrive, you need to implement all this stuff!.

I agree with this completely and would like to add some additional information about bounce handling. So after you get your Feedback loop setup with all the major ISPs, don’t blow it and ruin your reputation! Get some good bounce handling rules put in place.

The at sign, required character of the e-mail address.

Bounce Handling Rules

Your server will be put on a IP blacklist if you don’t handle bounces correctly. After you send a bunch of email the job is not done. The methodology I use for bounce handling was adopted from ISIPP’s white paper Bounce Handling Process, Email Delivery Rejection, and Receiving System Policies. I’ve been very happy with the results. Below is a brief summary, without getting into too much detail.

Hard bounce Handling Policy:

• Description: If a hard bounce, spam complaint, unsubscribe feedback, or user initiated block is received I consider the email address dead and remove it immediately from all mailing lists.
• Frequency: I check for these types to be immediately removed every 15 minutes.
• Example: A hard bounce is permanent, “user unknown” being one good example.

Soft Bounce Handling Policy:

• Description: Email address will be considered dead if the following criteria are met.
• At least three delivery rejections have occurred in the last 30 days,
• and user has had no successful deliveries in the last 15 days.
• In addition, the time between the most recent delivery rejection and the initial delivery rejection is greater than 15 days.
• Frequency: It’s acceptable to handle these types of bounces once per day
• Example: Most commonly, a soft bounce is a temporary condition, such as “mailbox full.

Other areas you need to understand before sending emails include unsubscribe compliance, Mime Type Specifications, and email headers.