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

So, let me explain by example. 

At the moment, I’m debugging the Silicon Valley Code Camp web site project and I’m checking a boolean I set called DoValidation.  I’m trying to figure out why it is changing, but first I have to figure out when.  So, I set a break point on the line as shown below:

Now, I hover over the variable I want to pin and press the little pin icon shown here:

I then see the following with my little watch window right in line with my code.

I can even click the little chevron under the pin and add a comment as I show next.

The nice thing is that this stays here just like your break point until you close it.  A very convenient feature.

This article is very short.  In the actual presentation, there was not much time to talk about this so a brief overview was done.  Basically, it’s all standard WCF stuff.  The idea is that the Silverlight Business Template adds logging in and supports Authentication just like an asp.net application does.  It uses the DomainDataSource to do the bridging between the silverlight clientside app, and the web application.  Authorization is built into the login module also so that you can assign attributes to your domainservice classes to restrict access.

That is, if you only want people who are logged in able to access one of your methods, you simply tag it as follows with the [RequiresAuthentication] attribute.

If you only want a certain logged in user role to be able to access a certain method, you tag it as follows

This of course solve the server side only.  On the client side, you need to call methods that are exposed through the domain data.  http://www.silverlightshow.net/items/Silverlight-3-with-Ria-Authentication-service.aspx discusses much of this on the client side.

In this section, we will talk about what happens when the users presses the “Sessions” hyperlink from the speakers page.  If you remember from the last article, we used a special converter on the Speakers.xaml page and bound that to the hyperlink titled sessions as shown below.

When this link is clicked, the navigation created is as follows:

http://localhost:9951/Presentation1TestPage.aspx#/Sessions?SpeakerId=903

// Executes when the user navigates to this page.

protected override void OnNavigatedTo(NavigationEventArgs e)

{

    //Handle SpeakerId

    var qs = NavigationContext.QueryString;

    if (qs.ContainsKey("SpeakerId"))

    {

        this.sessionsOverviewDomainDataSource.FilterDescriptors =

            new FilterDescriptorCollection();

        this.sessionsOverviewDomainDataSource.FilterDescriptors.Add(

              new FilterDescriptor("AttendeeId",

                  FilterOperator.IsEqualTo, qs["SpeakerId"]));

    }

}

This simply adds a filter to the current DomainDataSource that filters the column AttendeeId with the passed in query parameter SpeakerId.

The resulting page looks as follows assuming Peter Kellner’s Session link was clicked.

The video referenced in this article goes into building this page in more details, but fundamentally, the major point is just the query parameter.