To keep up with the exciting work we have coming in, we are in need of a seasoned .NET developer.  Here is a quick description of the job.

Senior .NET Developer

Key Responsibilities:

• Serve as the lead programmer on multiple projects.
• Ability to estimate project tasks, ensuring delivery of projects on-time and to specification
• Being self-directed and architecturally innovative
• Help analyze, design, code, test, debug and provide enhancements to existing software.
• Work closely with a team as well as interfacing with various external Client and Business Groups.

Qualifications

• Bachelors Degree, MCSD certification or other advanced level of industry certification.
• Minimum five(5) years working experience with Microsoft .Net (ASP.NET, C# and/or VB.NET).
  • Experience using various separation patterns such as: MVC, MVVM and MVP
• Minimum two (2) years experience with WCF (Windows Communication Foundation) experience
• Minimum five(5) years working experience with SQL Server or other advanced level databases
  • Strong database modeling skills
  • Experience  with Object-relational mapping (ORM) using Entity Framework, Linq-To-Sql or  NHibernate.
• Excellent oral and written professional communication skills that project a positive, professional image.

If you are interested in this opportunity please apply by sending a resume to careers@nomadicagency.com.

In the first part of my sample I check to see if I have a cache of RSS in Isolated Storage. If so, I use the “DataContractJsonSerializer” class to de-serialize the JSON array. Once de-serialized, I can bind it to my ListBox control in “Page.xaml”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void Page_Loaded(object sender, RoutedEventArgs e)
{
    RssService.RssItem[] items;
    if (_isf.FileExists("blog.json"))
    {
        //Read from IsolatedStorage the last set of blog entires
        using (IsolatedStorageFileStream isfs = 
         new IsolatedStorageFileStream("blog.json", System.IO.FileMode.Open, _isf))
        {
            //Deserialize the JSON array that was stored in Isolated storage.
            DataContractJsonSerializer djson = 
             new DataContractJsonSerializer(typeof(RssService.RssItem[]));
 
            items = djson.ReadObject(isfs) as RssService.RssItem[];
 
            isfs.Position = 0;
            using (StreamReader sr = new StreamReader(isfs))
            {
                this.txtBlock.Text = sr.ReadToEnd();
            }
            isfs.Close();
        }
        listBox.ItemsSource = items;
    }
 
    . . . . . . 
}

After we update our presentation of RSS, I will insert a animating UserControl to be use when we go to retrieve additional RSS items. This retrieval from our WCF 3.5 service will be executed every 10 seconds when our “DispatcherTimer” fires.

1
2
3
4
5
6
7
8
9
10
11
12

    //insert a UserControl that animates a spinner when we are retrieving 
    //an update of RSS data
    _indicator.HorizontalAlignment = HorizontalAlignment.Center;
    _indicator.VerticalAlignment = VerticalAlignment.Center;
    this.LayoutRoot.Children.Add(_indicator);
    _indicator.Visibility = Visibility.Collapsed;
 
    //we will use a timer here to simulate a 5 second delay in grabbing 
    //the next rss update
    _dt.Interval = new TimeSpan(0, 0, 10);
    _dt.Tick += new EventHandler(_dt_Tick);
    _dt.Start();

Upon successful retrieval from our WCF service, we will update our isolated storage by serializing our array of RssItems[] into JSON, and writing that text to a file.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

void wcf_GetFeedsCompleted(object sender, 
    IsolatedStorage.RssService.GetFeedsCompletedEventArgs e)
{
    try
    {
        RssService.RssItem[] items = e.Result as RssService.RssItem[];
        //if we were able to grab a new set of Rss items then update Isolated storage
        if (items.Length > 0)
        {
            if (_isf.FileExists("blog.json"))
            {
                _isf.DeleteFile("blog.json");
            }
            using (IsolatedStorageFileStream isfs = 
             new IsolatedStorageFileStream("blog.json", System.IO.FileMode.Create, _isf))
            {
                //Take the array of RssItem[] objects and convert it to a JSON array.
                DataContractJsonSerializer djson = new DataContractJsonSerializer(items.GetType());
                MemoryStream ms = new MemoryStream();
                djson.WriteObject(ms, items);
 
                this.txtBlock.Text = System.Text.Encoding.UTF8.GetString
                   (ms.GetBuffer(), 0, Convert.ToInt16(ms.Length));
 
                isfs.Write(ms.GetBuffer(), 0, Convert.ToInt16(ms.Length));
                isfs.Close();
            }
            listBox.ItemsSource = items;
        }
        this.listBox.Opacity = 1;
        _indicator.Animation.Stop();
        _indicator.Visibility = Visibility.Collapsed;
    }
    catch (Exception ex)
    {
        this.txtBlock.Text = ex.Message;
    }
}

Thanks again to Tim and Kirk for the majority of my example.

Code: IsolatedStorage.zip

One of the essential elements found in all interactive games is frame-by-frame animations. When a character moves across the screen that movement is a combination of repositioning the character as an element, combined with a sequence of character movements (the animation).

Now I don’t pretend to be a Flash developer, but what I have been told is that creating Frame-by-Frame animations in flash is very easy. You simply create a key frame and insert an object on to that frame. The combination of all key frames produces the animation sequence.

In Silverlight / Blend 2 December Preview creating this type of animation sequence is more difficult. Storyboards in Silverlight are independent of any canvases that will contain the individual animation sequences. Creating a key frame in Silverlight, does not generate a new canvas. In our first Silverlight game we achieved frame-by-frame animations by stacking a series of frames (canvases) and modifying the objects opacity property to appears as if we moved through the sequence. This technique was extremely difficult to work with in blend.

We figured there had to be a easier way. Instead of stacking the frames on top of themselves and using opacity, I decided to position them adjacent to each other and discreetly move the parent canvas from right to left. Think of it like an image strip when the first image starts at X=0 and each adjacent frame is positioned (X+FrameWidth). The result was the canvas shown in Figure 1.

Once the frames are positioned in the correct sequence, I created a Canvas.Clip to clip the main canvas at position 0,0 with a width and height equal to the size of each frame. This clip will mask all of the adjacent frames when we play the animation.

The next step was to create the animation storyboard. For my “less than” creative animation I generated 8 frames, each with a very simple vector. My storyboard will require 1 key frames per frame of the sequence, plus one additional key frame to get back to the starting position. By default, Blend will “tween ” between each key frame. To achieve a discrete transition, you must right click on the frame and select “Hold In “. This selection will change the xaml to a “DiscreteDoubleKeyFrame ” from a “SplineDoubleKeyFrame “. Once you have created a key frame you must move the strip “canvas” to its desired position. Figure 2 shows what the completed animation sequence looks like in the designer.

Figure 3 shows the xaml generated from this sequence.

To check out my super simple animation done in Silverlight 1.1 click here.

Download: page.xaml
Download: Solution

<?xml version="1.0" encoding="UTF-8"?>
<query>
  <session>2222222222</session>
  <users list="true">
    <user>
      <uid>10000001</uid>
      <name>Person 1</name>
    </user>
    <user>
      <uid>10000002</uid>
      <name>Person 2</name>
    </user>
  </users>
</query>

Examining the Xml arrangement we quickly see a pattern to how we might construct a data structure that would ease our ability to access specific keys within the information. The following is how I would like to parse the Xml data and access the list of users.

SimpleXmlResponse xml = SimpleXmlParser.Parse (fileContents, string.Empty);
SimpleXmlList list = xml["users"] as SimpleXmlList;

xml  Count = 2  SimpleXmlResponse
  [0]  {[session, 2222222222]}  KeyValuePair
          Key  "session" string
          Value "2222222222"  object {string}
   [1]  {[users, SimpleXmlList]}  KeyValuePair
          Key  "users" string
          Value Count = 2  object {SimpleXmlList}
                 [0]  {[10000001, SimpleXmlItem]} KeyValuePair
                         Key "10000001" string
                         Value  Count = 2  SimpleXmlItem
                            [0] {[uid, 10000001]} KeyValuePair
                            [1] {[name, Person 1]}  KeyValuePair
                  [1] {[10000002, SimpleXmlItem]} KeyValuePair
                          Key "10000002" string
                          Value Count = 2 SimpleXmlItem
                            [0] {[uid, 10000002]} KeyValuePair
                            [1] {[name, Person 2]}  KeyValuePair

Here are a few things to note:

• The three objects listed above (SimpleXmlResponse, SimpleXmlList, SimpleXmlItem) are nothing more than classes that inherit from System.Collections.Generic.Dictionary. There purpose is to ease readability and facilitate the casting of the result data.
• Since SimpleXmlResponse has a value which might contain either a string or a SimpleXmlList, we store this value as an object. This data type will require us to cast the value to string for simple nodes.
• Each child node contained within those elements flagged as lists (list attribute = true) will have more than one value key pair. As a result, we must either assume the first element is distinct and can be used as the key for the SimpleXmlList element, or we must explicitly identify which element is distinct.