The holidays are just about to end, but there's still time to boost your knowledge or learn something totally new.

Durint these 2 weeks we'll be giving the fourth and final topic of this summer issue their place in the sun, namely the Web and the web browser. Click through and you'll find all the best resources, presented based on the amount of time you want to spend on it.

Explore and dive into Web solutions

What is the most used application on a computer nowadays? Most likely it will be the web browser.  The Web and the web browser have quickly become a user's natural habitat, a familiar environment, and with Web 2.0, a place to work, interact and play.

You as an independent software vendor (ISV) can take advantage of this in many ways.  The Web provides you a marketing platform to reach out to millions of potential customers for your application.  In that case, you will want to fully show the beauty of the web on your website to stand out and attract these customers.

On the other hand, you can use the Web as your application platform to build web applications or to extend your desktop application with existing web services (e.g. mapping unctionality, social media integration, etc.) to augment your core application usiness value.

Have  look at our website and discover a handpicked choice of articles, white papers nd videos explaining what Microsoft web technologies can bring to you as an ISV.

Speaker : Nick Trogh

Other interesting Summer Campaigns :

-For IT Professionals : Virtualisation(Part 1), Desktop Deployment,Virtualisation (Part 2), Best of TechDays 2011

-For Architects : Cloud Power, the Windows AzurePlatform, Cloud Patterns and Practices, Windows Azure Platform Interoperability

-For Developers : Windows Phone 7 Mango, Visual Studio 2010 ALM, HTML5, The Windows Azure Platform

In all seriousness, with the online world becoming increasingly complex with its distributed services communicating over various protocols, information that materializes on end points as plain text, and non-uniform payment service policies—with the cherry on top being non-uniform identity of communicating parties—well, business can get messy. MSR researchers Shuo Chen and Shaz Qadeer, as well as PhD student and key author of this really interesting research paper, Rui Wang, join me for a conversation about the implications of this research(another author of the paper is XiaoFeng Wang of Indiana University Bloomington). Most importantly, however, I try to get them to give me the details about how I can fool online merchants into shipping me goods for free (just kidding!) and what they think is needed to fix this problem in a mathematically precise fashion (static/dynamic analysis, security-based policy languages for CaaS, etc.).

Here are some of the reports we got from the users:

• The application is too slow when exchanging currencies
• It uses too much data traffic/should cache the exchange rates
• It doesn’t work for some currencies
• The results are inaccurate/using out-of-date exchange rates

So, what we can see from these comments is that we need a better data source, and that we should use some sort of caching mechanism…

I think I’ll go ahead and put some coffee on to boil!

To Bing or not to Bing…

The first version of Currency Converter used Bing to make the exchanges, which resulted in some of the reports you read above!

For this version, however, we decided to use MSN Money because it has more accurate and up-to-date data, and because it works every time no matter the currency!

MSN Money provides a very nice page on which we can see current currency exchange rates in relation to US Dollars; just open your Internet Explorer 8.0+ and navigate to the following URL:

http://moneycentral.msn.com/investor/market/exchangerates.aspx

As you can see here, we have all the data we need to convert from X to USD and from USD to X, and we can even convert from X to USD to Y.

So, why not just get all of this data on a single request, cache it, and use it offline to make the currency exchanges? J

Like before, we will retrieve the data we require from the page HTML by using Regular Expressions. To do so, open Internet Explorer Developer Tools (press F12), use the “Select element by click” option (Ctrl + B), and click on the “Argentine Peso” text; you’ll get something looking like this:

Using the information above, we can see a pattern in the code:

HTML

<tr>
    <td>CURRENCY</td>
    <td style=”text-align:right”><a SOMETHING>VALUE_IN_USD</a></td>
    <td style=”text-align:right”><a SOMETHING>VALUE_PER_USD</a></td>
</tr>

Now that we know the pattern, we are now able to build this regular expression:

C#

private static Regex _resultRegex = 
    new Regex("<tr><td>(?<currency>[^<>]+)</td><td style=""text-align:right"">.*?>(?<value>[0-9.,]+)</a></td></tr>");

Applying this Regular Expression to the retrieved HTML will allows us to get every row matching it, and retrieve the Currency Name and the “Per USD” Exchange Rate!

Time for some coding

Now that we know how to get all the currency rates from a single URL, it’s time to make the necessary changes to our code to accommodate the new data!

Like the previous article, we will maintain the MVVM pattern, showing the coding from the pattern’s bottom (Model) to the very top (View).

The (Re)Model

Here are the changes we need to make on our model in order to accommodate the retrieved and cached currency rates:

• Set each currency to save its exchange rate and last update
• Mark the base currency (US Dollar), giving it an exchange rate of 1.0 (trying to convert from USD to USD? Right…)
• Add an “Update Exchange Rates” operation to the service

And here is the full Model, with the changes in yellow:

C#

using System;public interface ICurrencyExchangeService
{
    ICurrency[] Currencies { get; }    ICurrency BaseCurrency { get; }    void ExchangeCurrency(double amount, ICurrency fromCurrency, ICurrency toCurrency, Action<ICurrencyExchangeResult> callback);    void UpdateCachedExchangeRates(Action<CachedExchangeRatesUpdateResult> callback, object state);
}public interface ICurrency
{
    string Name { get; }    double CachedExchangeRate { get; set; }    DateTime CachedExchangeRateUpdatedOn { get; set; }
}public interface ICurrencyExchangeResult
{
    Exception Error { get; }    string ExchangedCurrency { get; }    double ExchangedAmount { get; }
}public interface ICachedExchangeRatesUpdateResult
{
    Exception Error { get; }    object State { get; }
}

The ICurrencyExchangeService now has a new BaseCurrency property that we will set with the “US Dollar” currency instance, as well as an UpdateCachedExchangeRates method to update all the exchange rates.

For the ICurrency, we have two new properties: the CachedExchangeRate to store the currency exchange rate value, and the CachedExchangeRateUpdatedOn for the last update date.

A new interface called ICachedExchangeRatesUpdateResult has been added in order to return any exception thrown by the ICurrencyExchangeService.UpdateCachedExchangeRates method asynchronous execution to the caller.

Now let’s look at the interface’s implementation:

The first new thing to take note of is that we now have a CurrencyBase abstract class. From here, we extend the MsnMoneyCurrency class, adding a single Id property to store the numeric Id for the Currency found in MSN Money.

Next is the MsnMoneyV2CurrencyExchangeService, a direct implementation of the ICurrencyExchangeService.

Unlike BingCurrencyExchangeService from the previous version, notice that MsnMoneyV2CurrencyExchangeService does not extend the CurrencyExchangeServiceBase, and that it only requests online data in the UpdateCachedExchangeRates method and not on every ExchangeCurrency method call.

Here is the code for these classes:

C#

public class MsnMoneyV2CurrencyExchangeService : ICurrencyExchangeService
{
    private const string MsnMoneyUrl = "http://moneycentral.msn.com/investor/market/exchangerates.aspx?selRegion=1&selCurrency=1";    #region Static Globals    private static Regex _resultRegex = new Regex(@"<tr><td>(?<currency>[^<>]+)</td><td style=""text-align:right"">.*?>(?<value>[0-9.,]+)</a></td></tr>");    private static ICurrency[] _currencies = new ICurrency[] { 
        //The currencies exposed by MSN Money will go here
    };    #endregion    #region Properties    public ICurrency[] Currencies
    {
        get
        {
            return _currencies;
        }
    }    public ICurrency BaseCurrency { get; protected set; }    #endregion    public MsnMoneyV2CurrencyExchangeService()
    {
        BaseCurrency = Currencies.First(x => x.Name == "US Dollar");
    }    public void ExchangeCurrency(double amount, ICurrency fromCurrency, ICurrency toCurrency, bool useCachedExchangeRates, Action<ICurrencyExchangeResult> callback, object state)
    {
        if (useCachedExchangeRates)
        {
            try
            {
                ExchangeCurrency(amount, fromCurrency, toCurrency, callback, state);                return;
            }
            catch
            {
            }
        }        UpdateCachedExchangeRates(result =>
        {
            if (result.Error != null)
            {
                callback(new CurrencyExchangeResult(result.Error, state));                return;
            }            try
            {
                ExchangeCurrency(amount, fromCurrency, toCurrency, callback, state);
            }
            catch (Exception ex)
            {
                callback(new CurrencyExchangeResult(ex, state));
            }
        }, state);
    }    private void ExchangeCurrency(double amount, ICurrency fromCurrency, ICurrency toCurrency, Action<ICurrencyExchangeResult> callback, object state)
    {
        var fromExchangeRate = fromCurrency.CachedExchangeRate;
        var toExchangeRate = toCurrency.CachedExchangeRate;
        var timestamp = DateTime.Now;        if (fromCurrency == BaseCurrency)
            fromExchangeRate = 1.0;
        else
        {
            if (timestamp > fromCurrency.CachedExchangeRateUpdatedOn)
                timestamp = fromCurrency.CachedExchangeRateUpdatedOn;
        }        if (toCurrency == BaseCurrency)
            toExchangeRate = 1.0;
        else
        {
            if (timestamp > toCurrency.CachedExchangeRateUpdatedOn)
                timestamp = toCurrency.CachedExchangeRateUpdatedOn;
        }        if (fromExchangeRate > 0 && toExchangeRate > 0)
        {
            var exchangedAmount = amount / fromExchangeRate * toExchangeRate;            callback(new CurrencyExchangeResult(toCurrency, exchangedAmount, timestamp, state));
        }
        else
            throw new Exception("Conversion not returned!");
    }    public void UpdateCachedExchangeRates(Action<CachedExchangeRatesUpdateResult> callback, object state)
    {
        var request = HttpWebRequest.Create(MsnMoneyUrl);        request.BeginGetResponse(ar =>
        {
            try
            {
                var response = (HttpWebResponse)request.EndGetResponse(ar);                if (response.StatusCode == HttpStatusCode.OK)
                {
                    string responseContent;                    using (var streamReader = new StreamReader(response.GetResponseStream()))
                    {
                        responseContent = streamReader.ReadToEnd();
                    }                    foreach (var match in _resultRegex.Matches(responseContent).Cast<Match>())
                    {
                        var currencyName = match.Groups["currency"].Value.Trim();                        var currency = Currencies.FirstOrDefault(x => string.Compare(x.Name, currencyName, StringComparison.InvariantCultureIgnoreCase) == 0);                        if (currency != null)
                        {
                            currency.CachedExchangeRate = double.Parse(match.Groups["value"].Value, CultureInfo.InvariantCulture);
                            currency.CachedExchangeRateUpdatedOn = DateTime.Now;
                        }
                    }                    callback(new CachedExchangeRatesUpdateResult(ar.AsyncState));
                }
                else
                {
                    throw new Exception(string.Format("Http Error: ({0}) {1}",
                        response.StatusCode,
                        response.StatusDescription));
                }
            }
            catch (Exception ex)
            {
                callback(new CachedExchangeRatesUpdateResult(ex, ar.AsyncState));
            }
        }, state);
    }
}

Here’s how it works: when the ExchangeCurrency method is called, we pass a parameter (useCachedExchangeRates) that instructs the method to use (or not!) the previously cached exchange rates.

Next, make the exchange operation and return the results. If the operation throws an exception, or if we didn’t allow for cached exchange rates usage, call the UpdateCachedExchangeRates to update the exchange rates and then run the exchange operation with the new data.

And that’s about it for the Model!

The ViewModel

We maintained the full ViewModel from the previous version, but added some new functionality to it. Here’s the coding (main changes are in yellow):

C#

public class MainViewModel : INotifyPropertyChanged
{
    //Full previous code    #region Properties    [IgnoreDataMember]
    public ICurrencyExchangeResult Result
    {
        get
        {
            return _result;
        }
        protected set
        {
            if (_result == value)
                return;            _result = value;            RaisePropertyChanged("Result");
            RaisePropertyChanged("ExchangedCurrency");
            RaisePropertyChanged("ExchangedAmount");
            RaisePropertyChanged("ExchangedTimeStamp");
        }
    }    [IgnoreDataMember]
    public string ExchangedTimeStamp
    {
        get
        {
            if (_result == null)
                return string.Empty;            return string.Format("Data freshness:\n{0} at {1}",
                _result.Timestamp.ToShortDateString(),
                _result.Timestamp.ToShortTimeString());
        }
    }    [DataMember]
    public CurrencyCachedExchangeRate[] CurrenciesCachedExchangeRates
    {
        get
        {
            return Currencies
                .Select(x => new CurrencyCachedExchangeRate()
                {
                    CurrencyIndex = Array.IndexOf(Currencies, x),
                    CachedExchangeRate = x.CachedExchangeRate,
                    CachedExchangeRateUpdatedOn = x.CachedExchangeRateUpdatedOn
                })
                .ToArray();
        }
        set
        {
            foreach (var currencyData in value)
            {
                if (currencyData.CurrencyIndex >= Currencies.Length)
                    continue;                var currency = Currencies[currencyData.CurrencyIndex];                currency.CachedExchangeRate = currencyData.CachedExchangeRate;
                currency.CachedExchangeRateUpdatedOn = currencyData.CachedExchangeRateUpdatedOn;
            }
        }
    }    #endregion    //Full previous code    public void ExchangeCurrency()
    {
        if (Busy)
            return;        BusyMessage = "Exchanging amount...";        _currencyExchangeService.ExchangeCurrency(_amount, _fromCurrency, _toCurrency, true, CurrencyExchanged, null);
    }    public void UpdateCachedExchangeRates()
    {
        if (Busy)
            return;        BusyMessage = "Updating cached exchange rates...";        _currencyExchangeService.UpdateCachedExchangeRates(ExchangeRatesUpdated, null);
    }    private void CurrencyExchanged(ICurrencyExchangeResult result)
    {
        InvokeOnUiThread(() =>
        {
            Result = result;            BusyMessage = null;            if (result.Error != null)
            {
                if (System.Diagnostics.Debugger.IsAttached)
                    System.Diagnostics.Debugger.Break();
                else
                    MessageBox.Show("An error has ocorred!", "Error", MessageBoxButton.OK);
            }
        });
    }    private void ExchangeRatesUpdated(ICachedExchangeRatesUpdateResult result)
    {
        InvokeOnUiThread(() =>
        {
            BusyMessage = null;            Save();            if (result.Error != null)
            {
                if (System.Diagnostics.Debugger.IsAttached)
                    System.Diagnostics.Debugger.Break();
                else
                    MessageBox.Show("An error has ocorred!", "Error", MessageBoxButton.OK);
            }
        });
    }    private void InvokeOnUiThread(Action action)
    {
        var dispatcher = System.Windows.Deployment.Current.Dispatcher;        if (dispatcher.CheckAccess())
            action();
        else
            dispatcher.BeginInvoke(action);
    }    #region Auxiliary Classes    public class CurrencyCachedExchangeRate
    {
        [DataMember]
        public int CurrencyIndex { get; set; }        [DataMember]
        public double CachedExchangeRate { get; set; }        [DataMember]
        public DateTime CachedExchangeRateUpdatedOn { get; set; }
    }    #endregion
}

The first thing you will notice here is a new ExchangedTimeStamp read-only property that feeds the interface with the date string to denote when the used currency data was obtained. The interface is notified that this property value has changed when the Result property value is also changed.

Further down there’s another new property, CurrenciesCachedExchangeRates, that stores the cached exchange rates. For this to work, we have an auxiliary class called CurrencyCachedExchangeRate that stores the currency index along with the exchange rate as well as the update timestamp.

The UpdateCachedExchangeRates method allows users to manually force an update over the cached exchange rates.

The CurrencyExchanged and ExchangeRatesUpdated callbacks use the InvokeOnUiThread method to make sure that their codes run properly on the UI thread.

The View

Two simple changes have been made in the MainPage.xaml (our main View): an area on the screen has been added to show the exchange operation result timestamp, and a menu option has been added to force a full exchange rate update.

To make the first change, add a simple TextArea on the bottom StackPanel and bind it to the ExchangedTimeStamp property of the ViewModel:

XAML

<StackPanel x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,0">
    <TextBlock Margin="12,0,0,-5" Style="{StaticResource PhoneTextSubtleStyle}">Amount</TextBlock>
    <TextBox InputScope="TelephoneNumber" Text="{Binding Amount, Mode=TwoWay, ValidatesOnExceptions=True, NotifyOnValidationError=True}" />
    <TextBlock Margin="12,10,0,-5" Style="{StaticResource PhoneTextSubtleStyle}">From</TextBlock>
    <toolkit:ListPicker ItemsSource="{Binding Currencies}" SelectedItem="{Binding FromCurrency, Mode=TwoWay}" FullModeHeader="FROM CURRENCY" Style="{StaticResource CurrencyListPicker}" />
    <TextBlock Margin="12,10,0,-5" Style="{StaticResource PhoneTextSubtleStyle}">To</TextBlock>
    <toolkit:ListPicker ItemsSource="{Binding Currencies}" SelectedItem="{Binding ToCurrency, Mode=TwoWay}" FullModeHeader="TO CURRENCY" Style="{StaticResource CurrencyListPicker}" />
    <StackPanel>
        <TextBlock Style="{StaticResource PhoneTextGroupHeaderStyle}" Text="{Binding ExchangedCurrency}"></TextBlock>
        <TextBlock Margin="25, 0, 0, 0" Style="{StaticResource PhoneTextTitle1Style}" Text="{Binding ExchangedAmount}"></TextBlock>
        <TextBlock Style="{StaticResource PhoneTextSubtleStyle}" Text="{Binding ExchangedTimeStamp}" TextWrapping="Wrap" TextAlignment="Right"></TextBlock>
    </StackPanel>
</StackPanel>

As for the “update exchange rates” menu option, add a new ApplicationBarMenuItem to the MenuItems collection, set the appropriate text, and add a handler for the click event:

XAML

<phone:PhoneApplicationPage.ApplicationBar>
    <shell:ApplicationBar IsVisible="True" IsMenuEnabled="True">
        <shell:ApplicationBarIconButton IconUri="/Images/appbar.money.usd.png" Text="Exchange" Click="ExchangeIconButton_Click" />
        <shell:ApplicationBar.MenuItems>
            <shell:ApplicationBarMenuItem Text="update exchange rates" Click="UpdateExchangeRatesMenuItem_Click" />
            <shell:ApplicationBarMenuItem Text="about" Click="AboutMenuItem_Click" />
        </shell:ApplicationBar.MenuItems>
    </shell:ApplicationBar>
</phone:PhoneApplicationPage.ApplicationBar>

Now, all that is missing is implementing the UpdateExchangeRatesMenuItem_To do so, click the event handler in the MainPage.xaml.cs:

C#

private void UpdateExchangeRatesMenuItem_Click(object sender, EventArgs e)
{
    var viewModel = DataContext as MainViewModel;    if (viewModel == null)
        return;    Dispatcher.BeginInvoke(() =>
    {
        viewModel.UpdateCachedExchangeRates();
    });
}

Conclusion

The bottom line is that your application is as good as the data source you use. By utilizing a new (better) data source, some really simple changes to the code, we now have the Currency Converter—faster than ever!

And just in time: the coffee is ready!

About The Author

Pedro Lamas is a Portuguese .Net Senior Developer on Microsoft’s Partner DevScope, where he works with all the cool stuff that Microsoft .Net has to offer its developers!

He’s also one of the administrators of PocketPT.net, the largest Windows Phone Portuguese community, where his contribution is mostly visible on support for Windows Phone developers, and as a speaker for Windows Phone Development in Microsoft Portugal Events.

You can read his blog or contact him via twitter!

1) Do you want to see how to send/receive every kind of Push Notification that there is for Windows Phone?

2) Do you want to know the certification rules and usage restrictions involved with using Push Notifications for Windows Phone?

3) Do you want to see how to make a web service and consume it in a Windows Phone app?

4) Have you been meaning to try Azure but thought it would take MORE than 90 seconds to learn how to publish on it?

If so, look no further; the answers to all these and more are inside.

Click here to download the source code used in this video.

Introduction

Microsoft has done an absolutely amazing job with the Windows Phone 7, giving each and every one of us all of the necessary tools to make our applications blend nicely on it; and the best part—the tools are, and will always be, free!!! J

Using Bing for the currency exchange

First let's look at what happens when I open up Bing on my browser, and enter a search query like “1 US Dollar in Euros”:

As you can see, Bing correctly understood my query, and knew that I was looking for an exchange rate. Then MSN Money made the exchange and presented the result.

Also, notice that the address displays as:

http://www.bing.com/search?q=1+US+Dollar+in+Euros&go=&form=QBRE&qs=n&sk=&sc=1-20

OK, but how can we use this to feed the WP7 application? Call the Internet Explorer Developer Tools (just press F12 on your IE8+) and use the “Select element by click” option (Ctrl + B) to select the result on the page and see its HTML code. The result will look just like this:

Now we know how to build the Bing currency exchange search query (using “http://www.bing.com/search?q={VALUE}+{SOURCE_CURRENCY}+in+{DESTINATION_CURRENCY}&go=&form=QBRE&qs=n&sk=&sc=1-20”) and also how to find the results on the returned HTML (search the “<span class="sc_bigLine">RESULT</span>”).

The final task is selecting that span tag on the full HTML and then extracting the converted amount; for this task, I'll be using the following Regular Expression (using System.Text.RegularExpressions):

C#

static Regex _resultRegex =   new Regex("<span class=\"sc_bigLine\">.*? = (?<value>[0-9.,]+).*?</span>");

This expression searches the HTML code for a span with class “sc_bigLine” and inner content matching something like the above example: “1 USD = 0.71270 EUR”.

The expression also allows me to extract the number after the “=” sign by using Groups[“value"].value property.

MVVM is our friend!

I'll start by quoting the Wikipedia:

The Model View ViewModel (MVVM) is an architectural pattern used in software engineering (…) is targeted at modern UI development platforms (Windows Presentation Foundation and Silverlight) in which there is a User Experience (UX) developer who has different requirements than a more “traditional” developer (i.e. oriented toward business logic and back end development).

Basically, the point is to clearly separate the user interface from all the business logic and data that our application will use!

We can summarize the MVVM pattern with this schema:

The View is the basic XAML for the user interface (although sometimes it can have a C# file attached to it) that will use Data Binding to read and change properties on the ViewModel, and Actions to invoke the methods.

The ViewModel is the abstraction of the View and will do all the work for binding the View to the Model, with the necessary data conversion.

The Model can represent the actual object model instance in a known state, or just a data access layer.

There is one basic rule in MVVM: don't look up! The Model has no knowledge of either the ViewModel or the View, and the ViewModel has no knowledge of the View.

This brings a new challenge on how to make the three components talk between themselves, and that's where notifications come along!

We use notifications to communicate changes from a lower component to an upper one; when the upper component gets notified, it will then query the lower for what changed and act accordingly to the new state!

You can read more about MVVM throughout the internet, but there is an article by Shawn Wildermuth that's one of the best I've seen; you can read it here: http://msdn.microsoft.com/enus/magazine/dd458800.aspx.

The Model

We will start at the very bottom (a.k.a. the Model), and as such I've created the following Interfaces to support our Data Model:

C#

using System; public interface ICurrencyExchangeService{    ICurrency[] Currencies { get; }    void ExchangeCurrency(        double amount,         ICurrency fromCurrency,         ICurrency toCurrency,         Action<ICurrencyExchangeResult> callback);} public interface ICurrency{    string Name { get; }} public interface ICurrencyExchangeResult{    Exception Error { get; }    string ExchangedCurrency { get; }    double ExchangedAmount { get; }}

From these three interfaces, we will extend our Bing Currency Exchange provider:

The abstract CurrencyExchangeServiceBase class implements the ICurrencyExchangeService.ExchangeCurrency method to do all the asynchronous work required to request data from a webserver and retrieve the resulting HTML; to achieve its goal, the CurrencyExchangeServiceBase has two abstract methods that must be implemented: CreateRequestUrl, to get the request url that will be passed to the WebRequest, and GetResultFromResponseContent, to parse the received HTML and return the exchanged value.

We then extend the BingCurrencyExchangeService from CurrencyExchangeServiceBase, implementing the CreateRequestUrl and GetResultFromResponseContent required methods and the ICurrencyExchangeService.Currencies property including all currencies supported by this service instance.

We have also a basic ICurrency interface implementation class called BingCurrency.

This is the CurrencyExchangeServiceBase abstract class implementation:

C#

public abstract class CurrencyExchangeServiceBase : ICurrencyExchangeService{   public abstract ICurrency[] Currencies { get; }   protected abstract string CreateRequestUrl(        double amount,         ICurrency fromCurrency,         ICurrency toCurrency);   protected abstract double         GetResultFromResponseContent(string responseContent);   public void ExchangeCurrency(        double amount,         ICurrency fromCurrency,         ICurrency toCurrency,         Action<ICurrencyExchangeResult> callback)   {      var url = CreateRequestUrl(amount, fromCurrency, toCurrency);      var request = HttpWebRequest.Create(url);      request.BeginGetResponse(ar =>       {         try         {            var response = (HttpWebResponse)request.EndGetResponse(ar);            if (response.StatusCode == HttpStatusCode.OK)            {               string responseContent;               using (var streamReader =                   new StreamReader(response.GetResponseStream()))               {                  responseContent = streamReader.ReadToEnd();               }               var exchangedCurrency =                   GetResultFromResponseContent(responseContent);               callback(                  new CurrencyExchangeResult(                     toCurrency.Name,                      exchangedCurrency));            }            else            {               throw new Exception(                string.Format("Http Error: ({0}) {1}",                  response.StatusCode,                  response.StatusDescription));            }         }         catch (Exception ex)         {            callback(new CurrencyExchangeResult(ex));         }      }, null);   }}

As I said before, this is an abstract class that requires any inheritor to implement the Currencies property as well as the CreateRequestUrl and GetResultFromResponseContent functions—and that's exactly what the BingCurrencyExchangeService class does:

C#

public class BingCurrencyExchangeService : CurrencyExchangeServiceBase{   private static Regex _resultRegex =       new Regex("<span class=\"sc_bigLine\">.*? = (?<value>[0-9.,]+).*?</span>");   private static ICurrency[] _currencies = new ICurrency[] {       new BingCurrency("Euro"),      new BingCurrency("US Dollar")      //all available currencies will go here!   };   #endregion   public override ICurrency[] Currencies   {      get      {         return _currencies;      }   }   protected override string CreateRequestUrl(double amount, ICurrency fromCurrency, ICurrency toCurrency)   {      return string.Format(         @"http://www.bing.com/search?q={0}+{1}+in+{2}&scope=web&mkt=en-US&FORM=W0LH",         amount,         fromCurrency.Name.Replace(" ", "+"),         toCurrency.Name.Replace(" ", "+"));   }   protected override double GetResultFromResponseContent(string responseContent)   {      var match = _resultRegex.Match(responseContent);      if (match.Success)         return double.Parse(            match.Groups["value"].Value,             CultureInfo.InvariantCulture);      else         throw new Exception("Conversion not returned!");   }}

As you can see here, the BingCurrencyExchangeService class knows how to build the Bing search url if given the currencies and the value of exchange, and also how to get the converted value out of the response HTML code (notice the usage of our regular expression).

The ViewModel

The ViewModel has a basic inheritance requirement: using INotifyPropertyChanged to notify the user interface of property value changes.

Our MainViewModel class will have to expose three base data properties for the user interface controls: FromCurrency, ToCurrency, and Amount.

All assembled, this is how the ViewModel looks:

C#

public class MainViewModel : INotifyPropertyChanged{   private ICurrencyExchangeService _currencyExchangeService;   private double _amount;   private ICurrency _fromCurrency;   private ICurrency _toCurrency;   public ICurrencyExchangeService CurrencyExchangeService   {      get      {         return _currencyExchangeService;      }      set      {         if (_currencyExchangeService == value)            return;         _currencyExchangeService = value;         _fromCurrency = Currencies.FirstOrDefault(x => x.Name == "US Dollar") ?? Currencies[0];         _toCurrency = Currencies.FirstOrDefault(x => x.Name == "Euro") ?? Currencies[1];         RaisePropertyChanged("CurrencyExchangeService");         RaisePropertyChanged("Currencies");      }   }   public ICurrency[] Currencies   {      get      {         return _currencyExchangeService.Currencies;      }   }   public string Amount   {      get      {         return _amount.ToString("0.00");      }      set      {         double amount;         if (double.TryParse(value, out amount))         {            if (_amount == amount)               return;            _amount = amount;            RaisePropertyChanged("Amount");         }         else            throw new Exception("Please enter a valid Amount");      }   }   public ICurrency FromCurrency   {      get      {         return _fromCurrency;      }      set      {         if (_fromCurrency == value)            return;         _fromCurrency = value;         RaisePropertyChanged("FromCurrency");      }   }   public ICurrency ToCurrency   {      get      {         return _toCurrency;      }      set      {         if (_toCurrency == value)            return;         _toCurrency = value;         RaisePropertyChanged("ToCurrency");      }   }   public MainViewModel()   {      CurrencyExchangeService = new BingCurrencyExchangeService();      Amount = "100";   }   public event PropertyChangedEventHandler PropertyChanged;   private void RaisePropertyChanged(string propertyName)   {      if (PropertyChanged != null)         PropertyChanged(this, new PropertyChangedEventArgs(propertyName));   }}

In order to allow the user to change the FromCurrency and ToCurrency properties, we need to list the available ones; as such, we added a Currencies property to return the ICurrency[] Currencies property of the Model instance.

On the MainViewModel constructor, set the CurrencyExchangeService property to a new BingCurrencyExchangeService instance, making it retrieve “Euro” and “US Dollar” (if available; if not, get the 1^st and 2^nd one instead) as the two default exchange currencies, and then set the Amount property to an initial value of “100.”

The PropertyChanged event is a basic implementation of the INotifyPropertyChanged interface, with a helper method called RaisePropertyChanged used to invoke the event.

Now we need to add functionality to request a currency exchange operation and show the results on the user interface:

C#

public class MainViewModel : INotifyPropertyChanged{    //remaining code...    private ICurrencyExchangeResult _result;    public ICurrencyExchangeResult Result    {        get        {            return _result;        }        protected set        {            if (_result == value)                return;            _result = value;            RaisePropertyChanged("Result");            RaisePropertyChanged("ExchangedCurrency");            RaisePropertyChanged("ExchangedAmount");        }    }    public string ExchangedCurrency    {        get        {            if (_result == null)                return string.Empty;            return _result.ExchangedCurrency;        }    }    public string ExchangedAmount    {        get        {            if (_result == null)                return string.Empty;            return _result.ExchangedAmount.ToString("N2");        }    }    public void ExchangeCurrency()    {        _currencyExchangeService.ExchangeCurrency(_amount, _fromCurrency, _toCurrency, CurrencyExchanged);    }    private void CurrencyExchanged(ICurrencyExchangeResult result)    {        System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() =>        {            Result = result;        });    }}

The ExchangeCurrency method will be used to request a currency exchange operation on the Model instance, including the entered data. When the operation ends, the CurrencyExchanged method will be invoked and we will then get an ICurrencyExchangeResult instance with the results; this method will be asynchronously called on another thread, so we will need get the current Dispatcher and use it to invoke the changes to the MainViewModel.Result property (so that they are made on the interface thread).

As the Result property gets changed, it will also make property changed notifications to the ExchangedCurrency and ExchangedAmount properties, allowing the user interface to show the returned values.

The View

The View that will support our application is really quite simple!

The basic requirements are two ListPicker controls (these are implemented on the Silverlight Toolkit): one for each Currency (the MainViewModel FromCurrency and ToCurrency properties) and a TextBox for the Amount.

We also need two more TextAreas to show the currency exchange results (one for the ExchangedCurrency property and the other for the ExchangedAmount property, both from our MainViewModel).

Using the current MainPage.xaml, start by adding a reference to the Silverlight for Windows Phone Toolkit, like so:

XAML

<phone:PhoneApplicationPagexmlns:toolkit="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls.Toolkit"&lt;!--remaining code... -->

Then, I'll change the default ContentPanel control from a Grid to a StackPanel, and add the required controls to edit the Currencies and the entry Value:

XAML

<StackPanel x:Name="ContentPanel" Grid.Row="1" Margin="12,0">   <TextBlock       Margin="12,0,0,-5"       Style="{StaticResource PhoneTextSubtleStyle}">      Amount   </TextBlock>   <TextBox       InputScope="TelephoneNumber"       Text="{Binding Amount, Mode=TwoWay, ValidatesOnExceptions=True, NotifyOnValidationError=True}" />   <TextBlock       Margin="12,10,0,-5"       Style="{StaticResource PhoneTextSubtleStyle}">         From   </TextBlock>   <toolkit:ListPicker       ItemsSource="{Binding Currencies}"       SelectedItem="{Binding FromCurrency, Mode=TwoWay}"       FullModeHeader="FROM CURRENCY"       Style="{StaticResource CurrencyListPicker}" />   <TextBlock       Margin="12,10,0,-5"       Style="{StaticResource PhoneTextSubtleStyle}">      To   </TextBlock>   <toolkit:ListPicker       ItemsSource="{Binding Currencies}"       SelectedItem="{Binding ToCurrency, Mode=TwoWay}"       FullModeHeader="TO CURRENCY"       Style="{StaticResource CurrencyListPicker}" />   <StackPanel>      <TextBlock          Style="{StaticResource PhoneTextGroupHeaderStyle}"          Text="{Binding ExchangedCurrency}" />      <TextBlock          Margin="25, 0, 0, 0"          Style="{StaticResource PhoneTextTitle1Style}"          Text="{Binding ExchangedAmount}" />   </StackPanel></StackPanel>

Here's how it looks right now:

Notice the CurrencyListPicker style applied to the two ListPicker controls on the code above? Here it is:

XAML

<phone:PhoneApplicationPage.Resources>   <Style x:Key="CurrencyListPicker" TargetType="toolkit:ListPicker">      <Setter          Property="DisplayMemberPath"          Value="Name" />      <Setter          Property="CacheMode"          Value="BitmapCache" />      <Setter Property="FullModeItemTemplate">         <Setter.Value>            <DataTemplate>               <StackPanel                      Orientation="Horizontal"                      Margin="16 21 0 20">                  <TextBlock                      Text="{Binding Name}"                      FontSize="43"                      FontFamily="{StaticResource PhoneFontFamilyLight}"/>               </StackPanel>            </DataTemplate>         </Setter.Value>      </Setter>   </Style></phone:PhoneApplicationPage.Resources>

This style sets the initial values of three properties on the ListPickers: the DisplayMemberPath (it will be binded to the ICurrency.Name property), the CacheMode (for optimization only), and, most importantly, the FullModeItemTemplate, which indicates how to show each item when the ListPicker window pops up.

The next step will be adding the “Exchange” button to the bottom ApplicationBar, like so:

XAML

<phone:PhoneApplicationPage.ApplicationBar>   <shell:ApplicationBar       IsVisible="True"       IsMenuEnabled="False">      <shell:ApplicationBarIconButton          IconUri="/Images/appbar.money.usd.png"          Text="Exchange"          Click="ExchangeIconButton_Click" />   </shell:ApplicationBar></phone:PhoneApplicationPage.ApplicationBar> 

Remember to create an Images folder in your project and copy the required “appbar.money.usd.png” image to it (you can find this and other ApplicationBar icons in your “%ProgramFiles%\Microsoft SDKs\Windows Phone\v7.0\Icons\dark”); then, set its “Build” and “Copy to Output Directory” properties to “Content” and “Copy always”, respectively.

On the MainPage.xaml.cs, we'll add the ExchangeIconButton_Click() method:

C#

private void ExchangeIconButton_Click(object sender, EventArgs e){   var viewModel = DataContext as MainViewModel;   if (viewModel == null)      return;   Focus();   Dispatcher.BeginInvoke(() =>   {      if (!NetworkInterface.GetIsNetworkAvailable())      {         MessageBox.Show(            "No network connection found!",             "Error",             MessageBoxButton.OK);         return;      }      viewModel.ExchangeCurrency();   });}

This method will check for a valid MainViewModel set on the DataContext, remove the Focus from any TextBox (thus hiding the on-screen keyboard), check if there is a valid network connection, and then call the MainViewModel.ExchangeCurrency() method.

Tombstoning

The final piece to developing this into the perfect Windows Phone 7 application is making it “Tombstoning” aware!

Since WP7 doesn't allow multitasking, every time an application is deactivated or closed you should save its state and then restore it when the application is reactivated or reopened; this process is called “Tombstoning.”

To do this, we use the System.Runtime.Serialization classes, namely, the DataMemberAttribute to mark all the properties of the MainViewModel we want to save (FromCurrency, ToCurrency, and Amount), and the IgnoreDataMemberAttribute to mark the ones we don't (CurrencyExchangeService, Currencies, Result, ExchangedCurrency, and ExchangedAmount).

We can't (or at least, shouldn't!) directly save the state of the FromCurrency and ToCurrency properties because they have complex values (rather than a base type like Int or String), so we mark these with the IgnoreDataMemberAttribute and add two new properties, one for each, that will get/set the relative index of the Currencies array:

C#

[DataMember] public int FromCurrencyIndex{    get    {        return Array.IndexOf(Currencies, FromCurrency);    }    set    {        FromCurrency = Currencies[value];    }}[DataMember] public int ToCurrencyIndex{    get    {        return Array.IndexOf(Currencies, ToCurrency);    }    set    {        ToCurrency = Currencies[value];    }}

Now add the methods to Load and Save the state of the MainViewModel instance; since the Save method has to be called on the App.xaml.cs Application_Deactivated() and Application_Closing() events, the best way is to make our View Model a singleton. To do this, add the following code to the MainViewModel class:

C#

[IgnoreDataMember] private const string SettingFileName = "mainviewmodel.dat"; public static MainViewModel Instance { get; protected set; } static MainViewModel(){    Instance = Load();} public static MainViewModel Load(){    return StorageHelper.LoadContract<MainViewModel>(SettingFileName, true);} public void Save(){    StorageHelper.SaveContract(SettingFileName, this, true);}

The StorageHelper class you see here is just a helper used to serialize and deserialize a file on the application's IsolatedStorage.

Now all we have to do is change the MainPage.xaml.cs constructor so it uses the singleton instead of creating a new MainViewModel instance:

C#

public MainPage(){    InitializeComponent();    this.DataContext = MainViewModel.Instance;}

Finally, invoke the Save method on the two required events of the App.xaml.cs file:

C#

private void Application_Deactivated(object sender, DeactivatedEventArgs e){    MainViewModel.Instance.Save();} private void Application_Closing(object sender, ClosingEventArgs e){    MainViewModel.Instance.Save();}

And that is it! To test the application, open it, press the windows key so that the Windows Phone main screen appears, wait a couple of seconds, and press the back key to return to the application: you will see a “resuming” message appear when the application state restores!

The application can now be Tombstoned anytime, and when it gets opened again, it will appear as if it never closed!

Conclusion

As you see here, you can build simple applications for Windows Phone 7 by using basic MVVM architecture, and still have time to go out and have a coffee with your friends!

Remember: If you want to try this out, the download link for the source code is at the top of the article!

The sample code uses the BingCurrencyExchangeService, but it also has a second provider for MSN Money, the MsnMoneyCurrencyExchangeService, which you can check out!

About The Author

Pedro Lamas is a Portuguese .Net Senior Developer on Microsoft's Partner DevScope, where he works with all the cool stuff that Microsoft .Net has to offer its developers!

He's also one of the administrators of PocketPT.net, the largest Windows Phone Portuguese community, where his contribution is mostly visible on support for Windows Phone developers, and as a speaker for Windows Phone Development in Microsoft Portugal Events.

You can read his blog or contact him via twitter!

In this video, Kent Brown (Product Manager, Microsoft) and Kamaljit Bath (Principal Program Manager, Microsoft) introduce Stonehenge and present an actual demo of the M2 release.

You can download the M1 and M2 releases of Apache Stonehenge from http://www.apache.org/dist/incubator/stonehenge and the documentation is up on the wiki: https://cwiki.apache.org/confluence/display/STONEHENGE/Index

Additional links:

• Apache Stonehenge project summary
• Blog: Stonehenge: showcasing Web Services interoperability
• Blog: Apache Stonehenge, interoperability at work
• Sun Joins Microsoft on JavaOne Stage in support of Apache Stonehenge Incubator Project 
• Blog: Apache Stonehenge Interoperability
• Presentation at the NYC .NET Dev User Group
• Blog: Apache Stonehenge demoed at PDC09

“Web Services on Devices” API (WSDAPI) is Microsoft’s interoperable implementation of Device Profile for Web Services. WSDAPI can be used for easy SOAP based communications between devices (including those that are embedded) and clients.  Because the DPWS is an open specification, compatibility with other implementations is ensured.  Microsoft’s WSDAPI not only offers a complete set of APIs, it also features a code generation utility that enables developers to focus on core functionality of the device and not on the communication.

Press release about MESDC:                     http://www.microsoft.com/presspass/press/2008/feb08/02-26MSEDCPR.mspx

More about WSDAPI on MSDN:               http://msdn.microsoft.com/en-us/library/aa826001(VS.85).aspx

Dan Driscoll’s WDAPI Blog:                         http://blogs.msdn.com/dandris/

Version 2.0 brings some new features and bug fixes.

Bug fixes

• Fixed: Twitter connection and authentication issues
• Removed: The Windows pop-up messages whenever Twitter's service goes down. You can now right-click on the TweetCraft icon to see what the current status is
• Removed: The use of LibDataBroker (LDB) for anything besides registering ourselves for other addons like ChocolateBar.

• In-game help, setup information and how to use TweetCraft
• Auto-updates: The TweetCraft client will now check for and let you know when updates are available.
• Curse deployment: The TweetCraft add-on is also now distributed through the Curse client so that you can easily get changes to just the addon without having to install TweetCraft again. Note that you will still need to have the TweetCraft Client installed in addition to the TweetCraft Wow AddOn for TweetCraft to work properly.
• Auto-screenshot Achievements: You can optionally have TweetCraft automatically take a screenshot of when you receive an achievement and have it posted using TwitPic.

Full source code will be available on CodePlex shortly for TweetCraft version 2.0 and if you want to know how this was build, check out the World of Warcraft RSS Feeder in the Coding4Fun book.

"This application is an end-to-end sample application for .NET Enterprise Application Server technologies. It is a service-oriented application based on Windows Communication Foundation (.NET 3.0) and ASP.NET, and illustrates many of the .NET enterprise development technologies for building highly scalable, rich "enterprise-connected" applications. It is designed as a benchmark kit to illustrate alternative technologies within .NET and their relative performance.

The application offers full interoperability with J2EE and IBM WebSphere's Trade 6.1 sample application. As such, the application offers an excellent opportunity for developers to learn about .NET and building interoperable, service-oriented applications."

Tune in!

"This application is an end-to-end sample application for .NET Enterprise Application Server technologies. It is a service-oriented application based on Windows Communication Foundation (.NET 3.0) and ASP.NET, and illustrates many of the .NET enterprise development technologies for building highly scalable, rich "enterprise-connected" applications. It is designed as a benchmark kit to illustrate alternative technologies within .NET and their relative performance.

The application offers full interoperability with J2EE and IBM WebSphere's Trade 6.1 sample application. As such, the application offers an excellent opportunity for developers to learn about .NET and building interoperable, service-oriented applications."

Tune in!

The goal of Stonehenge is to provide a public forum to test the interoperability of WS-* protocols on different vendor stacks and to build sample applications that could provide best practices and coding guidelines for better interoperability. The main sample application, StockTrader has been implemented on .NET (by Microsoft), PHP (by WSO2), WSAS JAVA stack (by WSO2), Metro (by SUN Microsystems), Spring (by SpringSource). The latest version of StockTrader uses the WS-Security and WS-Trust protocols for claims-based authentication scenarios. This allows the end-users to be authenticated through an independent Security Token Service (STS) that is trusted by the bank and to pass that token to the broker to process the transaction.

This week at PDC09, we were demoing the project. I went to see Kent Brown, product manager for WCF and asked him to give us an update and show a demo of the different StockTrader applications working together.

Watch the video till the end, Kent unveils the mystery on why the project was called Stonehenge!

Additional links:

• Project page: Apache Stonehenge
• Interoperability Team Blog: http://blogs.msdn.com/interoperability/

Dave Cook

He currently has 4 articles from the simple to the complex.

• API Basics
• Accessing the Title Catalog
• Accessing Subscriber Account Information
• Managing Account Information

If you are interested in doing a netflix project, you have to sign up for a developer account at the Netflix Developer Network home page.

WWSAPI enables several solution scenarios and benefits including:

1. Implement web services in native C/C++ code on both Windows client and server. C/C++ application developers have often requested this platform technology capability but were previously forced to write their own or interface their native-code solutions with managed-code wrappers.

2. Achieve interoperability with web services implemented using Windows Communication Foundation (WCF), ASP.NET XML Web Services, and even services implemented using non-Microsoft implementations of WS-* libraries.

3. Construct web services with minimal service startup time and minimal process working-set dependencies.

4. Use web services implementations in resource-constrained deployment environments.

5. Avoid native-management interop scenarios with potentially costly marshalling side-effects.

This is part 2 of a 2 episode series and focuses upon using WWSAPI to construct a web service. The example illustrates adding a web-service interface to a native (presumably legacy) application.  The demonstration provides a comparison between using a managed (WCF) interface and a native (WWSAPI) interface involving sorting algorthms with differing interop costs.

Find sample code and additional technical details at MSDN Code Gallery.

See part 1 of this series here.

WWSAPI enables several solution scenarios and benefits including:

1. Implement web services in native C/C++ code on both Windows client and server. C/C++ application developers have often requested this platform technology capability but were previously forced to write their own or interface their native-code solutions with managed-code wrappers.

2. Achieve interoperability with web services implemented using Windows Communication Foundation (WCF), ASP.NET XML Web Services, and even services implemented using non-Microsoft implementations of WS-* libraries.

3. Construct web services with minimal service startup time and minimal process working-set dependencies.

4. Use web services implementations in resource-constrained deployment environments.

5. Avoid native-management interop scenarios with potentially costly marshalling side-effects.

This is part 1 of a 2 episode series and focuses upon using WWSAPI from a client application. The example illustrates a client application using WWSAPI to interact with a "Sort Service".

Find sample code and additional technical details at MSDN Code Gallery.

See part 2 of this series here.

TweetCraft is a World of Warcraft add-on that enables you to send and receive tweets using Twitter without leaving the game, automatically upload and post screenshots using TwitPic and automatically tweet certain in-game events such as achievements and moving around in the world of Azeroth. TweetCraft customizes your World of Warcraft user interface by adding its own frame similar to the built-in ones (such as the Quest Log) and provides easy access to it through a button near the minimap, slash commands or your favorite launcher (e.g. ChocolateBar).

How TweetCraft works

Let’s quickly walk through the different things that TweetCraft does to bring Twitter into World of Warcraft.

Overview

World of Warcraft’s user interface is highly customizable and enables add-on developers to do almost anything in the game they can dream of. Add-ons can interact with the world, listen to events that happen in the game, alter the look of the default user interface or create brand new ones, but add-ons are seriously limited when it comes to talking to the world outside World of Warcraft. They cannot read or write files, call web services or do anything that could be potentially harmful. This is why TweetCraft comes with a Windows application that sits in the Notification Area (also known as the tray) and does the bulk of the work, giving the TweetCraft add-on only the data that it needs to display, such as tweets, replies and user pictures. All the Twitter web service calls, uploading of screenshots and housekeeping is done by this application. Let’s see how!

The TweetCraft Tray application

The TweetCraft Tray application is a WPF application that periodically checks for new tweets, dowloads and converts the user pictures of the tweets’ authors and writes it out to a file that World of Warcraft picks up and the add-on can use. It also picks up all outgoing tweets queued up for sending and sends them using Twitter one-by-one. It watches for screenshots taken by World of Warcraft and uploads them using TwitPic immediately.

To do all this, it has a couple of settings that need to be configured before it can work. For starters, it needs your Twitter credentials to be able to send tweets and post pictures on your behalf. It also needs to know which World of Warcraft account you are going to use to play and send and receive tweets with. Finally, you can opt out of automatically uploading screenshots you take during game. Figure 1 shows the TweetCraft Settings window that shows up when you first start TweetCraft after installation and is also available by right clicking the tray icon (Figure 2).

Figure 1. TweetCraft Settings Window

Figure 2. TweetCraft tray icon in the notification area

Getting data from Twitter

TweetCraft uses an open-source library called TwitterLib to send and receive tweets using Twitter’s API. TwitterLib is part of the open-source WPF Twitter Client WittyTwitter and wraps the web services provided by Twitter into an easy to use .NET class library. TweetCraft wraps this library into a simple class called TwitterClient that all the services in TweetCraft rely on. One of those services is the TwitterBackgroundService which polls Twitter periodically to check for new tweets. By default, this is set to five minutes. If new tweets or replies are available, an event is raised that other components of TweetCraft can handle and work with the new tweets, download user pictures, etc. Figure 3 shows the three classes that take part in downloading new tweets and replies and notifying other classes.

Figure 3. TwitterBackgroundService, TwitterClient and TwitterNet (TwitterLib)

Dynamically building TGA images

When it comes to visualizing images (or textures, in WoW parlance), World of Warcraft poses quite a few restrictions on what files can be used and where does files should be. First of all, World of Warcraft only supports the TGA and BLP file formats. TGA stands for the Truevision Targa format, whereas BLP is Blizzard’s own image format. The images must also have dimensions of two (32×32, 64×64 pixels and so on…), otherwise they won’t show up. On the other hand, Twitter user pictures are available as 48×48 or 75×75 pixels and in various well-known formats, such as JPG, PNG or even GIF. TweetCraft needs to convert these pictures to 64×64 TGA files if it wants to play nice with World of Warcraft. This is done for each tweet’s authors user picture that will show up in World of Warcraft. The converted pictures must be placed in the Interface folder of World of Warcraft where the add-ons themselves also reside. The TwitterUserPictureService can retrieve the user picture and convert it to a 64×64 TGA file that contains the 48×48 user picture in the middle and puts that file into the same directory where the TweetCraft add-on is installed. The files are named after each user’s screen name and if TwitterUserPictureService sees that a file is already there, it won’t convert it again, saving some time and computing power.

Figure 4 shows TwitterUserPictureService and two helper classes that take care of downloading and the actual conversion. The GetUserPicturePath method returns the path of the resulting World of Warcraft compatible TGA file for a single user.

Figure 4. TwitterUserPictureService and its helper classes

Serializing tweets into Lua

Until now, we were quite secretive about how we can avoid World of Warcraft’s restrictions and let TweetCraft be able to read the data and show it. We’ve said that add-ons cannot read or write files and that still hasn’t changed during the last few minutes, but add-ons must have a way somehow to save their settings and other information when I log out of the game and load that when I log back in, you sincerely ask and you’re right! Although add-ons cannot read or write to files, they can ask World of Warcraft to save and load some of their global variables whenever the user reloads the UI (by entering an instance or hearthing), logs in or logs out. These files are called the SavedVariables files. When TweetCraft finishes downloading tweets, converting user pictures and everything else, it saves them using the very same format and to the very same file World of Warcraft uses on behalf of the TweetCraft add-on. Neat, huh? Just wait a little bit more…

Those variables that an add-on asks to be saved between sessions are saved into a Lua file, which is the same programming language add-on developers can use to write their add-ons. So basically, World of Warcraft creates a file that contains code full of assignment statements (think a = 5) that it will just run whenever those values need to be set again. More complex data structures can also be expressed this way using Lua tables, the swiss army-knife of Lua.

It sounds like a great idea to put all the data we would like for TweetCraft to use, but all we have is .NET objects, arrays and dictionaries. Fortunately, all these data structures can be expressed with simple Lua types and tables and TweetCraft comes with a class called LuaSerializer that produces Lua code from any .NET object (with a few restrictions, of course), very similar to how XmlSerializer works.

To make this even more simple, TweetCraft contains the concept of a SavedVariablesChannel that you can just drop objects in, flush it and those object show up on the other side. In our case, as Lua variables. What’s even better, it works the other way around as well. The TweetCraft add-on stores all the tweets queued up and ready to be sent in a variable and triggers World of Warcraft to save them to the SavedVariables file. The SavedVariablesChannel detects this by watching for changes made to the SavedVariables file using FileSystemWatcher and notifies other components of the TweetCraft application that can pull out the information and send the tweets.

Figure 5 shows SavedVariablesChannel and its base class, ValueChannelBase which keeps track of all objects thrown into it until it is flushed.

Figure 5. SavedVariablesChannel and ValueChannelBase

Refreshing the data in World of Warcraft

There’s one last problem we face when trying to achieve this two-way communication between the TweetCraft add-on and the application. If World of Warcraft is running, we cannot just overwrite the SavedVariables file and expect World of Warcraft to pick it up as it does not watch for changes made to the file. If we were to overwrite the file and subsequently the user logs out, World of Warcraft will happily overwrite the information we placed there. There’s another trick we have to resort to: the TweetCraft add-on can trigger the reloading of the UI which will unload all add-ons, save their variables and then load them again. There’s a a little bit of time between the saving and loading of a particular add-ons SavedVariables file and that’s when TweetCraft can safely read the file for queued up tweets and overwrite it with the new data. This is what happens when the user clicks the Refresh button in TweetCraft’s frame.

Sending tweets and uploading screenshots

Whenever the user queues up tweets for sending, they are not immediately sent but kept in a data structure that will be saved out to the SavedVariables file by World of Warcraft. We’ve seen that his happens when either the user logs out or presses the Refresh button. The updated SavedVariables file gets detected by SavedVariablesChannel and the ChannelUpdated event is raised. When the TweetCraft application handles this event, it cannot immediately send the tweets as that would take a couple seconds and if you remember from the last section, we only have a tiny little window of time to process the values and save back all the data we would like to send back. For this reason, the tweets that are picked up from the SavedVariables file using the SavedVariablesChannel get quickly queued up in the TwitterDispatcherService that then goes ahead and starts sending them one by one in the background. To make sure that all the values we prepared to save into the file get flushed, the SavedVariablesChannel has a property called AutoFlush that is enabled by default.

One thing we have not mentioned is that TwitterDispatcherService can also upload and post pictures using TwitPic. It watches the Screenshots folder of World of Warcraft for new files and if AutoTweeting of screenshots is enabled, immediately queues up the picture for uploading and posting it. This also means that you don’t need to press the Refresh button or wait until you log off for screenshots to be posted. They will show up immediately in your Twitter feed.

The TwitterDispatcherService uses TwitterClient (and TwitterLib) to send the tweets but it does not interfere with the quick reading and writing of the SavedVariables file we discussed previously. It also uses TwitPicClient to upload and post pictures. Figure 6 shows TwitterDispatcherService, TwitterClient and TwitPicClient.

Figure 6. TwitterDispatcherService, TwitterClient and TwitPicClient

Bringing it all together

So far, we’ve looked at components of TweetCraft that implemented a particular part of the application. Retrieving and sending tweets, converting user pictures and making all this information available for the TweetCraft add-on, but there’s an important class that brings all this together and contains all the logic of how these components interact with each other. We also need to be able to detect World of Warcraft installations, figure out what accounts are available and where to look for files like the SavedVariables files and put the converted user pictures. The TweetCraft class implements the logic required and relies on the WorldOfWarcraft class for everything World of Warcraft related.

Figure 7 shows the TweetCraft and WorldOfWarcraft side by side.

Figure 7. TweetCraft and WorldOfWarcraft

Summary

While this is a high-level overview of TweetCraft only, it gives you a good idea of how it enables World of Warcraft players to use Twitter to send and receive tweets, upload the screenshots and share their achievements right inside the game. Make sure you try out TweetCraft if you have World of Warcraft installed and if you’re curious, download the source code and take a deeper look.

Gabor Ratky (Blog, Twitter), Senior Software Engineer and Coding4Fun Ninja at EPAM Systems 

Gabor is the developer behind TweetCraft and has been working on Coding4Fun projects for almost two years. He also leads the development of AddOn Studio for World of Warcraft, a Visual Studio-based IDE for building World of Warcraft add-ons and he co-authored the chapter in the Coding4Fun book about it. He is a VSX Insider and was invited to speak at various events about Visual Studio Extensibility. When not working on Coding4Fun projects, Gabor works on large scale, enterprise solutions using exciting Microsoft technologies. He lives in Budapest, Hungary and loves traveling, good wine and Channel9 videos.

We spend most of our time on the flight booking page.  This page was built using Silverlight to demonstrate some of the simple experiences that can be designed.  In this case the UI was built in Expression Blend.  Designers and developers work together closely on projects.  In fact, developers and designers work on the exact same project files but stay in their own environments; Developers stay in Visual Studio, Designers stay in Expression.  We’ll talk a lot more time about Silverlight in the final episode of this series tomorrow.

In our example we use a third party web service run by ezGDS to present the conference attendee with a list of flight options.  ezGDS takes care behind the scenes to retrieve that flight fare information from various global distribution systems including Amadeus, Worldspan, Sabre and others.  The attendee sees none of that complexity since we’ve built all of that directly into our system.  Even though the information coming back can be very complex, including ticket information and various inbound and outbound flight segments, Dynamics CRM easily handles storing this information in a custom entity.

This episode is part of a 5-part series. In this series we’ve tried to explain how you can combine the Microsoft Web Platform with Dynamics CRM to quickly build and deploy self-service solutions. The full set of videos include:

1. Dynamics Duo Rides Again
2. Dynamics Duo: Everybody needs an Identity
3. Dynamics Duo: Wide World Importers Code
4. Dynamics Duo: Composition with Third-Party Web Services (this video)
5. Dynamics Duo: Silverlight and Jazz Hands 

Both Girish and I enjoyed recording this series. We hope you enjoyed them as well. If you have comments or suggestions for other topics, feel free to add comments below or email Girish or me (Ben) directly.

Sanjay Jain
ISV Architect Evangelist
Microsoft Corporation
Blog: http://Blogs.msdn.com/SanjayJain
Twitter: http://twitter.com/SanjayJain369

If you weren’t able to attend the conference or watch the live stream at live.visitmix.com, here’s what you missed:

Silverlight 3

Already the download links are live for the Developer Runtime Beta of Silverlight 3, the SDK, documentation, and the Silverlight 3 Tools Beta 1 for Visual Studio 2008 SP1. And we heard the final version of Silverlight 3 should ship by year-end. In the new version of this technology, RIA developers will have more tools to work faster with new graphics, animation, and 3-D features and more than 60 new controls. There’s added support for the H.264 video format, deep linking, better SEO support, and new hardware-based graphics acceleration and animation features. Silverlight 3 will also allow developers to create lightweight web apps that can exist outside the browser, which should definitely lead to some interesting scenarios. (Like a Netflix desktop app, I can only hope).

Today, Silverlight is in use on a number of major websites including AOL, eBay, BSkyB, Netflix, CBS Sports Online, the European Commission, CareerBuilder.com, Samsung Electronics Co., and Yahoo! Japan. Microsoft, of course, has deployed the technology on 200+ products and sites like Microsoft.com, MSN, Live Search, Windows Live, Microsoft Office Online, Virtual Earth and the new Silverlight-based WorldWide Telescope application.

Microsoft’s Web Platform Installer & Gallery

Also available is a new preview release of .NET RIA Services, technology which brings the ASP.Net platform together with the Silverlight platform and the Web Platform Installer 2.0 Beta, a tool that simplifies the installation and maintenance of Microsoft’s web stack as well as other free components. This release lets users download both PHP and the final release of ASP.NET MVC 1.0. It’s available on on this page alongside the final version of the 1.0 release. With the new beta, you can easily install popular open source ASP.NET and PHP web apps and other extras like the latest community version of PHP for Windows.

Along with the Web Platform Installer beta 2, there’s now a Windows Web Application Gallery available where developers can discover, explore and download applications and components that can help them build web apps. This gallery doesn’t just feature Microsoft products either – it includes links to other online resources like Acquia Drupal, DotNetNuke and WordPress. The gallery divvies up the types of apps into categories and includes both a featured app section and a “top 5” section.

Windows Azure Tools and Upgrades

Finally, Guthrie unveiled the new Windows Azure Tools for Microsoft Visual Studio. These extend Visual Studio’s capabilities to allow for the creation, building, debugging, running, and packaging of scalable services on Windows Azure. The Azure Tools download also includes the Windows Azure SDK.

The Windows Azure Platform itself received an upgrade, too. Today Microsoft added new capabilities including support for full trust to increase the level of flexibility for developers through support of native code, non-.NET language support via FastCGI, and geolocation which will allow developers to host data and code across two U.S.-based datacenters. The Azure team has also addressed the top customer bugs and has implemented update notifications for future releases. Customers were reminded, however, that Azure is still a CTP (Community Technology Preview) and should not yet be used on production systems.