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).

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.

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!

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.

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.

This article will follow the previous article and go through the process of adding Converter’s for changing both the Id column and the Image column.  Basically, what we saw in the previous article was a DataGrid that was created and looked as follows.  (notice the Id column and the PKID columns which are highlighted.  Then, we will add a a DisplayItemTemplate that will format the page and make it look good.

What we are going to want to do is convert the Id column’s data from something that looks like “777” to “/Sessions?SpeakerId=777”.  We also will change the PKID column to change from showing a value like “222f32f83-8811” to http://localhost:52879/DisplayImage.ashx?sizex=60&PKID=222f32f83-8811”.  Then, we will apply a template that will make the page look like the following:

So, let’s get started.

First, we need to add two converters to the project.  Both are straight forward and I will not give much explanation besides saying they do exactly what was mentioned in the paragraph below the above picture.

Image Converter:

namespace BusinessApplicationSVCodeCamp

{

    public class ImageConverter : IValueConverter

    {

        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

        {

            throw new NotImplementedException();

        }

        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

        {

            string PKID = value.ToString();

            var s = Application.Current.Host.Source;

            int horizontalSize = 60;

            string path = String.Format("{0}://{1}:{2}/DisplayImage.ashx?sizex={3}&PKID={4}",

                s.Scheme, s.Host, s.Port, horizontalSize, PKID);

            return path;

        }

    }

}

Hyperlink Converter:

namespace BusinessApplicationSVCodeCamp
{
    /// <summary>
    /// NavigateUri="/Sessions?SpeakerId=2000" is what we want
    /// </summary>
    public class HyperLinkSessionsFormatter : IValueConverter
    {
        public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            throw new NotImplementedException();
        }

        public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
        {
            string sessionId = value.ToString();
            string path = String.Format("/Sessions?SpeakerId={0}",sessionId);
            return path;
        }

    }
}

Next, we need to add these converters to our Visual Studio 2010 Beta2 project as resources so we can use them in the DataGrid.  To do this, we use a very cool new feature in VS2010.  It’s a little indirect how we do this, but ultimately, it does make sense.  Just not very discoverable.  What we do is we bring up the properties editor for the DataGrid.  Notice below we are showing an icon next to the word “(Collection)”.  This is the icon you click that brings up the Collection Editors: Columns dialog.

How on the highlighted “Binding” property of the “idColumn”, you click the databinding icon and you will get the following binding dialog.

chose “Apply Data Binding” and you’ll get the following:

Nothing has to be done to the Source property.  This is already set to the the DomainDataSourceView we want.  The Path is already set to Id, which is also correct.  This all happened when we did the “Connect the dots” databinding with RIA Services.  That is, when we dragged the domain data service on top of the DataGrid.  We will need to set the Converter though so click on the currently unexpanded “Converters" control and you will see:

What this is telling us is that in the Presentation1 project, we have the two converters available to us.  We will need to add these to the project.  To do that, we have to do it one at a time.  First, click on HyperLinkSessionFormatter and you will see the following dialog.

When you press “Create New”, you will get a choice of which xaml to put the resource in as follows:

By default, it will put it in your current Navigation Page (Speakers.xaml), however, if you look at the drop down:

you’ll see that you can also put in other xaml files that may make more sense.  In our case, we are putting it in the Speakers.xaml file and when we press “OK”, it creates xaml as follows.

<navigation:Page.Resources>
   <my1:HyperLinkSessionsFormatter x:Key="HyperLinkSessionsFormatter1" />
</navigation:Page.Resources>

or

It also dropped in a namespace definition for us at the top of the file that looks like the following to reference the my1 prefix:

It seems like quite a few steps, however in practice, it’s very quick.  I won’t go through the same steps again, but you need to add the ImageFormatter converter the same way (see busy screen shot below for all steps combined into one).

Now, we’ve got xaml with two converters:

<navigation:Page.Resources>
        <my1:HyperLinkSessionsFormatter x:Key="HyperLinkSessionsFormatter1" />
        <my1:ImageConverter x:Key="ImageConverter1" />
</navigation:Page.Resources>

And, the columns of the DataGrid are bound to them correctly.  The xaml for that looks as follows:

This is hugely convenient, and not very error prone which as far as I’m concerned is very nice.

So, now when we run the page, we get the following:

Ugly, but you can see where we are headed.  Now, we create a DataTemplate (or we get Michael Scherotter to help us create one) that looks like the following:

<DataTemplate x:Key="SpeakersItemTemplate">
    <Grid >
        <!--<frameworkElement Margin="left,top,right,bottom  -->
        <StackPanel d:LayoutOverrides="Height" Margin="68,5,5,5">
            <StackPanel Orientation="Horizontal">
                <TextBlock x:Name="FirstName" Text="{Binding UserFirstName}"
                           Margin="0,0,6,0" FontFamily="Trebuchet MS" FontSize="16"
                           FontWeight="Bold"/>
                <TextBlock x:Name="LastName" Text="{Binding UserLastName}"
                           FontFamily="Trebuchet MS" FontSize="16" FontWeight="Bold"/>
            </StackPanel>
            <HyperlinkButton
                NavigateUri="{Binding Id, Converter={StaticResource HyperLinkSessionsFormatter1}}"
                Content="Sessions"/>
            <TextBlock x:Name="Description" Text="{Binding UserBio}"
                       TextWrapping="Wrap" FontFamily="Trebuchet MS" FontSize="12"/>
        </StackPanel>
        <Image  HorizontalAlignment="Left" Width="60" VerticalAlignment="Top"
                Source="{Binding Path=PKID, Converter={StaticResource ImagePathConverter1}}"  >
        </Image>
        <HyperlinkButton  Content="WebSite"  TargetName="_blank"
                          NavigateUri="{Binding UserWebSite}" VerticalAlignment="Top"
                          HorizontalAlignment="Right"/>
    </Grid>
</DataTemplate>

Then, when we add a listbox, rather than the DataGrid and bind it the same

<ListBox Height="600"
         ItemsSource="{Binding ElementName=speakersShort2009DomainDataSource, Path=Data}"
         ItemTemplate="{StaticResource SpeakersItemTemplate}"
         ScrollViewer.HorizontalScrollBarVisibility="Disabled"/>

We get something that looks pretty nice:

That’s it for this article.  In the next article we will actually talk about what happens when the Session hyperlink is pressed.  We know it will take us to the Sessions page, but how it filters the Sessions is worth reading about.

Well, if you have gotten this far in the series, you’ve probably realized I’ve gotten my articles and video’s a little out of sync.  The video attached here goes through the full process of building an application from scratch while adding a navigation page.  The process was somewhat explained in the previous article.  I’ve kept the title the same because that is what the video actually shows.

I won’t go through all the details again, however, what you will get at the end is a new speakers page which is just another tab on the home page that looks like the following.

In the next section, we will go through adding a SpeakerPageTemplate to style it and have it show up with actual pictures and hyperlinks.

For the past couple years, I’ve used a product called FinalBuilder from VSoft Technologies to automate my build processes.  Since I’ve been building web sites (about the past 5 years or so), one of the biggest hassles is maintaining them.  That is, updating the databases, deploying the web site, automating backups, etc.  I’ve used several products like FinalBuilder (including Cruise Control), and to be honest, none of them come close to the quality of FinalBuilder.

Basically, the way the product works is that you create a “project” file using the FinalBuilder IDE.  That project file has “Actions” in it which do things like “ftp” files to servers, rename files, iterate over sql scripts, parse and update files, checkout from source control, as well as hundreds of other convenient functions.  You then execute that “script” file and all the magic happens.

Then, VSoft has another product called FinalBuilder Server, which is really an asp.net web site that you run on your server.  That running web site can take one of your FinalBuilder scripts, and run it through a really nice dashboard (web page).

In my current scenario, I have 5 different web sites I can publish simply by pushing a button.  I log into the web page (dashboard), press “Start Build”, and behind the scenes this is what happens:

• A new temporary directory is created
• All My source code is exported from subversion into that directory
• All My Visual Studio Solutions are built
• All the config files (web.config,app.config, etc.) are updated with appropriate parameters (connection strings, etc.)
• The Web Site is copied to the correct location
• A Backup of the source is created an zipped into an archive directory
• The temporary directory and all it’s files are deleted

Of course, I really do more than this, but you get the basic idea.  It’s wonderful.  It’s not free, but worth every penny (not to mention the support is awesome).

Hope you get a chance to try it.  Here is a link to their site:

http://www.finalbuilder.com/home.aspx

Not sure how many times I’ve pressed the “Show All Files” menu choice on a Visual Studio 2008 Project and nothing happens.  Well, I think I have finally found the pattern.

My guess is that you actually have to be clicked on the solution itself for the Show All Files to work.  I think I’m usually on a directory inside the project and it doesn’t work. That is, I may be inside the /bin directory and expect that if I click “Show All Files” that I will see all the files in the bin directory (like the .config files).

So, post back if you know more about this.  This is just my best guess.

By the way, I’m blogging this in turbulence American Airlines flight 16 from San Francisco To New York City (JFK).  Wifi in the air is working great!!!

http://flightaware.com/live/flight/AAL16

So, how does the up to date work?  the way it works is when you get the latest from your version control, you simply right click on the vs2008 project and say “Deploy”.

It’s kind of a hassle though because you have to open the project first, the don this.

Here is a simple one line cmd file that you can use to do this task for you.

C:\Windows\Microsoft.NET\Framework\v3.5\MSBuild.exe /t:Deploy
  /p:Configuration="Debug";Platform="Any CPU" /v:normal /m
  "data\ThreePLogicDatabase\ThreePLogicDatabase.dbproj"
pause

That’s it!  hope this helps.

Richard has been developing a special training course for the Scrum development team.  He’s giving this course called “Scrum Developer Training” at the Microsoft Technology Center in just a few weeks (11/2-11/6).  If you have the opportunity, I can’t imagine a better thing to do to help improve you skills at being productive working in an engineering team.  You can register at the following URL:

http://www.regonline.com/Checkin.asp?EventId=780690

You can read more about the course here:  http://www.accentient.com/scrum.aspx

I hope you can make it!

So, the problem is you have a record that looks like this:

 public class LoadSegmentInfoFlat
        {
            public double? OriginLattitude { get; set; }
            public double? OriginLongitude { get; set; }
            public double? DestinationLattitude { get; set; }
            public double? DestinationLongitude { get; set; }
            public string Color { get; set; }
        }

You’ve created a list of these and defined it as follows:

var loadSegmentInfoFlats = new List<LoadController.LoadSegmentInfoFlat>();

Now, you want to create a unique list of Lattitude, Longitude Origins and Destinations by color.

The LINQ query that does the trick is a simple group by that creates an anonymous result (which is our answer).  Here is the LINQ query (thanks to my friend in the MSDN LINQ Forums, Lignzhi Sun).

var segments = from a in loadSegmentInfoFlats
               group a by
                   new
                       {
                           a.OriginLattitude,
                           a.OriginLongitude,
                           a.DestinationLattitude,
                           a.DestinationLongitude,
                           a.Color
                       }
               into grouplist
                   select
                   new
                       {
                           grouplist.Key.OriginLattitude,
                           grouplist.Key.OriginLongitude,
                           grouplist.Key.DestinationLattitude,
                           grouplist.Key.DestinationLongitude,
                           grouplist.Key.Color,
                           Count = grouplist.Count()
                       };

The resulting segments in Visual Studio 2008 debugger are as follows:

Hope this helps!

So, you have a GridView or DetailsView that has standard “Edit” “Update” “New” type command buttons on them.  The way they get there is by having the declaration something like this:

 <asp:DetailsView ID="DetailsView1" runat="server" Height="50px" Width="125px"
            AllowPaging="True" AutoGenerateRows="False" DataKeyNames="Id"
            DataSourceID="SqlDataSource1">
            <Fields>
                <asp:BoundField DataField="Id" HeaderText="Id" ReadOnly="True"
                    SortExpression="Id" />
                <asp:BoundField DataField="Name" HeaderText="Name" SortExpression="Name" />
                <asp:BoundField DataField="CampStartDate" HeaderText="CampStartDate"
                    SortExpression="CampStartDate" />
                <asp:BoundField DataField="CampEndDate" HeaderText="CampEndDate"
                    SortExpression="CampEndDate" />
                <asp:CommandField ShowEditButton="True" ShowInsertButton="True" />
            </Fields>
</asp:DetailsView>

What you want is to say something like:

“I only want admin’s to be able to add new rows so  want to hide the “new” button based on that”

So, first thing is to convert the field to a template from the following menu.  You do this by using the little helper in the upper right hand corner of the detailsview (in design mode), chose Edit Fields, CommandField, then convert to template (as in the picture below).

Then, you will have something like this:

 <asp:DetailsView ID="DetailsView1" runat="server" Height="50px" Width="125px"
            AllowPaging="True" AutoGenerateRows="False" DataKeyNames="Id"
            DataSourceID="SqlDataSource1">
            <Fields>
                <asp:BoundField DataField="Id" HeaderText="Id" ReadOnly="True"
                    SortExpression="Id" />
                <asp:BoundField DataField="Name" HeaderText="Name" SortExpression="Name" />
                <asp:BoundField DataField="CampStartDate" HeaderText="CampStartDate"
                    SortExpression="CampStartDate" />
                <asp:BoundField DataField="CampEndDate" HeaderText="CampEndDate"
                    SortExpression="CampEndDate" />
                <asp:TemplateField ShowHeader="False">
                    <ItemTemplate>
                        <asp:LinkButton ID="LinkButton1" runat="server" CausesValidation="False"
                            CommandName="Edit" Text="Edit"></asp:LinkButton>
                        &nbsp;<asp:LinkButton ID="LinkButton2" runat="server" CausesValidation="False"
                            CommandName="New" Text="New"></asp:LinkButton>
                    </ItemTemplate>
                    <EditItemTemplate>
                        <asp:LinkButton ID="LinkButton1" runat="server" CausesValidation="True"
                            CommandName="Update" Text="Update"></asp:LinkButton>
                        &nbsp;<asp:LinkButton ID="LinkButton2" runat="server" CausesValidation="False"
                            CommandName="Cancel" Text="Cancel"></asp:LinkButton>
                    </EditItemTemplate>
                    <InsertItemTemplate>
                        <asp:LinkButton ID="LinkButton1" runat="server" CausesValidation="True"
                            CommandName="Insert" Text="Insert"></asp:LinkButton>
                        &nbsp;<asp:LinkButton ID="LinkButton2" runat="server" CausesValidation="False"
                            CommandName="Cancel" Text="Cancel"></asp:LinkButton>
                    </InsertItemTemplate>
                </asp:TemplateField>
            </Fields>
</asp:DetailsView>

Now, you have standard <asp:LinkButton> so you can call the visible property from your codebehind like this:

 <asp:TemplateField ShowHeader="False">
                     <ItemTemplate>
                         <asp:LinkButton ID="LinkButton1" runat="server" CausesValidation="False" Visible='<%# GetShowEditButton() %>'
                             CommandName="Edit" Text="Edit"></asp:LinkButton>
                         &nbsp;<asp:LinkButton ID="LinkButton2" runat="server" CausesValidation="False" Visible='<%# GetShowInsertButton() %>'
                             CommandName="New" Text="New"></asp:LinkButton>
                         &nbsp;<asp:LinkButton ID="LinkButton3" runat="server" CausesValidation="False"
                             CommandName="Delete" Text="Delete" Visible='<%# GetShowDeleteButton() %>'     ></asp:LinkButton>
                     </ItemTemplate>
</asp:TemplateField>

Then, in your codebehind, you have the following:

 protected bool GetShowEditButton()
    {
        return Roles.IsUserInRole("Admin");
    }

    protected bool GetShowInsertButton()
    {
        return Roles.IsUserInRole("Admin");
    }
    protected bool GetShowDeleteButton()
    {
        return Roles.IsUserInRole("Admin");
    }
}

Hope you find this before spending a bunch of time reading about more complicated solutions.

William Bartholomew just published a new book on MSBuild and TFS. There is a great forward by Richard Hundhausen (Famous TFS Author and top MS consultant).  I personally don’t use TFS yet, but I do use MSBuild and plan on using it more extensively for web deployments going forward.  I have not yet read the book, but am anxiously looking forward to.  It is a topic that IMHO has been very under documented.  This should be a big help!

Microsoft Visual Studio 2010 Premium with MSDN Download – Download Direct from Microsoft

I’ll first try and explain in a nutshell what it is.  Then I’ll go through an example of creating a Visual Studio Database Project out of a site I’ve been working on to show the steps.  Finally, I’ll give a short summary reliving the experience and giving you some other pointers that may help you get through the experience.

What is VS2008 Database Edition?

Basically, what VS2008 does is to first process your existing schema into hundreds (maybe thousands) of little files.  That is, each file is one database thing. That thing might be a table definition, a stored procedure, a trigger, a constraint, a foreign key, etc.  The beauty of this is that now, each thing can be tracked separately.  Say for example, you want to update just one table and someone else on your team wants to update another table in the same schema.  Since the files are now separate files, it’s no problem.  When you grab the latest changes from source control, you will get your friends changes and he will get yours.  Very very clean!

Also, it has a very powerful comparison engine.  Say you update your data outside of this project.  VS2008 Database Edition will compare your definitions in all these little files with either a sql script you generate, or it will connect to an external database and compare to that.  Me personally, I like to use a tool called SqlManager to manage my data.  I can continue to do that, then when I’ve made my changes, I can simply connect VS2008 Database Edition to my updated development database and it will automatically figure out the changes.

So, you may ask, what version do I need to run this of Visual Studio?  The answer is in this link:  http://msdn.microsoft.com/en-us/vs2008/products/cc149003.aspx

Here We Go, Let’s do an Example

So, first, I will open my existing solution which has a web project in it, a data access project as well as other projects.  Then, I create the new Database solution by saying File/Open/New Project/Database Project.

Then, we follow the wizard…

Taking defaults…

Now, I choose my schema.

Press Start…

Once you’ve done that, you’ll now have your schema spread out across your project in little files.  Below is what the "file based" view of your schema looks like.

Notice that the file we are looking at also includes comments for both the table and the columns using the standard extended property documentation format as follows:

GO
EXECUTE sp_addextendedproperty @name = N'MS_Description',
@value = N'tracks all changes from each camp

title;link;guid;pubDate;category;description', @level0type = N'SCHEMA',
@level0name = N'dbo', @level1type = N'TABLE',
@level1name = N'CampFeed';

GO
EXECUTE sp_addextendedproperty @name = N'MS_Description',
@value = N'if true, this is the main news feed from the site.
there should only be one main news feed from any site.  this would
not be feeds like twitter', @level0type = N'SCHEMA',
@level0name = N'dbo',
@level1type = N'TABLE', @level1name = N'CampFeed',
@level2type = N'COLUMN', @level2name = N'PrimaryFeed';

Now, when you actually build the project as follows:

it will generate the full script combining all the files back into one again. Here is where it puts it:

So, that’s about it for now. I haven’t gone into any of the ways to compare and update your schema based on external changes, but we can leave that for another post.

To see a great video by Richard Hundhausen, President of Accentient, a Team Systems Consulting company, go to this link:  http://msdn.microsoft.com/en-us/vsts2008/cc659682.aspx

Also, if you are using Sql Server 2008, make sure you install visual studio 2008 sp1, then go to this link and install the download:  http://www.microsoft.com/downloads/details.aspx?FamilyID=bb3ad767-5f69-4db9-b1c9-8f55759846ed&displaylang=en

Conclusions

From what I can tell, this Visual Studio Database Edition will be a huge help in building database schema’s and database programs (sp’s, triggers,etc.) in a collaborative environment.   If you have the license to use this, I strongly recommend it.  It is definitely going to be part of my tool kit for now on.  Even if I’m the only author in the project.

Here is an example:

DataClassesGeneralDataContext db3pLogicContext;

db3pLogicContext.Log = Console.Out;

var companyQuery = from tbl in db3pLogicContext.Companies

                   where tbl.ParentId != 0

                   select tbl;

int totalCntParents = companyQuery.Count();

foreach (DBAccess.Company co in companyQuery)

{

    co.CreateDate = DateTime.Now;

    break;

}

db3pLogicContext.SubmitChanges();

Now, when you run the code, you can look on your debugger output and see something that looks like this:

Also, if you want to actually execute select type statements, take a look at the Query Visualizer posted on Scott Guthrie’s web site:

http://weblogs.asp.net/scottgu/archive/2007/07/31/linq-to-sql-debug-visualizer.aspx

I’m not a wizard at writing LINQ expressions so I often find myself in Google looking for something similar to what I want, then I put it into my application and run it. This has worked pretty well, but it takes a couple iterations to get it right. It occured to me that someone probably has written a LINQ interpreter so I just guessed the name, LINQPad, typed it into search, and I find the authors of the book C# 3.0 in a nutshell, Joseph Albahari and Ben Albahari, (which I like a lot) have written it.

I download it (it’s an exe file), run it (OK, I trust you guys somehow), and presto, I get a very nice interface that not only has tons of examples built into it with a nice tree view, but lets me make a connection to my database and run LINQ queries against it. It even cancels them when you create one that will run forever (very nice guys!).

So, the query I was going after is I have a huge list of cities that includes states. From that, I just want a unique list of states (this list does not have all the states so I want just the ones contained in it). Below is a screen shot of the LINQPad with my Query in it. I simply pressed the green triangle (trained by Sql Server Enterprise Manager), and presto, my list! Could not be much easier. This tool will be in my box for a long time.

Amazon.com: C# 3.0 in a Nutshell

Grab this now!  It’s a winner, believe me.

<%@ Page Language="C#" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<script runat="server">

    protected void Page_Load(object sender, EventArgs e)

    {

        LabelWhere.Text = System.Reflection.Assembly.GetExecutingAssembly().Location.ToString();

    }

</script>

<html xmlns="http://www.w3.org/1999/xhtml">

<head runat="server">

    <title></title>

</head>

<body>

    <form id="form1" runat="server">

    <div>

        <asp:Label ID="LabelWhere" runat="server" Text="Label"></asp:Label>

    </div>

    </form>

</body>

</html>

Hope this Helps!