So how to handle it when you have a corrupt DB and want to send a fix to a remote device or you just want to update the DB with some new data.

DB Operations

The first thing I decided was what operations I wanted to support, I limited this to supporting create, update and delete operations since those are the ones we are really look at here. I also limited it to each operation only operating against a single entity type at a time, it just made it easier and that covers most of the scenarios I needed at the time.

Command Serialization

The first problem I needed to tackle was getting the commands down to the phone application, how am I going to script this? I chose to create an object model of DatabaseInstruction objects which represent the serialized format of one of the above operations. I then used JSON as the format for my script as it’s nice and easy to then return that object model from a server to the client and it’s more compact than XML. Of course you can always change the serialization format by creating a new IDatabaseInstructionParser to process different serialization formats into the object model.

I used the excellent JSON.Net library to handle the serialization for me.

Database Commands

Once I’ve gotten a list of DatabaseInstruction objects I convert them into DbCommand objects, these are the objects that do the actual work of talking to the database using LINQ to SQL. That’s handled by calling CreateCommand against each instruction. If you’d like to reuse the same DatabaseInstruction classes in the server component to build the script then I suggest refactoring this to separate the command creation out. I started doing that with the CommandBuilder class but never finished it, currently that class is incomplete and unused.

Parsing

So far so simple. The next challenge was filtering the data in the instructions, in order to do that I needed to pass in predicates in my scripts to apply changes to certain rows or to delete specific items. I downloaded and slightly modified the Dynamic LINQ sample from Scott Guthrie’s blog. This almost worked on the phone out of the box but not quite, I had to chop out support for ‘new’ since the phone can’t do the dynamic code gen bits that the sample uses and I didn’t need the operator for what I was doing.

In the commands I then use the DynamicExpression.ParseLamba() method to create an Expression predicate from the predicate from the script. This can then be used in my command execution with a custom Where implementation that takes an Expression object.

And finally…

Using the library is fairly easy, I’ve put together a sample WP7 app that creates a database and then provides 2 buttons, one runs an JSON script to insert data, the other runs a JSON script to update the data and delete a row. The scripts are in the Content folder in the project and I just use the DatabaseInstructions.Execute() method to run the script. This can either take a TextReader or an IEnumerable<DatabaseInstruction> if you’d prefer to handle parsing yourself.

As usual the normal disclaimers about demo code apply, use at your own risk. To build the sample just download the DynamicLinq sample code and load it in Visual Studio 2010. It uses NuGet to pull down the JSON.Net bits so just build the solution and it’ll do that automatically.

Enjoy.

More...

No related posts.

Attempt number 1

At first I thought this would be really easy, add a reference to the web service, call the Logon API and then we’re away. Unfortunately that isn’t the case.

I found this blog article by Paul Stubbs which was a good starting point.

When I implemented this against Office 365 it all seemed good until I actually tried to logon, I kept getting a logon failure and couldn’t figure out why. Eventually I twigged, Office 365 uses federated identity. As a result the SharePoint logon APIs don’t recognise your credentials, it knows nothing about them.

Attempt number 2

I then traced out the flow of an actual logon and found that Office 365 uses login.microsoftonline.com to authenticate against. At least this is the case on my Office 365 site, if you federate with a different provider then you’ll have to adapt this solution appropriately.

Now the flow here is a fairly standard WS-Trust flow, you hit the SharePoint site, that redirects a couple of times internally and then goes off to microsoftonline.com passing it a bit of security information. This asks you for your username and password in a web page and then redirects you back to Office 365 with some more security information.

SharePoint then writes out a cookie with a security token in, as long as web service API requests pass this cookie they’ll work.

So this is simple, I pop up a web browser, hit SharePoint go through the logon flow, grab the cookie once it comes back to SharePoint and we’re good to go.

Except we’re not, the cookie gets written with HttpOnly which means that you cannot programatically get the cookie.

Enter the hack

The solution I came up with is a little brittle but it works ok for now for me. If you look at how the WS-Trust flow works as implemented by this secure token service (STS) after log on it writes out a form with POST data on it containing the WS-Trust security data, then it uses JavaScript to post this back to SharePoint.

So what I do is roughly this:

1. Check if not logged on
2. Pop up a web browser control
3. Navigate to the SharePoint site home page which will redirect to the STS
4. User enters credentials
5. I hook up navigation events from the browser control and when I spot a navigate to the page with the POST data from the STS…
6. Capture the security information from the form from the browser control
7. Programatically POST the form back to SharePoint using a new CookieContainer and HttpWebRequest
8. SharePoint completes the WS-Trust flow and issues the SP security cookie which goes into the new CookieContainer
9. Attach the new CookieContainer to all web service API calls and it’s sorted

Now as mentioned this is a little brittle as if the STS changes how it works a bit then it’ll break but most of the time that’s unlikely, especially if you are running you own STS to federate your corporate logons, you’ll control it’s appearance.

I’ve included some sample code that does this, usual caveats apply. The DefaultSettings class has the SharePoint site address and SSL settings in there, change this to point at your site.

I’ve wrapped the CookieContainer in a SharepointServerContext class to isolate the using code from this. This class also contains other information about the connection the server such as it’s address etc. All of the web service API calls are executed by my own ISharepointCommand classes, these commands all take a SharepointServerContext so they know which server to talk to and can get to the CookieContainer for authentication.

Most of the logon flow code is in the code behind for the LogonView since it needs access to the browser control.

Next steps

There are bugs in the code, things are not complete, this is a work in progress but it does demonstrate the flow mentioned above. Currently if you authenticate and tick remember me it’ll break the next time you run since the flow will be different, it doesn’t cache cookies yet as that’s something else I need to work out so this is not a perfect approach. But hopefully it’ll help as a starting point for people looking at this.

You can download the sample project from here SharePointConnector. Good luck.

Update

After a little bit of investigation with the help of Rob de Beir (see comments below) we’ve discovered that the solution as posted only actually works on E1 Office 365 deployments, if you’re running P1 then it doesn’t work.

This is down to 4 things;

1. P1 SOAP APIs only work over HTTP, E1 work over HTTPS
2. There was a bug in the code (gasp) that meant setting SSL = false didn’t work
3. The logon view didn’t process the POST address from the STS, it was hardcoded
4. P1 sites have a path

Fortunately this is an easy fix, disable SSL in the DefaultSettings.cs, fix the bug (shown below) and make sure you set the host in the DefaultSettings.cs to have the path too e.g. mysite.sharepoint.com/teamsite.

To fix the bug simply find the line of code in GetListItems.cs where the BasicHttpBinding is created and change it to read;

new BasicHttpBinding(ServerContext.UseSsl ?
 BasicHttpSecurityMode.Transport :
 BasicHttpSecurityMode.None),

There is another bit that needs to change in the LogonView.xaml.cs file too. Replace the OnBrowserNavigated method with this one in order to correctly parse out the return address from the STS.

private void OnBrowserNavigated(object sender, NavigationEventArgs e)
{
    if (!IsLastPage(e.Uri))
        return;

    string content = Browser.SaveToString();
    Regex actionRegex = new Regex("<FORM .* action=(?'action'.*?) target.*",
                                  RegexOptions.Multiline |
                                  RegexOptions.IgnoreCase);
    Regex tokenRegex = new Regex("name=t value=(?'token'.*?) type=",
                                 RegexOptions.Multiline |
                                 RegexOptions.IgnoreCase);

    Group tokenMatch = tokenRegex.Match(content).Groups["token"];
    Group actionMatch = actionRegex.Match(content).Groups["action"];

    if (tokenMatch.Success && actionMatch.Success)
    {
        _token = tokenMatch.Value;
        _action = actionMatch.Value;

        Browser.Navigated -= OnBrowserNavigated;
        Browser.NavigateToString(Strings.LogonPageLoadingMessage);
        Logon();
    }
}

Add a backing field for the action.

private string _action;

And finally update Logon() to use the new action.

HttpWebRequest request = (HttpWebRequest)WebRequest.Create(_action);

That should fix it all to work on E1 as well as P1. Thanks to Rob for his help in debugging this, I’ll try and get updated source up soon.

More...

No related posts.

In order to run the demo code you will need VS2010, WP7 SDK, Azure SDK.

Running for the first time

Run VS2010 elevated (needed for Azure) and build the project. Run using the GadgetVote.Client and GadgetVote.Server projects as startup projects.

Once running you will need to go to settings in the client and change the address of the server to localhost:81 (or whatever port your Azure service is running on in DevFabric). You can also choose to use the proper WP7 push notifications service by leaving the check box ticked or use the Azure based stub service by unticking the box. You will need to restart the client app after changing this setting.

It’s a demo project!

It’s a demo project, it will crash and break if you don’t do things just right. If the Azure service hasn’t started by the time the phone app starts then you’ll get an exception from the client app. Just hit F5 and carry on, once the Azure services have started you can go to settings and hit OK and it should register again with the Azure service and work.

Who am I?

You will want to go to settings and add a username for yourself, this is name@domain, I usually use something like rob@emulator or rob@phone1 etc.

I do have friends, honest

Next you’ll need to hit the + button and add a friend, you can just add yourself for now, the name doesn’t matter but the second field must match the name entered in settings.

Adding a gadget

You can then add a gadget by clicking the camera. Check the table storage on your Azure instance though first, the clients must all have registered themselves with push notification endpoints before doing this or you’ll get a crash! You can goto settings and hit OK to force it to re-register.

Multiple clients

You will need to run multiple machines to do this with an emulator on each. If you have phones then you can use those. Azure DevFabric only allows connections from the local machine though, to get around this I run a reverse proxy using IIS and the ARR plugin. Configure a proxy with a URL rewrite rule for something like /azure to map to localhost:81. Then you can use ip/azure for the host name in the client settings on the WP7 app and it’ll work remotely.

Usual caveats apply, this is demo code, it’ll explode if you prod it wrong and don’t use in production.

Enjoy!!

More...

Related posts:

1. TechEd code coming soon
2. Simulated Push Notifications on Windows Phone 7

More...

No related posts.

Now in the real world my application would indeed need an internet connection or it would actually be kind of useless, but in demoland I don’t need one as I can run the cloud services portion in the Azure DevFabric which is nice in case the internet connectivity in the demo room goes down, I have a backup.

The same isn’t true of push notifications, they are managed by Microsoft and if I can’t get to them I can run my demo even though my own cloud services are running locally. In order to get around this I wrote a simple WCF service that also runs in my Azure DevFabric along with my other services that can act as a push notification endpoint. It’s not totally seamless but it works quite nicely for me as I now have a fallback for push notifications as well as for my own cloud services.

The Service

The service is a REST based WCF service that has two methods on it’s rather simple interface.

[ServiceContract]
public interface INotifications
{
    [OperationContract]
    [WebInvoke(Method="POST", UriTemplate = "Notify",
        BodyStyle = WebMessageBodyStyle.Bare, RequestFormat = WebMessageFormat.Xml)]
    void Notify(Message message);

    [OperationContract]
    [WebInvoke(Method = "GET", UriTemplate = "Notifications/{id}")]
    Message GetNotifications(string id);
}

The service then queues any incoming messages until the client gets them. The notify endpoint will quite happily take push notification requests from my existing Azure services without modification.

[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single,
                    ConcurrencyMode = ConcurrencyMode.Multiple)]
public class NotificationsService : INotifications
{
    private class NotificationMessage
    {
        public string MessageContentBase64 { get; set; }
    }

    private ConcurrentDictionary<string, ConcurrentQueue<NotificationMessage>> _messages;

    public NotificationsService()
    {
        _messages = new ConcurrentDictionary<string, ConcurrentQueue<NotificationMessage>>();
    }

    public void Notify(Message message)
    {
        // Grab the notification from the message body
        var queryParams = ParseQueryString(message.Headers.To.Query);
        var body = message.GetReaderAtBodyContents();

        XElement data = XElement.Load(body);

        var queue = _messages.GetOrAdd(queryParams["id"], key => new ConcurrentQueue<NotificationMessage>());

        queue.Enqueue(new NotificationMessage
                        {
                            MessageContentBase64 = (string)data,
                        });

        Log.Default.TraceInformation("Notification from: {0}", queryParams["id"]);
    }

    private static IDictionary<string, string> ParseQueryString(string queryString)
    {
        var queryItems = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);

        queryString = queryString.TrimStart('?');
        string[] strings = queryString.Split('&');

        foreach(string queryItem in strings)
        {
            int equalsIndex = queryItem.IndexOf('=');
            if (equalsIndex >= 0)
            {
                queryItems.Add(queryItem.Substring(0, equalsIndex),
                                queryItem.Substring(equalsIndex + 1));
            }
            else
            {
                queryItems.Add(queryItem, null);
            }
        }

        return queryItems;
    }

    public Message GetNotifications(string id)
    {
        XElement response = new XElement("notifications");
        ConcurrentQueue<NotificationMessage> queue;

        Log.Default.TraceInformation("Checking notifications for: {0}", id);

        if (_messages.TryGetValue(id, out queue))
        {
            NotificationMessage message;
            while (queue.TryDequeue(out message))
            {
                response.Add(new XElement("notification", message.MessageContentBase64));

                Log.Default.TraceInformation("De-queued notification for: {0}", id);
            }
        }

        WebOperationContext.Current.OutgoingResponse.Headers[HttpResponseHeader.CacheControl] = "no-cache";
        return WebOperationContext.Current.CreateXmlResponse(response);
    }
}

The Client

The WP7 application isn’t quite as lucky. I could probably have done something that faked getting the notifications a little better but the simplest solution was to just have a background timer that polls my service and gets the notifications. It then processes these using the normal code path for push notifications in my application.

I really should probably use the reactive extensions (RX) to manage my push notifications in the client as that would make them nice and mockable too but for now this works as a solution and keeps the client code reasonably understandable for demo purposes.

All in all it works quite nicely and means I don’t have to have an internet connection to now demo my application, even with push notifications.

More...

Related posts:

1. Transferring large files using WCF

This particular query related to how to use the navigation framework introduced in Silverlight 3 with the MVVM pattern. For those that don’t know the Model-View-ViewModel pattern is a common pattern often used to build Silverlight and WPF applications since it has strong support for databound UIs and provides good abstraction for unit testing and keeping your view logic separate from the view and the model.

Enter the Silverlight Navigation Framework

Handling the page style navigation that we’ve all become used to on the web can be a real pain in RIAs written using Silverlight, Flash or AJAX involving lots of tracking of page clicks using HTML bookmarks and some liberal use of JavaScript. Fortunately Silverlight 3 added a navigation framework to help with this.

This framework works by you adding a Frame element to your root XAML and then creating many Page derived classes. These classes can then navigate between each other by calling into a NavigationService instance that each page inherits from it’s base class.

The issue with MVVM is that page navigation is a view logic, that means that it should sit inside the ViewModel, however the NavigationService is only on the Page class which the ViewModel doesn’t have access to.

Solving this problem is simple, just pass the NavigationService instance to the ViewModel, job done! Well ok, that works if you hate unit testing. If you like unit testing though you may find you have problems then when it comes to testing your ViewModel as you won’t have a NavigationService instance to pass it.

Additionally since many pages are likely to want to do this I’d like to have a reusable approach that doesn’t take much code to reuse.

The Solution

The solution I came up with is one of a few different ways you could implement this but this works for me at the moment. Feel free to point out any glaring errors in my design though.

Wrapping the NavigationService

First I need to make the NavigationService mockable so I can use it in unit tests. To do this I created a new interface INavigationService that exposes the methods and properties of the NavigationService. This sample version only exposes Navigate() but you could easily expose more as needed.

    public interface INavigationService
    {
        void Navigate(string url);
    }

Not the most complex interface ever devised you’ll agree.

Next I created a class that implemented the interface and took a reference to a System.Windows.Navigation.NavigationService on it’s constructor.

    public class NavigationService : INavigationService
    {
        private readonly System.Windows.Navigation.NavigationService _navigationService;

        public NavigationService(System.Windows.Navigation.NavigationService navigationService)
        {
            _navigationService = navigationService;
        }

        public void Navigate(string url)
        {
            _navigationService.Navigate(new Uri(url, UriKind.RelativeOrAbsolute));
        }
    }

Supporting INavigationService in the ViewModel

Now I had an abstraction I needed to pass the INavigationService to the ViewModel. I wanted to do this in a standard way. I could have made it a constructor argument but I couldn’t always guarantee I’d be there at construction. The best way seemed to be to add a property. I decided to put that property on an interface so I had a defined contract that ViewModels could support.

INavigable.

    public interface INavigable
    {
        INavigationService NavigationService { get; set; }
    }

This interface provides a single property that a ViewModel can implement that will contain a reference to the INavigationService that the ViewModel should use to perform navigation when it needs to.

Passing the INavigationService to the ViewModel

Next I need to create an instance of the NavigationService that wraps the System.Windows.Navigation.NavigationService in the Page class and pass that to the ViewModel. I’d like this to be reusable code and if possible I don’t want any code behind in my View.

This is a perfect use for an attached behaviour. What’s one of those? It’s simply an attached property with a property changed handler on it that hooks up code to the DependencyObject that the property gets attached to. It’s simpler than it sounds and is a nice way of making reusable logic that you want to attach to objects in XAML.

The Navigator.

    public static class Navigator
    {
        public static INavigable GetSource(DependencyObject obj)
        {
            return (INavigable)obj.GetValue(SourceProperty);
        }

        public static void SetSource(DependencyObject obj, INavigable value)
        {
            obj.SetValue(SourceProperty, value);
        }

       public static readonly DependencyProperty SourceProperty =
            DependencyProperty.RegisterAttached("Source", typeof(INavigable), typeof(Navigator), new PropertyMetadata(OnSourceChanged));

        private static void OnSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            Page page = (Page) d;

            page.Loaded += PageLoaded;
        }

        private static void PageLoaded(object sender, RoutedEventArgs e)
        {
            Page page = (Page)sender;

            INavigable navSource = GetSource(page);

            if (navSource != null)
            {
                navSource.NavigationService = new NavigationService(page.NavigationService);
            }
        }
    }

This class provides a single attached property definition of the type INavigable. This property has a handler that when invoked grabs the DependencyObject you are attaching the property to and hooks up it’s Loaded event.

So when you attach this property to a Page instance in XAML it will fire off the PageLoaded method when the Page you attach it to loads. In the page load handler I then query the Page instance for the Source attached property. Remember that this property is of type INavigable. If the source supports INavigable I then create a new instance of the NavigationService, wrapping the Page’s instance and set it on the source using the INavigable.NavigationService property.

And there we have it, a reusable way of attaching the navigation service instance for a Page to the Page’s view model.

The View XAML

And finally using the attached property is a case of assigning the ViewModel to the DataContext of the Page as normal and then doing this.

<navigation:Page x:Class="SLNavigation.Page1"
           xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
           xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
           xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
           mc:Ignorable="d"
           xmlns:navigation="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation"
           xmlns:SLNavigation="clr-namespace:SLNavigation"
           d:DesignWidth="640" d:DesignHeight="480"
           Title="Page1 Page"
           SLNavigation:Navigator.Source="{Binding}"
    >

Summary

So that’s it, my solution. I think it’s reasonable, it minimised the amount of code needed in the View code behind to nil, makes the only code you need on the ViewModel is to derive from and implement INavigable which is one property and to put an attached property on the Page in the XAML. It keeps a good separate of concerns as the ViewModel is still unit testable but it can now support navigation.

Let me know what you think.

Sample code: NavigationSample

*edit* Added a sample

More...

Related posts:

1. Flexible Data Template Support in Silverlight

I’ve put together a small sample application that does a few maths calculations and ran the profiling tools in VS2010 against it. Once you have the the .vsp file that the profiler gives you all you need to do is open it in VS and away you go.

The first thing that you will see in VS is the summary report. This looks something like the one shown here.

The first thing that you will notice is you have a nice CPU graph, a hot path section and a list of functions with the most work. I’ll not concentrate on the CPU chart and but on the other two sections.

Inclusive and Exclusive

You’ll notice the terms inclusive and exclusive mentioned a lot in profiling, these refer to timing information for a function including all children and excluding all children. To start with you’ll want to concentrate on inclusive as that will help you find the path that is costing the most, otherwise known as the hot path.

The Hot Path

Looking at the hot path in the screenshot above you can see the the exe first calls Main, then two functions DataProcessor.Process() and DataProvider.GetData(). Now that isn’t the order that they are actually called in but that doesn’t matter here. What this section is showing is the order of costliness measured by the inclusive % time spent in that function compared to the overall program run.

Main() accounts for 100% of the time which is to be expected as remember we are looking at inclusive time so the children of main (the whole program) is included in the figures.

Next comes DataProcessor.Process() and its children which account for 56.36% of the time and then DataProvider.GetData() and children which account for the other 41.74%.

Drilling Down

The next thing to do is drill down into the hot path to see what’s going on. Clicking the DataProcessor.Process() function gives us the following screen.

This screen is now looking at the elapsed inclusive time % but you can change that from the dropdown. The pretty graphic in blue is showing the parent function on the left, Main() and what % this method is of the parent. We can see the same 56.4% from earlier there.

On the right you can see at the top the cost of this function itself and then underneath all of the child functions that this function calls.

We can ignore the small stuff for now and concentrate on the two larger figures at the top. The function itself is taking 27.1% of the time which isn’t surprising since it does do some calculations, it is going to take time. The interesting one is the first child. Count() is accounting for 26% of the overall time of the program execution, surely that can’t be right?

My Dodgy Code

Lets take a look at the code for that function and see what’s going on. The same screen shows the code in the lower pane which I omitted from the screenshot above. Lets look at that now.

internal class DataProcessor
{
    public int[] Process(int[] data)
    {
        // Average every 1000 numbers
        List<int> results = new List<int>();

        for(int i = 0; i < data.Count() / 1000; i++)
        {
            int total = 0;

            int j;
            for(j = 0; j < Math.Min(1000, data.Count()- (i*1000)); j++)
            {
                total += data[(i*1000) + j];
            }

            results.Add(total / j);
        }

        return results.ToArray();
    }
}

Looking at the line of code where Count() is called you can see I’m calling it as a check inside a loop! No wonder it’s consuming that much of the program execution. Let’s quickly fix that one and use the correct Length property instead. We can also see that Min() is taking 3% of the execution time so lets also pre-calculate the bound so it’s only calculated once rather than each loop.

Getting Some Figures

Ok so all these graphics are nice and pretty but lets get some hard figures shall we. If we change the current view to Caller / Callee then that will give is a tabular format of the previous graphic. It looks like this.

The top pane shows the parent function, the middle bit is the current function and at the bottom we have the child functions. And now we have columns with some nice figures in there.

The first column (I’ve rearranged them) shows the number of times a function was called. You can see that Count() was called a staggering 10,020,001 times! No wonder it was slow. Min() was also called over 10 million times. Well that should be fixed now.

How slow were they? Look across at the next column and you can see that Count() was accounting for nearly 10 seconds of run time, and Min() for just over 1 second. That a good improvement.

Comparisons

Profiling is all well and good but how do you really know if you’ve made things better or worse? Easy, compare with a known baseline. VS makes this quite easy. Once you have two performance runs you can compare the two and see what’s changed.

Lets run the profile trace again now I’ve fixed the Count() and Min() issue and see what it looks like compared to the first run.

At first glace this looks bad, four items have gone up and 3 have come down. However, if you look at the metric we’re looking at you’ll see it’s a % of overall run time. It makes sense then as something comes down the others will go up as they’ll now be consuming a larger % of the program’s run time, that’s ok, it’s productive work.

So how much time did we save, lets look at the elapsed exclusive time for those 3.

Not bad, over a 10 second improvement is performance.

Conclusion

Hopefully that has given you some insight in how to profile your own code and improve it’s performance. The biggest thing to remember is don’t make assumptions, just because you think something might be slow doesn’t mean it is, or even if it is doesn’t mean that it’s too slow for what you need.

Always optimize with hard data to show where the bottleneck is and how much you have improved (or made worse). Also keep sight of what is acceptable performance, is it really worth spending 5 days re-coding something for a 1 second improvement in a 30 second task or a 10ms improvement in a 1000ms page load? Most likely not.

More...

Related posts:

1. Performance Profiling .NET Applications Using the Visual Studio Profiler

The source code is below, the usual caveats about if it blows up your computer don’t blame me etc. apply.

using System;
using System.Linq;
using System.Text;
using System.Xml.Linq;

namespace UnBase64BlogML
{
    class Program
    {
        static void Main(string[] args)
        {
            XDocument doc = XDocument.Load(@"blogml-b64.xml");
            XNamespace blogML = "http://www.blogml.com/2006/09/BlogML";

            var query = doc.Descendants(blogML + "content")
                .Where(node => (string) node.Attribute("type") == "base64");
            foreach(var item in query)
            {
                string content = Encoding.UTF8.GetString(Convert.FromBase64String(item.Value));

                item.SetValue(content);
            }

            doc.Save(@"blogml.xml");

            Console.WriteLine("Press a key to continue");
            Console.ReadKey(true);
        }
    }
}

More...

No related posts.

All of the posts and comments + RSS feeds etc should have now been moved across but let me know if you notice any problems.

More...

Related posts:

1. Moved blogging engine

*updated* with new plug-ins.

More...

No related posts.