Knowledgecast

Collapsible Panel Makes it to Silverlight 2 RTM

This was something that had been bothering me for a while. Silverlight 2 came out almost two months ago now and I still haven't had the time to go back and update CollapsiblePanel, my sample content control. To read more about CollapsiblePanel, go here and here.

Today I finally updated the code. It took me all of 6 minutes. Here's the changes I made:

1. Moved the generic.xaml from the root of the Knowledgecast.Controls project to a subfolder called Themes. I think this change was introduced for WPF compat.

2. Went into the generic.xaml and ensured that the vsm: prefix was only used for VisualStateManager related tags. In Silverlight 2 Beta 2 Blend would sometimes use this prefix on Style and Setter tags as well. This causes problems with the released version.

That's it! The CollapsiblePanel control is now Silverlight 2 compatible. To see the latest version in action, go here. To get the latest version of the code, go here:

Finally, I should point out that the Silverlight Toolkit (http://www.codeplex.com/Silverlight) has an Expander control that is very similar to the Collapsible Panel. The control is currently in the Preview quality band but the team behind the Toolkit make releases very rapidly so I'm sure it'll move up the quality ladder quickly.

Posted: Friday, November 28, 2008 12:05 PM by Arunjeet Singh | 1 Comments

Filed under: silverlight, collapsible, control, content, custom, .NET

Consuming Feeds with the .NET Syndication API

One of the nicest (and very under-advertised) features to make it into .NET framework 3.5 was the new Syndication API (http://msdn.microsoft.com/en-us/library/system.servicemodel.syndication.aspx). The Syndication API provides .NET applications a great way to consume and publish RSS and Atom feeds. If you've been paying attention to Azure lately you will have realised that Atom forms a major part of Azure and Live services in the cloud. Syndication feeds (Atom/RSS) are fast emerging as the de facto way for applications to update interested parties about changes in state, news and any other updates. There's a good reason for this. Feeds allow consumers (that's you and me) to control when, where and how often to receive updates.

Without further ado, let me present some sample code to consume an RSS feed using the Syndication API:

XmlReader reader = XmlReader.Create("http://blogs.msdn.com/knowledgecast/rss.xml");
Rss20FeedFormatter rss = new Rss20FeedFormatter();
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
var items = from item in rss.Feed.Items.OfType<SyndicationItem>()
                   select new
                   {
                      Title = item.Title.Text,
                      Url = item.Links.First<SyndicationLink>().Uri.AbsoluteUri
                   };

lstFeedTitles.DataSource = items;
lstFeedTitles.DataBind();
}

reader.Close();

We open an XmlReader with the RSS feed for this blog as URL. We then create an Rss20FeedFormatter (System.ServiceModel.Syndication.Rss20FeedFormatter) and use the CanRead method to verify that the feed loaded in our XmlReader is an RSS feed. The ReadFrom method reads the feed into the feed formatter.

Now things start to get really interesting. I use a clever LINQ query to slurp out the Title and Url of the post into a collection. Note that the objects in this collection all use an anonymouse type that is defined inside the LINQ query. We then bind the resulting collection (which should be an IEnumerable) to a DataList we have sitting in our ASPX page. Here's what our ASPX form looks like:

<form id="form1" runat="server">
    <div>
    <ul>
    <asp:DataList ID="lstFeedTitles" runat="server">
        <ItemTemplate>
         <li>
            <asp:LinkButton ID="lnkTitle" runat="server" Text='<%# DataBinder.Eval(Container.DataItem, "Title")%>' PostBackUrl='<%# DataBinder.Eval(Container.DataItem, "Url")%>' />
         </li>
        </ItemTemplate>
    </asp:DataList>
    </ul>
    </div>
    </form>

And voila! You have your very own super simple RSS feed reader. It's almost too easy :) Here's what the rendered page looks like:

Silverlight 2: So Close I Can Taste It

Phew! It's Been a Busy Month

Encrypting Configuration Settings in .NET 2.0

Using VisualTransition with a Silverlight Content Control

Assigning a Name to a Silverlight Element

Writing a Silverlight Content Control

Microsoft SQL Server 2005 Express Edition with Advanced Services

Quick Guide to Silverlight 2 Beta 2

Quick Guide to Silverlight 2 Beta 1

Are you an aspiring architect?

Windows Mobile Power Savers

Windows XP Service Pack 3 released

Biztalk Server 2006 R3 announced

Paste As Text 1.0

TechReady 5

To get this code to work with a proxy server, you can run the XmlReader off a WebClient instead of a direct URL. Here's how you'd do that:

WebClient wc = new WebClient();
WebProxy proxy = new WebProxy("myproxy.corp.com", true);
wc.Proxy = proxy;
wc.Credentials = CredentialCache.DefaultCredentials;
Stream s = wc.OpenRead("http://blogs.msdn.com/knowledgecast/rss.xml");

XmlReader reader = XmlReader.Create(s);

//Syndication API code here

Posted: Tuesday, November 18, 2008 6:59 PM by Arunjeet Singh | 1 Comments

Filed under: tricks, tips, web 2.0, .NET

Silverlight 2: So Close I Can Taste It

No doubt many of you have heard that Silverlight 2 RC0 just debuted. There's loads of bug fixes here since Silverlight 2 Beta 2 and some breaking changes as well. Unlike the breaking changes document from Beta 1 to Beta 2 (which was 80 odd pages) this one's only about 20 pages. To be honest, I don't think it's going to be very much work going from SL2B2 to SL2RC0. Go here for the breaking changes document and here for the release. The tools are meant for Visual Studio 2008 SP1 so make sure you upgrade to that before installing.

There's also a corresponding version of Expression Blend that came out to support this release. Get Expression Blend 2 Service Pack 1 Preview here.

Let there be light indeed! :)

Word of caution though. This version is not intended for releasing applications on, only to help update your applications to work with the eventual Silverlight 2 release.

Posted: Friday, September 26, 2008 10:48 AM by Arunjeet Singh | 1 Comments

Filed under: silverlight, .NET

Phew! It's Been a Busy Month

It's been a busy time here in Arunjeetland. Up until a couple of weeks ago, I was working on two projects simultaneously. As I was doing that I had an interesting realization. It's easier to do multiple projects if they're on the same technology. The context switch takes a lot out of you. Unfortunately for me, one of the projects was a Biztalk implementation (with loads of code refactoring) and the other an ASP.NET application. Not easy juggling :)

I have also been busy prepping for an upcoming Silverlight training that I am supposed to deliver. I was fortunate enough to get my hands on a lot of content that the evangelism folk put out recently, but getting them to fit in the expected formats is a bit of a challenge. Nevertheless, I am learning a lot of new things about Silverlight (finally managed to write a custom panel control) and having a lot of fun with the labs. Oh, and did I mention my sister's getting married and I'm getting engaged next month? Oh yeah, the fun just never ends :D

Posted: Sunday, September 14, 2008 5:22 PM by Arunjeet Singh | 1 Comments

Encrypting Configuration Settings in .NET 2.0

This article describes a utility called ProtectConfig that can be used to Encrypt/Decrypt .NET 2.0 configuration files using the ProtectSection (http://msdn.microsoft.com/en-us/library/system.configuration.sectioninformation.protectsection.aspx) API. The source code of the utility is available here:

Here's what the ProtectConfig utility looks like:

If you have ever worked on a large project that involved accessing a database server or other network resources, you will have realised at some stage a lot of potentially sensitive information (credentials, settings etc.) end up inside the configuration files. Ideally, you would want to store all this information in a secure data store. Some information however, such as the database connection strings, are best placed in the configuration file. Thankfully, .NET Framework 2.0 ships with a great utility called aspnet_regiis.exe that can be used to encrypt configuration settings in a web.config file. The encryption can be based on the RSA provider or Windows' own Data Protection API (DPAPI). The RSA provider also allows you to tie the encryption to a user certificate so that you can use the same encrypted data across multiple hosts (provided each of them has the correct certificate in its certificate store). More information about aspnet_regiis.exe can be found here: http://msdn.microsoft.com/en-us/library/ms998280.aspx.

What a lot of people don't realise is that it is possible to encrypt the settings of any .NET 2.0 (or upwards) application, not just web sites and web applications. What lies behind the aspnet_regiis utility is the ProtectSection method (http://msdn.microsoft.com/en-us/library/system.configuration.sectioninformation.protectsection.aspx) of the SectionInformation class. This method lets you encrypt a configuration section belonging to a .NET configuration file based on a given protection provider. At the moment there are two protection providers (RSA and DPAPI) available out of the box although there is nothing stopping you from writing one.

Recently, I needed to encrypt a large set of configuration files for a client. We decided to go with the DPAPI provider because we considered it secure enough (it is what Windows machines use to protect logged on user credentials) and we also wanted to tie the encrypted configuration to the machine it was running on. The configuration files to be encrypted were a mixture of background services, web services and web sites. I realised that we would have to provide the deployment team a way to encrypt all these confguration files. My first thought was to go with aspnet_regiis. However, seeing the large number of files and the discomfort the deployment team expressed with a command-line tool I decided to write something that would make their life and mine a bit easier. This was where ProtectConfig was born.

At the moment, ProtectConfig uses DPAPI to encrypt settings and encrypts the appSettings, connectionStrings, identity and authorization sections. It is smart enough to detect the presence of these sections in the configuration file and then process them. It can also be used to decrypt settings when needed. The really nice thing about ProtectConfig though is that it can process a folder full of .config files (recursively or non-recursively). This makes it easy to encrypt/decrypt all the files on a host in one go.

Lets take a quick look at the code. The meat of the application lies in two methods: _EncryptConfig and _DecryptConfig. Here's what _EncryptConfig looks like:

private void _EncryptConfig(string fileName)
        {
            if (String.IsNullOrEmpty(fileName) == false && File.Exists(fileName))
            {
                lbLog.Items.Add("Analyzing " + fileName);

                XmlDocument configDom = new XmlDocument();
                configDom.Load(fileName);
                bool hasConfig = false;
                bool hasAppSettings = false;
                bool hasConnectionStrings = false;
                bool hasIdentity = false;
                bool hasAuthorization = false;
                bool hasSystemWeb = false;

                XmlNode node = configDom.SelectSingleNode("/*[local-name()='configuration']");
                if (node != null)
                {
                    lbLog.Items.Add(fileName + " has a <configuration> section.");
                    hasConfig = true;
                }
                else
                {
                    lbLog.Items.Add(fileName + " has no <configuration> section. This file will not be processed.");
                }

                if (hasConfig)
                {
                    node = configDom.SelectSingleNode("/*[local-name()='configuration']/*[local-name()='appSettings']");
                    if (node != null)
                    {
                        lbLog.Items.Add("Found appSettings");
                        hasAppSettings = true;
                    }

                    node = configDom.SelectSingleNode("/*[local-name()='configuration']/*[local-name()='connectionStrings']");
                    if (node != null)
                    {
                        lbLog.Items.Add("Found connectionStrings");
                        hasConnectionStrings = true;
                    }

                    node = configDom.SelectSingleNode("/*[local-name()='configuration']/*[local-name()='system.web']");
                    if (node != null)
                    {
                        hasSystemWeb = true;

                        XmlNode innerNode = configDom.SelectSingleNode("/*[local-name()='configuration']/*[local-name()='system.web']/*[local-name()='identity']");
                        if (innerNode != null)
                        {
                            lbLog.Items.Add("Found identity");
                            hasIdentity = true;
                        }

                        innerNode = configDom.SelectSingleNode("/*[local-name()='configuration']/*[local-name()='system.web']/*[local-name()='authorization']");
                        if (innerNode != null)
                        {
                            lbLog.Items.Add("Found authorization");
                            hasAuthorization = true;
                        }
                    }

                    ExeConfigurationFileMap map = new ExeConfigurationFileMap();
                    map.ExeConfigFilename = fileName;
                    Configuration config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);

                    if (hasAppSettings)
                    {
                        if (config.AppSettings.SectionInformation.IsProtected)
                        {
                            lbLog.Items.Add("appSettings is already protected!");
                        }
                        else
                        {
                            lbLog.Items.Add("Encrypting appSettings");
                            config.AppSettings.SectionInformation.ProtectSection("DataProtectionConfigurationProvider");
                        }
                    }

                    if (hasConnectionStrings)
                    {
                        if (config.ConnectionStrings.SectionInformation.IsProtected)
                        {
                            lbLog.Items.Add("connectionStrings is already protected!");
                        }
                        else
                        {
                            lbLog.Items.Add("Encrypting connectionStrings");
                            config.ConnectionStrings.SectionInformation.ProtectSection("DataProtectionConfigurationProvider");
                        }
                    }

                    if (hasSystemWeb)
                    {
                        ConfigurationSectionGroup systemwebgroup = config.SectionGroups["system.web"];

                        if (hasIdentity)
                        {
                            ConfigurationSection section = systemwebgroup.Sections["identity"];
                            if (section.SectionInformation.IsProtected)
                            {
                                lbLog.Items.Add("identity is already protected!");
                            }
                            else
                            {
                                lbLog.Items.Add("Encrypting identity");
                                section.SectionInformation.ProtectSection("DataProtectionConfigurationProvider");
                            }
                        }

                        if (hasAuthorization)
                        {
                            ConfigurationSection section = systemwebgroup.Sections["authorization"];
                            if (section.SectionInformation.IsProtected)
                            {
                                lbLog.Items.Add("authorization is already protected!");
                            }
                            else
                            {
                                lbLog.Items.Add("Encrypting authorization");
                                section.SectionInformation.ProtectSection("DataProtectionConfigurationProvider");
                            }
                        }
                    }

lbLog.Items.Add("Done encrypting information. Saving file " + config.FilePath);

config.Save();

                    lbLog.Items.Add("File " + config.FilePath + " saved to disk.");
                }
            }
            else
            {
                lbLog.Items.Add("Can't find the file " + fileName);
            }
        }

The algorithm itself is quite simple. The method first loads up a configuration file in an XmlDocument and checks what sections it has available. After that, armed with this information it goes about encrypting each of these sections using the ProtectSection method of the SectionInformation class. Notice the argument to the ProtectSection method. This argument (DataProtectionConfigurationProvider) is what tells the method to use DPAPI to encrypt the section. To use the RSA provider, simply use the string RsaProtectedConfigurationProvider as argument. To learn how to create and export an RSA key container for use with ProtectSection, see http://msdn.microsoft.com/en-us/library/2w117ede.aspx.

The code also makes use of the IsProtected property to ensure that it isn't encrypting a configuration section that is already encrypted. The _DecryptConfig method basically reverses the whole process and uses UnprotectSection to decrypt the configuration. Here's what it looks like:

private void _DecryptConfig(string fileName)
        {
            if (String.IsNullOrEmpty(fileName) == false && File.Exists(fileName))
            {
                lbLog.Items.Add("Analyzing " + fileName);