Sergey Barskiy's Blog

I posted another small update to my WinRT database project on CodePlex.

I added support for roaming.  You can now specify the location of the database, picking either local or roaming folder.  For example, here is how you can create database in Roaming folder:

_database = await
   Database.CreateDatabaseAsync(DatabaseName, StorageLocation.Roaming);

I added the same parameter – StorageLocation to OpenDatabaseAsync and DoesDatabaseExistsAsync method for full support.  If you are curious on how this was done, I used support for those folder that can be found via properties on ApplicationData.Current class/property.

Please let me know of any suggestions you might have.  Feedback is always appreciated.

I update quick start project, included in the download, to demonstrate the use of new functionality.

Thanks.

If you follow my posts, you noticed that I started up WinRT database project on CodePlex. I just published as small update to it that now support data binding of commands objects to IsDirty flag on database and each table.  The code is quite simple, for example here is how Save command is setup. 

public SimpleCommand<object> SaveCommand { get; set; }

public void OnSave(object parameter)
{
  if (_database != null)
  { 
    _database.SaveAsync();
  }
}

public bool CanSave(object parameter)
{
  return (_database != null && !_database.IsBusy && _database.IsDirty);
}

Now you can have cleaner UI, where Save button provides visual feedback to the users. Comments are welcomed as always.

Thanks.

I just posted new version for my CodePlex based project for WinRT database.  This chance is small – I added IsBusy property to the database class in order to enable data binding scenarios between buttons and commands.  You can take a look at the Quick Start project that distributed as part of the download for sample use of this property to support Save button on the main screen.

Please let me know if you have any questions.

Thanks.

As part of working on WinRT database I wanted to support ability to encrypt the data. The reason for that is that the data you persist using file system can be opened essentially in NotePad as long as you know where it is stored on the hard drive, which you can figure out. So, similarly to how I support encryption in Silverlight, I wanted to do the same in WinRT. I did some digging, and did find bits and pieces of information on the Win RT forum and in samples. Nothing however fully explained and had examples for encrypting and decrypting strings, which is what I wanted to accomplish. As a result, I wrote a helper class that I wanted to share.

My requirement were simple: just have two methods in a static class that take two parameters: input string and a password to use. I do not exactly use the password, but I use it to create a key: If you try to hack the code and pass password that was not used to encrypt into decryption method, you will get an exception. One thing that I found extremely annoying, is that all exceptions are coming in as COM exception (oh, no, do not take me back into the 90s – smile)

I added commented everywhere to make clear what I am doing. I coded this class using AES encryption provider. There is an ability in SymmetricKeyAlgorithmProvider.OpenAlgorithm to use various algorithms, but I could not find the list to save my life. As a result, I used the one mentioned in an example on the web – AES_CBC_PKCS7.

using System;
using System.Text;
using Windows.Security.Cryptography;
using Windows.Security.Cryptography.Core;
using Windows.Storage.Streams;
namespace EncryptDecrypt
{
/// <summary>
/// Class used for encryption and decryption using AES algorithm
/// </summary>
public static class EncryptionProvider
  {
    /// <summary>
    /// Encrypt a string
    /// </summary>
    /// <param name="input">String to encrypt</param>
    /// <param name="password">Password to use for encryption</param>
    /// <returns>Encrypted string</returns>
    public static string Encrypt(string input, string password)
    {
      //make sure we have data to work with
      if (string.IsNullOrEmpty(input))
        throw new ArgumentException("input cannot be empty");
      if (string.IsNullOrEmpty(password))
        throw new ArgumentException("password cannot be empty");
      // get IV, key and encrypt
      var iv = CreateInitializationVector(password);
      var key = CreateKey(password);
      var encryptedBuffer = CryptographicEngine.Encrypt(
        key, CryptographicBuffer.ConvertStringToBinary(input, BinaryStringEncoding.Utf8), iv);
      return CryptographicBuffer.EncodeToBase64String(encryptedBuffer);
    }
    /// <summary>
    /// Decrypt a string previously ecnrypted with Encrypt method and the same password
    /// </summary>
    /// <param name="input">String to decrypt</param>
    /// <param name="password">Password to use for decryption</param>
    /// <returns>Decrypted string</returns>
    public static string Decrypt(string input, string password)
    {
       //make sure we have data to work with
      if (string.IsNullOrEmpty(input))
         throw new ArgumentException("input cannot be empty");
       if (string.IsNullOrEmpty(password))
         throw new ArgumentException("password cannot be empty");
       // get IV, key and decrypt
       var iv = CreateInitializationVector(password);
       var key = CreateKey(password);
       var decryptedBuffer = CryptographicEngine.Decrypt(
         key, CryptographicBuffer.DecodeFromBase64String(input), iv);
       return CryptographicBuffer.ConvertBinaryToString(
        BinaryStringEncoding.Utf8, decryptedBuffer);
    }
    /// <summary>
    /// Create initialization vector IV
    /// </summary>
    /// <param name="password">Password is used for random vector generation</param>
    /// <returns>Vector</returns>
    private static IBuffer CreateInitializationVector(string password)
    {
      var provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm("AES_CBC_PKCS7");
      var newPassword = password;
      // make sure we satify minimum length requirements
      while (newPassword.Length < provider.SupportedKeyLengths.Min)
      {
        newPassword = newPassword + password;
      }
      //create vecotr
      var iv = CryptographicBuffer.CreateFromByteArray(
        UTF8Encoding.UTF8.GetBytes(newPassword));
      return iv;
    }
    /// <summary>
    /// Create encryption key
    /// </summary>
    /// <param name="password">Password is used for random key generation</param>
    /// <returns></returns>
    private static CryptographicKey CreateKey(string password)
    {
       var provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm("AES_CBC_PKCS7");
       var newPassword = password;
       // make sure we satify minimum length requirements
      while (newPassword.Length < provider.SupportedKeyLengths.Min)
      {
        newPassword = newPassword + password;
      }
      var buffer = CryptographicBuffer.ConvertStringToBinary(
        newPassword, BinaryStringEncoding.Utf8);
      buffer.Length = provider.SupportedKeyLengths.Min;
      var key = provider.CreateSymmetricKey(buffer);
      return key;
    }
  }
}

Using this class is very easy. Here is the example from my sample WinRT application.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Windows.Foundation;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Data;
namespace EncryptDecrypt
{
partial class MainPage
  {
    public MainPage()
    {
      InitializeComponent();
    }
    bool encrypt = true;
    private void Button_Click(object sender, RoutedEventArgs e)
    {
       var password = this.password.Text;
       if (encrypt)
       {
          this.input.Text = this.input.Text;
          this.ouput.Text = EncryptDecrypt.EncryptionProvider.Encrypt(this.input.Text, password);
          this.button.Content = "Decrypt";
          encrypt = false;
      }
      else
      {
          this.input.Text = this.ouput.Text;
          this.ouput.Text = EncryptDecrypt.EncryptionProvider.Decrypt(this.ouput.Text, password);
          this.button.Content = "Encrypt";
         encrypt = true;
      }
    }
  }
}

As you can see, my sample test app just calls two main methods and shows the results of encryption and decryption. Password and input string are required and cannot be left empty.

I am hoping to expand this in the future, once documentation is more complete, but this suffices for now. Please feel free to comment on this, especially if you have more information on the subject.

Thanks.

I have been learning WinRT, new Windows 8 run time for developing Windows 8 application for a little while now.  I am using my CodePlex project as study project.  One of my goals is have an ability to persist collections of object into file system, loosely called database.  I really want my collections to be bindable, so I attempted to use ObservableCollection<T> as the base class for my collections.  This worked just find in Windows Phone 7 and Silverlight based projects.  The same however does not hold true in WinRT.  It contains a number of bases classes that WinRT controls such as ListBox listen to instead of INotifyCollectionChanged.  Specifically, it is IObservableVector<T>.  There is a sample implementation in one of the WinRT sample apps, but I really did not like how it was done – via extension method on INotifyCollectionChanged.  What I really wanted to do is extend Observable Collection, because I think Microsoft will eventually have an implementation for IObservableVector<T>, maybe they would event extend the observable collection itself.  First thing I ran into is that if you use IObservableVector with T anything other than object, your program will throw “bad image” exception.  So, here is the outline of my solution.

• Use Observable Collection as base class
• Implement IObservableVector<object>

That should do it, right?

So, I am starting with this declaration:

public class ExtendedObservableCollection<T> : ObservableCollection<T>, IObservableVector<object>

Then I use smart tag for IObservableVector and let Visual Studio fill in the necessary interfaces I have to implement.  Then I simply call base methods of Observable Collection for the majority of implementation, casting object to T as necessary.  Simple and efficient, and most importantly, something I could simply remove down the road as WinRT API becomes more mature.  Here is the final class.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using Windows.Foundation.Collections;
 
namespace WinRTDatabase.Core
{
    /// <summary>
    /// Class that works for data bindings for WinRT list based controls
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ExtendedObservableCollection<T> : ObservableCollection<T>, IObservableVector<object>
    {
 
        /// <summary>
        /// Raises collection changed event
        /// </summary>
        /// <param name="e">Event arguments for collection changed event</param>
        protected override void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            base.OnCollectionChanged(e);
            switch (e.Action)
            {
                case System.Collections.Specialized.NotifyCollectionChangedAction.Add:
                    OnVectorChanged(CollectionChange.ItemInserted, (uint)e.NewStartingIndex);
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Move:
                    OnVectorChanged(CollectionChange.Reset, (uint)e.NewStartingIndex);
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Remove:
                    OnVectorChanged(CollectionChange.ItemRemoved, (uint)e.OldStartingIndex);
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Replace:
                    OnVectorChanged(CollectionChange.ItemChanged, (uint)e.NewStartingIndex);
                    break;
                case System.Collections.Specialized.NotifyCollectionChangedAction.Reset:
                    OnVectorChanged(CollectionChange.Reset, (uint)e.NewStartingIndex);
                    break;
                default:
                    break;
            }
        }
        protected void OnVectorChanged(CollectionChange collectionChange, uint index)
        {
            if (VectorChanged != null)
            {
                VectorChanged(this, new VectorChangedEventArgs(collectionChange, index));
            }
        }
 
        public event VectorChangedEventHandler<object> VectorChanged;
 
        public int IndexOf(object item)
        {
            return base.IndexOf((T)item);
        }
 
        public void Insert(int index, object item)
        {
            base.InsertItem(index, (T)item);
        }
 
        public new object this[int index]
        {
            get
            {
                return base[index];
            }
            set
            {
                base[index] = (T)value;
            }
        }
 
        public void Add(object item)
        {
            base.Add((T)item);
        }
 
        public bool Contains(object item)
        {
            return base.Contains((T)item);
        }
 
        public void CopyTo(object[] array, int arrayIndex)
        {
            T[] newArray = new T[array.Length];
            for (int i = 0; i < array.Length; i++)
            {
                newArray[i] = (T)array[i];
            }
            CopyTo(newArray, arrayIndex);
        }
 
        public bool IsReadOnly
        {
            get { return false; }
        }
 
        public bool Remove(object item)
        {
            if (Contains(item))
            {
                base.Remove((T)item);
                return true;
            }
            return false;
        }
 
        public new IEnumerator<object> GetEnumerator()
        {
            return base.GetEnumerator() as IEnumerator<object>;
        }
    }
}

Thanks.