Introduction

People often ask me if I use MVC or WebForms for my Microsoft ASP.NET projects.  I always tell them MVC, but I don’t use it in the classic way that most others do.  That is to say, I emit no html from my views, and for that matter really don’t even use views (with the exception of one view which is essentially my entire app.   People often refer to this as a SPA or Single-Page-Application. What this basically means is that my entire view is built with JavaScript (in my case Sencha’s ExtJS) and the only interaction with the server is to simply bring down Json results.

In this post, I’m going to build a simple app following this principle. It’s purpose will be to take a big pile of text, chop it up into words, then output it in some c# friendly manner.  My motivation for doing this is I happen to need that functionality right now and instead of creating a little awk script to do it, I’m going to right a web site!

So, Here is what we will build.  A handy formatter! (and you can run it at:   http://reformatter.peterkellner.net/ )

Part I, The Visual Studio Project

Let’s first create the Visual Studio project.  My development these days is actually using the latest Windows 8 Consumer build with the beta of Visual Studio 2011 running on it.  The nice thing about this is because Microsoft added “Round Tripping” to VS2011, I can now use VS2011 to create the project and you, my happy readers, can download the project and open it in Visual Studio 2010.  This has been long in coming and Microsoft has finally done it for the newest version of Visual Studio.  Thank you Microsoft!

And with an Internet Application with Razor (though I really don’t need all that extra stuff, it does not hurt)

The structure created is as as shown below with a Controller and Views folder and all the proper routing setup.

Because I want to make a very simple MVC app that only emits Json, Let’s create our own empty controller called ReformatterController.  We do that by right clicking on the Controller folder and pressing “Add Controller”, then “Add Empty Controller”.

Now, let’s create a very very simple controller with just one method that returns a JSON Result.  I’m returning the data in a friendly format to  Sencha’s ExtJS (or SenchaTouch for that matter).  JQuery would be similar.  Here is our new controller class (I’m sure my little tokenizer, line maker could be improved, but I’m just doing this to show some real work.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.Mvc;

namespace MvcLiteApp.Controllers
{
    public class ReformatterController : Controller
    {

        public JsonResult ConvertTextToFriendlyText(string inputText)
        {
            const int maxCharactersInLine = 30;
            bool success;
            string messageReturn;
            var outputDataList = new List<string>();

            try
            {
                var words = inputText.Split(' ').ToList();
                var newLine = new StringBuilder();
                foreach (var word in words)
                {
                    if (newLine.Length + word.Length < maxCharactersInLine &&
                        word.Length < maxCharactersInLine)
                    {
                        newLine.Append(" ");
                        newLine.Append(word);
                    }
                    else
                    {
                        outputDataList.Add(newLine.ToString().Trim());
                        newLine = new StringBuilder();
                        newLine.Append(word);
                    }
                }
                success = true;
                messageReturn = "";
            }
            catch (Exception e)
            {
                messageReturn = e.ToString();
                success = false;
            }

            return Json(new
            {
                Success = success,
                Data = outputDataList,
                message = messageReturn
            }, JsonRequestBehavior.AllowGet);
        }

    }
}

Now, let’s feed it a URL and see what happens.  Here is a sample URL:

http://localhost:3600/Reformatter/ConvertTextToFriendlyText?inputText=Romeo%20Montague%20and%20Juliet%20Capulet%20meet%20and%20fall%20in%20love%20in%20Shakespeare’s%20lyrical%20tale%20of%20%22star-cross’d%22%20lovers.

I actually pasted the sentence in to the the browser’s URL line and it added the nice encoded spaces for me.  The output is as follows:

{"Success":true,"Data":["Romeo Montague and Juliet","Capulet meet and fall in love","in Shakespeare\u0027s lyrical tale"],"message":""}

Notice that it created the nice lines formatted as a JavaScript array!

Next step, let’s make a real JavaScript program out of this.

Part 2, Our SPA (Single Page App) That Does Real Work

I’m only going to explain here the part of the Sencha Program that actually consumes the data but first, let’s add a little “properness” to our controller so it responds only to POST.  That is, we add an attribute to the top of the method and we change the behavior attribute on the bottom to say to not allow get.

        [HttpPost]
        public JsonResult ConvertTextToFriendlyText(string inputText)
        {
            .......
            return Json(new
            {
                Success = success,
                Data = outputDataList,
                message = messageReturn
            }, JsonRequestBehavior.DenyGet);
        }

And, the JavaScript in the SPA is very straight forward and is here:

var beforeTextAreaComponent = Ext.getCmp('BeforeFormatTextAreaId');
textBefore = beforeTextAreaComponent.getValue();

// how to not pollute global name space here?
var stringbuildervalue = Ext.getCmp('stringbuilderid').getValue();
var javascriptarrayvalue = Ext.getCmp('javascriptarrayid').getValue();
var noformattingvalue = Ext.getCmp('noformattingid').getValue();
var outputwidthvalue = Ext.getCmp('outputwidthid').getValue();

Ext.Ajax.request({
    url: 'ReFormatter/ConvertTextToFriendlyText',
    params: {
        inputText: textBefore,
        stringbuilder: stringbuildervalue,
        javascriptarray: javascriptarrayvalue,
        noformatting: noformattingvalue,
        outputwidth: outputwidthvalue
    },
    success: function(response){
        var localData = Ext.JSON.decode(response.responseText).Data;
        var numberRows = localData.length;
        var newData = '';
        for (var i=0;i<numberRows;i++) {
            newData += localData[i] + '\n';
        }

        var afterTextAreaComponent = Ext.getCmp('AfterFormatTextAreaId');
        afterTextAreaComponent.setValue(newData);

    },
    failure: function(error) {
        alert('error');
    }

});

Now, in reality, I’ve added some useful stuff to the controller (and put the project here for your review, comments and suggestions).

The goal is to create a simple Service in Windows 7 (or other similar OS’s) with Visual Studio 2010 that simply starts, sleeps for 15 seconds, then stops.  I realize this is not that useful, but basically, it covers the case of building a service that actually does something and when finished stops.  In my personal case, my thread has a while(true) loop which keeps looking for new work and only completes when certain conditions are met (like a fatal error that is non recoverable).

Microsoft has given us a pretty good set of docs and walk through.  You can find them all here:  http://msdn.microsoft.com/en-us/library/y817hyb6.aspx

The Steps

Create a new Visual Studio Project of type “Windows Service”

Once the project is created, make sure you have the design surface up for Service1 [Design] and right click on it and say “Add Installer”.

Now, you’ll get to “gear” icons that you can set properties for.  They are “serviceProcessInstaller1” and “serviceInstaller1” as follows:

Select “serviceProcessInstaller1” and in it’s properties window change the account to “LocalSystem”.  You should have a screen that looks like the following:

Then, on the other gear “serviceInstaller”, change the nanes as follows.  I’m naming my service “MyDoNothingService”.

Now, rebuild your project and you’ll get an exe file in your /bin/Debug folder.  Open that folder with the Visual Studio Command Prompt (elevated as admin).  To install the service, enter the command:

InstallUtil WindowsServiceCreateSample.exe

You should get some messages that end with “The Commit phase completed successfully”, then “The Transaction install has completed”.

Now, you should see that you have the service in your services panel (you can get there by going to control panel / Administrative / Services or simple run “services” from your start button.

(sorry for the rename here to MyServiceTest, but I got distracted and had to come back and rename the project)

So, now we want to add something to this project.  Let’s just add to the OnStart event of Service1.cs something that starts a thread that sleeps for 15 seconds, then stops the thread.  Very simple code as follows:

  protected override void OnStart(string[] args)
        {
            new Thread(()
                      =>
            {
                Thread.Sleep(15000); // sleep 15 seconds
                this.Stop();
            }).Start();
        }

Now, before we can install the service, we first need to uninstall it.  Very easy, just add a /u to the end of your install command.

InstallUtil WindowsServiceCreateSample.exe /u

You should be greeted with “The uninstall has completed.”.

Now, when you try and reinstall, sadly, you might get this error: “Error 1001. The specified service has been marked for deletion”.  If you do, thanks to a post by Mr. Laxdel, all you have to do is exit your services dialog and restart the service.

Assuming you left the default autoLog set to true as follows:

In your event viewer, you should see you service starting and stopping as follows:

Conclusions

That was pretty straight forward.  Hopefully, you can follow along and generate the same thing yourself.  Here is the source code attached for a visual studio 2010 project if for some reason you have trouble recreating it yourself.  HTH’s!

Many of us know we should be using test first development, however it is hard to break old habits.  I have to admit, I started to solve this particular problem I’m going to use an an example first without test first, then realized what a pickle I was going to be in proving to myself it worked.  So, I thought, why not blog my experience as I do it.  Using Visual Studio unit testing makes this pretty easy.

The Problem

I’m currently building a multithreaded email processor and part of that process is I have to figure out, for any given use whether they are supposed to have there email server checked.  So, the way I look at it, I need a method that takes in the following parameter.

1. Now – This is actually todays date and time in UTC, but since this method need to be tested, I’m going to pass in now rather just use it directly.
2. LastActivityOfUserDateTime – This is the last time we saw any activity for this user.
3. LastEmailSession – This is when the email session was last run (server check).
4. DefaultSecondsForLastActivityTreshold – This is used to determine weather the user last activity makes that user considered active or inactive.  That is, say this is 60 seconds.  Then, if the user has been active in the last 60 seconds, then this user is considered active.
5. DefaultSecondsBetweenEmailRetryOutsideThreshold – If the user is not active (as defined by DefaultSecondsForLastActivityTreshold) then this is the number of seconds we should wait before we should try and contact the users email server again.
6. DefaultSecondsBetweenEmailRetryInsideThreshold – If the user is active (as defined by DefaultSecondsForLastActivityTreshold) then this is the number of seconds we should wait before we should try and contact the users email server again.

Given these 4 parameters, we should write a method that returns a Boolean indicating weather the mail server needs to be rechecked for a given user.

The Method To Test

So, let’s write a method signature.  We will use this in our real project, then write some tests to see if it works correctly.  We have not written the actual method yet, we are just defining what it does, then first, very important, writing the tests to prove it will work.  This way, as we add all the corner cases, we can keep making sure the original cases we programmed have not broken.

So, here is how I see the class definition:

public bool IsUserReadyToContactEmailServer(DateTime currentDateTime,
            DateTime lastActivityOfUserDateTime,
            DateTime lastEmailSession,
            int defaultSecondsForLastActivityTreshold,
            int defaultSecondsBetweenEmailRetryOutsideThreshold,
            int defaultSecondsBetweenEmailRetryInsideThreshold)
        {
            bool activeUser = IsUserCurrentlyActive(currentDateTime, lastActivityOfUserDateTime,
                                                      defaultSecondsForLastActivityTreshold);
            int thresholdForRetrySeconds =
                activeUser
                    ? defaultSecondsBetweenEmailRetryInsideThreshold
                    : defaultSecondsBetweenEmailRetryOutsideThreshold;

            // this has to be a double because could be huge number if last email send very long ago
            double timeSinceLastEmailSessionSeconds =
                currentDateTime.Subtract(lastEmailSession).TotalSeconds;

           return timeSinceLastEmailSessionSeconds > thresholdForRetrySeconds;
        }

Creating a Test Project In Visual Studio 2011 Preview

Now that we have our method we want to test, let’s create a test project.  This is very straight forward.  We first just say “File/New Project” then choose “Unit Test Project”.

I’m going to simply create a method called TestMethodIsUserReadyToContactEmailServer().

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace AEWeb.Tests
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethodIsUserReadyToContactEmailServer()
        {
        }
    }
}

Now, we need to add some guts.  There is an automated way to create the actual test stubs, but at the moment I can’t seem to find it.  In this case, we really just need to test a bunch of corner cases so let’s code the tests up. Below are the tests I’ve come up with including comments that make them self explanatory.

So, as I’m creating my tests, I realize I need to create an extra class to help this one.  That is specifically, I need to add a method that simply determines if the user is currently active.  I’m going to call that IsCurrentlyActive and have it take three paramaters.  currentDateTime, DefaultSecondsForLastActivityThreshold and usersLastActivityDate.  I realized this because solving the full problem of figuring out if the user is ready to sync email is to complex in one step.

If I were developing this without unit tests, I would have figured the same thing out, but then as I built it, I would not be verifying it’s correctness with testing.

Creating Stub Classes

So, my new class I want to test will be this:

 /// <summary>
        /// This really just a supporting method for the above IsUserReadyToContactEmailServer call
        /// </summary>
        /// <param name="currentDateTime">Current datetime (for testing can be anything)</param>
        /// <param name="usersLastActivityDate">time user was last seen </param>
        /// <param name="defaultSecondsForLastActivityTreshold">our definition of what makes a user currently active</param>
        /// <returns></returns>
        public bool IsUserCurrentlyActive(DateTime currentDateTime,
            DateTime usersLastActivityDate,
            int defaultSecondsForLastActivityTreshold
            )
        {

            return true;
        }

The Unit Tests Themselves

So, now is time to actually write the tests.  I’m not going to explain here all the mechanics of testing.  I assume you understand the basics are you right calls to methods, then make assertions for correctness.  If the assertion is wrong, then print that message and of course the test fails.

So, Here are my test cases for just the helper method (IsUserCurrentlyActive).

using System;
using AELib;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace AEWeb.Tests
{
    [TestClass]
    public class UnitTestEmailReadyCheck
    {

        [TestMethod]
        public void UnitTestRecentActivity()
        {
            {
                // a long time ago
                var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
                var lastActivityOfUserDateTime = new DateTime(2012, 2, 1, 12, 0, 0);
                // last activity was a month ago, 2/1/2012 at noon
                // threshhold for calling a user active
                const int defaultSecondsForLastActivityTreshold = 60*15; // let's call this 15 minute threshhold
                bool isActive = new MailServerReadyCheck().
                    IsUserCurrentlyActive(currentDateTime, lastActivityOfUserDateTime,
                                          defaultSecondsForLastActivityTreshold);
                Assert.IsFalse(isActive,
                               "User Should Be Inactive because last activity was 1 month ago and threshhold is 15 minutes");
            }
        }

        [TestMethod]
        public void UnitTestNoRecentActivity()
        {
            // a just inside threshold
            var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
            var lastActivityOfUserDateTime = new DateTime(2012, 3, 1, 11, 55, 0);
            // last activity was 5 minutes before noon on 2/1/2012
            // threshhold for calling a user active
            const int defaultSecondsForLastActivityTreshold = 60*15; // let's call this 15 minute threshhold
            bool isActive = new MailServerReadyCheck().
                IsUserCurrentlyActive(currentDateTime, lastActivityOfUserDateTime,
                                      defaultSecondsForLastActivityTreshold);
            Assert.IsTrue(isActive,
                          "User Should Be active because last activity was 5 minutes ago and threshhold is 15 minutes");
        }

        [TestMethod]
        public void UnitTestCurrentDateBehindActivity()
        {
            // impossible cause of last activity being after current time. just need to
            // make sure it returns true and does not crash
            var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
            var lastActivityOfUserDateTime = new DateTime(2012, 3, 1, 18, 0, 0);
            // last activity was 5 minutes after noon on 2/1/2012
            // threshhold for calling a user active
            const int defaultSecondsForLastActivityTreshold = 60*15; // let's call this 15 minute threshhold
            bool isActive = new MailServerReadyCheck().
                IsUserCurrentlyActive(currentDateTime, lastActivityOfUserDateTime,
                                      defaultSecondsForLastActivityTreshold);
            Assert.IsTrue(isActive,
                          "User Should Be active because last activity was 5 minutes after current time");
        }
    }
}

Then, I write the actual method:

       /// <summary>
        /// This really just a supporting method for the above IsUserReadyToContactEmailServer call
        /// </summary>
        /// <param name="currentDateTime">Current datetime (for testing can be anything)</param>
        /// <param name="usersLastActivityDate">time user was last seen </param>
        /// <param name="defaultSecondsForLastActivityTreshold">our definition of what makes a user currently active</param>
        /// <returns></returns>
        public bool IsUserCurrentlyActive(DateTime currentDateTime,
            DateTime usersLastActivityDate,
            int defaultSecondsForLastActivityTreshold
            )
        {
            int secondsSinceLastActivity = Convert.ToInt32(currentDateTime.Subtract(usersLastActivityDate).TotalSeconds);
            bool activeStatus = defaultSecondsForLastActivityTreshold > secondsSinceLastActivity;
            return activeStatus;
        }

And finally, run the test (skipping a little debugging to make them all work)

Presto!

For completeness, I’m pasting the full unit test for the other main class I’m interested in testing below (as well as the class itself), however I won’t go into all the details.  Everything is basically the same, just more of it

Conclusions and Observations

Turns out, this was quite a bit of work to generate all these tests.  At first pass, I can hear someone saying it seems like a lot to do just for two fairly simple methods.  My answer is that I struggled trying to get it right until I finally decided to write the tests.  Now, I’m confident it works correctly.  What is more, if there is a bug in my algorithm, or something else comes up I need to include (which is very likely) I now have a great way to prove to myself (and others) that my class works.  Also, this serves as great documentation for what expectations are for this very important function.

Appendex – Full Unit Test And Class Source

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace AELib
{
    public class MailServerReadyCheck
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="currentDateTime">This is actually todays date and time in UTC, but since 
        ///    this method need to be tested, I’m going to pass in now rather just use it directly</param>
        /// <param name="lastActivityOfUserDateTime"> This is used to determine weather the user last activity
        ///      makes that user considered active or inactive.  That is, say this is 60 seconds.
        ///      Then, if the user has been active in the last 60 seconds, then this user is considered active.</param>
        /// <param name="lastEmailSession">When the last email completed for this user</param>
        /// <param name="defaultSecondsForLastActivityTreshold">This is used to determine weather the user last activity makes that 
        ///      user considered active or inactive.  That is, say this is 60 seconds.  Then, if the user has 
        ///      been active in the last 60 seconds, then this user is considered active.</param>
        /// <param name="defaultSecondsBetweenEmailRetryOutsideThreshold"> If the user is not active (as defined by 
        ///      DefaultSecondsForLastActivityTreshold) then this is the number of seconds we should wait before 
        ///      we should try and contact the users email server again.</param>
        /// <param name="defaultSecondsBetweenEmailRetryInsideThreshold">If the user is active (as defined by 
        ///      DefaultSecondsForLastActivityTreshold) then this is the number of seconds we should wait 
        ///      before we should try and contact the users email server again.</param>
        /// <returns>returns a boolean indicating weather the mail server needs to be rechecked for a given user.</returns>
        public bool IsUserReadyToContactEmailServer(DateTime currentDateTime,
            DateTime lastActivityOfUserDateTime,
            DateTime lastEmailSession,
            int defaultSecondsForLastActivityTreshold,
            int defaultSecondsBetweenEmailRetryOutsideThreshold,
            int defaultSecondsBetweenEmailRetryInsideThreshold)
        {
            bool activeUser = IsUserCurrentlyActive(currentDateTime, lastActivityOfUserDateTime,
                                                      defaultSecondsForLastActivityTreshold);
            int thresholdForRetrySeconds =
                activeUser
                    ? defaultSecondsBetweenEmailRetryInsideThreshold
                    : defaultSecondsBetweenEmailRetryOutsideThreshold;

            // this has to be a double because could be huge number if last email send very long ago
            double timeSinceLastEmailSessionSeconds =
                currentDateTime.Subtract(lastEmailSession).TotalSeconds;

           return timeSinceLastEmailSessionSeconds > thresholdForRetrySeconds;
        }

        /// <summary>
        /// This really just a supporting method for the above IsUserReadyToContactEmailServer call
        /// </summary>
        /// <param name="currentDateTime">Current datetime (for testing can be anything)</param>
        /// <param name="usersLastActivityDate">time user was last seen </param>
        /// <param name="defaultSecondsForLastActivityTreshold">our definition of what makes a user currently active</param>
        /// <returns></returns>
        public bool IsUserCurrentlyActive(DateTime currentDateTime,
            DateTime usersLastActivityDate,
            int defaultSecondsForLastActivityTreshold
            )
        {
            int secondsSinceLastActivity = Convert.ToInt32(currentDateTime.Subtract(usersLastActivityDate).TotalSeconds);
            bool activeStatus = defaultSecondsForLastActivityTreshold > secondsSinceLastActivity;
            return activeStatus;
        }
    }
}

And the tests…

 

using System;
using AELib;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace AEWeb.Tests
{
    [TestClass]
    public class UnitTestEmailReadyCheck
    {

        ///////////////////// IsUserCurrentlyActive follows

        [TestMethod]
        public void UnitTestRecentActivity()
        {
            {
                // a long time ago
                var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
                var lastActivityOfUserDateTime = new DateTime(2012, 2, 1, 12, 0, 0);
                // last activity was a month ago, 2/1/2012 at noon
                // threshhold for calling a user active
                const int defaultSecondsForLastActivityTreshold = 60*15; // let's call this 15 minute threshhold
                bool isActive = new MailServerReadyCheck().
                    IsUserCurrentlyActive(currentDateTime, lastActivityOfUserDateTime,
                                          defaultSecondsForLastActivityTreshold);
                Assert.IsFalse(isActive,
                               "User Should Be Inactive because last activity was 1 month ago and threshhold is 15 minutes");
            }
        }

        [TestMethod]
        public void UnitTestNoRecentActivity()
        {
            // a just inside threshold
            var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
            var lastActivityOfUserDateTime = new DateTime(2012, 3, 1, 11, 55, 0);
            // last activity was 5 minutes before noon on 2/1/2012
            // threshhold for calling a user active
            const int defaultSecondsForLastActivityTreshold = 60*15; // let's call this 15 minute threshhold
            bool isActive = new MailServerReadyCheck().
                IsUserCurrentlyActive(currentDateTime, lastActivityOfUserDateTime,
                                      defaultSecondsForLastActivityTreshold);
            Assert.IsTrue(isActive,
                          "User Should Be active because last activity was 5 minutes ago and threshhold is 15 minutes");
        }

        [TestMethod]
        public void UnitTestCurrentDateBehindActivity()
        {
            // impossible cause of last activity being after current time. just need to
            // make sure it returns true and does not crash
            var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
            var lastActivityOfUserDateTime = new DateTime(2012, 3, 1, 18, 0, 0);
            // last activity was 5 minutes after noon on 2/1/2012
            // threshhold for calling a user active
            const int defaultSecondsForLastActivityTreshold = 60*15; // let's call this 15 minute threshhold
            bool isActive = new MailServerReadyCheck().
                IsUserCurrentlyActive(currentDateTime, lastActivityOfUserDateTime,
                                      defaultSecondsForLastActivityTreshold);
            Assert.IsTrue(isActive,
                          "User Should Be active because last activity was 5 minutes after current time");
        }

        ///////////////////// IsUserReadyToContactEmailServer follows

        [TestMethod]
        public void UnitTestIsUserReadyToContactEmailServerLongTimeAgoUserInActive()
        {
            // let's use these parameters for every test

            // let's call this 30 minute threshhold. no contact within 30 minutes, than user is inactive
            const int defaultSecondsForLastActivityTreshold = 60 * 30;

            // if active user, check email every 2 minutes
            const int defaultSecondsBetweenEmailRetryInsideThreshold = 60 * 2;

            // if inactive user, check email every 20 minutes
            const int defaultSecondsBetweenEmailRetryOutsideThreshold = 60 * 20; 

            // user checked email 5 hours ago and email has not been run for 3 hours
            var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
            var lastEmailSessionDateTime = new DateTime(2011,3,1,2, 0, 0); // email session 2am of 1 year ago (very long ago)
            var lastActivityOfUserDateTime = new DateTime(2011, 3, 1, 7, 0, 0); // user checked email at 7am a year ago

            bool emailSessionNeeded = new MailServerReadyCheck().IsUserReadyToContactEmailServer(currentDateTime,
                lastActivityOfUserDateTime,lastEmailSessionDateTime,defaultSecondsForLastActivityTreshold,
                defaultSecondsBetweenEmailRetryOutsideThreshold,
                defaultSecondsBetweenEmailRetryInsideThreshold);

            Assert.IsTrue(emailSessionNeeded,
                          "user checked email 5 hours ago and email has not been run for 3 hours. Should have needed email session");
        }

        [TestMethod]
        public void UnitTestIsUserReadyToContactEmailServerLongTimeAgoUserActive()
        {
            // let's use these parameters for every test
            // let's call this 30 minute threshhold. no contact within 30 minutes, than user is inactive
            const int defaultSecondsForLastActivityTreshold = 60 * 30;

            // if active user, check email every 2 minutes
            const int defaultSecondsBetweenEmailRetryInsideThreshold = 60 * 2;

            // if inactive user, check email every 20 minutes
            const int defaultSecondsBetweenEmailRetryOutsideThreshold = 60 * 20;

            // user checked email 1 minute ago and email has not been run for 3 hours
            var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
            var lastEmailSessionDateTime = new DateTime(2011, 3, 1, 2, 0, 0); // email session 2am of 1 year ago (very long ago)
            var lastActivityOfUserDateTime = new DateTime(2012, 3, 1, 11, 59, 0); // user checked email 1 minute ago

            bool emailSessionNeeded = new MailServerReadyCheck().IsUserReadyToContactEmailServer(currentDateTime,
                lastActivityOfUserDateTime, lastEmailSessionDateTime, defaultSecondsForLastActivityTreshold,
                defaultSecondsBetweenEmailRetryOutsideThreshold,
                defaultSecondsBetweenEmailRetryInsideThreshold);

            Assert.IsTrue(emailSessionNeeded,
                          "user checked email  1 minute ago and email not been run for 1 year. should have run email again");
        }

        [TestMethod]
        public void UnitTestIsUserReadyToContactEmailServerRecentlyUserActive()
        {
            // let's use these parameters for every test
            // let's call this 30 minute threshhold. no contact within 30 minutes, than user is inactive
            const int defaultSecondsForLastActivityTreshold = 60 * 30;

            // if active user, check email every 2 minutes
            const int defaultSecondsBetweenEmailRetryInsideThreshold = 60 * 2;

            // if inactive user, check email every 20 minutes
            const int defaultSecondsBetweenEmailRetryOutsideThreshold = 60 * 20;

            // user checked email 1 minute ago and email has not been run for 3 hours
            var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
            var lastEmailSessionDateTime = new DateTime(2012, 3, 1, 11, 50, 0); // email session 10 minutes ago
            var lastActivityOfUserDateTime = new DateTime(2012, 3, 1, 11, 59, 0); // user checked email 1 minute ago

            bool emailSessionNeeded = new MailServerReadyCheck().IsUserReadyToContactEmailServer(currentDateTime,
                lastActivityOfUserDateTime, lastEmailSessionDateTime, defaultSecondsForLastActivityTreshold,
                defaultSecondsBetweenEmailRetryOutsideThreshold,
                defaultSecondsBetweenEmailRetryInsideThreshold);

            Assert.IsTrue(emailSessionNeeded,
                          "active user, email checked 10 minutes ago but since active should check again");
        }

        [TestMethod]
        public void UnitTestIsUserReadyToContactEmailServerRecentlyUserInActive()
        {
            // let's use these parameters for every test
            // let's call this 30 minute threshhold. no contact within 30 minutes, than user is inactive
            const int defaultSecondsForLastActivityTreshold = 60 * 30;

            // if active user, check email every 2 minutes
            const int defaultSecondsBetweenEmailRetryInsideThreshold = 60 * 2;

            // if inactive user, check email every 20 minutes
            const int defaultSecondsBetweenEmailRetryOutsideThreshold = 60 * 20;

            // user checked email 1 minute ago and email has not been run for 3 hours
            var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
            var lastEmailSessionDateTime = new DateTime(2012, 3, 1, 11, 50, 0); // email session 10 minutes ago
            var lastActivityOfUserDateTime = new DateTime(2011, 3, 1, 11, 59, 0); // user checked email 1 year ago

            bool emailSessionNeeded = new MailServerReadyCheck().IsUserReadyToContactEmailServer(currentDateTime,
                lastActivityOfUserDateTime, lastEmailSessionDateTime, defaultSecondsForLastActivityTreshold,
                defaultSecondsBetweenEmailRetryOutsideThreshold,
                defaultSecondsBetweenEmailRetryInsideThreshold);

            Assert.IsFalse(emailSessionNeeded,
                          "inactive user, but email checked very recently so should not be checking again");
        }

        [TestMethod]
        public void UnitTestIsUserReadyToContactEmailServerEmailLastSession10MinutesagoActive()
        {
            // let's use these parameters for every test
            // let's call this 30 minute threshhold. no contact within 30 minutes, than user is inactive
            const int defaultSecondsForLastActivityTreshold = 60 * 30;

            // if active user, check email every 2 minutes
            const int defaultSecondsBetweenEmailRetryInsideThreshold = 60 * 2;

            // if inactive user, check email every 20 minutes
            const int defaultSecondsBetweenEmailRetryOutsideThreshold = 60 * 20;

            // user checked email 1 minute ago and email has not been run for 3 hours
            var currentDateTime = new DateTime(2012, 3, 1, 12, 0, 0); // assume current time is 3/1/2012 at noon
            var lastEmailSessionDateTime = new DateTime(2012, 3, 1, 1, 11, 50); // email session 10 minutes ago
            var lastActivityOfUserDateTime = new DateTime(2011, 3, 1, 11, 59, 0); // user checked email 5 minutes ago

            bool emailSessionNeeded = new MailServerReadyCheck().IsUserReadyToContactEmailServer(currentDateTime,
                lastActivityOfUserDateTime, lastEmailSessionDateTime, defaultSecondsForLastActivityTreshold,
                defaultSecondsBetweenEmailRetryOutsideThreshold,
                defaultSecondsBetweenEmailRetryInsideThreshold);

            Assert.IsTrue(emailSessionNeeded,
                          "active user, but email checked very recently so should be checking again");
        }

    }
}

And the results of all tests running

And, if you are still reading, I’ve got 100% of these two methods covered from these unit tests using Code Coverage.

I do not even want to admit how much time I spent today in a more complex application trying to get a button to respond to a tap event in SenchaTouch 2.0 Beta.  I did notice several people like me on the forums with similar issues, but I did not find one concrete example that made the simple “click a button application”.  Of course I’m building this in Microsoft Visual Studio 2010 and debugging with Chrome.  Let me start at the end.  When you are done, you will have a simple two button page that you can click on either button and have your MVC controller react to either button as well as trap the button hit inside the actual Panel.

And for those of you that have read enough, here is the source:  

The Nitty Gritty

Creating an SenchaTouch project with MVC is a little tricky to setup.  You need to get all the directories right.  My favorite way to do this is to use the Sencha Designer to create the project, then abandon it if I want to strike out on my own.  That is what I’ve done here.  I don’t even think you can tell.

Here is the file layout as seen from Visual Studio:

5 Files and 3 directories.

Let’s first take a look at the Panel that contains the buttons.  Here is the code:

Ext.define('MyApp.view.MyPanel', {
    extend: 'Ext.Panel',
    alias: 'widget.mypanel',
    config: {
        items: [
            {
                xtype: 'button',
                itemId: 'mybutton1',
                text: 'MyButton1',
                action: 'b1'
            },
            {
                xtype: 'button',
                itemId: 'mybutton2',
                text: 'MyButton2',
                action: 'b2'
            }
        ],

        listeners: [
            {
                fn: 'onMybutton1Tap',
                event: 'tap',
                delegate: '#mybutton1'
            }
        ]
    },
    onMybutton1Tap: function (button, e, options) {
        console.log('tap from mybutton1');
    }
});

Just a couple things to notice.  1) I’m defining an itemId which we will only be using in the local event (onMybutton1Tap).  If you notice the listener has a property delegate which looks for that.  I’m not sure if this is the best way to do this.  I’ve notice several forum people saying use the “on” syntax.  I did not find an example of that so this is what we have and it works.  Also notice the action property.  If you try and look that up on the SenchaTouch doc’s you will not find it.  I just made it up out of thin air (really!, well, I followed others examples).  I actually asked about this in the forums and I was told that is OK.  As a type safe language guy, it hurts, but I did it.

That’s it for the view.  Let’s move over to the controller.  Here is the source for that:

Ext.define('MyApp.controller.MyController', {
    extend: 'Ext.app.Controller',

    views: [
        'MyPanel'
    ],

    refs: [
        {
            ref: 'MyPanel',
            selector: 'mypanel'
        }],

    init: function () {

        this.control({
            'button[action=b1]': {
                tap: this.onButtonTap1
            },
            'button[action=b2]': {
                tap: this.onButtonTap2
            }
        });
    },

    onLaunch: function () {
        console.log('onLaunch');
    },

    onButtonTap1: function () {
        console.log('controller: onButtonTap1');
    },

    onButtonTap2: function () {
        console.log('controller: onButtonTap2');
    },

    config: {

    }
});

Basically, what this is doing is filtering all buttons, then looking at just the buttons that have an action of b1 or b2.  If this was a large application, we’d probably want to do some more fancy component querying, but for now, this is OK.  If you keep your controllers small, this should always work.

That’s it for now.  Download the source and run it.  I hope it saves you a ton of time. 

As always any experts want to comment and improve or correct what I’ve done, please feel free to comment. 

So, here is the problem.  I created a CodeFirst implementation of EntityFramework in Visual Studio and created a simple hierarchy in my data model.  That is, without showing all the code, here is what I have:

public class Person{    [Key]    [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]    public int Id { get; set; }

    public virtual List<EmailAddressInfo> EmailAddressInfoList { get; set; }    ..}

public class EmailAddressInfo{    [Key]    [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]    public int Id { get; set; }

    public string EmailAddress { get; set; }

}

public class EmailAccount{    [Key]    [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]    public int Id { get; set; }    ...}

Now, if you execute a LINQ command like the following:

var recs = (from data in db.Persons                            select data);                foreach (var rec in recs)                {                    foreach (var email in rec.EmailAddressInfoList)                    {                        Console.WriteLine(email);                    }                }

You get the error:

Exception Details: System.InvalidOperationException: There is already an open DataReader associated with this Command which must be closed first.

To solve this, you need to tell EntityFramework/CodeFirst to include the EmailAddressInfoList in the query.  All you need to do is change the db.Persons to db.Persons.Include("EmailAddressInfoList") as follows:

var recs = (from data in db.Persons.Include("EmailAddressInfoList")            select data);

Then, it all works!

Hope this helps.

Let’s say I’ve created two Visual Studio Projects with the same name “WebApp” but reside in different directories as shown below (c:\temp\Proj1 and c:\temp\Proj2).  I often call the project WebApp, however I want to keep the projects totally separate.  Below are the File/New Project dialog examples.

Now, when I click start (this is with the vs2011 preview I’m demonstrating), I see the following:

I actually have to hover over each “WebApp.sln” to tell which project is which.  I think that information should be in the pinned app itself, not require a hover over to tell which project it is.

Agree?  Add your comment below and go to the following link to vote up my connect suggestion.

https://connect.microsoft.com/VisualStudio/feedback/details/679081/should-have-vs-launch-shortcuts-inside-vs-recent-projects-because-run-as-admin

From the comments, Microsoft said they would consider it for the next release, but it looks like it has not made it.  Let’s try and change that!

SV Code Camp is happening next weekend with well over 200 sessions.  The conference is really technology agnostic and try hard to keep it that way, but I am an ASP.NET guy these days so I think it reasonable I take my Code Camp Coordinator hat off for the moment and put on my ASP.NET hat.  As an ASP.NET Microsoft MVP, I feel I’m in a good position to give a tour of some sessions in ASP.NET and throw in my own 2 cents.  Below are a list of these sessions in no particular order.

Demystifying ASP.NET MVC, $(Lino).MVC{getknowledge()}

Sunday, October 9th 9:45AM

MVC (Model View Controller) is one of the hottest patterns around building web sites these days no matter what the technology. When Microsoft first introduced Web programming to Visual Studio, they did it such that almost anyone who had done windows programming (VB or other) could quickly come up to speed and build a web site. Personally, this what sucked me into web programming. Drag a button, drag a textbox, double click on the button and add some code to set the text box and WHAM, you have a web site. Unfortunately, as things get more complicated, this model does not scale so well. ASP.NET’s MVC implementation does scale, it takes a little bit of flipping your mind around if you are Web Forms programmer, but definitely worth learning about and seeing if it’s right for you.

Lino Tadros is one of my favorite presenters and I’m sure will give you a much better understanding of MVC and how it fits into the ASP.NET programming model. I strongly recommend this one. Lino is the CEO for one of the top Application development and training companies in the world that partners with Microsoft, Falafel Software. In other words, GO TO THIS SESSION!

Pragmatic JavaScript, jQuery & Ajax with ASP.NET

Saturday, October 9th 1:45PM

Damian Edwards is a Program Manager on the Microsoft ASP.NET team.  That’s right, he is flying here from Redmond just to present to us.  He’s also an awesome presenter and we are extremely lucky to have him at Code Camp!   Damien will tak about using JQuery while building sites with the Microsoft ASP.NET framework.  Something Damien knows very very well.  For those who don’t know, Damien is also leading the next generation efforts around ASP.NET WebForms which is the technology 90% of who use ASP.NET use (it’s what the silicon valley code camp web site is built with).

DON’T MISS THIS PRESENTATION!

WebMatrix In Depth

Saturday, October 9th  5:00PM

John Sheehan, one of the best guys I know at explaining complex things is presenting this session on WebMatrix.  I’m not sure everyone would agree with me, but for those people that really don’t like the heavy weight feeling of building web applications with Visual Studio, WebMatrix will make you feel right at home. It’s much lighter weight and also gives tons of punch.  Come see John and ask him a million questions!  He loves that.

All the sessions Tagged ASP.NET can be found here:  http://www.siliconvalley-codecamp.com/Sessions.aspx?sortby=title&by=category&tag=3

OK, I think this is the longest post title I’ve ever made, but if you understand it, you’ll know why it needs to be so long.  I discovered this totally by accident.  I would never ever have pressed F11 (step into) from a client side proxy and expect to get into anything but a bunch of ugly machine generated proxy code (especially with Azure).  To my total surprise, I landed right inside my WCF service as if I had started the Windows Azure Developer fabric in debug mode and set a break point.

So, I’ll step through the process an show screen shots on the outside chance I was dreaming and can’t reproduce it. If I can, now I will have proof so I can do it again.  Sorry for the work in progress code you will see.  The point here is really the debugger and not the code I’m showing so try and ignore that.

OK, here we go.

Let’s assume you have a completely configured azure web role that is hosting a simple WCF service.  When you start that web role and point at the service, you’ll get something like this: (just a note that I started the app fabric by deploying directly from Microsoft Visual Studio 2010 with the start/run.  I am using a debug profile but am NOT running in debug mode.  If I do run the app fabric in debug mode, this does not work.

OK, now let’s run my app that has a WCF client configured to connect to this service.  The configuration is the normal “Add Service Reference” you would expect but I’m showing it any how just to be clear.

Next, we simply Launch Visual Studio 2010 in debug mode and put a break point just before we cross over into the WCF service by calling the above proxy code.  Here is what that screen looks like after the break point is hit and I’m about to step INTO.

F11

and…..

There we are!!! right inside the source code that is my WCF service with everything working as if I had launched the site on it’s own, set a break point and waited.

Truly amazing!!!  I have nothing more to say.

The magic lines are as follows:

<system.net>
    <defaultProxy>
      <proxy bypassonlocal="false" usesystemdefault="true" />
    </defaultProxy>
  </system.net>
</configuration>

That’s it!  Now, Fiddler just sees the traffic.  I’m a happy camper.

Error during serialization or deserialization using the JSON JavaScriptSerializer. The length of the string exceeds the value set on the maxJsonLength property.

I then tried to set the web.config property that everyone seems to reference on the web as follows:

<system.web.extensions>
    <scripting>
        <webServices>
            <jsonSerialization maxJsonLength="2147483645" recursionLimit="100">
            </jsonSerialization>
        </webServices>
        </scripting>
</system.web.extensions>

However, I kept getting the same error over and over.  So, I used the technique suggested in this article

http://thoughtfulcode.wordpress.com/2011/01/03/custom-jsonresult-class-for-asp-net-mvc-to-avoid-maxjsonlength-exceeded-exception/

by Brian Reiter to create an override of the JsonResult class.  That actually worked for me, however unfortunately, it does not show the shape of the data that is currently being returned by MVC3.  That is, MVC3 currently returns a JsonResult as follows:

return Json(new
{
    total = blobs.Count,
    data = blobs.ToList()
}, JsonRequestBehavior.AllowGet);

return new LargeJsonResult() { Data = output, MaxJsonLength = int.MaxValue };

return
   new LargeJsonResult
       {
           MaxJsonLength = 20000000,
           JsonRequestBehavior = JsonRequestBehavior.AllowGet,
           Data = new
                      {
                          total = blobs.Count,
                          data = blobs.ToList()
                      }
       };

Today, I accidentally figured out a way to stop it.  Simply go to the web project and right mouse button on your project and say “Publish”. You will be immediately presented with an option to stop the deployment!

That’s it.  Simple, but pretty undiscoverable IMHO.

The way I got here was to first hover over the variable I wanted to look at.

Then, expand the details and press the push pin with the red arrow pointing at it.

Pressing the push pin puts the variable on your desktop and lets you drag it where ever you want.  The other nice thing is it stays there after you close visual studio and bring it up again (for those of us that require more than one debugging session to find a problem).

A very nice feature! 

This post shows a very simple technique for processing a gzip compression on a background thread using c# with Visual Studio 2010.  What is unique here is we are using no statics to do it.  I’m not totally against using statics, but in general, it is best to avoid them.  I’ve heard the notorious Ward Bell say statics are evil and have had many cases where they have bitten me.  Since I heard Ward say this, I’ve been trying to avoid them where I can.

The Simple Problem

The problem is to simply compress a file to bytes and return to us the compressed, uncompressed and byte array of the result.  We can pass parameters into a thread, however we can not return them (when I say thread, I mean the anonymous method that processes our data).

Some Code

So, to that end, Let’s create a main method as below.  Notice that it creates a very simple anonymous method which executes the code cryptoCopress.CompressFile(…), then simply starts that thread.  Once the thread starts, it simply waits for the thread to end by looping every 50 milliseconds on the thread.IsAlive method.  Finally, when it returns, it simply looks at the cryptCompress object for the results.  No Statics!

private static void Main(string[] args){    var cryptCompress =        new CryptCompress();    var thread =        new Thread(            () =>            cryptCompress.CompressFile                (@"G:\NoBackup\ext-3.2.1\ext-all-debug-w-comments.js"));    thread.Start();

    int cnt = 0;    while (thread.IsAlive)    {        cnt++;        Console.WriteLine("Waiting... " + cnt);        Thread.Sleep(50);    }    Console.WriteLine("Before Compression KBytes: {0}",                        cryptCompress.BeforeCompressionBytes/1000);    Console.WriteLine("After Compression KBytes: {0}",                        cryptCompress.AfterCompressionBytes/1000);}

Now, Lets look at the CryptCompress class.  Notice that it’s basically got one public method (CompressFile) and 3 public properties that will be used to hold the return values.  This way, the main method that started the thread can get the results.  Again, notice that there is no word static any place in this project.

public class CryptCompress{public byte[] CompressedBytes { get; set; }public long BeforeCompressionBytes { get; set; }public long AfterCompressionBytes { get; set; }

public void CompressFile(string fileName){    using (var fileStream =         new FileStream(fileName, FileMode.Open, FileAccess.Read))    {        var uncompressedBytes = new byte[fileStream.Length];        fileStream.Read(uncompressedBytes, 0,             (int) fileStream.Length);        CompressedBytes = CompressGzip(uncompressedBytes);        BeforeCompressionBytes = fileStream.Length;        AfterCompressionBytes = CompressedBytes.Length;        fileStream.Close();    }}

/// <summary>/// Take a simple stream of uncompressed bytes and compress them/// </summary>/// <param name="uncompressedBytes"></param>/// <returns></returns>public byte[] CompressGzip(byte[] uncompressedBytes){    using (var memory = new MemoryStream())    {        using             (var gZipStream =                 new GZipStream(memory, CompressionMode.Compress, true))        {            gZipStream.Write                (uncompressedBytes, 0, uncompressedBytes.Length);        }        return memory.ToArray();    }}}

The Results

When we run this, notice that it takes 3 iterations (or 150 milliseconds) to complete. I’m only compressing a small file so no surprise.  The file is actually 2.7 Megabytes and compress to .7 Megabytes.

That’s it for now! Hope this helps.

Background And Conclusion

In my very last post I talked about how using SHA256 seemed to not be affected by whether you use Buffered or Not Buffered streams.  An astute reader (Samuel Jack) referenced an article by one of my favorite ex MIcrosoft employees (Brad Abrams) saying that almost all the .Net streams have buffering built in.

Well, I think SHA256Managed does not.  One of the challenges I’ve been facing lately with my current project is to provide feedback while doing all kinds of byte piping (stream stuff).  While figuring out how to do this, I inadvertently figured out that buffering makes a huge difference.  Briefly, let me show my results first, then talk about the code that went into it.

Notice that when I use a 64MB Buffer, the memory used for the process is 77MB and when I use an 8MB buffer, the memory used is 17MB.  Clearly the buffer allocated matters.  Just for information, I’ve also included the code that does not break the SHA256 hash into blocks, and it has the same results based on the size of the Memory Buffer declared.  That is, small buffer, small use, big buffer, big use.

The Code

The code that I wrote to do this basically does a nice job of splitting up the processing so that you can log progress as it runs. I’m attaching the Visual Studio 2010 project here as well as pasting the relevant source code.  It’s a good base to experiment with.  Feel free to comment on interesting things you find experimenting with it.

Visual Studio 2010 Project:      

/// <summary>/// Used so we can get MD5Hash and get progress on calculation/// </summary>/// <param name="streamIn"></param>/// <returns></returns>public static string GetSha512Buffered(Stream streamIn){    Process process = Process.GetCurrentProcess();    const int bufferSizeForMd5Hash = 1024*1024*8; // 8MB    Console.WriteLine("-----------------------------------");    Console.WriteLine("Memory Buffer Size {0} MB", bufferSizeForMd5Hash/1000);    Console.WriteLine("-----------------------------------");    string hashString;    using (var md5Prov = new SHA256Managed())    {        int readCount;        long bytesTransfered = 0;        var buffer = new byte[bufferSizeForMd5Hash];        while ((readCount = streamIn.Read(buffer, 0, buffer.Length)) != 0)        {            // Need to figure out if this is final block            if (bytesTransfered + readCount == streamIn.Length)            {                md5Prov.TransformFinalBlock(buffer, 0, readCount);            }            else            {                md5Prov.TransformBlock(buffer, 0, bufferSizeForMd5Hash, buffer, 0);            }            bytesTransfered += readCount;            Console.WriteLine("GetSha512Buffered:{0}MB/{1}MB.   Memory Used: {2}MB",                                bytesTransfered/1000000,                                streamIn.Length/1000000,                                process.PrivateMemorySize64/1000000);        }        hashString = BitConverter.ToString(md5Prov.Hash).Replace("-", String.Empty);        md5Prov.Clear();    }    return hashString;}

The End Result

Motivation

As you can imagine, The Silicon Valley Code Camp web site has lots of “back end” functions that need to be done. That is, things like doing mailings, assigning roles to users, making schedules, allocating rooms and times and literally  hundreds of other tasks like that.  Over the 5 years of code camp, I’ve always built simple protected asp.net web pages to do this.  I’ve always used the simplest asp.net control I could find, such as GridView, DetailsView, DropDownList, and SqlDataSource.  The interfaces usually basically work but are very clumsy and lacking in both functionality and aesthetics.

Why Now

I’ve seen lots of short demos on LightSwitch for Visual Studio and recently read on someone else’s blog that they are now building all their simple applications using LIghtSwitch.  Also, my friend Beth Massi has been running around the world espousing the greatness of this product and I knew if I ran into any dumb issues that she’d bail me out (I’m the king of running into dumb issues.  I’ve found that given two choices that seem right, I always pick the wrong one which is what actually happened here along the way, and Beth did bail me out).

First Blood

First thing to do (after installing LightSwitch) is to say “File/New/Project”.  My plan is to add this project right off my SV Codecamp solution.  So, here goes.

So far so good.  Next step is to choose attach to an external database

Continuing, but don’t get tripped up here like I did.  You will use WCF RIA Services under the covers but you don’t want to select that choice.  You want to say that you want to connect to a database and let LightSwitch do the work for you.

PIck your database and connection strings.

Now, pick the tables you plan on working with.  If this were Linq2sql, I’d be choosing them all, but now that I’m in RIA Services land, I’m hoping I can  have separate “Domains” and not have to reference all the tables all the time.  Jury is still out on that one but for now, I’m following the advice of the team and just picking the tables I want to manage now.

And, I’m going to name the Data Source “svcodecampDataJobs”.  I’ll have to see how this goes and report later.  I’m doing this live so I really don’t know where I’ll end up.

click finish, then rebuild all and it  all works.  It comes up with this screen showing me my relationship between the tables. It is showing me a Company table with a link to a JobListing table which is what I have. Here is what LightSwitch shows me.

The reality of my database is that I also have a JobListingDates table that is now shown here.  Taking a step backwards to explain my database, I have a simple company table, the company has a detail table associated with it called JobListings, and the JobListings table has a details file associated with it called JobListingsDates.  That is, a company may run an ad for 30 days, take it down for 30,and bring it back up again.

Here is what that schema actually looks like in SqlManager from EMS.

One thing I like about great software is that it has things that are discoverable.  So, just now, I double clicked on the little table called JobListings and the view changed to having JobListing as primary and if you look on the bottom right, it shows JobListingDate.  Very cool.  I have no idea where this is all going but I’m starting to get excited.  Here is what I’m looking at now.

Building a Screen

So now, let’s push the “Screen” button and see what happens (while looking at the Company View).

This is nice, I get a list of sample screens.  How about if we build an Editable Grid Screen with the hope of editing and adding new Companies.  Notice that I’m naming it EditableGridCompany and chosing the Company for the data in the dropdown.

You now get a screen that is a little scary looking so rather than actually try and understand it, I thought “maybe I’m done, maybe this will just run”.  So, here goes, Debug/Start Without Debug.  Here is the scary screen, followed by what happens after the run.

And the Run:

Wow!  Paging, Fancy editing including date pickers, exporting to Excel, Inserts, Updates and Deletes on the company table.  This is amazing.  Let me add another Grid so that I can add JobListings to the company.  To do that, go back to the solution explorer and choose add screen.

Then again, I have choices.

I choose Details Screen and check Company in the dropdown, Company Details and Company JobListings for the additional data.

Another intimidating screen, but simply do Debug/Debug Start.

Well, that’s it for now.  Code Camp is 4 days away and I don’t really have time to take this to the next level.  You can see from the screen at the top of the post that this is pretty amazing for the effort!  I’m sure I’ll be back to this.

My friend RobinDotNet suggested I look at his article about how to use Visual Studio 2010 to view the blob storage.  Sure enough, in VS, I can set my account and key in server explorer and see the blob storage!  Thanks Robin.

Link to Thread with details below:

Reply:

The billing portal will give you a fairly detailed report on your storage consumption (it’s about 4 hours behind realtime). You can get to this from the Azure portal (should be near the upper-right by your Live ID). This won’t give you per-container breakdowns or anything that detailed though.

This Azure Storage Team blog post gives a fairly detailed breakdown of how consumption is computed. Knowing this, you could create a more detailed storage consumption report than the billing report by enumerating your containers, then enumerating each blob within the containers and reading each blob’s size (via CloudBlob.Properties.Length).

There’s nothing I know of that will give you a bandwidth breakdown for each container. For that, you’d need to create some sort of service tier, where you could then retrieve the blob in question and accumulate your own stats within that service tier.

Here is the starting code.

public static int SynchronizeScopesAsyncStart(  int dbSyncPairId, string schemaName,   string connectionStringLeft,  string scopeLeft, string connectionStringRight,   string scopeRight, bool skipDbLogging)    {...

So, We need to add a couple new parameters as follows.

public static int SynchronizeScopesAsyncStart           (int dbSyncPairId, string schemaName,            string connectionStringLeft,            string scopeLeft, string connectionStringRight,            string scopeRight, bool skipDbLogging,            int pauseMsScopeLeft,int pauseMsScopeRight)        {

So now, we want to create an overloaded method with the two new parameters (pauseMsScopeLeft and pauseMsScopeRight) left out. 

The way we do this is first, hover the cursor over the method name (SynchronizeScopeAsynStart) as follows.

Notice the helper message telling us

Create an overloaded method similar to this one with fewer parameters.

This is exactly what we want to do so we chose this by pressing enter.  CodeRush now gives us a red arrow pointer telling us where it will put the overloaded method by default as well as giving us some instructions on how to put the method someplace else.  In our case, I’m happy to have it right below where the original method is, so I just press enter.

Now, is the really clever part.  I can simply follow the little helper window and move through the parameter list and exclude parameters I don’t want in the parameter list of my new overloaded method.  In my case, I want to get rid of the last two parameters.  It highlights the last one to start, so I simply press “space” as it says, then I press Shift-Tab to get to the previous parameter, space bar again to exclude that one and I’m almost done.  Here is the screen I’m now looking at.

Finally, I press enter to commit my changes and I have a new overloaded method that looks like the following.

You can continue with the refactoring and tell CodeRush to “inline” your temporary variables, but I think this is enough for now.

Hope this helps!

Before I go into the details, I’d just like to disclose that when I was first writing the Silicon Valley Code Camp web site, I was an asp.net and c# newby.  I’m not claiming wizard status now, but I have to admit that when I go back and look at some of the code I wrote back then (including what I’m showing below before the refactoring), it’s a little embarrassing.  Silicon Valley Code Camp for me as “when I’m not doing real work” web site so I don’t really have the time to go back and clean things up.  Now, with CodeRush, it’s easy to clean things up when I see them with very little effort.

Introduce Using Statement Refactoring

Here is the code I wrote 5+ years ago:

SqlConnection conn = new SqlConnection(connectionString);conn.Open();

// First, make a quick list of counts for each id that is unavailable and show// not be shownstring selectCount = @"select VistaSlotsId FROM attendees                      WHERE VistaSlotsId >= 2 AND VistaSlotsId <= 5 Group By VistaSlotsId                      HAVING COUNT(*) >= @MaxPerSlot  ";List<int> unavailableSlotsList = new List<int>();SqlDataReader readerUnavailable = null;SqlCommand cmdUnAvailable = new SqlCommand(selectCount, conn);cmdUnAvailable.Parameters.Add("@MaxPerSlot", SqlDbType.Int).Value = maxPerSlot;readerUnavailable = cmdUnAvailable.ExecuteReader();try{    while (readerUnavailable.Read())    {        int id = readerUnavailable.GetInt32(0);        unavailableSlotsList.Add(id);    }}finally{    if (readerUnavailable != null) readerUnavailable.Close();}

By placing the cursor over the “conn” on the top line of the code above, CodeRush gives us the following result:

There are actually quite a few things happening here.

1. It is showing us in the top textbox what the using syntax will be
2. It is crossing out the lines of code it will change
3. It is teaching us a little about the using statement

If I accept the changes, I get a nice refactoring.  I can continue doing this with “using” for SqlCommand and SqlReader.  I did need to move the SqlReader declaration inside the SqlCommand codeblock for this to work.  Here is the final refactored code that took about 10 seconds.  By hand, I’d say it would have taken me 3 minutes and I may have gotten it wrong which is why I would never do it before.  Now, I’m confident I did not break my code.

using (SqlConnection conn = new SqlConnection(connectionString)){    conn.Open();    // First, make a quick list of counts for each id that is unavailable and show    // not be shown    string selectCount = @"select VistaSlotsId FROM attendees                                  WHERE VistaSlotsId >= 2 AND VistaSlotsId <= 5 Group By VistaSlotsId                                  HAVING COUNT(*) >= @MaxPerSlot  ";    List<int> unavailableSlotsList = new List<int>();    using (SqlCommand cmdUnAvailable = new SqlCommand(selectCount, conn))    {        cmdUnAvailable.Parameters.Add("@MaxPerSlot", SqlDbType.Int).Value = maxPerSlot;        using (SqlDataReader readerUnavailable = cmdUnAvailable.ExecuteReader())        {            try            {                while (readerUnavailable.Read())                {                    int id = readerUnavailable.GetInt32(0);                    unavailableSlotsList.Add(id);                }            }            finally            {                if (readerUnavailable != null)                    readerUnavailable.Close();            }        }    }

Compress To Lambda Expression Refactoring

A lot of the Silicon Valley Code Camp web site was written prior to the introduction of Lamba Expressions.  If you recall, I wrote an MSDN article back in 2006 entitled Adding Personalization via Profiles to the ObjectDataSource in ASP.NET 2.0.  Ted Neward inspired a construct to cleverly sort the result list using delegates as shown in the screen shot (form that above post).

The code below is similar to the above but not quite the same.  This is how it looks before the refactoring:

Comparison<DataObjectSessionsOverview> comparison = null;    switch (sortDataBase)    {        case "Userfirstname":            comparison = new Comparison<DataObjectSessionsOverview>(               delegate(DataObjectSessionsOverview lhs, DataObjectSessionsOverview rhs)               {                   return lhs.Userfirstname.CompareTo(rhs.Userfirstname);               }             );            break;

CodeRush suggests:

Which then give us:

switch (sortDataBase){   case "Userfirstname":       comparison = (lhs, rhs) => lhs.Userfirstname.CompareTo(rhs.Userfirstname);       break;

I like it!

So, say you have code like this:

var sessionAttendeeOds =   new SessionAttendeeODS();listSessionAttendees =   sessionAttendeeOds.GetByUsername(Context.User.Identity.Name);

When I chose “InlineTemp”, the code changes to the following, make it easier to read.

listSessionAttendees =                 new SessionAttendeeODS().GetByUsername(Context.User.Identity.Name);

Again, this is not a huge deal, but small fixes like this will add up over time and make my code cleaner and more readable.  CodeRush makes it so easy that I’m sure I’ll do this kind of thing more and more.

HTH’s.

To save anyone some time who wants to do the same thing, I’ve created a VS2010 project from the example, added a very simple Windows C# console application that consumes the service, as well as made some small changes in a very nice Windows Presentation Foundation (WPF) calculator project so that the calculator does it operations inside the windows service rather than in the calculator itself.

In this article, I’ve attached the source code (with my small changes and additions) for you to work with and change as you like.

First, here is the project:

Now, let’s talk about the details

The Visual Studio 2010 Solution Itself

There are three projects in this solution.  The service itself which is called WCFServiceInmanagedWindowsService, Console Application and Calculator.

WCFServiceInManagedWindowsService Project

This project is really what is taken from the MSDN article. It’s got almost no change and is primarily created by following the directions in the article.  There are a couple batch files added for creating and deleting the service itself in the root of that project directory, but that’s about it.  All the code is in a file called service.cs.

To Add the service, go to the “Service Reference”/”Add Service” Dialog and enter the address of the service (you can find it in the app.config file).

http://localhost:8000/ServiceModelSamples/service

Notice that the methods exposed are Add/Divide/Multiple and Subtract.

To start the actual service, after rebuilding the project, execute the bat file InstallService.bat in the root directory.  Make sure you build the release version because this script installs the service from the release directory. Once started, you will see it in the services application as follows:

Then, start the service by running the command: “net start WCFWindowsServiceSample”  If you get the error: “No connection could be made because the target machine actively refused it 127.0.0.1:8000”, this likely means you did not start your service.

The Console Application

The Console application is new and very simple. All you have to do is create a new windows c# console project, use the “Add Service” DialWCFWindowsServiceSampleog and point it at  ( http://localhost:8000/ServiceModelSamples/service ) as follows:

Now, you can simply write a console app with the following code and you will be calling the service correctly.  Here is the code:

class Program    {        static void Main(string[] args)        {            var calculatorClient = new CalculatorClient();

            var answer = calculatorClient.Add(5, 4);            Console.WriteLine("Answer to Adding 5 + 4: {0}", answer);            Console.ReadKey();

        }    }

And, when we run it, now surprise, we get 9!

…

The Calculator Application

Just to show a real life use of the service, I grabbed the codeplex project http://code.google.com/p/wpf-mvvm-calculator/.

Then, modifying a small section of code inside (after adding the service reference of course, just like we did in the above console project, we now have a calculator that adds by calling a service for the answer.  Here is the modified code:

try           {               // Establish the connection to the Service               var calculatorClient = new CalculatorClient();               var firstOperand = Convert.ToDouble(FirstOperand);               var secondOperand = Convert.ToDouble(SecondOperand);

               var stopwatch = new Stopwatch();               stopwatch.Start();

               switch (Operation)               {                   case ("+"):                       result = calculatorClient.Add(firstOperand, secondOperand).ToString();                       break;

                   case ("-"):                       result = calculatorClient.Subtract(firstOperand, secondOperand).ToString();                       break;

                   case ("*"):                       result = calculatorClient.Multiply(firstOperand, secondOperand).ToString();                       break;

                   case ("/"):                       result = calculatorClient.Divide(firstOperand, secondOperand).ToString();                       break;               }

               stopwatch.Stop();

And, when we run the calculator, it looks like this:

Conclusions

In this post, we simply implemented the source as a Visual Studio 2010 project from the MSDN article on how to build a windows service using WCF.  It’s been pointed out that we are better off using named pipes for this kind of application for better performance, but our purpose here was just to elaborate on the existing application.

Hope this helps.