Eclipsed4utoo's Blog» C#

WP7 – Using IsolatedStorageSettings

Ryan Alford — Sun, 14 Aug 2011 23:00:07 +0000

In a previous tutorial, I wrote about using the Isolated Storage to store files on a WP7 device. Let’s say that instead of storing data, you wanted to store settings for your application. This where the IsolatedStorageSettings comes in.

The IsolatedStorageSettings is a place to store Key/Value pairs of data.

So let’s say that my application used the Microsoft Ad control, but I wanted to be nice and give the user the ability to turn the ads on and off.

On my Settings screen, I would have a checkbox(AdsCheckbox) for allowing the ads. In code, I would save the value by doing this…

var settings = IsolatedStorageSettings.ApplicationSettings;

if (settings.Contains("AllowAds"))
    settings["AllowAds"] = AdsCheckbox.IsChecked.Value;
else
    settings.Add("AllowAds", AdsCheckbox.IsChecked.Value);

settings.Save();

If you will notice, the ApplicationSettings object does have a method that allows you to check to see if the key already exists in the Settings. An exception will be thrown if you try to add a key that already exists, so it’s necessary to do this check before assigning a value.

Also, as you can see, it’s very easy to get the value out of the settings…

// when the form opens, I want to set the Checkbox to being checked
//   or unchecked depending on the setting
var settings = IsolatedStorageSettings.ApplicationSettings;

if (settings.Contains("AllowAds"))
    AdsCheckbox.IsChecked = bool.Parse(settings["AllowAds"].ToString());

However, the IsolatedStorageSettings class isn’t only for simply datatypes. It can also store your custom class objects.

Employee class

public class Employee
{
    public string FullName { get; set; }
    public decimal Salary { get; set; }
}

Then on my form, I have a button to save an instance of the Employee class to the IsolatedStorageSettings…

private void btnSave_Click(object sender, RoutedEventArgs e)
{
    var settings = IsolatedStorageSettings.ApplicationSettings;

    Employee emp = new Employee()
    {
        FullName = "John Doe",
        Salary = 250000
    };

    settings.Add("Employee1", emp);
    settings.Save();
}

I also have a button that will load the object from the IsolatedStorageSettings…

private void btnLoad_Click(object sender, RoutedEventArgs e)
{
    var settings = IsolatedStorageSettings.ApplicationSettings;

    Employee emp;

    if (settings.TryGetValue("Employee1", out emp))
    {
         MessageBox.Show(string.Format("Full Name: {0}\nSalary: {1:c}", emp.FullName, emp.Salary));
    }
}

Notice that the IsolatedStorageSettings.ApplicationSettings class also has the TryGetValue method. This method behaves exactly like the TryParse methods of the .Net datatypes. It will return a boolean specifying whether the key was found and whether the conversion from object –> Employee was successful. If it’s successful, it will return the instance as the out parameter.

After running the application, clicking the Save button, then clicking the Load button, we will get this message box…

WP7 – Working With Isolated Storage

Ryan Alford — Thu, 11 Aug 2011 23:00:28 +0000

In this tutorial, I will demonstrate how to work with Isolated Storage in Windows Phone 7. This is going to be a very simple tutorial where we create a text file and write data to it. We will then read that data and append more data to it.

So first, we need to add these using statements to the top of the code(if they aren’t already there):

using System.IO;
using System.IO.IsolatedStorage;
using System.Windows;

Next we will have our form. Very basic. It has two Textboxes and a Button. The first TextBox will allow the user to type in some text. The Button will save the data to IsolatedStorage, then read the data from the file and put it into the second TextBox.

Here is the XAML:

So now we move to the code. We need to create an IsolatedStorageFile object:

using (var isoStorage = IsolatedStorageFile.GetUserStoreForApplication())
{

}

Since we will always be appending to the file, we need to check to make sure the file exists. If it doesn’t exist, we need to create it.

// we need to check to see if the file exists
if (!isoStorage.FileExists(fileName))
{
    // file doesn't exist...time to create it.
    isoStorage.CreateFile(fileName);
}

Once we have done the FileExists check, we can now open the file. Once the file has been opened, we can now use the StreamWriter class to write to it.

// since we are appending to the file, we must use FileMode.Append
using (var isoStream = new IsolatedStorageFileStream(fileName, FileMode.Append, isoStorage))
{
    // opens the file and writes to it.
    using (var fileStream = new StreamWriter(isoStream))
    {
        fileStream.WriteLine(txtText.Text);
    }
}

Note: notice that we opened the file using FileMode.Append. Because we used this mode, we can’t read from the file, we can only write to it.

So to read from the file, we will need to open the file again, this time using FileMode.Open. We are going to do this in another using block. Once the file is opened, we use the StreamReader class to read it.

// you cannot read from a stream that you opened in FileMode.Append.  Therefore, we need
//   to close the IsolatedStorageFileStream then open it again in a different FileMode.  Since we
//   we are simply reading the file, we use FileMode.Open
using (var isoStream = new IsolatedStorageFileStream(fileName, FileMode.Open, isoStorage))
{
    // opens the file and reads it.
    using (var fileStream = new StreamReader(isoStream))
    {
        txtCurrentText.Text = fileStream.ReadToEnd();
    }
}

And that’s it. If you run the application, type in the first textbox, hit Save, the data will show up in the bottom textbox. Do it again, and you will see that it has appended to the file.

As you can see, writing to Isolated Storage is really easy.

Here is the entire code for the form…

using System.IO;
using System.IO.IsolatedStorage;
using System.Windows;
using Microsoft.Phone.Controls;

namespace WP7IsoStorageDemo
{
    public partial class MainPage : PhoneApplicationPage
    {
        // Constructor
        public MainPage()
        {
            InitializeComponent();
        }

        private void btnSave_Click(object sender, RoutedEventArgs e)
        {
            string fileName = "MyTextfile.txt";

            using (var isoStorage = IsolatedStorageFile.GetUserStoreForApplication())
            {
                // we need to check to see if the file exists
                if (!isoStorage.FileExists(fileName))
                {
                    // file doesn't exist...time to create it.
                    isoStorage.CreateFile(fileName);
                }

                // since we are appending to the file, we must use FileMode.Append
                using (var isoStream = new IsolatedStorageFileStream(fileName, FileMode.Append, isoStorage))
                {
                    // opens the file and writes to it.
                    using (var fileStream = new StreamWriter(isoStream))
                    {
                        fileStream.WriteLine(txtText.Text);
                    }
                }

                // you cannot read from a stream that you opened in FileMode.Append.  Therefore, we need
                //   to close the IsolatedStorageFileStream then open it again in a different FileMode.  Since we
                //   we are simply reading the file, we use FileMode.Open
                using (var isoStream = new IsolatedStorageFileStream(fileName, FileMode.Open, isoStorage))
                {
                    // opens the file and reads it.
                    using (var fileStream = new StreamReader(isoStream))
                    {
                        txtCurrentText.Text = fileStream.ReadToEnd();
                    }
                }
            }
        }
    }
}

C# – Get Windows Mobile Theme Color

Ryan Alford — Thu, 04 Aug 2011 23:00:01 +0000

I recently had a business requirement to color the background of a TextBox in Windows Mobile to a specific color. After completing the tasks, I noticed that the color that was chosen(blue) didn’t look right on devices that used a different theme like red or green. So I decided to figure out how to set the background color to match the theme color.

The theme system colors are located in the registry entry HKLM\System\GWE\SysColor. This registry entry is a BLOB that contains 29 DWORD values that correspond to the different colors of the theme.

For my application, I decided to use the color of the title bar of active windows. This color is normally the dominate color of the theme. This color is the third DWORD value in the registry entry.

Each DWORD value in the registry entry is a 4 byte HEX value that corresponds to a specific color. The first byte is the RED value, second value is the GREEN value, third value is the BLUE value, and the fourth value is always 0.

For this code, I used the OpenNetCF framework to get the registry values.

/// 
/// Gets the theme color
/// 
///  Returns a Color or null
public Color? GetThemeColor()
{
    try
    {
         // gets the registry key
         RegistryKey keyColor = Registry.LocalMachine.OpenSubKey(@"System\GWE");

         // keyColor will be null if registry key was not found
         if (keyColor == null)
             return null;

        byte[] data = (byte[])keyColor.GetValue("SysColor");

        if (data[8] != 0 && data[9] != 0 && data[10] != 0)
        {
             // the third set of values is for the color of the
             //    title bar of an active window.
             int red = Convert.ToInt32(data[8]);
             int green = Convert.ToInt32(data[9]);
             int blue = Convert.ToInt32(data[10]);

             return Color.FromArgb(red, green, blue);
        }

        return null;
    }
    catch
    {
         return null;
    }
}

Usage is pretty simple for the method…

Color? themeColor = GetThemeColor();

if(themeColor != null)
   txtComments.BackColor = themeColor;

C# – XML Element Value Generic Extention Method

Ryan Alford — Mon, 01 Aug 2011 19:00:52 +0000

Recently, I was working on integrating a help desk API into one of our applications. The API would return XML and I was using LINQ-To-XML to get the values of the elements. However, a number of the elements in the API were allowed to be null, like a field for the completed date of a help desk ticket. So, I started out writing my code like this…

// constructor for Ticket class
public Ticket(XElement element)
{
     AssignedDate = (!string.IsNullOrEmpty(element.Element("assigned-date").Value)) ? DateTime.Parse(element.Element("assigned-date").Value) : (DateTime?)null;

     // .... on and one for about 40 elements
}

I looked back and thought I should come up with a better way of getting the data from the Element and into the datatype that I needed. So I came up with this generic extension method…

/// 
/// Gets the value of the element.  Will convert the value to specified type if
///    possible.  If not possible, will return default value for type.
/// 
/// Type that should be returned
/// 
/// 
public static T GetElementValue(this XElement ele)
{
    // if the element is null, then return the default
    if (ele == null)
        return default(T);

    // if value is blank or null, just return the default value
    //   for the type.
    if (string.IsNullOrEmpty(ele.Value))
        return default(T);

    // since the type of the Value property is a string, no need
    //   to do anything fancy.  Just return the value.
    if (typeof(T) == typeof(string))
        return (T)Convert.ChangeType(ele.Value, typeof(T));

    // creates new object of type T to store converted value
    T newObject = default(T);

    // check to see if it's a nullable type.  If so, get the underlying
    //   type.
    // Nullable types don't have a Parse method.  Therefore, we need the
    //   underlying type so we can call the Parse method through reflection
    //   to convert the value.
    PropertyInfo[] properties = typeof(T).GetProperties();
    Type underlyingType = typeof(T);

    // Nullable types will have two properties.  The first is the HasValue
    //   property.  The second is the underlying type.  However, some other
    //   types(such as String), and custom classes/structs could also have
    //   only two properties.  So we check to make sure that there are only
    //   2 properties, then we make sure the first property is the HasValue
    //   property.  Theoretically, this could still give a false positive.
    if (properties.Count() == 2 &&
        string.Equals(properties[0].Name, "HasValue", StringComparison.InvariantCultureIgnoreCase))
        underlyingType = properties[1].PropertyType;

    try
    {
        // calls Parse method for the type
        MethodInfo method = underlyingType.GetMethod("Parse", new[] { typeof(string) });
        newObject = (T)method.Invoke(null, new[] { ele.Value });
    }
    catch (Exception)
    {
        throw;
    }

    return newObject;
}

Now with this extension method, it really cuts down on the amount of code I have to write. I can now use it like this..

public Ticket(XElement element)
{
     AssignedDate = element.Element("assigned-date").GetElementValue();
}

I hope this can help out somebody.

C# – Generic Serialization Methods

Ryan Alford — Fri, 29 Jul 2011 14:19:51 +0000

Short blog post today. These are a couple of generic serialize and deserialize methods that can be easily used when needing to serialize and deserialize classes. The methods work with any .Net type. That includes built-in .Net types and custom classes that you might create yourself.

These methods will only serialize PUBLIC properties of a class. Also, the XML will be human-readable instead of one long line of text.

Serialize Method

/// 
 /// Serializes the data in the object to the designated file path
 /// 
 /// Type of Object to serialize
 /// Object to serialize
 /// FilePath for the XML file
 public static void Serialize(T dataToSerialize, string filePath)
 {
      try
      {
           using (Stream stream = File.Open(filePath, FileMode.Create, FileAccess.ReadWrite))
           {
                 XmlSerializer serializer = new XmlSerializer(typeof(T));
                 XmlTextWriter writer = new XmlTextWriter(stream, Encoding.Default);
                 writer.Formatting = Formatting.Indented;
                 serializer.Serialize(writer, dataToSerialize);
                 writer.Close();
           }
      }
      catch
      {
           throw;
      }
 }

Deserialize Method

/// 
 /// Deserializes the data in the XML file into an object
 /// 
 /// Type of object to deserialize
 /// FilePath to XML file
 /// Object containing deserialized data
 public static T Deserialize(string filePath)
 {
      try
      {
            XmlSerializer serializer = new XmlSerializer(typeof(T));
            T serializedData;

            using (Stream stream = File.Open(filePath, FileMode.Open, FileAccess.Read))
            {
                 serializedData = (T)serializer.Deserialize(stream);
            }

            return serializedData;
      }
      catch
      {
            throw;
      }
 }

Here is some sample code to show the methods in action.

Person p = new Person() { Name = "John Doe", Age = 42 };
XmlHelper.Serialize(p, @"D:\text.xml");

Person p2 = new Person();
p2 = XmlHelper.Deserialize(@"D:\text.xml");

Console.WriteLine("Name: {0}", p2.Name);
Console.WriteLine("Age: {0}", p2.Age);

Console.Read();

Silverlight 4 – Copy/Paste From Clipboard

Ryan Alford — Thu, 04 Nov 2010 23:00:20 +0000

In this tutorial, I will show how you can use Silverlight 4 to get access to the client clipboard. Silverlight 3 had limited clipboard access, but Microsoft implemented more complete access to the clipboard.

For security purposes, access to the clipboard is only allowed through a user-initialed event. For example, you couldn’t have a timer running in the background to constantly get text from the clipboard.

For first, let’s create a Silverlight 4 application and name it SL4ClipboardAccess. Then Click OK on the next popup.

I added some controls to the page..

Which look like this…

Now, the Click Event for the CopyToClipboard Button would look like this…

private void CopyToClipboardButton_Click(object sender, RoutedEventArgs e)
{
    string textToCopy = CopyTextTextBox.Text;

    try
    {
         Clipboard.SetText(textToCopy);
    }
    catch (SecurityException se)
    {
        MessageBox.Show(se.Message);
    }
}

and the Click Event for the PasteToTextBox Button would be this..

private void PasteToTextBoxButton_Click(object sender, RoutedEventArgs e)
{
    string textFromClipboard = string.Empty;

    try
    {
         textFromClipboard = Clipboard.GetText();
    }
    catch (SecurityException se)
    {
         MessageBox.Show(se.Message);
    }

    PasteTextTextBox.Text = textFromClipboard;
}

Now run the application and type into the Text To Copy textbox. When you click the Copy To Clipboard button, you will be prompted for permission for access to the clipboard.

After allowing access, click the Paste To TextBox button, and the text will now be in the other textbox.

Very simple tutorial for a very powerful feature.

WP7 – Context Menu From Listbox

Ryan Alford — Thu, 26 Aug 2010 11:58:40 +0000

In writing one of my Windows Phone 7 applications, I needed to do a allow the user to delete an entry from a ListBox. Since my ListBox didn’t have enough room for an actual delete button, I decided I would use a ContextMenu to do it. To my surprise, even though the OS seems to support a long press action(the way to uninstall an application), that action doesn’t seem to be available to developers(or not that I could find). So I decided to roll my own using the [b]MouseLeftButtonDown [/b]and [b]MouseLeftButtonUp [/b]events, and a [b]DispatcherTimer[/b]. Add these two using statements to the top of the code…

 using System.Collections.ObjectModel; using System.Windows.Threading;

So first, we need our initial code to get the [b]ListBox [/b]populated. I created a [b]Person [/b]class just for simplistic reasons.

 public class Person {     public string FirstName { get; set; }     public string LastName { get; set; } }

Next, I will set up the [b]ListBox [/b]to simply show the [b]FirstName [/b]of the [b]Person[/b].

Now I will create an generic [b]ObservableCollection [/b]object to store the [b]Person [/b]objects. This will be a class level variable since it will be accessed from multiple events.

 public partial class MainPage : PhoneApplicationPage {     ObservableCollection personList = new ObservableCollection();      // Constructor     public MainPage()     {         InitializeComponent();          this.Loaded += new RoutedEventHandler(MainPage_Loaded);     }      void MainPage_Loaded(object sender, RoutedEventArgs e)     {         personList.Add(new Person() { FirstName = "John", LastName = "Doe" });         personList.Add(new Person() { FirstName = "Jane", LastName = "Doe" });         personList.Add(new Person() { FirstName = "John", LastName = "Adams" });          lbNames.ItemsSource = personList;     } }

Now I need to create the event handlers for the [b]MouseLeftButtonDown [/b]and [b]MouseLeftButtonUp [/b]events. This can simply be done by using the [b]Events [/b]list from the [b]Properties [/b]window in the designer.

 private void lbNames_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e) {  }  private void lbNames_MouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e) {  }

We now need to create two class level objects: a [b]DispatcherTimer [/b]object, and a [b]Person [/b]object. These are class level because they will need to be accessed from different events. We will also subscribe to the Tick event for the timer.

 ObservableCollection personList = new ObservableCollection();  DispatcherTimer timer;  Person selectedPerson = null;  // Constructor public MainPage() {     InitializeComponent();      this.Loaded += new RoutedEventHandler(MainPage_Loaded);      timer = new DispatcherTimer();     timer.Tick += delegate(object s, EventArgs e)     {      }; }

Next, we will add a [b]Popup [/b]in XAML. This can go above or below the [b]ListBox[/b] that is currently holding the names.

And the event handler for selecting the Delete item…

 private void DeleteContextMenu_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e) {  }

Here is how it’s going to work. When the user presses down, we will start the timer. When the user releases, then we stop the timer. So if the timer’s interval is reached, we know that the user was holding down on the screen, so we will display the popup. So now we move to our code. First we are going to handle the [b]MouseLeftButtonDown [/b]event.

 private void lbNames_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e) {     // if there is no person selected, then there is no person to delete     //   no need to do any code if nothing is selected     if (selectedPerson == null)         return;      // gets the position of the mouse cursor to set the Margin     //    of the Popup to show at the mouse coordinates.  You     //    may need to tweak these values to get it to display in     //    the correct location.     Point position = e.GetPosition((UIElement)this);     DeleteContextMenu.Margin = new Thickness(position.X, position.Y - 200, 20, 0);      // sets the interval to 1.1 seconds.  This means the user will need      //    to hold down on the screen for 1.1 seconds before we determine     //    to show the ContextMenu.     timer.Interval = TimeSpan.FromMilliseconds(1100);     timer.Start(); }

Next, we will do our code for the [b]MouseLeftButtonUp[/b] event

 private void lbNames_MouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e) {     // stop the timer when the user releases the screen     timer.Stop();      // sets the class level variable to the selected row     selectedPerson = lbNames.SelectedItem as Person; }

Now for our code in the [b]Tick [/b]event for the [b]Timer[/b].

 // Constructor public MainPage() {     InitializeComponent();      this.Loaded += new RoutedEventHandler(MainPage_Loaded);      timer = new DispatcherTimer();     timer.Tick += delegate(object s, EventArgs e)     {         // stop the timer so that it doesn't popup the Context menu again         timer.Stop();          // since we are using the same ListBox over and over, this will         //   make it so when the Context Menu is shown, there will be no         //   selected item from any previous showing of the Context Menu         lbDeleteContextMenu.SelectedIndex = -1;          // opens the Context Menu         DeleteContextMenu.IsOpen = true;     }; }

Last, we have our code from the [b]SelectionChanged [/b]event for the [b]ListBox [/b]that is part of the Context Menu.

 private void DeleteContextMenu_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e) {     // in the Timer's Tick event, we set the SelectedIndex of the     //   Context Menu's Listbox back to -1.  However, this does     //   fire the SelectionChanged event.  This code will handle that.     if (lbDeleteContextMenu.SelectedIndex == -1)         return;      // closes the Context Menu     DeleteContextMenu.IsOpen = false;      if (selectedPerson == null)         return;      // removes the selected person from the list     personList.Remove(selectedPerson);      // since we are using an ObservableCollection, we do not have     //   to rebind the list to the ListBox.      selectedPerson = null; }

Now you can run the application, and you will see the list show up. You must click on an item first before clicking and holding to show the Context Menu.

So I decided to roll my own using the [b]MouseLeftButtonDown [/b]and [b]MouseLeftButtonUp [/b]events, and a [b]DispatcherTimer[/b].

Add these two using statements to the top of the code…

using System.Collections.ObjectModel;

using System.Windows.Threading;

So first, we need our initial code to get the [b]ListBox [/b]populated. I created a [b]Person [/b]class just for simplistic reasons.

public class Person

{

public string FirstName { get; set; }

public string LastName { get; set; }

}

Next, I will set up the [b]ListBox [/b]to simply show the [b]FirstName [/b]of the [b]Person[/b].

Name="lbNames"

Height="240"

HorizontalAlignment="Left"

Margin="10,119,0,0"

VerticalAlignment="Top"

Width="460"

ItemsSource="{Binding}">

Now I will create an generic [b]ObservableCollection [/b]object to store the [b]Person [/b]objects. This will be a class level variable since it will be accessed from multiple events.

public partial class MainPage : PhoneApplicationPage

{

ObservableCollection personList = new ObservableCollection();

// Constructor

public MainPage()

{

InitializeComponent();

this.Loaded += new RoutedEventHandler(MainPage_Loaded);

}

void MainPage_Loaded(object sender, RoutedEventArgs e)

{

personList.Add(new Person() { FirstName = "John", LastName = "Doe" });

personList.Add(new Person() { FirstName = "Jane", LastName = "Doe" });

personList.Add(new Person() { FirstName = "John", LastName = "Adams" });

lbNames.ItemsSource = personList;

}

private void lbNames_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)

{

}

private void lbNames_MouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e)

{

}

ObservableCollection personList = new ObservableCollection();

DispatcherTimer timer;

Person selectedPerson = null;

// Constructor

public MainPage()

{

InitializeComponent();

this.Loaded += new RoutedEventHandler(MainPage_Loaded);

timer = new DispatcherTimer();

timer.Tick += delegate(object s, EventArgs e)

{

};

}

Next, we will add a [b]Popup [/b]in XAML. This can go above or below the [b]ListBox[/b] that is currently holding the names.

x:Name="DeleteContextMenu"

Height="200"

Width="400">

x:Name="lbDeleteContextMenu"

Background="White"

SelectionChanged="DeleteContextMenu_SelectionChanged">

Content="Delete Person"

Foreground="Red"

FontSize="25"

FontWeight="Bold"/>

And the event handler for selecting the Delete item…

private void DeleteContextMenu_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)

{

}

So now we move to our code. First we are going to handle the [b]MouseLeftButtonDown [/b]event.

private void lbNames_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)

{

// if there is no person selected, then there is no person to delete

// no need to do any code if nothing is selected

if (selectedPerson == null)

return;

// gets the position of the mouse cursor to set the Margin

// of the Popup to show at the mouse coordinates. You

// may need to tweak these values to get it to display in

// the correct location.

Point position = e.GetPosition((UIElement)this);

DeleteContextMenu.Margin = new Thickness(position.X, position.Y - 200, 20, 0);

// sets the interval to 1.1 seconds. This means the user will need

// to hold down on the screen for 1.1 seconds before we determine

// to show the ContextMenu.

timer.Interval = TimeSpan.FromMilliseconds(1100);

timer.Start();

}

Next, we will do our code for the [b]MouseLeftButtonUp[/b] event

private void lbNames_MouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e)

{

// stop the timer when the user releases the screen

timer.Stop();

// sets the class level variable to the selected row

selectedPerson = lbNames.SelectedItem as Person;

}

Now for our code in the [b]Tick [/b]event for the [b]Timer[/b].

// Constructor

public MainPage()

{

InitializeComponent();

this.Loaded += new RoutedEventHandler(MainPage_Loaded);

timer = new DispatcherTimer();

timer.Tick += delegate(object s, EventArgs e)

{

// stop the timer so that it doesn't popup the Context menu again

timer.Stop();

// since we are using the same ListBox over and over, this will

// make it so when the Context Menu is shown, there will be no

// selected item from any previous showing of the Context Menu

lbDeleteContextMenu.SelectedIndex = -1;

// opens the Context Menu

DeleteContextMenu.IsOpen = true;

};

}

Last, we have our code from the [b]SelectionChanged [/b]event for the [b]ListBox [/b]that is part of the Context Menu.

private void DeleteContextMenu_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)

{

// in the Timer's Tick event, we set the SelectedIndex of the

// Context Menu's Listbox back to -1. However, this does

// fire the SelectionChanged event. This code will handle that.

if (lbDeleteContextMenu.SelectedIndex == -1)

return;

// closes the Context Menu

DeleteContextMenu.IsOpen = false;

if (selectedPerson == null)

return;

// removes the selected person from the list

personList.Remove(selectedPerson);

// since we are using an ObservableCollection, we do not have

// to rebind the list to the ListBox.

selectedPerson = null;

}

Now you can run the application, and you will see the list show up. You must click on an item first before clicking and holding to show the Context Menu.

So I decided to roll my own using the [b]MouseLeftButtonDown [/b]and [b]MouseLeftButtonUp [/b]events, and a [b]DispatcherTimer[/b].

Add these two using statements to the top of the code…

using System.Collections.ObjectModel;

using System.Windows.Threading;

So first, we need our initial code to get the [b]ListBox [/b]populated. I created a [b]Person [/b]class just for simplistic reasons.

public class Person

{

public string FirstName { get; set; }

public string LastName { get; set; }

}

Next, I will set up the [b]ListBox [/b]to simply show the [b]FirstName [/b]of the [b]Person[/b].

Name="lbNames"

Height="240"

HorizontalAlignment="Left"

Margin="10,119,0,0"

VerticalAlignment="Top"

Width="460"

ItemsSource="{Binding}">

Now I will create an generic [b]ObservableCollection [/b]object to store the [b]Person [/b]objects. This will be a class level variable since it will be accessed from multiple events.

public partial class MainPage : PhoneApplicationPage

{

ObservableCollection personList = new ObservableCollection();

// Constructor

public MainPage()

{

InitializeComponent();

this.Loaded += new RoutedEventHandler(MainPage_Loaded);

}

void MainPage_Loaded(object sender, RoutedEventArgs e)

{

personList.Add(new Person() { FirstName = "John", LastName = "Doe" });

personList.Add(new Person() { FirstName = "Jane", LastName = "Doe" });

personList.Add(new Person() { FirstName = "John", LastName = "Adams" });

lbNames.ItemsSource = personList;

}

private void lbNames_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)

{

}

private void lbNames_MouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e)

{

}

ObservableCollection personList = new ObservableCollection();

DispatcherTimer timer;

Person selectedPerson = null;

// Constructor

public MainPage()

{

InitializeComponent();

this.Loaded += new RoutedEventHandler(MainPage_Loaded);

timer = new DispatcherTimer();

timer.Tick += delegate(object s, EventArgs e)

{

};

}

Next, we will add a [b]Popup [/b]in XAML. This can go above or below the [b]ListBox[/b] that is currently holding the names.

x:Name="DeleteContextMenu"

Height="200"

Width="400">

x:Name="lbDeleteContextMenu"

Background="White"

SelectionChanged="DeleteContextMenu_SelectionChanged">

Content="Delete Person"

Foreground="Red"

FontSize="25"

FontWeight="Bold"/>

And the event handler for selecting the Delete item…

private void DeleteContextMenu_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)

{

}

So now we move to our code. First we are going to handle the [b]MouseLeftButtonDown [/b]event.

private void lbNames_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)

{

// if there is no person selected, then there is no person to delete

// no need to do any code if nothing is selected

if (selectedPerson == null)

return;

// gets the position of the mouse cursor to set the Margin

// of the Popup to show at the mouse coordinates. You

// may need to tweak these values to get it to display in

// the correct location.

Point position = e.GetPosition((UIElement)this);

DeleteContextMenu.Margin = new Thickness(position.X, position.Y - 200, 20, 0);

// sets the interval to 1.1 seconds. This means the user will need

// to hold down on the screen for 1.1 seconds before we determine

// to show the ContextMenu.

timer.Interval = TimeSpan.FromMilliseconds(1100);

timer.Start();

}

Next, we will do our code for the [b]MouseLeftButtonUp[/b] event

private void lbNames_MouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e)

{

// stop the timer when the user releases the screen

timer.Stop();

// sets the class level variable to the selected row

selectedPerson = lbNames.SelectedItem as Person;

}

Now for our code in the [b]Tick [/b]event for the [b]Timer[/b].

// Constructor

public MainPage()

{

InitializeComponent();

this.Loaded += new RoutedEventHandler(MainPage_Loaded);

timer = new DispatcherTimer();

timer.Tick += delegate(object s, EventArgs e)

{

// stop the timer so that it doesn't popup the Context menu again

timer.Stop();

// since we are using the same ListBox over and over, this will

// make it so when the Context Menu is shown, there will be no

// selected item from any previous showing of the Context Menu

lbDeleteContextMenu.SelectedIndex = -1;

// opens the Context Menu

DeleteContextMenu.IsOpen = true;

};

}

Last, we have our code from the [b]SelectionChanged [/b]event for the [b]ListBox [/b]that is part of the Context Menu.

private void DeleteContextMenu_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)

{

// in the Timer's Tick event, we set the SelectedIndex of the

// Context Menu's Listbox back to -1. However, this does

// fire the SelectionChanged event. This code will handle that.

if (lbDeleteContextMenu.SelectedIndex == -1)

return;

// closes the Context Menu

DeleteContextMenu.IsOpen = false;

if (selectedPerson == null)

return;

// removes the selected person from the list

personList.Remove(selectedPerson);

// since we are using an ObservableCollection, we do not have

// to rebind the list to the ListBox.

selectedPerson = null;

}

Now you can run the application, and you will see the list show up. You must click on an item first before clicking and holding to show the Context Menu.

To my surprise, even though the OS seems to support a long press action(the way to uninstall an application), that action doesn’t seem to be available to developers(or not that I could find).

So I decided to roll my own using the MouseLeftButtonDown and MouseLeftButtonUp events, and a DispatcherTimer.

Add these two using statements to the top of the code…

using System.Collections.ObjectModel;
using System.Windows.Threading;

So first, we need our initial code to get the ListBox populated. I created a Person class just for simplistic reasons.

public class Person
{
     public string FirstName { get; set; }
     public string LastName { get; set; }
}

Next, I will set up the ListBox to simply show the FirstName of the Person.

Now I will create an generic ObservableCollection object to store the Person objects. This will be a class level variable since it will be accessed from multiple events.

public partial class MainPage : PhoneApplicationPage
{
    ObservableCollection personList = new ObservableCollection();

    // Constructor
    public MainPage()
    {
        InitializeComponent();

        this.Loaded += new RoutedEventHandler(MainPage_Loaded);
    }

    void MainPage_Loaded(object sender, RoutedEventArgs e)
    {
        personList.Add(new Person() { FirstName = "John", LastName = "Doe" });
        personList.Add(new Person() { FirstName = "Jane", LastName = "Doe" });
        personList.Add(new Person() { FirstName = "John", LastName = "Adams" });

        lbNames.ItemsSource = personList;
    }
}

Now I need to create the event handlers for the MouseLeftButtonDown and MouseLeftButtonUp events. This can simply be done by using the Events list from the Properties window in the designer.

private void lbNames_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
{

}

private void lbNames_MouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
{

}

We now need to create two class level objects: a DispatcherTimer object, and a Person object. These are class level because they will need to be accessed from different events. We will also subscribe to the Tick event for the timer.

ObservableCollection personList = new ObservableCollection();

DispatcherTimer timer;

Person selectedPerson = null;

// Constructor
public MainPage()
{
    InitializeComponent();

    this.Loaded += new RoutedEventHandler(MainPage_Loaded);

    timer = new DispatcherTimer();
    timer.Tick += delegate(object s, EventArgs e)
    {

    };
}

Next, we will add a Popup in XAML. This can go above or below the ListBox that is currently holding the names.

And the event handler for selecting the Delete item…

private void DeleteContextMenu_Selectionchanged(object sender, System.Windows.Controls.SelectionchangedEventArgs e)
{

}

So now we move to our code. First we are going to handle the MouseLeftButtonDown event.

private void lbNames_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
    // if there is no person selected, then there is no person to delete
    //   no need to do any code if nothing is selected
    if (selectedPerson == null)
        return;

    // gets the position of the mouse cursor to set the Margin
    //    of the Popup to show at the mouse coordinates.  You
    //    may need to tweak these values to get it to display in
    //    the correct location.
    Point position = e.GetPosition((UIElement)this);
    DeleteContextMenu.Margin = new Thickness(position.X, position.Y - 200, 20, 0);

    // sets the interval to 1.1 seconds.  This means the user will need
    //    to hold down on the screen for 1.1 seconds before we determine
    //    to show the ContextMenu.
    timer.Interval = TimeSpan.FromMilliseconds(1100);
    timer.Start();
}

Next, we will do our code for the MouseLeftButtonUp event

private void lbNames_MouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
    // stop the timer when the user releases the screen
    timer.Stop();

    // sets the class level variable to the selected row
    selectedPerson = lbNames.SelectedItem as Person;
}

Now for our code in the Tick event for the Timer.

// Constructor
public MainPage()
{
    InitializeComponent();

    this.Loaded += new RoutedEventHandler(MainPage_Loaded);

    timer = new DispatcherTimer();
    timer.Tick += delegate(object s, EventArgs e)
    {
        // stop the timer so that it doesn't popup the Context menu again
        timer.Stop();

        // since we are using the same ListBox over and over, this will
        //   make it so when the Context Menu is shown, there will be no
        //   selected item from any previous showing of the Context Menu
        lbDeleteContextMenu.SelectedIndex = -1;

        // opens the Context Menu
        DeleteContextMenu.IsOpen = true;
    };
}

Last, we have our code from the SelectionChanged event for the ListBox that is part of the Context Menu.

private void DeleteContextMenu_Selectionchanged(object sender, System.Windows.Controls.SelectionchangedEventArgs e)
{
    // in the Timer's Tick event, we set the SelectedIndex of the
    //   Context Menu's Listbox back to -1.  However, this does
    //   fire the Selectionchanged event.  This code will handle that.
    if (lbDeleteContextMenu.SelectedIndex == -1)
        return;

    // closes the Context Menu
    DeleteContextMenu.IsOpen = false;

    if (selectedPerson == null)
        return;

    // removes the selected person from the list
    personList.Remove(selectedPerson);

    // since we are using an ObservableCollection, we do not have
    //   to rebind the list to the ListBox.

    selectedPerson = null;
}

Now you can run the application, and you will see the list show up. You must click on an item first before clicking and holding to show the Context Menu.

WPF – Dynamically Loading LINQ-To-SQL Tables and Columns Into ComboBox

Ryan Alford — Tue, 25 May 2010 22:00:21 +0000

Here is some code to dynamically load the table names into a ComboBox. Then on the selection of a specific table, load the columns for that table into a second ComboBox.

First is the XAML:

 x:Class="WpfApplication4.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    
         
            Name="cboTables" 
            Height="23" 
            HorizontalAlignment="Left" 
            Margin="186,60,0,0" 
            VerticalAlignment="Top" 
            Width="120"
            ItemsSource="{Binding}"
            Selectionchanged="cboTables_Selectionchanged"
            DisplayMemberPath="RowType.Name" 
            SelectedValuePath="RowType.DataMembers" />
        
         
            Height="23" 
            HorizontalAlignment="Left" 
            Margin="186,107,0,0" 
            Name="cboColumns" 
            VerticalAlignment="Top" 
            Width="120"
            ItemsSource="{Binding}"
            DisplayMemberPath="MappedName"/>
         
            Name="label1"
            Content="Tables:" 
            Height="28" 
            HorizontalAlignment="Left" 
            Margin="134,60,0,0"  
            VerticalAlignment="Top" />

         
            Name="label2" 
            Content="Columns:" 
            Height="28" 
            HorizontalAlignment="Left" 
            Margin="121,107,0,0" 
            VerticalAlignment="Top" />

Notice that we have set the ItemsSource attribute to {Binding}. This lets the control know that we are binding data to the control(big surprise). Notice that I have also set theDisplayMemberPath and SelectedValuePath in the Tables ComboBox and theDisplayMemberPath in the Columns ComboBox.

Next is the code:

using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Controls;

namespace WpfApplication4
{
    /// 
    /// Interaction logic for Mainwindow.xaml
    /// 
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Loaded += new RoutedEventHandler(MainWindow_Loaded);
        }

        void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            // creates a new instance of our DataContext
            using (InformationDataContext db = new InformationDataContext())
            {
                // gets the list of tables
                var tableList = db.Mapping.GetTables();
                cboTables.ItemsSource = tableList;
            }
        }

        private void cboTables_Selectionchanged(object sender, SelectionchangedEventArgs e)
        {
            cboColumns.ItemsSource = cboTables.SelectedValue as ReadOnlyCollection<System.Data.Linq.Mapping.MetaDataMember>;
        }
    }
}

We use the GetTables method of the DataContext class to get the list of tables. The objects themselves are of type System.Data.Linq.Mapping.AttributedMetaTable. Two properties of this class are RowType.Name and RowType.DataMembers. The RowType.Name is the name of the table without the “dbo” in front. The RowType.DataMembers is a list of the columns of that table.

The RowType.DataMembers objects are of type System.Data.Linq.Mapping.MetaDataMember. One property of this class is the MappedName property that we are using as the DisplayMemberPath. This gives us the name of the column without any extra data.

WPF – Create Animation Programmatically

Ryan Alford — Thu, 20 May 2010 22:00:48 +0000

This is a short code snippet on creating an animation in WPF through code.

In my Twitter app that I have been working on, I was recently doing some optimizations. When I first did the app, I was new to WPF and knew nothing about animations. After spending time in Silverlight, I used that knowledge to do some animations in WPF.

I wanted to do simple “fade-in” and “fade-out” animations when removing tweets from view and adding new tweets to the view. And being the person that I am, I like doing this stuff in code. While I like XAML a lot, I still like writing the code. So here is how to do an animation that changes the Opacity property programmatically.

// because I am doing these as extension methods, they
//   will be available to all UIElement objects, which are
//   basically all controls that can be added to the GUI
public static class ControlAnimationExtensionMethods
{
    public static void FadeIn(this UIElement targetControl)
    {
        DoubleAnimation fadeInAnimation = new DoubleAnimation(0, 1, new Duration(TimeSpan.FromSeconds(1.5)));
        Storyboard.SetTarget(fadeInAnimation, targetControl);
        Storyboard.SetTargetProperty(fadeInAnimation, new PropertyPath(UIElement.OpacityProperty));
        Storyboard sb = new Storyboard();
        sb.Children.Add(fadeInAnimation);
        sb.Begin();
    }

    public static void FadeOut(this UIElement targetControl)
    {
        DoubleAnimation fadeInAnimation = new DoubleAnimation(1, 0, new Duration(TimeSpan.FromSeconds(1.5)));
        Storyboard.SetTarget(fadeInAnimation, targetControl);
        Storyboard.SetTargetProperty(fadeInAnimation, new PropertyPath(UIElement.OpacityProperty));
        Storyboard sb = new Storyboard();
        sb.Children.Add(fadeInAnimation);
        sb.Begin();
    }
}

This code is useful when dynamically creating controls that you want to do animations on.

TextBlock tb = new TextBlock();
tb.Name = "textBlock1";
// set more property values

tb.FadeIn();

Silverlight 4 – Connecting To Remote Database With WCF

Ryan Alford — Fri, 14 May 2010 22:00:36 +0000

This tutorial will show how to connect to a database that is located on the deploy server from a Silverlight application.

I will be using Visual Studio 2010 and Silverlight 4.

So first, we will create a Silverlight 4 application.

Next, we are just going to put a DataGrid on our MainPage.xaml.


 x:Class="SilverlightWCFTutorial.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/exp ression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400" xmlns:sdk="http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk">

     x:Name="LayoutRoot" Background="White">
         
            Name="dataGridPerson" 
            AutoGenerateColumns="True" 
            Height="206" 
            HorizontalAlignment="Left" 
            Margin="12,44,0,0"  
            VerticalAlignment="Top" 
            Width="376"
            ItemsSource="{Binding}">

So for the Grid, we are simply going to show a list of names that are in a database table. I have a database table setup as:

Table Name: Person

Columns:
ID
FirstName
LastName
Age

I am going to concatenate the First Name and Last Name, then bind that to the grid.

Now that we have our Silverlight application ready, we will add a WCF service to our existing “SilverlightWCFTutorial.Web” project that was automatically created for us.

Now we are going to setup the interface that was created for us. The interface automatically creates a method called “DoWork”. We are going to change the name of this to be a little more specific. I gave the method the name of “GetNames”.

[ServiceContract]
public interface IDatabaseService
{
    [OperationContract]
    List GetNames();
}

Now that the interface is finished, we will move to the service file. Double-click on the “DatabaseService.svc” file to get to the code. This code is just going to run some simple ADO to get the data from the database.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;
using System.Data.SqlClient;
using System.Data;

namespace SilverlightWcfService
{
    // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "DatabaseService" in code, svc and config file together.
    public class DatabaseService : IDatabaseService
    {
        string myConnectionString = "someConnectionString";

        public List GetNames()
        {
            List list = new List();

            using (SqlConnection cn = new SqlConnection(myConnectionString))
            {
                using (SqlCommand cmd = cn.CreateCommand())
                {
                    cmd.CommandText = "SELECT FirstName + ' ' + LastName FROM Person";
                    cmd.CommandType = CommandType.Text;

                    cn.Open();

                    using (SqlDataReader dr = cmd.ExecuteReader())
                    {
                        while (dr.Read())
                        {
                            list.Add(dr.GetString(0));
                        }
                    }
                }
            }

            return list;
        }
    }
}

Next, we will need to fix the “Markup” of the “DatabaseService.svc” file. Right-click on the file, then choose “View Markup”. In the markup, you will notice a “Service” attribute. This should be in the format of “Namespace.ServiceName”. In our case, the autogenerated value could be incorrect. Change the code to this..

<%@ ServiceHost Language="C#" Debug="true" Service="SilverlightWCFTutorial.Web.DatabaseService" CodeBehind="DatabaseService.svc.cs" %>

Now that our WCF service is complete, we are going back to the Silverlight app. We are going to add an event handler for the “Loaded” event of the MainPage.xaml.

public MainPage()
{
    InitializeComponent();

    this.Loaded += new RoutedEventHandler(MainPage_Loaded);
}

You will need to rebuild your solution at this point.

We will also need to add a Reference to the Service for our Silverlight project. Right-click on the “SilverlightWCFTutorial” project, and choose “Add Service Reference…”. Once the Add Service Reference window comes up, click the “Discover” button. This will find our service. Fill in the “Namespace”(called mine “MyDatabaseService”). Then click OK.

Now we are ready to do some code. Remember that the requests in Silverlight are made asynchronously.

In our “MainPage_Loaded’ event handler, we will have this code..

void MainPage_Loaded(object sender, RoutedEventArgs e)
{
    // The DatabaseServiceClient class was automatically created for us.
    // The autogeneration takes the name of the service, then appends "Client" to it,
    //   giving us the "DatabaseServiceClient" class.
    DatabaseServiceClient client = new DatabaseServiceClient();

    // Since requests in Silverlight are asynchronous, we have a Completed method
    //   that will be fired when the request has been completed.
    client.GetNamesCompleted += delegate(object s, GetNamesCompletedEventArgs es)
    {
        // when the request has been completed, we want to bind the data to the grid.
        // the Result property of the EventArgs contains the returned data.
        // ObservableCollection is a common collection that is used when databinding to
        //    a DataGrid.
        ObservableCollection myList = es.Result;

        dataGridPerson.DataContext = myList;
    };

    client.GetNamesAsync();
}

And that’s it. We now run the Silverlight app, and we get this…

Here is the full code of the MainPage.xaml…

using System.Collections.ObjectModel;
using System.Windows;
using System.Windows.Controls;
using SilverlightWCFTutorial.MyDatabaseService;

namespace SilverlightWCFTutorial
{
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();

            this.Loaded += new RoutedEventHandler(MainPage_Loaded);
        }

        void MainPage_Loaded(object sender, RoutedEventArgs e)
        {
            // The DatabaseServiceClient class was automatically created for us.
            // The autogeneration takes the name of the service, then appends "Client" to it,
            //   giving us the "DatabaseServiceClient" class.
            DatabaseServiceClient client = new DatabaseServiceClient();

            // Since requests in Silverlight are asynchronous, we have a Completed method
            //   that will be fired when the request has been completed.
            client.GetNamesCompleted += delegate(object s, GetNamesCompletedEventArgs es)
            {
                // when the request has been completed, we want to bind the data to the grid.
                // the Result property of the EventArgs contains the returned data.
                // ObservableCollection is a common collection that is used when databinding to
                //    a DataGrid.
                ObservableCollection myList = es.Result;

                dataGridPerson.DataContext = myList;
            };

            client.GetNamesAsync();
        }
    }
}