c#

Help me build a great software development course

Noah — Tue, 09 Feb 2010 17:17:45 GMT

It looks like I might be giving a course on Beginning .NET Development to non developers with IT backgrounds. I'm putting together my lectures and it's really hard. I want to make sure that I explain things so others can understand them.

Even though this is a .NET course (with a web-based slant), I really see it as a fundamental software development (crash) course. You can’t become a great developer without understanding what’s going on behind the scenes. If you have any thoughts or advice on any of the topics at hand (am I missing a topic? are they poorly ordered? do you have a great analogy for something?) or just some general thoughts or advice, I'd be grateful if you would pass them along.

Here's what I have in regards to topics for the course:

Principals in software engineering

What are numbers (decimal, binary, hex)
Memory & microprocessors (rundown on how code gets executed)

Into to OOP

What's assembly language
C and low level languages
Beginning OOP (concepts relevant to OOP)

Microsoft .NET Platform

Native executable vs intermediate language (history, how it works)
Basic types & operators
Pass by Value vs reference
Using Visual Studio

Principals of web architecture

What's the internet?
State vs stateless

Fundamentals of ASP.NET

What is ViewState?
Configuration

Proficiency in C#

Basic structure
Flow control, ifs, fors, whiles, methods
OOP (classes, interfaces, polymorphism)
Generics*
Lambda expressions & functional programming*

* These topics might have to be left for the next, more advanced course depending on time contraints

Rx Framework Subscriber Actions are blocking

Noah — Thu, 28 Jan 2010 15:46:30 GMT

The NY ALT.NET Meetup group met last night and Scott Weinstein delivered a terrific presentation on the Reactive Framework (also known as Rx Framework). If you haven’t heard about it, the Rx Framework is a framework for composing (and consuming) asynchronous events.

The way that the framework works is that you subscribe to an IObservable and get notified of new events. Since this is all done async, one of my questions was whether a single subscriber’s consumption of these events is blocking (to itself) or not. That’s probably not the best way to phrase the question, but the code’s easy enough to understand. Anyway, Scott said he thought so, but it would be worth testing, so I did.

        1: static void Main(string[] args)

       2: {

       3:     var range = Observable.Range(1, 5)

       4:         .Subscribe((int i) =>

       5:     {

       6:         DateTime future = DateTime.Now.AddSeconds(5);

       7:         DateTime lastPrint = DateTime.MinValue;

       8:         if (i % 2 == 0)

       9:         {

      10:             while (DateTime.Now < future)

      11:             {

      12:                 if (DateTime.Now.Subtract(lastPrint).Milliseconds >= 900)

      13:                 {

      14:                     Console.WriteLine("Sleeping...");

      15:                     lastPrint = DateTime.Now;

      16:                 }

      17:             }

      18:         }

      19:         Console.WriteLine("Sleeper {0}", i);

      20:     });

      21:     Console.ReadLine();

      22: }

Basically, my IObservable is counting from 1 to 5 but taking it’s time on 2 and 4. So the question was, will the Action passed to the subscribe be called in order (each one blocks) or will we have some (like 3 and 5) called before others (like 2 and 4, which means they don’t block).

And the output shows that they block, which is what Scott (and I) expected since it really is the only way that makes sense, but it was worth a look-see.

Sleeper 1
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeper 2
Sleeper 3
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeper 4
Sleeper 5

In case you were worried though, other subscribers are not blocked just because one subscriber blocks itself.

       1: static void Main(string[] args)

       2: {

       3:     var range = Observable.Range(1, 5);

       4:     range.Subscribe((int i) =>

       5:     {

       6:         DateTime future = DateTime.Now.AddSeconds(5);

       7:         DateTime lastPrint = DateTime.MinValue;

       8:         if (i % 2 == 0)

       9:         {

      10:             while (DateTime.Now < future)

      11:             {

      12:                 if (DateTime.Now.Subtract(lastPrint).Milliseconds >= 900)

      13:                 {

      14:                     Console.WriteLine("Sleeping...");

      15:                     lastPrint = DateTime.Now;

      16:                 }

      17:             }

      18:         }

      19:         Console.WriteLine("Sleeper {0}", i);

      20:     });

      21:     range.Subscribe((int i) => { Console.WriteLine(i); });

      22:     Console.ReadLine();

      23: }

renders (and this obviously isn’t deterministic because this is all async, so it may be slightly different order every run, but it proves the point):

1
Sleeper 1
2
3
4
5
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeper 2
Sleeper 3
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeping...
Sleeper 4
Sleeper 5

.NET, XPath, and XmlNamespaceManager

Noah — Thu, 03 Dec 2009 19:16:49 GMT

Take the following XML fragment

        1: <?xml version="1.0" encoding="iso-8859-1"?>

       2: <con:search-results 

       3: xmlns:con="http://namespace.contoso.com/business-objects" 

       4: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

       5: xsi:noNamespaceSchemaLocation="http://www.contoso.com/dtd/syndication/biz-objects.xsd">

       6:     <con:search-query>ipod</con:search-query>

       7:     <con:result-count>2207</con:result-count>

       8:     <con:start-index>0</con:start-index>

       9:     <con:result-count>15</con:result-count>

      10:     <con:results>

      11:         <con:result>

      12:             ...

      13:

Now suppose you loaded this XML into an XmlDocument, how would you query for all the <con:result> nodes? Using XPath you’d write something like

       1: /search-results/results/result

So you might try writing something like

       1: XmlDocument doc = new XmlDocument();

       2: doc.LoadXml(response);

       3: var resultNodes = doc.SelectNodes("/search-results/results/result");

but you would find that resuldNodes would be null. You have to instantiate an XmlNamespaceManager to help correctly maneuver your namespaces. That’s done like so:

       1: XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);

       2: nsmgr.AddNamespace("con", "http://namespace.contoso.com/business-objects");

Then you would query your xml like so:

       1: var resultNodes = doc.SelectNodes("/con:search-results/con:results/con:result")

That took me a little searching to dig up, but it makes sense, right?

Find/Replace on Render – an MVC alternative to Response Filters

Noah — Mon, 16 Nov 2009 22:55:28 GMT

UPDATE 02/03/2010: You might NOT want to use this method as it screws up Page Caching: http://blog.statichippo.com/archive/2010/02/03/response.flush-and-the-crimes-against-page-caching.aspx

This post is sort of in response to another post of mine entitled Rendering ViewPage to random stream (or not). Back then I was looking for this solution. Now I found it!

If you’re not familiar with Response Filters, read the MSDN article and this quick example at aspnetlibrary.com. Basically, Reponse Filters are used to filter output before it gets sent downstream. This is useful if you want to, say, replace certain special characters.

Background & the existing Response Filter solution

I’m working on a Content Management System that does just this. Let’s say you want to create a page break in your page, you might have a <PAGEBREAK /> tag inside the content. This is a simple example, but there are more complex examples too, such as displaying Commerce info based on information in content.

The way this was done before was via Response Filters, but I wanted these special tags to be handled as each Page/Partial was rendered. There were a few reasons for this:

Using response filters meant storing the HTML to render outside of an ASPX page. I have seen people render ASPX pages for this kind of thing, but considering the logic for rendering a special tag in a Controller “felt” right, I didn’t want to go this route
The existing solution was using a separate filter for each tag. What that meant was that before the Response was sent downstream, it was converted into a String numerous times in order to do a Find/Replace (one time for each tag filter). Keep in mind that one tag might render another tag, so there is a bit of recursive goodness going on here too. Now this could also have been refactored so that a single Filter would do the Find and hand over the Replace to other classes, but, again, I wanted these tags to be rendered through a Controller in-pipeline with the pages that contain them.

IView, in-pipeline rendering solution

At first I thought it would be a pretty simple fix. I’d just create an IView that renders to a string and then do a find/replace. That’s basically what I did, however, this is harder than it sounds.

        1: public class MyView : WebFormView

       2: {

       3:     string _Masterpath;

       4:     string _ViewPath;

       5:  

       6:     public MyView(string viewPath)

       7:         : this(viewPath, null)

       8:     {

       9:     }

      10:     public MyView(string viewPath, string masterpath)

      11:         : base(viewPath, masterpath)

      12:     {

      13:         _Masterpath = masterpath;

      14:         _ViewPath = viewPath;

      15:     }

      16:     

      17:     public override void Render(ViewContext viewContext, System.IO.TextWriter writer)

      18:     {

      19:         string response = RenderToString(viewContext, writer);

      20:     

      21:         // WebFormView doesn't care about the writer arg

      22:         var outputTextWriter = viewContext.HttpContext.Response.Output; 

      23:         MyTagParser.RenderTags(response, viewContext, outputTextWriter);

      24:     }

      25: }

I created a class called MyView that inherits from WebFormView, since that’s the default we’re using anyway. You’ll notice the above code is missing the RenderToString() method. That’s what I had the hardest time on.

After some failed attempts, I did a quick google search and found this post on stackoverflow. The question was how to render a View to a String and Tim Scott had a great idea, which I ended up using. I just wish I thought of it!

The idea is basically to create a new MemoryStream and use it as your Response Filter. Render your View the normal way, but now it will be rendered to the MemoryStream instead of the Response. Now you can create a StreamReader to read the contents of the MemoryStream into a string.

Here’s that method:

       1: private string RenderToString(ViewContext viewContext, TextWriter writer)

       2:     {

       3:         string responseString = null;

       4:         var response = viewContext.HttpContext.Response;

       5:         response.Flush();

       6:         var oldFilter = response.Filter;           

       7:         Stream filter = null;

       8:         try

       9:         {

      10:             filter = new MemoryStream();

      11:             response.Filter = filter;

      12:             

      13:             base.Render(viewContext, writer);

      14:             response.Flush();

      15:             filter.Position = 0;

      16:             var reader = new StreamReader(filter, response.ContentEncoding);

      17:             responseString = reader.ReadToEnd();

      18:         }

      19:         finally

      20:         {

      21:             if (filter != null)

      22:                 filter.Dispose();

      23:  

      24:             response.Filter = oldFilter;

      25:         }

      26:         return responseString;

      27:     }

So, now that the I’m getting a string, it’s time for the Find/Replace code. That’s in the MyTagParser class with its helper methods (but missing the main, RenderTags method, below):

       1: public class MyTagParser

       2:     {

       3:         public static IDictionary<string, ITagParser> TagParsers = 

       4:             new Dictionary<string, ITagParser>(StringComparer.CurrentCultureIgnoreCase);

       5:         const int MAX_RECURSION = 50;

       6:         private const string k_RECURSION_COUNT = "tag_parser_recursion_count";

       7:  

       8:         private static Dictionary<string, string> GetTagParameters(string tag)

       9:         {

            Dictionary<string, string> paramDictionary = new Dictionary<string, string>();

            // Get param/value pairs

            Regex parameterRegex = new Regex("([a-z0-9]+)=\"([\\w\\s#|]*)\"", 

                    RegexOptions.IgnoreCase);

            foreach (Match paramMatch in parameterRegex.Matches(tag))

            {

                string paramName = paramMatch.Groups[1].Value;

                string paramValue = paramMatch.Groups[2].Value;

                paramDictionary.Add(paramName.ToLower(), paramValue);

            }

            // Get params with no value pair (e.g. "notable" in <zifftag notable>)

            Regex novalueRegex = new Regex("\\s\\b([a-z0-9]+)\\b(?!=)", 

                    RegexOptions.IgnoreCase);

            foreach (Match paramMatch in novalueRegex.Matches(tag))

            {

                string paramName = paramMatch.Groups[1].Value;

                paramDictionary.Add(paramName.ToLower(), null);

            }

            return paramDictionary;

        }

  

        private static ITagParser FindCorrespondingTag(string tagName)

        {

            ITagParser ziffTag = null;

            if (TagParsers.ContainsKey(tagName))

                return TagParsers[tagName];

            return null;

        }

        private static int IncrementRecursionCount(ViewContext viewContext)

        {

            IDictionary httpItems = viewContext.HttpContext.Items;

            if (!httpItems.Contains(k_RECURSION_COUNT))

                httpItems[k_RECURSION_COUNT] = 0;

            int recursionCount = (int)httpItems[k_RECURSION_COUNT];

            httpItems[k_RECURSION_COUNT] = ++recursionCount;

            return recursionCount;

        }

        private static void WriteTextToOutput(string origString, TextWriter writer, 

                int startOffset, int endOffset)

        {

            int length = endOffset - startOffset;

            string str = origString.Substring(startOffset, length);

            writer.Write(str);

        }

        // RenderMyTags() method below

    }

Since these tags can be nested, we don’t want infinite loops. I have a key that’s stored in the HttpContext Items to prevent this – if our count gets beyond MAX_RECURSION, we won’t process any more tags. Just an explanation of some of the regex:

Our tags aren’t HTML and can look like any of these examples:

And finally, the RenderMyTags method does all the manly work:

       1: public static void RenderMyTags(string origString, ViewContext viewContext, 

       2:     TextWriter writer)

       3:  {

       4:      if (string.IsNullOrEmpty(origString))

       5:          return;

       6:      int recursionCount = IncrementRecursionCount(viewContext);

       7:      int renderOffset = 0;

       8:  

       9:      Regex specialTagRegex = new Regex("<(SPECIAL[A-Z0-9]*)[^>]*>((.*?)</\\1>)?", 

        RegexOptions.IgnoreCase);

     MatchCollection specialTagMatches = specialTagRegex.Matches(origString);

  

     foreach (Match match in specialTagMatches)

     {

         // Write the text before this tag

         WriteTextToOutput(origString, writer, renderOffset, match.Index);

  

         if (recursionCount <= MAX_RECURSION)

         {

             string fullTag = match.Value;

             string tagName = match.Groups[1].Value;

             string innerText = string.Empty;

             if (match.Groups.Count == 4 /* has closing tag */)

                 innerText = match.Groups[3].Value;

             int trueMatchIndex = match.Index + renderOffset;

  

             ITagParser tagParser  = FindCorrespondingTag(tagName);

             if (tagParser != null)

             {

                 Dictionary<string, string> parameters = GetTagParameters(fullTag);

                 tagParser.RenderTag(viewContext, fullTag, innerText, parameters);

             }

         }

         renderOffset = match.Index + match.Length;

     }

  

     // Write the remaining text

     WriteTextToOutput(origString, writer, renderOffset, origString.Length);

     

 }

Regex blows up with NULL strings, so line 4 just checks for that. Line 7 keeps renderOffset – this helps us keep track of where we are in the string we’re processing. Imagine the following string:

SOME TEXT <SPECIALTAG> SOME MORE TEXT

We want to write out the SOME TEXT, then render the SPECIALTAG, then again write the SOME MORE TEXT.

The rest is pretty self explanatory.

Run generic tasks async (fluent-ly)

Noah — Mon, 09 Nov 2009 16:40:38 GMT

I saw a post entitled Run Async tasks with Fluent Interface written in response to another post entitled Async without the pain. I suppose this post is my response to those posts.

While I liked what I saw there, there were some things I wanted to add (like the ability to block until tasks complete), so I wrote my own class along the same lines. There are still some things I’d like to add (like the ability to queue tasks into jobs that run in order), but this works for me right now for what I’m doing.

        1: public class AsyncQueueManager

       2:     {

       3:         private ILog _logger = log4net.LogManager.GetLogger(typeof(AsyncQueueManager));

       4:         private ManualResetEvent _WaitHandle = new ManualResetEvent(true);

       5:         private int _QueueCount = 0;

       6:         object locker = new object();

       7:  

       8:         private Action<object> GetActionWrapper(Action<object> action)

       9:         {

            Action<object> actionWrapper = (object obj) =>

                        {

                            try

                            {

                                action(obj);

                            }

                            catch(Exception ex)

                            {

                                LogException(action, ex);

                            }

                            finally

                            {

                                lock (locker)

                                    _QueueCount = _QueueCount - 1;

                                SetWaitHandle();

                            }

                        };

            return actionWrapper;

        }

        public AsyncQueueManager Queue(Action<object> action)

        {

            lock(locker)

                _QueueCount = _QueueCount + 1;

            _WaitHandle.Reset();            

            Action<object> actionWrapper = GetActionWrapper(action);

            WaitCallback waitCallback = new WaitCallback(actionWrapper);

            ThreadPool.QueueUserWorkItem(waitCallback);

            return this;

        }

        private void SetWaitHandle()

        {

            if (_QueueCount == 0)

            {

                _WaitHandle.Set();

            }

        }

  

        public void WaitOne()

        {

            _WaitHandle.WaitOne();

        }

  

        public void WaitOne(TimeSpan timeout)

        {

            _WaitHandle.WaitOne(timeout);

        }

  

        private void LogException(Action<object> action, Exception ex)

        {

            string exceptionString = "Exception occured while running async operation." + 

                "  Details below." + Environment.NewLine +

                "Method name:" + action.Method.Name + Environment.NewLine +

                "Exception:" + ex.ToString();

            _logger.Error(exceptionString);

        }

    }

Running code is as simple as:

       1: int resultA;

       2: int resultB;

       3: int resultC;

       4: var async = new AsyncQueueManager();

       5: async.Queue((object obj) => {

       6:     int result = 0;

       7:     for (int i = 0; i < 1000000; i++)

       8:         result++;

       9:     resultA = result;

      10: });

      11: async.Queue((object obj) => {

      12:     int result = 1;

      13:     for (int i = 0; i < 1000000; i++)

      14:         result += 2;

      15:     resultB = result;

      16: });

      17: async.Queue((object obj) => {

      18:     int result = 1;

      19:     for (int i = 0; i < 1000000; i++)

      20:         result += 3;

      21:     resultC = result;

      22: });

      23: async.Wait(); // wait for these to complete in no particular order

      24:  

      25: Console.WriteLine("resultA: " + resultA);

      26: Console.WriteLine("resultB: " + resultB);

      27: Console.WriteLine("resultC: " + resultC);

Now you’d have to have a pretty slow machine for this to actually take any noticeable time, but you get the idea.

Notice of course how I can set local variables within my in-line Actions. This is because, as I understand it, the compiler actually creates a separate class to handle these since it knows where you’re going with this. Of course you could also call methods or do whatever you want here.