/atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">

  <title><![CDATA[Curried Functions]]></title>
  <link href="http://efvincent.github.io/atom.xml" rel="self"/>
  <link href="http://efvincent.github.io/"/>
  <updated>2014-08-18T13:03:44-04:00</updated>
  <id>http://efvincent.github.io/</id>
  <author>
    <name><![CDATA[Eric F. Vincent]]></name>
    
  </author>
  <generator uri="http://octopress.org/">Octopress</generator>

  
  <entry>
    <title type="html"><![CDATA[Debounce as a Directive]]></title>
    <link href="http://efvincent.github.io/blog/2014/08/18/debounce-as-a-directive/"/>
    <updated>2014-08-18T01:28:33-04:00</updated>
    <id>http://efvincent.github.io/blog/2014/08/18/debounce-as-a-directive</id>
    <content type="html"><![CDATA[<p>Some months ago a co-worker asked if there were a way to buffer the input on a text box
so that the handler would not be called more than every X milliseconds. His app was doing
the fairly typical chore of searching through a long list as the user types into a
search box. Firing a <code>digest</code> (that’s Angular’s re-bind and re-render loop) for each
keystroke causes a jumpy, jittery refresh storm.</p>

<p>What he was looking for is commonly referred to as to <em>debounce</em> or <em>throttle</em> a
function. There are many implementations around, but his question was specifically
about debounce in the context of Angular, preferably as a directive.</p>

<!-- more -->

<p>I found a snippet authored by <a href="http://tommaitland.net">Tom Maitland</a> that does just
what we need. I tweaked it slightly (also as a <a href="https://gist.github.com/efvincent/9784923">Gist</a>
and <a href="http://jsfiddle.net/efvincent/vkphp2fa/">JSFiddle</a>):</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
<a href="#n24" name="n24">24</a>
<a href="#n25" name="n25">25</a>
<a href="#n26" name="n26">26</a>
</pre></td>
  <td class="code"><pre><span class="comment">// Defines the module as &quot;app&quot;, this is not best practice for module</span>
<span class="comment">// definition or project structure, focus on the directive</span>
angular.module(<span class="string"><span class="delimiter">'</span><span class="content">app</span><span class="delimiter">'</span></span>, []).directive(<span class="string"><span class="delimiter">'</span><span class="content">tlDebounce</span><span class="delimiter">'</span></span>, <span class="keyword">function</span>(<span class="predefined">$timeout</span>) {
  <span class="keyword">return</span> {
    <span class="key">restrict</span>: <span class="string"><span class="delimiter">'</span><span class="content">A</span><span class="delimiter">'</span></span>,
    <span class="key">require</span>: <span class="string"><span class="delimiter">'</span><span class="content">ngModel</span><span class="delimiter">'</span></span>,
    <span class="key">priority</span>: <span class="integer">99</span>,
    <span class="function">link</span>: <span class="keyword">function</span>(scope, elm, attr, ngModelCtrl) {
      <span class="keyword">if</span> (attr.type === <span class="string"><span class="delimiter">'</span><span class="content">radio</span><span class="delimiter">'</span></span> || attr.type === <span class="string"><span class="delimiter">'</span><span class="content">checkbox</span><span class="delimiter">'</span></span>) <span class="keyword">return</span>;

      elm.unbind(<span class="string"><span class="delimiter">'</span><span class="content">input</span><span class="delimiter">'</span></span>);

      <span class="keyword">var</span> debounce;
      elm.bind(<span class="string"><span class="delimiter">'</span><span class="content">input</span><span class="delimiter">'</span></span>, <span class="keyword">function</span>() {
        <span class="predefined">$timeout</span>.cancel(debounce);
          ngModelCtrl.<span class="predefined">$setViewValue</span>(elm.val());
        }, attr.tlDebounce || <span class="integer">1000</span>);
      });
      elm.bind(<span class="string"><span class="delimiter">'</span><span class="content">blur</span><span class="delimiter">'</span></span>, <span class="keyword">function</span>() {
        scope.<span class="predefined">$apply</span>(<span class="keyword">function</span>() {
          ngModelCtrl.<span class="predefined">$setViewValue</span>(elm.val());
        });
      });
    }
  }
});
</pre></td>
</tr></table>
</div>

<h2 id="examining-the-directive">Examining the directive</h2>

<p>The directive starts at line 3 by defining a module and calling the <code>directive</code> function
which causes Angular to register a directive in that module. This directive is called <code>tlBounce</code>.
To define a directive we pass a function and our function returns a directive definition object.</p>

<h3 id="injecting-angulars-timer-service">Injecting Angular’s Timer service</h3>

<p>The debounce directive will use a timer to assure that when attached to a text box, the underlying
model will only be updated every X milliseconds. We’ll see the algorithm in a bit.</p>

<p>When Angular needs an instance of our directive, it will call the function we’ve provided. Angular
will inspect the function and detect that it has a dependency; to call the function Angular must
provide, or <em>inject</em> something called <code>$timeout</code>, which is one of Angular’s services. Angular offers
many <em>services</em> to you as the application developer to use in creating a directive (or factory,
filter, controller, or the other Angular things). These services are objects or functions provided by the framework.</p>

<p>The tip-off that <code>$timeout</code> is a service is the leading dollar sign. Angular will use its
<a href="https://docs.angularjs.org/api/auto/service/$injector#!">Injector</a> service to find a <code>$timeout</code> and pass it
to us. We’ll then use the <code>$timeout</code> in our <em>link function</em>.</p>

<h3 id="the-link-function">The link function</h3>

<p>Without getting into the guts of directive development, suffice it to say that in most
cases when writing a directive you’ll want to focus on the <code>link</code> function. For more information
on the link function, there’s the <a href="http://angularjs.org/">Angular Docs</a>, and another good source of information is
<a href="http://www.angularjshub.com/examples/customdirectives/compilelinkfunctions/">AngularJS Hub</a>.</p>

<p>The <code>link</code> function sets up each instance of the directive. You supply the function that can have
up to four parameters. <code>link: function(scope, elm, attr, ngModelCtrl)</code>.</p>

<h4 id="link-function-parameters">Link function parameters</h4>

<p>The first is the directive’s local scope, which is usually used like you use scope in a controller
to maintain and bind to the internal state of the directive. We’ll see how <code>scope</code> is used here in a second.</p>

<p>Second is the <code>elm</code> or <em>element</em> parameter. This is the DOM element that the directive to which the
directive is attached. For debounce, the directive is attached to an input, usually a text box. You can do the
usual DOM-stuff to the element, attach event handlers, change content, add children, etc. AAMOF you actually
have an Angular wrapper around the element, so you get some additional JQuery like functions on the element.</p>

<p>Third is <code>attr</code>, the attributes. This is a map of the attributes on the element to which our directive is
attached. In our case, we’re using the <code>attr</code> to detect if we’re attached to a radio button or check box; our
deBounce doesn’t have a meaning for those controllers, so we bail if we see that we’re attached to one (line 9).</p>

<p>Lastly is the <code>ngModelCtrl</code>, which is the least intuitive. This is a controller requirement of our directive,
it says that any directive we’re attached to needs to have an <code>ngModelCtrl</code> controller. This sort of limits
our deBouncer, but the target use case is to put this directive on a text box that’s using AngularJS’s binding.</p>

<h3 id="debounce-algorithm">DeBounce Algorithm</h3>

<p>The strategy is as follows:</p>

<ol>
  <li>Detach the input handler (line 11) that usually updates the model</li>
  <li>Bind a new input handler
    <ol>
      <li>Cancel any pending debounce timer (line 15)</li>
      <li>Set up a new debounce timer
        <ol>
          <li>It should go off in the time specified by the <code>tl-debounce</code> attribute, or 1,000ms if the attribute is
 not specified (line 18).</li>
        </ol>
      </li>
      <li>When it goes off, it should tell the model controller <code>ngModelCtrl</code> to set it’s value <code>.$setViewValue(elm.val())</code></li>
    </ol>
  </li>
  <li>Bind a new blur handler, so when th user leaves the field the model is always updated.
    <ol>
      <li>Put the call to <code>$setNewValue()</code> inside a <code>scope.apply()</code> so the change causes a digest (Angular rebinds everything).</li>
    </ol>
  </li>
</ol>

<h3 id="the-digest">The Digest</h3>
<p>One important point - you may be thinking that you could have used the standard JavaScript timer. Why
use Angular’s <code>$timer</code> service? It’s because Angular needs to know when the model changes so that it
can perform it’s two way binding / model-view synchronization. By using Angular’s timer, you can be assured
that Angular will know when the timer goes off and will do all the right Angular binding stuff at that time.</p>

<h3 id="but-eric-youre-wrong-and-oh-so-stupid">But Eric, you’re wrong and oh so stupid!</h3>
<blockquote>
  <p>You <strong>could</strong> use the normal timer, because when you call <code>.$setViewValue()</code>
you’re letting Angular know something needs to change, right? I mean, it starts in a dollar sign,
so it’s all Angulary, right?  </p>
</blockquote>

<p>Heh. You’d think so, but you’d be wrong. This is the kind of thing that makes you scratch your head, then waste
fifteen minutes, then look up the docs, then unleash a stream of profanities. It happens that <code>.$setViewValue()</code> does
<strong>not</strong> cause a digest, probably because of performance or some other really good reason. Doesn’t make it fun though, and
it’s the kind of undiscoverable crap that qualifies as a legit complaint about AngularJS. Take your medicine.</p>

<p>So that’s DeBounce - it actually works pretty well for things like text boxes that do searches and stuff like that.
I use it in production, but there’s no warrentee so YMMV. Have a good one…</p>

<p>-e</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[GitHubify(Blog)]]></title>
    <link href="http://efvincent.github.io/blog/2014/08/15/Octopress-github-ruby-windows/"/>
    <updated>2014-08-15T12:00:11-04:00</updated>
    <id>http://efvincent.github.io/blog/2014/08/15/Octopress-github-ruby-windows</id>
    <content type="html"><![CDATA[<p>For my shiney new blog I decided to go full hipster and host on GitHub. This means that
the entire site, source code as well as the blog website itself, can be seen at
<a href="https://github.com/efvincent/efvincent.github.io">my blog’s repository</a>. Of course all of this will be painfully
uncool by this time next year. But for the time being it’s fun and the tech is relevant.</p>

<p>Dig in if you want to see the ins and outs of setting all this up on a Windows workstation,
because Windows is so far out of fashion stuff is starting to not work on it by default. Karma.
<!--more -->
## Static Site Generation
The way GitHub hosted web sites work is that the entire web site is pure static HTML,
JavaScript, and CSS. If you work in the industry you realize that all the web site
frameworks (server side) like JSP, ASP.NET, Rails, PHP, etc. all <em>generate</em> pages on
the fly as the requests come in. This requires a server be running somewhere that can
run .NET, Java, Ruby, or whatever.</p>

<p>A static site everything is pre-generated, so any server that can respond to requests
by serving up a file can host a static site. But no one want’s to hand craft HTML pages
for every blog post. So what you have is a generator; some kind of program that can take
blog posts written in plain text and <strong>poof!</strong> Generate a static website.</p>

<p>The basic idea is that you have a <em>source</em> directory that has your blog posts written
in (typically) <a href="https://en.wikipedia.org/wiki/Markdown">markdown</a>, CSS, templates for HTML,
and the Ruby / JavaScript / whatever that the generator is written in.</p>

<p>There’s typically a command line interface; so you issue the proper command the
generator takes your markdown and creates a complete, static web site.</p>

<h2 id="github">GitHub</h2>
<p>That’s where <a href="www.github.com">GitHub</a> comes in. If you don’t know what GitHub is, or
if you’re completely lost at this point, then you probably need to hit up this
<a href="https://www.youtube.com/watch?v=oHg5SJYRHA0">everything you need to know to become a modern developer</a>
tutorial.</p>

<p>Think about it for two seconds, it makes perfect sense. GitHub hosts files in a repository and is a web site.
So if you put a static web site’s worth of files <em>in a repository</em>, and GitHub does a tiny bit of magic, it
can serve those web pages up. And that’s all a GitHub hosted static site is. You write posts in
markdown, you use a generator to create a static site, and you check it into GitHub.</p>

<h2 id="octopress">OctoPress</h2>
<p>I admittedly don’t have a ton of experience with static site generators. I played with
a couple before committing to <a href="www.octopress.org">Octopress</a>. At first I wanted to
use a <a href="http://nodejs.org">Node.js</a> based static site generator. I googled around a bit
and ended up playing with <a href="https://github.com/jnordberg/wintersmith">Wintersmith</a> for
a night. It worked, but GitHub makes it easiest to use a Ruby based generator called <a href="http://jekyllrb.com">Jekyll</a>.
A bit more poking around and I ended up with <a href="www.octopress.org">Octopress</a>, which is
built on top of Jekyll, offers additional features, and incredibly well written, well
documented, and easy to use.</p>

<p>When you go to their site you’ll get walked through the installation step by step,
and there are some nice Ruby build tools available to get things moving, including
configuring your new Octopress generator to work with GitHub web sites. <strong>Highly recommended</strong></p>

<h2 id="ruby">Ruby</h2>
<p>Ok so <a href="https://www.youtube.com/watch?v=gBkDvqIGSaE">Ruby hates Windows</a>. It might be passive,
but the ill feelings are there. Which is fine, everyone can’t love everyone, and Microsoft
has kinda earned it by being a dick until very recently. But whatever, I’m not with starting
flame war. It happens that I still use Windows for all kinds of reasons, so I needed to
get Ruby on my workstation.</p>

<p>Actually I had installed Ruby using <a href="http://chocolatey.org/">Chocolately</a> because I
love playing with all the languages, but to run Jekyll you’ll need the
<a href="http://rubyinstaller.org/downloads/">Ruby Development Kit</a>. The RDK is platform
specific, and is needed to build <em>gems</em> (Ruby packages) that are platform specific,
which Jekyll either is or depends on indirectly (I didn’t check).</p>

<p>There are <a href="https://github.com/oneclick/rubyinstaller/wiki/Development-Kit">very clear instructions</a>
that you can follow for getting this set up. Once that’s done you can play along with
the <a href="www.octopress.org">Octopress</a> setup instructions, which are great. Just follow the
track that has you deploy to GitHub.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Abandonment Issues]]></title>
    <link href="http://efvincent.github.io/blog/2014/08/15/abandonment-issues/"/>
    <updated>2014-08-15T11:52:11-04:00</updated>
    <id>http://efvincent.github.io/blog/2014/08/15/abandonment-issues</id>
    <content type="html"><![CDATA[<p>I’ve moved my blog from WordPress on my own personal site to GitHub, because … GitHub of course. <em>No One</em> is going
to miss my other blog. It had a couple of what I thought were interesting posts on F# and dependency injection in C#. But it’s time
for a fresh start.</p>

<p>Expect posts on JavaScript and front end development for a little while. After a career spent designing relational
databases for finance, insurance and other LOB domains, I’ve been working on SPA style front end enterprise applications for
a couple of years. And it’s fun. I may actually have a couple of interesting things to say. We’ll see.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[DI – Constructor Injection, Bootstrapping]]></title>
    <link href="http://efvincent.github.io/blog/2011/06/24/di-bootstrap/"/>
    <updated>2011-06-24T02:07:31-04:00</updated>
    <id>http://efvincent.github.io/blog/2011/06/24/di-bootstrap</id>
    <content type="html"><![CDATA[<h2 id="constructor-injection">Constructor Injection</h2>
<p>The idea of dependency injection is that classes are defined such that any dependencies on other classes or services, are <em>injected</em> into the class by some external mechanism, as opposed to being “newed up” directly. The most common form of DI is constructor injection, where a class defines a constructor that has as its parameters the external dependencies required by the class.
<!-- more -->
There are several benefits to this particular method of injection; the most obvious is that in a well designed system the dependencies of a class are clearly visible in the constructor. In the <a href="http://blog.efvincent.com/practical-di-101">DI 101</a> post a data provider was defined like this:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
</pre></td>
  <td class="code"><pre><span class="directive">public</span> <span class="type">class</span> <span class="class">DevDataProvider</span> : IDataProvider {
    <span class="directive">private</span> readonly IIdentService _identService;
    <span class="directive">private</span> readonly ILogService _logSvc;
    <span class="directive">private</span> <span class="directive">static</span> readonly <span class="predefined-type">List</span>&lt;Employee&gt; EmployeeStore = <span class="keyword">new</span> <span class="predefined-type">List</span>&lt;Employee&gt;();

    <span class="directive">public</span> DevDataProvider(IIdentService identService, ILogService logSvc) {
        <span class="keyword">if</span> (identService == <span class="predefined-constant">null</span>) <span class="keyword">throw</span> <span class="keyword">new</span> ArgumentNullException(<span class="string"><span class="delimiter">&quot;</span><span class="content">identService</span><span class="delimiter">&quot;</span></span>);
        <span class="keyword">if</span> (logSvc == <span class="predefined-constant">null</span>) <span class="keyword">throw</span> <span class="keyword">new</span> ArgumentNullException(<span class="string"><span class="delimiter">&quot;</span><span class="content">logSvc</span><span class="delimiter">&quot;</span></span>);
        _identService = identService;
        _logSvc = logSvc;
    }

    <span class="comment">// Remaining implementation omitted for brevity</span>
}
</pre></td>
</tr></table>
</div>

<p>The constructor is on line 6. From this constructor we can see that the DevDataProvider has dependencies on an IIdentityService and an ILogService. There should be no other dependencies in the class other than to well known, stable libraries like the <a href="http://msdn.microsoft.com/en-us/library/hfa3fa08.aspx">BCL</a>.</p>

<p>There are other advantages to using constructor injection. Should the list of dependencies get too long, say longer than four parameters, you’ve got a code smell that perhaps the class is doing too much, violating the single responsibility principal.</p>

<h2 id="bootstrapping">Bootstrapping</h2>

<p>In order to be able to resolve dependencies, the DI container must be configured. This set up is done during the <strong>bootstrapping</strong> phase. Typically this only needs to be done once, but changes to the container make sense in some scenarios like when a DI container is being used to support extensions or plug-ins. In that case components might be added or removed from the DI container while the app is running. These scenarios are out of scope for this post.</p>

<p>The container may be configured in several ways – Auto configuring, configuration in code, and configuration files (typically XML / app or web.config files). My current favorite DI framework is AutoFac, and I typically configure in code, but different projects will have different demands, so familiarize yourself with the specifics of your selected framework and understand the tradeoffs involved in the different types of configuration. You can even configure the DI container using more than one method – perhaps Auto configuring for the bulk of the registrations, then code or XML for more specific configuration needs.</p>

<h2 id="bootstrapping-a-console-application">Bootstrapping a Console Application</h2>

<p>Depending on the type of application you’re working on, there are specific places for bootstrapping to take place. The <em>place</em> to do configuration and bootstrapping is sometimes referred to as the <strong>composition root</strong> <em>(you can read about these concepts in more detail in <a href="http://www.manning.com/seemann/">Mark Seeman’s Dependency Injection</a> book, published by Manning)</em>.</p>

<p>In a console application, the static Main() method is a typical place to configure the container. While we rarely write console apps in production (at least I rarely do), the simplicity makes it easy to see the implications of the bootstrapping procedure.</p>

<p>In the following sequence diagram, in step one [1] the Main() entry point is called on the console application. Main() is serving as the composition root. From there a private Bootstrap() methods is called [2] and the DI container is configured. The exact mechanism varies by framework.</p>

<p><a href="http://blog.efvincent.com/wp-content/uploads/2011/06/Capture.png"><img src="http://blog.efvincent.com/wp-content/uploads/2011/06/Capture_thumb.png" alt="Capture" /></a></p>

<p>Once the container is configured, the main entry point requests that the DI container resolve the App type [3]. The DI container creates whatever dependencies are required by the App [4]. This happens hierarchically; dependencies may themselves have dependencies and so on. The DI container sorts all this out and is also responsible for lifetimes of create objects etc. The DI container can create and return the instance off the App [5]. The Main() function can then pass control to the app [6] which will leverage the injected dependencies [7] to do the real work.</p>

<h2 id="only-directly-reference-the-di-container-in-the-bootstrapper">Only Directly Reference the DI Container in the Bootstrapper</h2>
<p>This is an important point, and if you get nothing else from this post, understand this.</p>

<ul>
  <li>The DI container is configured in the composition root (Main() in this case)</li>
  <li>The DI container is used to resolve or build the App</li>
  <li>The app is then run to do the work</li>
</ul>

<p>Once the app is instantiated, it should have all of its dependencies injected. <strong>The app should not have a reference to the DI container!</strong> If we allow the app or any of its dependencies to have access to the container, then several bad things happen:</p>

<h4 id="weve-taken-on-a-dependency-to-the-di-container-itself">We’ve taken on a dependency to the DI Container itself</h4>

<p>Yes its true that the assembly has a dependency on the DI container. But for purposes of this discussion the assembly is not the application. The App class and the services (other classes) it depends on is the application. We don’t want to take a dependency on the DI container in those classes; rather, we should be able to switch to a different DI container if needed and not effect the App and the dependent services.</p>

<p>In any kind of a significant application the app’s classes would be in a different assembly, and services might be scattered across even more assemblies, and those should not have a dependency on a DI container. They should however be designed and built with the DI pattern in mind – with the dependencies specified in the constructor, with references to abstract types or interfaces, rather than to concrete implementations.</p>

<h4 id="were-hiding-a-dependency-inside-the-app">We’re hiding a dependency inside the App</h4>

<p>Earlier I mentioned that a benefit of constructor injection is that the dependencies are clearly visible (even <em>documented</em> if you will) in the signature of the constructor. We really don’t want to see lines like this buried in the methods of the classes:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
</pre></td>
  <td class="code"><pre><span class="comment">// Anti-pattern - don't use DI container except</span>
<span class="comment">// in composition root</span>

var dal = <span class="predefined-type">Container</span>.Resolve&lt;IDataAccessService&gt;();

<span class="comment">// And defintely don't do this</span>

var dal = <span class="keyword">new</span> SqlDataAccessService(connectString);
</pre></td>
</tr></table>
</div>

<p>A class that that has these lines buried inside somewhere has hidden dependencies on both the DI container and IDataAccessService (or worse, by using the new keyword directly, on the SqlDataAccessService). These hidden dependencies undermine the benefits of using DI containers at all.</p>

<h3 id="bootstrapping-in-other-application-types">Bootstrapping in other Application Types</h3>

<p>Other types of apps have different places for bootstrapping and application roots. Unlike a console app, an ASP.NET MVC 3 application isn’t top-down linear, the application must respond to web requests. It does so by creating instances of controllers, and calling methods on those controllers to respond to web requests.</p>

<p>A controller in MVC3 is like the app was in our console example above. It will be resolved, or created, by the DI container. Controllers are different in that there will likely be several different controllers in an MVC application. Also, we don’t get to resolve a controller and tell it to run right from the composition root, the ASP.NET MVC framework will be receiving web requests and will need to resolve controllers later, after bootstrapping.</p>

<p>In ASP.NET MVC 3 this is accomplished by providing a <em>hook</em>, or a place where we can supply a DI container for ASP.NET MVC 3 to use when creating controllers. The developer configures the DI container, and then wires that container into the MVC framework via an instance of IControllerActivator. In the case of AutoFac, there’s a <a href="http://nuget.org/List/Packages/Autofac.Mvc3">NuGet package called AutoFac.Mvc3</a> that includes classes to integrate with MVC3. The implementation details are beyond the scope of this post – just <a href="http://duckduckgo.com/">DuckDuckGo</a> AutoFac.Mvc and find a wealth of additional detail. Same goes for WCF, WPF, and Silverlight applications. There are best practices for configuring DI containers for each app type.</p>

<h3 id="di-unfriendly-application-types">DI Unfriendly Application Types</h3>

<p>Some application types just do not lend themselves very easily to dependency injection patterns. Classic ASP.NET pops into mind immediately. It was written before Microsoft was as willing to accept OSS, community driven concepts such as DI Containers. A big red flag with ASP.NET is that all subclasses to the Page class (which is what all your ASP.NET pages are) must have a parameterless default constructor. Well there goes parameter injection!</p>

<p>There are other mechanisms for implementing DI patterns in this case, but they’re sub-optimal. Again I’d refer you to <a href="http://www.manning.com/seemann/">Mark Seeman’s Dependency Injection</a> book, which is far and away the best DI book in the .NET space, for advice and examples in dealing with DI unfriendly application types.</p>

<h3 id="in-summary">In Summary</h3>

<p>Hopefully this was helpful in your understanding of a couple of key aspects of using DI containers. Practice a few console applications, and write some tests too. Once you get the idea, move on to more interesting application types. Before long you’ll be shocked you ever wrote applications <em>without</em> some degree of dependency injection. Yea – it’s that good for you.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[A Taste of Dependency Injection, Testing, and Mocking]]></title>
    <link href="http://efvincent.github.io/blog/2011/05/27/di-mock/"/>
    <updated>2011-05-27T20:28:53-04:00</updated>
    <id>http://efvincent.github.io/blog/2011/05/27/di-mock</id>
    <content type="html"><![CDATA[<p><a href="http://blog.efvincent.com/practical-di-101">My last post</a> provided a brief introduction into dependency injection. To review, the example included a data provider for Employee objects, which included a feature to return the object corresponding to the currently logged in user. In the end the following interfaces were defined:</p>

<p><strong>IDataProvider</strong> – the function is obvious from the name. One implementation, the DevDataProvider, uses a static List<employee> as a data store.</employee></p>

<p><strong>IIdentityService</strong> – describes a service that supplies the <em>current</em> identity. What current is depends on the implementation of course. A concrete WindowsIdentService defines current as the currently logged in Windows user. The TestIdentService implementation always returned the same username, which is useful for testing as we will see.</p>

<p><strong>ILogService</strong> – describes a simple logging service. The ConsoleLogService implementation prints logs to the console.</p>

<!-- more -->
<p>### Dependency Injection &amp;Testing</p>

<p>For this post I’ve added a standard MSTest project and a couple of tests for the data provider. The use of dependency injection patterns in the design of this simple example allows us to easily isolate the code under test.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
</pre></td>
  <td class="code"><pre><span class="directive">static</span> IContainer afContainer;

[ClassInitialize]
<span class="directive">public</span> <span class="directive">static</span> <span class="type">void</span> TestInit(TestContext ctx) {
    var idSvc = A.Fake&lt;IIdentService&gt;();
    A.CallTo(() =&gt; idSvc.GetCurrentUserName())
        .Returns(<span class="string"><span class="delimiter">&quot;</span><span class="content">FAKE-ID</span><span class="delimiter">&quot;</span></span>);

    var bldr = <span class="keyword">new</span> ContainerBuilder();
    bldr.RegisterInstance(idSvc);
    bldr.RegisterInstance(A.Fake&lt;ILogService&gt;());
    bldr.RegisterType&lt;DevDataProvider&gt;().As&lt;IDataProvider&gt;();
    afContainer = bldr.Build();
}
</pre></td>
</tr></table>
</div>

<p>The test class has a static DI container instance, initialized in the class initializer. I’m using <a href="http://code.google.com/p/fakeiteasy/">FakeItEasy</a> to create a fake IIdentService at line five. Like six tells the FakeItEasy framework what to return when the GetCurrentUserName() method is called on the fake ident service. Having a fixed response makes testing the data provider a piece of cake.</p>

<p>I then register the fake ident service as well as a fake log service. For the log service, we don’t need to specify any behavior for the methods. The FakeItEasy framework will effectively sink any calls to the methods of the fake log service, which is fine for this test.</p>

<p>Lastly the data provider we want to test is registered with the DI container builder, and then container is built. The tests go on to use the DI container to resolve an instance of the data provider. The DI container will configure the data provider’s dependencies for a log service and an identity service with the fakes we built.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
</pre></td>
  <td class="code"><pre>[TestMethod()]
<span class="directive">public</span> <span class="type">void</span> GetCurrentEmployeeTest() {
    var e = <span class="keyword">new</span> Employee { WindowsUsername = <span class="string"><span class="delimiter">&quot;</span><span class="content">FAKE-ID</span><span class="delimiter">&quot;</span></span> };
    var dal = afContainer.Resolve&lt;IDataProvider&gt;();
    dal.AddEmployee(e);
    var result = dal.GetCurrentEmployee();
    Assert.AreEqual(e.WindowsUsername, result.WindowsUsername);
}
</pre></td>
</tr></table>
</div>

<p>This is just a small example of using a DI container in combination with a mock / fake framework for testing. The AutoFac DI container can handle much more complex scenarios than what we’ve thrown at it here. The same is true for the FakeItEasy component. Both of these components are well used, well maintained open source projects. You can find lots of documentation and examples for both. Or you can use any number of other DI containers and mocking frameworks to achieve equivalent results.</p>

<p>The source code for the example is available <a href="https://bitbucket.org/efvincent/blog-post-dependency-injection-101">here</a>, and the blog entry the precedes this one is available <a href="http://blog.efvincent.com/practical-di-101/">here</a>.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Practical Dependency Injection 101]]></title>
    <link href="http://efvincent.github.io/blog/2011/05/27/practical-di-101/"/>
    <updated>2011-05-27T13:08:27-04:00</updated>
    <id>http://efvincent.github.io/blog/2011/05/27/practical-di-101</id>
    <content type="html"><![CDATA[<p>In this post we take a look at dependency injection (DI). Target audience is competent .NET developers, C# specifically (but VB’ers who read C# can benefit just as much), who’ve heard of DI but haven’t gotten around to figuring out how it fits in their day to day.</p>

<!-- more -->
<p>### What is Dependency Injection</p>

<p>The first question that we need to address is: What is it that DI does for us? What problem is being solved? DI is about coupling; the degree to which program unit refers to other units. In .NET the units we’re typically worried about are classes, interfaces, components, and assemblies. Dependency injection facilitates reduction these interdependencies. Are DI patterns a silver bullet? Of course not. You can always write bad code regardless of patterns. That being said, if you’re already writing decent code and have good fundamentals, but are not using DI patterns, you’ve got the opportunity to take a leap forward.</p>

<p>How does DI reduce help reduce coupling? The easiest way to describe it is by diving directly into an example.</p>

<h3 id="example-scenario">Example Scenario</h3>

<p>We’ll work on a hypothetical in-house app where the Windows AD authenticates employees, and their Windows username is used to index a database with Employee information. It’s pretty common to see stuff like this happening in-house with line of business applications.</p>

<p>The example uses a provider pattern – all the data access will go through a data access provider, allowing us to build a simple provider that stores records in memory during this, our prototype phase. Theoretically we’d replace this as development continued with a provider that leverages persistent storage later.</p>

<p>Here’s the base level example program with no consideration for dependency injection:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
<a href="#n24" name="n24">24</a>
<a href="#n25" name="n25">25</a>
<a href="#n26" name="n26">26</a>
<a href="#n27" name="n27">27</a>
<a href="#n28" name="n28">28</a>
<a href="#n29" name="n29">29</a>
<strong><a href="#n30" name="n30">30</a></strong>
<a href="#n31" name="n31">31</a>
<a href="#n32" name="n32">32</a>
<a href="#n33" name="n33">33</a>
<a href="#n34" name="n34">34</a>
<a href="#n35" name="n35">35</a>
<a href="#n36" name="n36">36</a>
<a href="#n37" name="n37">37</a>
<a href="#n38" name="n38">38</a>
<a href="#n39" name="n39">39</a>
<strong><a href="#n40" name="n40">40</a></strong>
<a href="#n41" name="n41">41</a>
<a href="#n42" name="n42">42</a>
<a href="#n43" name="n43">43</a>
<a href="#n44" name="n44">44</a>
<a href="#n45" name="n45">45</a>
<a href="#n46" name="n46">46</a>
<a href="#n47" name="n47">47</a>
<a href="#n48" name="n48">48</a>
<a href="#n49" name="n49">49</a>
<strong><a href="#n50" name="n50">50</a></strong>
<a href="#n51" name="n51">51</a>
<a href="#n52" name="n52">52</a>
<a href="#n53" name="n53">53</a>
<a href="#n54" name="n54">54</a>
<a href="#n55" name="n55">55</a>
<a href="#n56" name="n56">56</a>
<a href="#n57" name="n57">57</a>
<a href="#n58" name="n58">58</a>
<a href="#n59" name="n59">59</a>
<strong><a href="#n60" name="n60">60</a></strong>
<a href="#n61" name="n61">61</a>
</pre></td>
  <td class="code"><pre><span class="type">class</span> <span class="class">Program</span> {
    <span class="directive">static</span> <span class="type">void</span> Main(string<span class="type">[]</span> args) {

        <span class="comment">// ** Without using an DI Container approach **</span>

        <span class="comment">// Create a new provider aka data access layer</span>
        var dal = <span class="keyword">new</span> DevDataProvider();

        <span class="comment">// New up an employee that's supposed to represent the currently logged in user</span>
        var e = <span class="keyword">new</span> Employee() {
            WindowsUsername = <span class="string"><span class="delimiter">&quot;</span><span class="content">thanos</span><span class="char">\\</span><span class="content">efvincent</span><span class="delimiter">&quot;</span></span>,
            EmployeeId = <span class="string"><span class="delimiter">&quot;</span><span class="content">0001</span><span class="delimiter">&quot;</span></span>,
            FName = <span class="string"><span class="delimiter">&quot;</span><span class="content">Eric</span><span class="delimiter">&quot;</span></span>,
            LName = <span class="string"><span class="delimiter">&quot;</span><span class="content">Vincent</span><span class="delimiter">&quot;</span></span>
        };

        <span class="comment">// Add it to the data access layer</span>
        dal.AddEmployee(e);

        <span class="comment">// See if the dal can find the current user</span>
        e = dal.GetCurrentEmployee();

        Console.WriteLine(
            <span class="string"><span class="delimiter">&quot;</span><span class="content">Current logged in person is: {0}</span><span class="delimiter">&quot;</span></span>, e == <span class="predefined-constant">null</span> ? <span class="string"><span class="delimiter">&quot;</span><span class="content">unknown</span><span class="delimiter">&quot;</span></span> : e.FName);

        <span class="comment">// End</span>
        Console.Write(<span class="string"><span class="delimiter">&quot;</span><span class="content">Press any key...</span><span class="delimiter">&quot;</span></span>);
        Console.ReadKey(<span class="predefined-constant">true</span>);

    }
}

<span class="directive">public</span> <span class="type">class</span> <span class="class">DevDataProvider</span> {
    <span class="directive">private</span> <span class="directive">static</span> readonly <span class="predefined-type">List</span>&lt;Employee&gt; EmployeeStore = <span class="keyword">new</span> <span class="predefined-type">List</span>&lt;Employee&gt;();

    <span class="directive">public</span> Employee GetCurrentEmployee() {
        var emp = EmployeeStore.FirstOrDefault(
            e =&gt; e.WindowsUsername.Equals(GetCurrentUserName(), StringComparison.OrdinalIgnoreCase));
        <span class="keyword">return</span> emp;
    }

    <span class="directive">public</span> <span class="type">void</span> AddEmployee(Employee e) {
        EmployeeStore.Add(e);
    }

    <span class="directive">public</span> IQueryable&lt;Employee&gt; Employees() {
        <span class="keyword">return</span> EmployeeStore.AsQueryable();
    }

    <span class="directive">private</span> <span class="directive">static</span> string GetCurrentUserName() {
        var wu = WindowsIdentity.GetCurrent();
        <span class="keyword">return</span> wu == <span class="predefined-constant">null</span> ? string.Empty : wu.Name;
    }
}

<span class="directive">public</span> <span class="type">class</span> <span class="class">Employee</span> {
    <span class="directive">public</span> string WindowsUsername { get; set; }
    <span class="directive">public</span> string EmployeeId { get; set; }
    <span class="directive">public</span> string FName { get; set; }
    <span class="directive">public</span> string LName { get; set; }
}
</pre></td>
</tr></table>
</div>

<p>In Main() we new up the data access layer, create a new employee, and add it to our store using the data access layer. At line 21 we ask the data access layer to retrieve the employee record for the currently logged in user. Looks pretty typical, so how can IoC help? Let’s look at the coupling here – what classes are dependent on what other classes?</p>

<p><a href="http://blog.efvincent.com/wp-content/uploads/2011/05/image.png"><img src="http://blog.efvincent.com/wp-content/uploads/2011/05/image_thumb.png" alt="image" /></a></p>

<p>Our main program depends on the DevDataProvider class, and that depends on System.Security to find the Windows username of the currently logged in user. Asking the data access layer to determine the currently logged in user isn’t the best idea, but this is blog post code created to check out dependency injection, so deal with that for the moment.</p>

<p>Why are these dependencies undesirable? First consider how flexible this software is. Or rather, inflexible. We created a “quick” DevDataProvider that stores stuff in a static list. As we continue to build a system, we’d have to refer to DevDataProvider from more and more classes, creating a brittle, tightly coupled system. Replacing DevDataProvider becomes more of a maintenance problem.</p>

<p>Next think about testability. In real life there are unit tests (there should be anyway). One reason why people find excuses not to unit test is because their code is difficult to test. In this example, if we want to test DevDataProvider.GetCurrentEmployee() we have to consider that under the covers it’s calling the Windows API to get the current username. This makes that method harder to than it needs to be.</p>

<h3 id="step-one--leveraging-interfaces">Step One – Leveraging Interfaces</h3>

<p>In this version, we’ve factored out an interface called IDataProvider, and one called IIdentService. The IDataProvider should be pretty obvious – but IIdentService? The idea here is to decouple from the Windows API itself. A developer should understand <em>everywhere _that the application makes contact with _any</em> external modules, including the operating system, and then consider what the repercussions of that contact are. In this example, coupling to the Windows API to get then logged in username so directly is undesirable. We want to use a <em>service</em> that would supply us with credentials. That way if we’re testing, we can create a fake service that provides a predictable answer, and is therefore easier to test.</p>

<p>Coding to an interface also allows us to radically change the behavior of the service without having to alter its dependencies. If we move to a ASP.NET environment for example, we won’t want to use the current Windows Identity, we may want to use user information from the http context.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
<a href="#n24" name="n24">24</a>
<a href="#n25" name="n25">25</a>
<a href="#n26" name="n26">26</a>
<a href="#n27" name="n27">27</a>
<a href="#n28" name="n28">28</a>
<a href="#n29" name="n29">29</a>
<strong><a href="#n30" name="n30">30</a></strong>
<a href="#n31" name="n31">31</a>
<a href="#n32" name="n32">32</a>
<a href="#n33" name="n33">33</a>
<a href="#n34" name="n34">34</a>
<a href="#n35" name="n35">35</a>
<a href="#n36" name="n36">36</a>
<a href="#n37" name="n37">37</a>
<a href="#n38" name="n38">38</a>
<a href="#n39" name="n39">39</a>
<strong><a href="#n40" name="n40">40</a></strong>
<a href="#n41" name="n41">41</a>
<a href="#n42" name="n42">42</a>
<a href="#n43" name="n43">43</a>
<a href="#n44" name="n44">44</a>
<a href="#n45" name="n45">45</a>
<a href="#n46" name="n46">46</a>
<a href="#n47" name="n47">47</a>
</pre></td>
  <td class="code"><pre><span class="comment">// Interface defining an identity service</span>
<span class="directive">public</span> <span class="type">interface</span> <span class="class">IIdentService</span> {
    string GetCurrentUserName();
}

<span class="comment">// Implementation of an identity service that returns the current</span>
<span class="comment">// logged in windows username</span>
<span class="directive">public</span> <span class="type">class</span> <span class="class">WindowsIdentService</span> : IIdentService {
    <span class="directive">public</span> string GetCurrentUserName() {
        var wu = WindowsIdentity.GetCurrent();
        <span class="keyword">return</span> wu == <span class="predefined-constant">null</span> ? string.Empty : wu.Name;
    }
}

<span class="comment">// Interface defining a data provider service</span>
<span class="directive">public</span> <span class="type">interface</span> <span class="class">IDataProvider</span> {
    Employee GetCurrentEmployee();
    <span class="type">void</span> AddEmployee(Employee e);
    IQueryable&lt;Employee&gt; Employees();
}

<span class="comment">// Our development data provider now implements the interface</span>
<span class="directive">public</span> <span class="type">class</span> <span class="class">DevDataProvider</span> : IDataProvider {
    <span class="directive">private</span> readonly IIdentService _identService;
    <span class="directive">private</span> <span class="directive">static</span> readonly <span class="predefined-type">List</span>&lt;Employee&gt; EmployeeStore = <span class="keyword">new</span> <span class="predefined-type">List</span>&lt;Employee&gt;();

    <span class="directive">public</span> DevDataProvider(IIdentService identService) {
        <span class="keyword">if</span> (identService == <span class="predefined-constant">null</span>) <span class="keyword">throw</span> <span class="keyword">new</span> ArgumentNullException(<span class="string"><span class="delimiter">&quot;</span><span class="content">identService</span><span class="delimiter">&quot;</span></span>);
        _identService = identService;
    }

    <span class="directive">public</span> Employee GetCurrentEmployee() {
        var emp = EmployeeStore.FirstOrDefault(
                        e =&gt; e.WindowsUsername.Equals(
                            _identService.GetCurrentUserName(),
                            StringComparison.OrdinalIgnoreCase));
        <span class="keyword">return</span> emp;
    }

    <span class="directive">public</span> <span class="type">void</span> AddEmployee(Employee e) {
        EmployeeStore.Add(e);
    }

    <span class="directive">public</span> IQueryable&lt;Employee&gt; Employees() {
        <span class="keyword">return</span> EmployeeStore.AsQueryable();
    }
}
</pre></td>
</tr></table>
</div>

<p>We’re part of the way to where we need to be. Altering DevDataProvider to depend on the IIdentService interface frees it from a hard dependency on a particular identity implementation. The downside is we’ve made creation of the DevDataProvider a bit more complex, as we need to supply the new instance with an IIdentityService instance.</p>

<p>~~~C#
// Create a new ident service, required for the DAL
IIdentService identSvc = new WindowsIdentService();</p>

<p>// Create a new DAL
IDataProvider dal = new DevDataProvider(identSvc);
~~~</p>

<p>The DevDataProvider now takes a constructor parameter of type IIdentService. This is where the <em>injection</em> in dependency injection comes from. DevDataProvider has a dependency, but instead of hard coding it into the definition of DevDataProvider, we inject it. There are different ways of injecting dependencies, but constructor injection is very popular and works well in many, or even most cases.</p>

<p>The complexity of constructing instances increases when we add a simple logging service which logs information or errors messages.</p>

<p>~~~C#
// Interface defining a logging service
public interface ILogService {
    void LogInfo(string msg, params object[] args);
    void LogError(string msg, params object[] args);
}</p>

<p>// Implementation of a console logging service
public class ConsoleLogger : ILogService {
    public void LogInfo(string msg, params object[] args) {
        Console.WriteLine(
            “{0} INFO: {1}”, DateTime.Now,
            string.Format(msg, args));
    }</p>

<pre><code>public void LogError(string msg, params object[] args) {
    Console.WriteLine(
        "{0} ERROR: {1}", DateTime.Now,
        string.Format(msg, args));
} } ~~~
</code></pre>

<p>The ILogService is implemented by a simple console logger. Now both the WindowsIdentService and the DevDataProvider can leverage the logger. They’re both modified to have ILogService instance injected via their respective constructors.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
<a href="#n24" name="n24">24</a>
<a href="#n25" name="n25">25</a>
<a href="#n26" name="n26">26</a>
<a href="#n27" name="n27">27</a>
<a href="#n28" name="n28">28</a>
<a href="#n29" name="n29">29</a>
<strong><a href="#n30" name="n30">30</a></strong>
<a href="#n31" name="n31">31</a>
<a href="#n32" name="n32">32</a>
<a href="#n33" name="n33">33</a>
<a href="#n34" name="n34">34</a>
<a href="#n35" name="n35">35</a>
<a href="#n36" name="n36">36</a>
<a href="#n37" name="n37">37</a>
<a href="#n38" name="n38">38</a>
<a href="#n39" name="n39">39</a>
<strong><a href="#n40" name="n40">40</a></strong>
<a href="#n41" name="n41">41</a>
<a href="#n42" name="n42">42</a>
<a href="#n43" name="n43">43</a>
<a href="#n44" name="n44">44</a>
<a href="#n45" name="n45">45</a>
<a href="#n46" name="n46">46</a>
<a href="#n47" name="n47">47</a>
<a href="#n48" name="n48">48</a>
<a href="#n49" name="n49">49</a>
</pre></td>
  <td class="code"><pre><span class="comment">// Implementation of an identity service that returns the current</span>
<span class="comment">// logged in windows username</span>
<span class="directive">public</span> <span class="type">class</span> <span class="class">WindowsIdentService</span> : IIdentService {
    <span class="directive">private</span> readonly ILogService _logSvc;

    <span class="directive">public</span> WindowsIdentService(ILogService logSvc) {
        <span class="keyword">if</span> (logSvc == <span class="predefined-constant">null</span>) <span class="keyword">throw</span> <span class="keyword">new</span> ArgumentNullException(<span class="string"><span class="delimiter">&quot;</span><span class="content">logSvc</span><span class="delimiter">&quot;</span></span>);
        _logSvc = logSvc;
    }

    <span class="directive">public</span> string GetCurrentUserName() {
        var wu = WindowsIdentity.GetCurrent();
        var un = wu == <span class="predefined-constant">null</span> ? string.Empty : wu.Name;
        _logSvc.LogInfo(<span class="string"><span class="delimiter">&quot;</span><span class="content">Identified current user as: {0}</span><span class="delimiter">&quot;</span></span>, un);
        <span class="keyword">return</span> un;
    }
}

<span class="comment">// Our development data provider now implements the interface</span>
<span class="directive">public</span> <span class="type">class</span> <span class="class">DevDataProvider</span> : IDataProvider {
    <span class="directive">private</span> readonly IIdentService _identService;
    <span class="directive">private</span> readonly ILogService _logSvc;
    <span class="directive">private</span> <span class="directive">static</span> readonly <span class="predefined-type">List</span>&lt;Employee&gt; EmployeeStore = <span class="keyword">new</span> <span class="predefined-type">List</span>&lt;Employee&gt;();

    <span class="directive">public</span> DevDataProvider(IIdentService identService, ILogService logSvc) {
        <span class="keyword">if</span> (identService == <span class="predefined-constant">null</span>) <span class="keyword">throw</span> <span class="keyword">new</span> ArgumentNullException(<span class="string"><span class="delimiter">&quot;</span><span class="content">identService</span><span class="delimiter">&quot;</span></span>);
        <span class="keyword">if</span> (logSvc == <span class="predefined-constant">null</span>) <span class="keyword">throw</span> <span class="keyword">new</span> ArgumentNullException(<span class="string"><span class="delimiter">&quot;</span><span class="content">logSvc</span><span class="delimiter">&quot;</span></span>);
        _identService = identService;
        _logSvc = logSvc;
    }

    <span class="directive">public</span> Employee GetCurrentEmployee() {
        var un = _identService.GetCurrentUserName();
        var emp = EmployeeStore.FirstOrDefault(
                        e =&gt; e.WindowsUsername.Equals(un,
                            StringComparison.OrdinalIgnoreCase));
        <span class="keyword">if</span> (emp == <span class="predefined-constant">null</span>) _logSvc.LogInfo(<span class="string"><span class="delimiter">&quot;</span><span class="content">Current employee {0} not found</span><span class="delimiter">&quot;</span></span>, un);
        <span class="keyword">return</span> emp;
    }

    <span class="directive">public</span> <span class="type">void</span> AddEmployee(Employee e) {
        EmployeeStore.Add(e);
        _logSvc.LogInfo(<span class="string"><span class="delimiter">&quot;</span><span class="content">Added employee with id {0}</span><span class="delimiter">&quot;</span></span>, e.EmployeeId);
    }

    <span class="directive">public</span> IQueryable&lt;Employee&gt; Employees() {
        <span class="keyword">return</span> EmployeeStore.AsQueryable();
    }
}
</pre></td>
</tr></table>
</div>

<p>Now the services are getting more robust and they’re not tightly coupled to each other, they refer only to interfaces of the services they depend on. Main() however, where construction is going on, is getting messy.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
</pre></td>
  <td class="code"><pre><span class="directive">static</span> <span class="type">void</span> Main(string<span class="type">[]</span> args) {

    <span class="comment">// ** Without using an DI Container approach **</span>

    <span class="comment">// Create a new logging service, required for uh.. everything</span>
    ILogService consoleLog = <span class="keyword">new</span> ConsoleLogger();

    <span class="comment">// Create a new ident service, required for the DAL</span>
    IIdentService identSvc = <span class="keyword">new</span> WindowsIdentService(consoleLog);

    <span class="comment">// Create a new DAL</span>
    IDataProvider dal = <span class="keyword">new</span> DevDataProvider(identSvc, consoleLog);
</pre></td>
</tr></table>
</div>

<p>Finally we’re at the point where we can see the benefit of an dependency injection container. One thing about DI containers is that they’re already written. Several mature, robust, open-source DI containers exist. We’ll use AutoFac, because that’s what I’ve been using lately. We include <a href="http://www.nuget.org/List/Packages/Autofac">AutoFac</a> using <a href="http://www.nuget.org">NuGet</a>.</p>

<pre><code>// Create a singleton dependency injection container
private static readonly IContainer Container = ConfigureContainer();

// Configure the container
static IContainer ConfigureContainer() {
    // This is how AutoFac works. Other DI containers have similar
    // mechanisms for configuring the container
    var bld = new ContainerBuilder();

    // Register the types that implement the interfaces that are required
    // for injection. Note that we have robust control over lifetime, in
    // this case ILogService and IIdentService will be singletons, and
    // IDataProvider will provide a new instance each time it's requested
    bld.RegisterType&lt;ConsoleLogger&gt;().As&lt;ILogService&gt;().SingleInstance();
    bld.RegisterType&lt;WindowsIdentService&gt;().As&lt;IIdentService&gt;().SingleInstance();
    bld.RegisterType&lt;DevDataProvider&gt;().As&lt;IDataProvider&gt;();
    return bld.Build();
}

static void Main(string[] args) {

    // ** Using an IoC Container approach **
    var dal = Container.Resolve&lt;IDataProvider&gt;();
</code></pre>

<p>We’ve created a static instance of IContainer (an AutoFac DI container). When we start the app we configure the container, which fundamentally consists of mapping the interfaces to concrete types that will be injected. For example, line 14 specifies that when there’s a need for an instance of ILogService, we will create an instance of ConsoleLogger. It further says that the DI container should use a SingleInstance() of ConsoleLogger. This has the effect of making ConsoleLogger a singleton. In our example, both the WindowsIdentService and the DevDataProvider will be handed the same instance of ConsoleLogger.</p>

<p>The magic happens when we call Container.Resolve<idataprovider>(). The container determines what concrete class to create, and it looks for any dependencies in the constructor. It will see that to build a DevDataProvider, it needs an ILogService and an IWindowsIdentService, it will recursively resolve those as well.</idataprovider></p>

<p>These are the basics of dependency injection. Even in this simple example, it should be obvious that the components and classes that we can create can be designed with very low coupling and cohesion using this technique. There are anti-patterns for using DI as well. You should endeavor to practice this technique, do research and learn the most effective uses; there’s plenty of material out there.</p>

<p>I hope this example was helpful. Next post I’ll extend this sample by looking at testing, and mock objects, and how DI injection can make testing far easier.</p>

<p>Source code samples can be found at this <a href="https://bitbucket.org/efvincent/blog-post-dependency-injection-101">bitbucket repository</a>.</p>

<p><em>Update:</em> Follow up post - <a href="http://efvincent.github.io/2011/05/28/di-mock">Dependency Injection, Testing, and Mocking</a></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[NuGet – Galleries of Geeky Goodness.]]></title>
    <link href="http://efvincent.github.io/blog/2011/01/12/nuget-geeky-goodness/"/>
    <updated>2011-01-12T18:27:26-05:00</updated>
    <id>http://efvincent.github.io/blog/2011/01/12/nuget-geeky-goodness</id>
    <content type="html"><![CDATA[<p>In a <a href="http://blog.efvincent.com/open-source-nuget-and-more/">previous post</a> I described how Scott Hanselman’s <a href="http://www.hanselman.com/blog/PDC10BuildingABlogWithMicrosoftUnnamedPackageOfWebLove.aspx">presentation</a> during PDC 2010 introduced me to several wonderful and interesting technologies that are either just now out or about to be. The first one I’ll discuss is <a href="http://nuget.codeplex.com">NuGet</a>. There are many excellent introductions to NuGet by <a href="http://www.hanselman.com/blog/IntroducingNuPackPackageManagementForNETAnotherPieceOfTheWebStack.aspx">Hanselman</a> and others. I’ll see if I can make a meaningful contribution.</p>

<p>NuGet is an add-on to VS2010. It allows us to access <em>packages</em> that have been published either locally or publicly on the web. The main NuGet gallery just went live today at <a href="http://nuget.org">http://nuget.org</a>. These packages make it easy to install, update, and remove libraries and tools in Visual Studio 2010.</p>

<!-- more -->

<h2 id="installation">Installation</h2>

<p>NuGet, like dozens of other useful add-ins, is available through the Visual Studio Extension Manager, reached under _Tools… Extension Manager…. _</p>

<p><a href="http://blog.efvincent.com/wp-content/uploads/2011/01/image.png"><img src="http://blog.efvincent.com/wp-content/uploads/2011/01/image_thumb.png" alt="image" /></a></p>

<p>From the Extension Manager choose (1) the online gallery, and then (2) search for NuGet. A restart of Visual Studio is required.</p>

<h2 id="the-nuget-package-manager-console">The NuGet Package Manager Console</h2>

<p>NuGet has two user interfaces. There’s a PowerShell powered console window. This is the UI I was first introduced to and have gravitated towards. The console gives you a more complete sense of control over the process. Open the console by selecting <em>View… Other Windows… Package Manager Console</em>.</p>

<p><a href="http://blog.efvincent.com/wp-content/uploads/2011/01/image1.png"><img src="http://blog.efvincent.com/wp-content/uploads/2011/01/image_thumb1.png" alt="image" /></a></p>

<p>The <em>Package Source</em> drop down defaults to the official NuGet package gallery. There are already hundreds of packages out in the gallery, and you can expect it to grow rapidly. You can list the packages in the official library with:</p>

<p>List-Packages –remote</p>

<p>There are a lot of them, and since the console is PowerShell we can take advantage of a PowerShell grid display:</p>

<table>
  <tbody>
    <tr>
      <td>List-Packages –remote</td>
      <td>out-GridView</td>
    </tr>
  </tbody>
</table>

<p><a href="http://blog.efvincent.com/wp-content/uploads/2011/01/image2.png"><img src="http://blog.efvincent.com/wp-content/uploads/2011/01/image_thumb2.png" alt="image" /></a></p>

<h2 id="installing-and-removing-packages">Installing and Removing Packages</h2>

<p>Now comes the really cool part. The whole idea of NuGet is to be able to install / add external libraries to your project without having to find them on the web, download a zip or msi file, install it somewhere on your local machine, figure out what the instructions are for incorporating them into your project, and patching it in manually.</p>

<p>Let’s take for example, the latest CTP5 version of Entity Framework, that allows for <em>Code First</em> use of the Entity Framework. EF4 will justify at least one future dedicated post, but we’ll use it here for a quick example. Normally, if you want to try out something like a new version of Entity Framework, there’s downloading, installing, shaving the chicken, bla bla bla that you’ve got to do. Not with NuGet. NuGet can effectively _“_xcopy deploy” it into our project.</p>

<p>Create a new console application in Visual Studio. From the Package Manager Console, type <em>Install-Package EF</em> and press the tab key. An intellisense window will pop up showing packages that begin with EF.</p>

<p><a href="http://blog.efvincent.com/wp-content/uploads/2011/01/image3.png"><img src="http://blog.efvincent.com/wp-content/uploads/2011/01/image_thumb3.png" alt="image" /></a></p>

<p>At the time of this writing, there are five packages. The EFCTP4 ones are obsolete, from the last CTP. For this example, choose <em>EFCodeFirst</em> and press enter. The console displays license info, downloads the EFCodeFirst package, and incorporates it into your project. In the solution explorer, we can see a reference  (1) and a file (2) added to the project.</p>

<p><a href="http://blog.efvincent.com/wp-content/uploads/2011/01/image4.png"><img src="http://blog.efvincent.com/wp-content/uploads/2011/01/image_thumb4.png" alt="image" /></a></p>

<p>Checking the properties of the reference to EntityFramework, you can see that it’s not installed to the GAC, it’s local to the solution. NuGet creates a solution level folder called <em>packages</em>. In that folder, in addition to components used as references, is all the data that NuGet needs to install and uninstall packages. All local, without changing any configuration on the machine. More details of the inner workings of NuGet and its packages will come at a later date, plus there’s information out there you can dig up if you’re so inclined.</p>

<h2 id="using-entity-framework">Using Entity Framework</h2>

<p>Now that we’ve got it installed, let’s quickly use EFCodeFirst just to prove it’s working. For this example, you’ll need SQL Server installed (there are other options, but one thing at a time). I’ve got Express which works fine. In another post I’ll show the new SQL Server Compact Edition 4, which coincidentally you can add to a project using NuGet <img src="http://blog.efvincent.com/wp-content/uploads/2011/01/wlEmoticon-smile.png" alt="Smile" />.</p>

<p>EFCodeFirst allows you to build POCO objects and use them to build a DB. Let’s build a quick model. There are a few examples floating around modeling blog posts and comments, so lets <em>not</em> do that. Let’s do (super simple) prescriptions and medications. It’s on my mind because I’m recovering from knee surgery. This code is entered directly into the Program.cs source file for this example.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
<a href="#n24" name="n24">24</a>
<a href="#n25" name="n25">25</a>
<a href="#n26" name="n26">26</a>
<a href="#n27" name="n27">27</a>
<a href="#n28" name="n28">28</a>
<a href="#n29" name="n29">29</a>
<strong><a href="#n30" name="n30">30</a></strong>
<a href="#n31" name="n31">31</a>
<a href="#n32" name="n32">32</a>
<a href="#n33" name="n33">33</a>
<a href="#n34" name="n34">34</a>
<a href="#n35" name="n35">35</a>
<a href="#n36" name="n36">36</a>
<a href="#n37" name="n37">37</a>
<a href="#n38" name="n38">38</a>
<a href="#n39" name="n39">39</a>
<strong><a href="#n40" name="n40">40</a></strong>
<a href="#n41" name="n41">41</a>
<a href="#n42" name="n42">42</a>
<a href="#n43" name="n43">43</a>
<a href="#n44" name="n44">44</a>
<a href="#n45" name="n45">45</a>
<a href="#n46" name="n46">46</a>
<a href="#n47" name="n47">47</a>
<a href="#n48" name="n48">48</a>
<a href="#n49" name="n49">49</a>
<strong><a href="#n50" name="n50">50</a></strong>
<a href="#n51" name="n51">51</a>
<a href="#n52" name="n52">52</a>
<a href="#n53" name="n53">53</a>
<a href="#n54" name="n54">54</a>
<a href="#n55" name="n55">55</a>
<a href="#n56" name="n56">56</a>
<a href="#n57" name="n57">57</a>
<a href="#n58" name="n58">58</a>
<a href="#n59" name="n59">59</a>
<strong><a href="#n60" name="n60">60</a></strong>
<a href="#n61" name="n61">61</a>
<a href="#n62" name="n62">62</a>
<a href="#n63" name="n63">63</a>
<a href="#n64" name="n64">64</a>
<a href="#n65" name="n65">65</a>
<a href="#n66" name="n66">66</a>
<a href="#n67" name="n67">67</a>
<a href="#n68" name="n68">68</a>
<a href="#n69" name="n69">69</a>
<strong><a href="#n70" name="n70">70</a></strong>
<a href="#n71" name="n71">71</a>
<a href="#n72" name="n72">72</a>
<a href="#n73" name="n73">73</a>
<a href="#n74" name="n74">74</a>
<a href="#n75" name="n75">75</a>
<a href="#n76" name="n76">76</a>
<a href="#n77" name="n77">77</a>
<a href="#n78" name="n78">78</a>
<a href="#n79" name="n79">79</a>
<strong><a href="#n80" name="n80">80</a></strong>
<a href="#n81" name="n81">81</a>
<a href="#n82" name="n82">82</a>
<a href="#n83" name="n83">83</a>
<a href="#n84" name="n84">84</a>
<a href="#n85" name="n85">85</a>
<a href="#n86" name="n86">86</a>
<a href="#n87" name="n87">87</a>
<a href="#n88" name="n88">88</a>
<a href="#n89" name="n89">89</a>
<strong><a href="#n90" name="n90">90</a></strong>
<a href="#n91" name="n91">91</a>
<a href="#n92" name="n92">92</a>
<a href="#n93" name="n93">93</a>
<a href="#n94" name="n94">94</a>
<a href="#n95" name="n95">95</a>
<a href="#n96" name="n96">96</a>
<a href="#n97" name="n97">97</a>
<a href="#n98" name="n98">98</a>
<a href="#n99" name="n99">99</a>
<strong><a href="#n100" name="n100">100</a></strong>
<a href="#n101" name="n101">101</a>
<a href="#n102" name="n102">102</a>
<a href="#n103" name="n103">103</a>
<a href="#n104" name="n104">104</a>
<a href="#n105" name="n105">105</a>
<a href="#n106" name="n106">106</a>
<a href="#n107" name="n107">107</a>
<a href="#n108" name="n108">108</a>
<a href="#n109" name="n109">109</a>
<strong><a href="#n110" name="n110">110</a></strong>
<a href="#n111" name="n111">111</a>
<a href="#n112" name="n112">112</a>
<a href="#n113" name="n113">113</a>
<a href="#n114" name="n114">114</a>
<a href="#n115" name="n115">115</a>
<a href="#n116" name="n116">116</a>
<a href="#n117" name="n117">117</a>
<a href="#n118" name="n118">118</a>
<a href="#n119" name="n119">119</a>
<strong><a href="#n120" name="n120">120</a></strong>
<a href="#n121" name="n121">121</a>
<a href="#n122" name="n122">122</a>
<a href="#n123" name="n123">123</a>
<a href="#n124" name="n124">124</a>
<a href="#n125" name="n125">125</a>
<a href="#n126" name="n126">126</a>
<a href="#n127" name="n127">127</a>
<a href="#n128" name="n128">128</a>
<a href="#n129" name="n129">129</a>
<strong><a href="#n130" name="n130">130</a></strong>
</pre></td>
  <td class="code"><pre><span class="directive">public</span> <span class="type">class</span> <span class="class">Prescription</span> {
    <span class="directive">public</span> <span class="type">int</span> Id { get; set; }
    <span class="directive">public</span> string MedName { get; set; }
    <span class="directive">public</span> string Directions { get; set; }
    <span class="directive">public</span> <span class="type">int</span> Quantity { get; set; }
    <span class="directive">public</span> <span class="type">int</span> Refills { get; set; }
    <span class="directive">public</span> <span class="type">int</span> RefillsRemaining { get; set; }
    <span class="directive">public</span> ICollection&lt;FilledScript&gt; FilledScripts { get; set; }
}

<span class="directive">public</span> <span class="type">class</span> <span class="class">FilledScript</span> {
    <span class="directive">public</span> <span class="type">int</span> Id { get; set; }
    <span class="directive">public</span> Prescription Script { get; set; }
    <span class="directive">public</span> DateTime Filled { get; set; }
    <span class="directive">public</span> <span class="type">int</span> Doses { get; set; }
}

<span class="directive">public</span> <span class="type">class</span> <span class="class">MedContext</span> : DbContext {
    <span class="directive">public</span> DbSet&lt;Prescription&gt; Prescriptions { get; set; }
    <span class="directive">public</span> DbSet&lt;FilledScript&gt; FilledScripts { get; set; }
}
&lt;div <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">bogus-wrapper</span><span class="delimiter">'</span></span>&gt;&lt;<span class="class">notextile</span>&gt;&lt;figure <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">code</span><span class="delimiter">'</span></span>&gt;&lt;<span class="class">div</span> <span class="type">class</span>=<span class="string"><span class="delimiter">&quot;</span><span class="content">highlight</span><span class="delimiter">&quot;</span></span>&gt;&lt;<span class="class">table</span>&gt;&lt;tr&gt;&lt;td <span class="type">class</span>=<span class="string"><span class="delimiter">&quot;</span><span class="content">gutter</span><span class="delimiter">&quot;</span></span>&gt;&lt;<span class="class">pre</span> <span class="type">class</span>=<span class="string"><span class="delimiter">&quot;</span><span class="content">line-numbers</span><span class="delimiter">&quot;</span></span>&gt;&lt;<span class="class">span</span> <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">1</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">2</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">3</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">4</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">5</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">6</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">7</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">8</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">9</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">10</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">11</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">12</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">13</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">14</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">15</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">16</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">17</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">18</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">19</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">20</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">21</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">22</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">23</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">24</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">25</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">26</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">27</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">28</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">29</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">30</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">31</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">32</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">33</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">34</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">35</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">36</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">37</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">38</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">39</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">40</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">41</span>&lt;/<span class="class">span</span>&gt;
&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line-number</span><span class="delimiter">'</span></span>&gt;<span class="integer">42</span>&lt;/<span class="class">span</span>&gt;
&lt;/pre&gt;&lt;/td&gt;&lt;td <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">code</span><span class="delimiter">'</span></span>&gt;&lt;<span class="class">pre</span>&gt;&lt;code <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="delimiter">'</span></span>&gt;&lt;<span class="class">span</span> <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;<span class="class">We</span> have a <span class="type">class</span> <span class="class">for</span> a Prescription, and one <span class="keyword">for</span> a FilledScript (filled prescription). We give each one an integer Id, which EF will interpret (by convention) as the primary key and identity <span class="keyword">for</span> each entity. A relation is created between them, again by convention. On the <span class="error">“</span>one<span class="error">”</span> side,<span class="error"> </span> the Prescription has a collection of filled scripts, and on the <span class="error">“</span>many<span class="error">”</span> side, the filled script has a reference to its prescription.
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;<span class="class">The</span> _MedContext_ <span class="type">class</span> <span class="class">inherits</span> from EF<span class="error">’</span>s DbContext, and pulls the model together. Each DbSet&amp;lt;<span class="error">…</span>&amp;gt; identifies an entity to EF. In <span class="local-variable">this</span> minimal <span class="keyword">case</span>, that<span class="error">’</span>s all that<span class="error">’</span>s required to define a model using EFCodeFirst. Lets take a look at using it:
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;~~~<span class="class">java</span>  
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;<span class="class">static</span> <span class="type">void</span> Main(string<span class="type">[]</span> args) {
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    <span class="class">DbDatabase</span>.SetInitializer(<span class="keyword">new</span> DropCreateDatabaseAlways&amp;lt;MedContext&amp;gt;());
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    <span class="class">var</span> ctx = <span class="keyword">new</span> MedContext();
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    <span class="class">var</span> p = <span class="keyword">new</span> Prescription() {
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;        <span class="class">MedName</span> = <span class="string"><span class="delimiter">&quot;</span><span class="content">Vicoden</span><span class="delimiter">&quot;</span></span>,
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;        <span class="class">Directions</span> = <span class="string"><span class="delimiter">&quot;</span><span class="content">One every 4 hours as needed for pain</span><span class="delimiter">&quot;</span></span>,
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;        <span class="class">Quantity</span> = <span class="integer">60</span>,
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;        <span class="class">Refills</span> = <span class="integer">2</span>,
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;        <span class="class">RefillsRemaining</span> = <span class="integer">1</span>,
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;        <span class="class">FilledScripts</span> = <span class="keyword">new</span><span class="type">[]</span> {
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;            <span class="class">new</span> FilledScript() {
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;                <span class="class">Filled</span> = DateTime.Parse(<span class="string"><span class="delimiter">&quot;</span><span class="content">12/28/2010</span><span class="delimiter">&quot;</span></span>),
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;                <span class="class">Doses</span> = <span class="integer">0</span>
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;            },
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;            <span class="class">new</span> FilledScript() {
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;                <span class="class">Filled</span> = DateTime.Parse(<span class="string"><span class="delimiter">&quot;</span><span class="content">1/12/2011</span><span class="delimiter">&quot;</span></span>),
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;                <span class="class">Doses</span> = <span class="integer">48</span>
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;            }
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;        }
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    };
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    <span class="class">ctx</span>.Prescriptions.Add(p);
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    <span class="class">ctx</span>.SaveChanges();
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    <span class="class">foreach</span> (var script in ctx.Prescriptions) {
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;        <span class="class">Console</span>.WriteLine(<span class="string"><span class="delimiter">&quot;</span><span class="content">Script for {0}, filled {1} time(s), we have {2} doses on hand</span><span class="delimiter">&quot;</span></span>,
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;            <span class="class">script</span>.MedName,
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;            <span class="class">script</span>.FilledScripts.Count(),
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;            <span class="class">script</span>.FilledScripts.Sum(fs =&amp;gt; fs.Doses));
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    }
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;
&lt;/<span class="class">span</span>&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    <span class="class">Console</span>.Write(<span class="string"><span class="delimiter">&quot;</span><span class="char">\n</span><span class="content">Press any key...</span><span class="delimiter">&quot;</span></span>);
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;    <span class="class">Console</span>.ReadKey(<span class="predefined-constant">true</span>);
&lt;/span&gt;&lt;span <span class="type">class</span>=<span class="string"><span class="delimiter">'</span><span class="content">line</span><span class="delimiter">'</span></span>&gt;}&lt;/<span class="class">span</span>&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/div&gt;&lt;/figure&gt;&lt;/notextile&gt;&lt;/div&gt;

For <span class="local-variable">this</span> simple example I<span class="error">’</span>m just adding some data and retrieving it right from the main() function of the console app. Line <span class="integer">3</span> probably the only line that needs explanation. It<span class="error">’</span>s a call to the <span class="directive">static</span> method SetInitializer() on the <span class="directive">static</span> DbDatabase <span class="type">class</span> <span class="class">of</span> EF. The parameter is a <span class="keyword">new</span> instance of DropCreateDatabaseAlways&lt;MedContext&gt;. Creating <span class="local-variable">this</span> initializer with it<span class="error">’</span>s type parameter set to our MedContext tells the EF engine that it should always drop the database and recreate it, every time the app is run. This is part of EF<span class="error">’</span>s <span class="keyword">new</span> fluent <span class="type">interface</span>. Under <span class="class">almost</span> no circumstance would you actually use <span class="local-variable">this</span> initializer, but it<span class="error">’</span>s handy <span class="keyword">for</span> testing and playing around. This way you can iterate over your model getting a <span class="keyword">new</span> database <span class="keyword">for</span> each run.

The rest of the function adds a Prescription object with two FilledScript objects, and saves it in the context. It then loops through the prescriptions and writes some info to the console about each. No rocket science there.


<span class="error">#</span><span class="error">#</span> Where did EF Create the Database?


One cool thing about EFCodeFirst is that you can leave off pretty much all the configuration information. We didn<span class="error">’</span>t tell EF anything about how or where to create the database. It came up with some reasonable defaults. If you open SSMS and connect to your instance of SQL Express, you can see the database it created. Here<span class="error">’</span>s a DB diagram in SSMS from what EF created:

[![image](http:<span class="comment">//blog.efvincent.com/wp-content/uploads/2011/01/image_thumb5.png)](http://blog.efvincent.com/wp-content/uploads/2011/01/image5.png)</span>

The database it created (<span class="integer">1</span>) is named according to the context that it stores, MedContext <span class="keyword">for</span> us. It created tables (<span class="integer">2</span> &amp; <span class="integer">3</span>) <span class="keyword">for</span> the entities we created, and to implement the one to many relationship, it added a foreign key to the FilledScripts table linking it to the Prescriptions table. There<span class="error">’</span>s always a DBA to disagree with an auto-generated schema, but in <span class="local-variable">this</span> simple <span class="keyword">case</span>, you must admit there<span class="error">’</span>s not a whole lot you could <span class="keyword">do</span> differently. If we select the records out of the database after our run you get the expected results:

[![image](http:<span class="comment">//blog.efvincent.com/wp-content/uploads/2011/01/image_thumb6.png)](http://blog.efvincent.com/wp-content/uploads/2011/01/image6.png)</span>

All of <span class="local-variable">this</span> was created by convention, and can also be overridden and specified explicitly using either attributes on the classes that make up the model, or by using EF<span class="error">’</span>s fluent API. This barely scratches the surface, but hopefully gets you interested. I<span class="error">’</span>ll cover EF in more depth in a future post, plus there<span class="error">’</span>s plenty of info out there already.


<span class="error">#</span><span class="error">#</span> Back to NuGet <span class="error">–</span> Removing a <span class="predefined-type">Package</span>


Ok, we<span class="error">’</span>ve seen how easy it is to add a <span class="keyword">package</span> <span class="namespace">like</span> <span class="namespace">EFCodeFirst</span> (<span class="namespace">and</span> <span class="namespace">how</span> <span class="namespace">cool</span> <span class="namespace">EF</span> <span class="namespace">itself</span> <span class="namespace">is</span>). <span class="namespace">NuGet</span> <span class="namespace">also</span> <span class="namespace">allows</span> <span class="namespace">you</span> <span class="namespace">to</span> <span class="namespace">remove</span> <span class="namespace">a</span> <span class="namespace">package</span> <span class="namespace">easily</span>. <span class="namespace">In</span> <span class="namespace">the</span> <span class="namespace">Package</span> <span class="namespace">Manager</span> <span class="namespace">Console</span> <span class="namespace">window</span>, <span class="namespace">issue</span> <span class="namespace">the</span> <span class="namespace">command</span>:

</pre></td>
</tr></table>
</div>
<p>PM&gt; Uninstall-Package EFCodeFirst
Successfully removed ‘EFCodeFirst 0.8’ from ConsoleApplication2
Successfully uninstalled ‘EFCodeFirst 0.8’
~~~</p>

<p>NuGet will remove all traces of the package from your project. For EFCodeFirst there’s not much to remove. But other packages are far more complicated, even pulling in prerequisite packages, and modifying the web or app.config. NuGet undoes all these changes when a package is removed.</p>

<h2 id="try-it-yourself">Try it yourself!</h2>

<p>One great thing about NuGet is how painless it makes trying out new things. You’re not fouling up your precious work machine with a bunch of installations. You can create a quick test project, add a bunch of things you’ve always wanted to try, and just blow it all away when you’re done. No evidence you’ve been <em>learning</em>.</p>

<p>Ever want to try Fluent NHibernate but didn’t feel like dealing with all the crap that goes with tracking it down and installing it? How about Ninject, Castle, ELMAH, iTextSharp, Moq, or Prism? They’re all out there. Just NuGet them and start playing / learning.</p>

<h2 id="what-else">What else?</h2>

<p>I didn’t even mention the wizardy, non-console approach. Right click on your project, and select Add Library Package Reference… and you get a pretty UI that lets you click instead of type. But you’re a coder. You can type.</p>

<p>Publishing your own package. You can create any package you want. Perhaps one that pulls in some of your favorite utility classes. Or perhaps you’ve got some corporate libraries and frameworks that you want to be able to incorporate using NuGet. You can create your own private or a corporate NuGet gallery. Or if you have something worth while, publish it up to the official NuGet gallery, it’s own to the public.</p>

<p>I hope you’ve found this ramble of mine useful. Search around for more NuGet goodness. There are plenty of bloggers way more interesting then me publishing good information.</p>

<p>Happy Coding!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Open Source, MVC, MVVM, Entity Framework, NuGet, and More…]]></title>
    <link href="http://efvincent.github.io/blog/2011/01/12/open-source-nuget-and-more/"/>
    <updated>2011-01-12T08:53:31-05:00</updated>
    <id>http://efvincent.github.io/blog/2011/01/12/open-source-nuget-and-more</id>
    <content type="html"><![CDATA[<p><strong>Updated</strong>: see the <a href="http://blog.efvincent.com/nuget-geeky-goodness/">NuGet post</a></p>

<p>The 2010 PDC was a few months ago. There was plenty of interesting and exciting tech news coming from the conference, but the one session that really sparked something with me was Scott Hanselman’s Presentation, <em><a href="http://www.hanselman.com/blog/PDC10BuildingABlogWithMicrosoftUnnamedPackageOfWebLove.aspx">ASP.NET + Packaging + Open Source = Crazy Delicious</a></em>. Officially, I was mining PDC for Azure and Windows Identity Foundation material for the project I was (and still am) working on. But I <em>love</em> Hanselman’s presentation style; is stuff is always entertaining, stimulating, and <strong>packed</strong> with information. This one was no exception.
<!-- more -->
In a nutshell, the presentation described several different new and pre-release technologies mashed up together into a single very technical demo. All of these techs are interesting, and over the last couple of months I’ve dived into several, if not all of them and I’ve learned a whole lot. I plan on writing about these techs, mostly because when I do I end up learning a lot in the process. But also so I can promote some of these in some small way. In the coming [random time period] I’ll be posting on:</p>

<p><a href="http://nuget.codeplex.com/"><strong>NuGet</strong></a> – <em>a free, open source developer focused package management system for the .NET platform intent on simplifying the process of incorporating third party libraries into a .NET application during development</em>. (that’s quoted from the Codeplex page). It’s way cooler then it sounds… you’ll see.</p>

<p><strong><a href="http://weblogs.asp.net/scottgu/archive/2010/07/16/code-first-development-with-entity-framework-4.aspx">Entity Framework Magic Unicorn Edition</a></strong> – That’s what Hanselman called it, it’s got one of those painful Microsoft names in real life, but Magic Unicorn sounds better. It’s Entity Framework 4, the Code Only Entity Framework. EF without boxes and lines. It’s super cool and you’ll love it. Trust me.</p>

<p><strong><a href="http://weblogs.asp.net/scottgu/archive/2010/12/10/announcing-asp-net-mvc-3-release-candidate-2.aspx">ASP.NET MVC</a> –</strong> Not bleeding edge, it’s been around for a couple of years now. Version 3 is in beta right now, and it’s getting tight. Time to take a look. Even if you’re not going to use it at work next week, it’s important to start thinking about web development done differently then ASP.NET (some would argue, correctly).</p>

<p><strong>MVVM Pattern in WPF and Silverlight</strong> – Ok this one is not from Hanselman’s talk, but at the same time I’ve been looking at all the other tech I’ve had to dive into some WPF UI work for a project, and I figured I’d see what all the chatter was about with MVVM. I’ve spent so many years server side, I decided to approach UI with a clean slate.</p>

<p>I’m sure there’ll be more. I’m rehabbing from knee replacement surgery, so I have some extra time behind the keyboard. Now – <a href="http://blog.efvincent.com/nuget-geeky-goodness/">on to NuGet</a>.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[In Car Video–Carolina Motorsports Park]]></title>
    <link href="http://efvincent.github.io/blog/2010/08/22/in-car-videocarolina-motorsports-park/"/>
    <updated>2010-08-22T19:57:06-04:00</updated>
    <id>http://efvincent.github.io/blog/2010/08/22/in-car-videocarolina-motorsports-park</id>
    <content type="html"><![CDATA[<p>I’ve just finished uploading a new in-car video from the Hurricane region PCA Driver’s Ed event at Carolina Motorsports Park in South Carolina. View it embedded here, or click the link below the picture to go to Vimeo.</p>

<p><a href="http://vimeo.com/14339850">PCA DE CMP August 2010</a> from <a href="http://vimeo.com/efvincent">Eric Vincent</a> on <a href="http://vimeo.com">Vimeo</a>.</p>

<p><!-- more --></p>

<p>Some notes about the video and data acquisition, for those interested in the gory, geeky details:</p>

<p>· Video was shot on a <a href="http://www.amazon.com/gp/product/B002VA57XC">GoPro HD</a>. Last year I tried a ContourHD, but the picture wasn’t quite as good and the sound was terrible – the GoPro does a better job dealing with the wind noise.</p>

<p>· The data (speedo, Tach, Throttle position) was collected using a <a href="http://www.amazon.com/PLX-Devices-2340-KIWI-Wifi/dp/B002ICSOTC">PLX 2340 KIWI Wifi</a>. This device interfaces with the OBD-II port of your car (also used by mechanics to read diagnostics), and transmits several different types of metrics in real time over Wi-Fi at with an observed sample rate of about 3 samples / second.</p>

<p>· The data was then recorded using <a href="http://www.devtoaster.com/products/rev/">Rev by DevToaster</a> for iPhone. This app is compatible with the PLX, so it can collect data being transmitted by your car. It also adds accelerometer data. There’s GPS too, but the iPhone’s GPS is completely unusable for track purposes. The sampling frequency is too low, and it does some very funky interpolation which in the end renders the GPS data useless. For example, here’s a simple plot (graphed using F#) of one of the runs:</p>

<p><a href="http://blog.efvincent.com/wp-content/uploads/2010/08/GPSPlot10081401.png"><img src="http://blog.efvincent.com/wp-content/uploads/2010/08/GPSPlot10081401_thumb.png" alt="GPS Plot 100814-01" /></a></p>

<p>· The data is then exported from the phone as an emailed comma separated value file (.csv).</p>

<p>· A small program I wrote in F# reads the file and transforms the timestamps in to frame numbers (29.97 frames/second), and the data into either rotational data (for the analog gauges) or simple integers (for the digital gauges).</p>

<p>· That data can then be imported into Adobe After Effects. Images of the gauges (drawn from scratch in Adobe Illustrator) are animated into a video overlay using the PLX/Rev data.</p>

<p>· Adobe Premiere then takes the gauges and overlays them on top of the video from the track. There’s some fiddling involved to get the gauge data and video in sync. Premiere then renders the video (20 minutes took 6 hours… not sure if I’m doing that right).</p>

<p>· That rendered video is HD and is pretty big, so I used Microsoft Expression Encoder (Adobe has an encoder too) to re-encode the video into a smaller MP4 format that Vimeo wanted for uploading.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Combinators in C#]]></title>
    <link href="http://efvincent.github.io/blog/2010/05/03/combinators-in-c/"/>
    <updated>2010-05-03T01:15:43-04:00</updated>
    <id>http://efvincent.github.io/blog/2010/05/03/combinators-in-c</id>
    <content type="html"><![CDATA[<p>As C# has evolved it has acquired more and more of what some people refer to has functional programming features and constructs. One such concept is the idea that a function is a “first class” value. This is a fancy way of saying that functions are values that can be passed to and returned from other functions. A function that operates on other functions is called a high-order function.</p>

<!-- more -->

<p>Combinators are high order functions that compose, combine, or otherwise modify functions in useful and interesting ways. These types of operations are not typically seen in C#, but expanding your problem solving toolkit to include these concepts is not only fun and interesting, but can result in new, efficient, robust solutions.</p>

<h2 id="the-timer">The Timer</h2>

<p>Imagine you’ve got a method that you want to put a stopwatch on. For example, in the following code, you need to see how long it’s taking each download to complete, for debugging information.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
<a href="#n24" name="n24">24</a>
<a href="#n25" name="n25">25</a>
</pre></td>
  <td class="code"><pre><span class="type">class</span> <span class="class">Program</span> {

    <span class="directive">static</span> string url;

    <span class="directive">static</span> <span class="type">void</span> Main(string<span class="type">[]</span> args) {

        url = <span class="string"><span class="delimiter">&quot;</span><span class="content">http://microsoft.com</span><span class="delimiter">&quot;</span></span>;
        RetrieveFromWeb();

        url = <span class="string"><span class="delimiter">&quot;</span><span class="content">http://amazon.com</span><span class="delimiter">&quot;</span></span>;
        RetrieveFromWeb();

        url = <span class="string"><span class="delimiter">&quot;</span><span class="content">http://dpreview.com</span><span class="delimiter">&quot;</span></span>;
        RetrieveFromWeb();

        Console.Write(<span class="string"><span class="delimiter">&quot;</span><span class="content">Press any key...</span><span class="delimiter">&quot;</span></span>);
        Console.ReadKey(<span class="predefined-constant">true</span>);
    }

    <span class="directive">static</span> <span class="type">void</span> RetrieveFromWeb() {
        <span class="predefined-type">System</span>.Net.WebClient wc = <span class="keyword">new</span> <span class="predefined-type">System</span>.Net.WebClient();
        var s = wc.DownloadString(url);
        Console.WriteLine(<span class="string"><span class="delimiter">&quot;</span><span class="content">URL: {0} - string length is {1}</span><span class="delimiter">&quot;</span></span>, url, s.Length);
    }
}
</pre></td>
</tr></table>
</div>

<p>An ugly solution would be to do this.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
</pre></td>
  <td class="code"><pre><span class="directive">static</span> <span class="type">void</span> Main(string<span class="type">[]</span> args) {
    var sw = <span class="keyword">new</span> <span class="predefined-type">System</span>.Diagnostics.Stopwatch();

    sw.Start();
    url = <span class="string"><span class="delimiter">&quot;</span><span class="content">http://microsoft.com</span><span class="delimiter">&quot;</span></span>;
    RetrieveFromWeb();
    Console.WriteLine(<span class="string"><span class="delimiter">&quot;</span><span class="content">{0:#,##0}ms</span><span class="delimiter">&quot;</span></span>, sw.ElapsedMilliseconds);

    sw.Restart();
    url = <span class="string"><span class="delimiter">&quot;</span><span class="content">http://amazon.com</span><span class="delimiter">&quot;</span></span>;
    RetrieveFromWeb();
    Console.WriteLine(<span class="string"><span class="delimiter">&quot;</span><span class="content">{0:#,##0}ms</span><span class="delimiter">&quot;</span></span>, sw.ElapsedMilliseconds);

    sw.Restart();
    url = <span class="string"><span class="delimiter">&quot;</span><span class="content">http://dpreview.com</span><span class="delimiter">&quot;</span></span>;
    RetrieveFromWeb();
    Console.WriteLine(<span class="string"><span class="delimiter">&quot;</span><span class="content">{0:#,##0}ms</span><span class="delimiter">&quot;</span></span>, sw.ElapsedMilliseconds);

    Console.Write(<span class="string"><span class="delimiter">&quot;</span><span class="content">Press any key...</span><span class="delimiter">&quot;</span></span>);
    Console.ReadKey(<span class="predefined-constant">true</span>);
}
</pre></td>
</tr></table>
</div>

<p>Try not to get physically ill. You and I both know there’s plenty of code running around in the wild that looks a lot like this. Red flags – you see repeated code – starting, stopping, printing the time. Should we go into the RetrieveFromWeb() method and modify it for timing? Let’s not. Lets try this instead. Step one, let’s define a variable for the method we’re calling. Leaving out the timing code for now, we make this change:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
</pre></td>
  <td class="code"><pre><span class="directive">static</span> <span class="type">void</span> Main(string<span class="type">[]</span> args) {&lt;/p&gt;&lt;p&gt;    <span class="comment">// Create a delegate, set it to the method of interest&lt;/p&gt;&lt;p&gt;    Action retrieveFromWeb = RetrieveFromWeb;</span>

    url = <span class="string"><span class="delimiter">&quot;</span><span class="content">http://microsoft.com</span><span class="delimiter">&quot;</span></span>;
    retrieveFromWeb();

    url = <span class="string"><span class="delimiter">&quot;</span><span class="content">http://amazon.com</span><span class="delimiter">&quot;</span></span>;
    retrieveFromWeb();

    url = <span class="string"><span class="delimiter">&quot;</span><span class="content">http://dpreview.com</span><span class="delimiter">&quot;</span></span>;
    retrieveFromWeb();

    Console.Write(<span class="string"><span class="delimiter">&quot;</span><span class="content">Press any key...</span><span class="delimiter">&quot;</span></span>);
    Console.ReadKey(<span class="predefined-constant">true</span>);
}
</pre></td>
</tr></table>
</div>

<p>I’ve added a local variable of type <em>Action, _and set it equal to the call to the method _RetrieveFromWeb(),</em> and now we’re calling that method indirectly. It has the same exact effect, the method gets called three times. Only we’ve added a layer of indirection. We do this all the time in OO programming; for example, you might have a Person object, but rather than coding directly to that object, you create an IPerson interface, and code to that, opening up the possibility of mocking the object, decorating it, etc. Similar thing here. Rather than “binding” the call sites directly to the method, we’re binding to a variable that points to the method.</p>

<p>We’re doing this because now we’ve got a value that can be altered or augmented to add additional functionality. This is where a combinator comes in. This is a simple timer combinator:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
</pre></td>
  <td class="code"><pre><span class="type">class</span> <span class="class">Combinators</span> {

    <span class="directive">public</span> <span class="directive">static</span> <span class="predefined-type">Action</span> <span class="predefined-type">Time</span>(<span class="predefined-type">Action</span> a) {
        <span class="keyword">return</span> () =&gt; {
            var sw = <span class="keyword">new</span> <span class="predefined-type">System</span>.Diagnostics.Stopwatch();
            sw.Start();
            <span class="keyword">try</span> {
                a();
            } <span class="keyword">finally</span> {
                Console.WriteLine(<span class="string"><span class="delimiter">&quot;</span><span class="content">{0:#,##0}ms</span><span class="delimiter">&quot;</span></span>, sw.ElapsedMilliseconds);
            }
        };
    }
}
</pre></td>
</tr></table>
</div>

<p>This combinator takes an <em>Action</em> and returns a new action (aka a new function), that has timing included. At line 8 the parameter action is being called, the timing is what’s added. The only change we have to make to the main method is where the delegate is being defined:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
</pre></td>
  <td class="code"><pre><span class="predefined-type">Action</span> retrieveFromWeb = Combinators.Time(RetrieveFromWeb);&lt;/p&gt;
</pre></td>
</tr></table>
</div>

<p>The rest of the method stays the same, but now, there’s timing added. This is a super-simple, contrived example, but you should be starting to see what’s possible. Let’s take this a step further. Here’s an example simulating retrieval of information from the database:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
</pre></td>
  <td class="code"><pre><span class="directive">static</span> <span class="type">void</span> Main(string<span class="type">[]</span> args) {

    Func&lt;string, Guid&gt; lookupUser = LookupUser;

    var emails = <span class="keyword">new</span><span class="type">[]</span> {
        <span class="string"><span class="delimiter">&quot;</span><span class="content">eric@work.com</span><span class="delimiter">&quot;</span></span>, <span class="string"><span class="delimiter">&quot;</span><span class="content">joel@office.com</span><span class="delimiter">&quot;</span></span>, <span class="string"><span class="delimiter">&quot;</span><span class="content">cole@school.com</span><span class="delimiter">&quot;</span></span>,
        <span class="string"><span class="delimiter">&quot;</span><span class="content">karin@job.com</span><span class="delimiter">&quot;</span></span>, <span class="string"><span class="delimiter">&quot;</span><span class="content">haley@home.com</span><span class="delimiter">&quot;</span></span> };

    foreach (var em in emails) {
        var id = lookupUser(em);
        Console.WriteLine(<span class="string"><span class="delimiter">&quot;</span><span class="content">user {0} id = {1}</span><span class="delimiter">&quot;</span></span>, em, id);
    }

    Console.Write(<span class="string"><span class="delimiter">&quot;</span><span class="content">Press any key...</span><span class="delimiter">&quot;</span></span>);
    Console.ReadKey(<span class="predefined-constant">true</span>);
}

<span class="directive">static</span> Guid LookupUser(string email) {
    <span class="comment">// Fake looking up a user in the database</span>
    var rnd = <span class="keyword">new</span> <span class="predefined-type">Random</span>(<span class="predefined-type">System</span>.DateTime.Now.Millisecond);
    <span class="predefined-type">Thread</span>.Sleep(rnd.Next(<span class="integer">250</span>, <span class="integer">2500</span>));
    <span class="keyword">return</span> Guid.NewGuid();
}
</pre></td>
</tr></table>
</div>

<p>Memoization is the idea that a function can remember the results for given parameters. It’s like caching, but the term is specific to caching function results based on input. Here’s a simple Memoization combinator for C#:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
</pre></td>
  <td class="code"><pre><span class="directive">public</span> <span class="directive">static</span> Func&lt;A, B&gt; Memoize&lt;A, B&gt;(Func&lt;A, B&gt; fn) {
    var dict = <span class="keyword">new</span> <span class="predefined-type">Dictionary</span>&lt;A, B&gt;();
    <span class="keyword">return</span> a =&gt; {
        B b = <span class="keyword">default</span>(B);
        <span class="keyword">if</span> (!dict.TryGetValue(a, out b)) {
            b = fn(a);
            dict.Add(a, b);
        }
        <span class="keyword">return</span> b;
    };
}
</pre></td>
</tr></table>
</div>

<p>It’s simple, but it demonstrates some very useful and interesting functional programming concepts. First, it’s takes and returns Func&lt;A,B&gt;. This is a delegate with a parameter of type A that returns a type B. This will work for effectively any method with that signature. Next point of interest, a dictionary is created, then the lambda is created and returned. The lambda refers to the dictionary defined outside the lambda. It is said that the dictionary is <em>captured</em> in a <em>closure</em>. It’s not important that you remember the terms, but look over the code and see if the concept is clicking for you. This function will return (effectively) a function, the dictionary is <em>captured</em> by that function. Even when the call to Memoize() goes out of scope, the dict variable will still exist in the returned function. Enough talk. We modify the main program just slightly:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
</pre></td>
  <td class="code"><pre>Func&lt;string, Guid&gt; lookupUser = Combinators.Memoize(LookupUser);
</pre></td>
</tr></table>
</div>

<p>The Memoize function will create a new function, one that caches results of the LookupUser function <em>automatically.</em> Nothing else has to change in the program to take advantage of this. Want to be sure that it’s actually working? Time it! The non-memoized LookupUser() has a built in Thread.Sleep(2500), and so takes 2.5sec * number of lookups to run. The memoized version will run almost instantly, so we can prove the memoizer is working by timing. The time combinator we created earlier was for timing Actions. I’ve created a overload of the time combinator that has the signature we need - Func&lt;A,B&gt;:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
</pre></td>
  <td class="code"><pre><span class="directive">public</span> <span class="directive">static</span> Func&lt;A, B&gt; <span class="predefined-type">Time</span>&lt;A, B&gt;(Func&lt;A, B&gt; fn) {
    <span class="keyword">return</span> a =&gt; {
        var sw = <span class="keyword">new</span> <span class="predefined-type">System</span>.Diagnostics.Stopwatch();
        sw.Start();
        <span class="keyword">try</span> {
            <span class="keyword">return</span> fn(a);
        } <span class="keyword">finally</span> {
            Console.WriteLine(<span class="string"><span class="delimiter">&quot;</span><span class="content">{0:#,##0}ms</span><span class="delimiter">&quot;</span></span>, sw.ElapsedMilliseconds);
        }
    };
}
</pre></td>
</tr></table>
</div>

<p>and added it to the definition of lookUpUser in the main function</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
</pre></td>
  <td class="code"><pre>Func&lt;string, Guid&gt; lookupUser =
  Combinators.Time(
      Combinators.Memoize&lt;string,Guid&gt;(LookupUser));&lt;/p&gt;
</pre></td>
</tr></table>
</div>

<p>Again without modifying the main code, we’ve augmented the method. Throw in some duplicate email addresses to test it out. The real power of these techniques becomes more evident the more you use them. Functional programming developers have been using these are similar techniques for years, and now with the added ability and flexibility of C#, we can employ these patters as well.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Parsing Json Using F#]]></title>
    <link href="http://efvincent.github.io/blog/2010/04/27/parsing-json-using-f/"/>
    <updated>2010-04-27T14:29:49-04:00</updated>
    <id>http://efvincent.github.io/blog/2010/04/27/parsing-json-using-f</id>
    <content type="html"><![CDATA[<p>I was in one of those curious moods the other day, and decided to check out the API for the service behind my RSS reader, <a href="http://www.newsgator.com/Individuals/FeedDemon/Default.aspx">FeedDemon</a>. I like this reader because it keeps my subscriptions and read / unread data synchronized across machines and my iPhone via an app called <a href="http://netnewswireapp.com/iphone/">NetNewsWire</a>.</p>

<!-- more -->

<p>Well it ends up that Google has gobbled up the service and it’s now Google Reader. Fair enough. It means you can also read your RSS feeds on the web at the Google reader site. Whatevs. It also turns out that Google has not publicized the API for that service yet. Yuck. But there are a couple of people out there (like <a href="http://code.google.com/p/pyrfeed/wiki/GoogleReaderAPI">here</a> and <a href="http://blog.martindoms.com/2009/08/15/using-the-google-reader-api-part-1/">here</a>) who have picked it apart using fiddler or some such thing.</p>

<p>Well to put this meandering story to an end, I was playing with the API and it seems that some of the methods only return JSON. Others return XML, and others still are switchable. Messy. No wonder it’s not public yet. So that brings me to the point of this post… Parsing Json using F#.</p>

<h3 id="why-f">Why F#?</h3>

<p>I’ve avoided posting about F# to date, even though I love “playing” with it; I feel that posts about C# are more relevant. People are using F#, but I’ve never had the chance to use it on the job, and I don’t know anyone personally who has either. But since it’s <em>mainstream</em> now, what the heck. Plus parsing is one of those tasks that’s right up F#’s alley. If you haven’t worked with a functional language since college (or ever), give it a whirl. It’s refreshingly different from pure, straight, intensely object oriented thinking.</p>

<h3 id="json-briefly">Json, Briefly</h3>

<p>Most everyone knows what Json is by now. It’s just a tad more horrifying in real life as the supernatural killer from the Friday the 13th movies with whom it homophonetically shares its name. It’s a text format for representing data that can be evaluated in that wonderfully fast and lose language of the web, JavaScript, resulting in actual JavaScript objects. Read about it from the <a href="http://json.org">experts here</a>. Here’s an example of some awesome <a href="http://json.org">Json</a>:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
</pre></td>
  <td class="code"><pre>{
    <span class="key"><span class="delimiter">&quot;</span><span class="content">glossary</span><span class="delimiter">&quot;</span></span>: {
        <span class="key"><span class="delimiter">&quot;</span><span class="content">title</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">example glossary</span><span class="delimiter">&quot;</span></span>,
        <span class="key"><span class="delimiter">&quot;</span><span class="content">GlossDiv</span><span class="delimiter">&quot;</span></span>: {
            <span class="key"><span class="delimiter">&quot;</span><span class="content">title</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">S</span><span class="delimiter">&quot;</span></span>,
            <span class="key"><span class="delimiter">&quot;</span><span class="content">GlossList</span><span class="delimiter">&quot;</span></span>: {
                <span class="key"><span class="delimiter">&quot;</span><span class="content">GlossEntry</span><span class="delimiter">&quot;</span></span>: {
                    <span class="key"><span class="delimiter">&quot;</span><span class="content">ID</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">SGML</span><span class="delimiter">&quot;</span></span>,
                    <span class="key"><span class="delimiter">&quot;</span><span class="content">SortAs</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">SGML</span><span class="delimiter">&quot;</span></span>,
                    <span class="key"><span class="delimiter">&quot;</span><span class="content">GlossTerm</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">Standard Generalized Markup Language</span><span class="delimiter">&quot;</span></span>,
                    <span class="key"><span class="delimiter">&quot;</span><span class="content">Acronym</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">SGML</span><span class="delimiter">&quot;</span></span>,
                    <span class="key"><span class="delimiter">&quot;</span><span class="content">Abbrev</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">ISO 8879:1986</span><span class="delimiter">&quot;</span></span>,
                    <span class="key"><span class="delimiter">&quot;</span><span class="content">GlossDef</span><span class="delimiter">&quot;</span></span>: {
                        <span class="key"><span class="delimiter">&quot;</span><span class="content">para</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">A meta-markup language, used to create markup languages such as DocBook.</span><span class="delimiter">&quot;</span></span>,
                        <span class="key"><span class="delimiter">&quot;</span><span class="content">GlossSeeAlso</span><span class="delimiter">&quot;</span></span>: [<span class="string"><span class="delimiter">&quot;</span><span class="content">GML</span><span class="delimiter">&quot;</span></span>, <span class="string"><span class="delimiter">&quot;</span><span class="content">XML</span><span class="delimiter">&quot;</span></span>]
                    },
                    <span class="key"><span class="delimiter">&quot;</span><span class="content">GlossSee</span><span class="delimiter">&quot;</span></span>: <span class="string"><span class="delimiter">&quot;</span><span class="content">markup</span><span class="delimiter">&quot;</span></span>
                }
            }
        }
    }
}
</pre></td>
</tr></table>
</div>

<h3 id="the-tokenizer">The Tokenizer</h3>

<p>I’m no parsing / compiler / language expert, but I do know that tokenizing is the first step. This is when we run through the string and create tokens; identifying the open and close braces, the name value pairs, etc.</p>

<p>First thing we want to look at is the Token type, which is a discriminated union. This type defines the <em>logical</em> things that are in the Json string. For example, an open quote, some characters, and a close quote is a string.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
</pre></td>
  <td class="code"><pre>type <span class="constant">Token</span> =
  | <span class="constant">OpenBracket</span> | <span class="constant">CloseBracket</span>
  | <span class="constant">OpenArray</span> | <span class="constant">CloseArray</span>
  | <span class="constant">Colon</span> | <span class="constant">Comma</span>
  | <span class="constant">String</span> of string
  | <span class="constant">Number</span> of string
</pre></td>
</tr></table>
</div>

<p>For this simple parser, the tokens are as above, open and close bracket and square bracket (aka array), colon, comma, numbers, and strings. This is a good reason to start with Json, it’s painfully simple. The tokenize function below turns the string into a list of tokens.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
<a href="#n24" name="n24">24</a>
<a href="#n25" name="n25">25</a>
<a href="#n26" name="n26">26</a>
<a href="#n27" name="n27">27</a>
<a href="#n28" name="n28">28</a>
<a href="#n29" name="n29">29</a>
<strong><a href="#n30" name="n30">30</a></strong>
<a href="#n31" name="n31">31</a>
<a href="#n32" name="n32">32</a>
<a href="#n33" name="n33">33</a>
<a href="#n34" name="n34">34</a>
<a href="#n35" name="n35">35</a>
<a href="#n36" name="n36">36</a>
<a href="#n37" name="n37">37</a>
<a href="#n38" name="n38">38</a>
<a href="#n39" name="n39">39</a>
<strong><a href="#n40" name="n40">40</a></strong>
</pre></td>
  <td class="code"><pre>let tokenize source =

  let rec parseString acc = function
    | <span class="string"><span class="delimiter">'</span><span class="char">\\</span><span class="delimiter">'</span></span> :: <span class="string"><span class="delimiter">'</span><span class="content">&quot;</span><span class="delimiter">'</span></span> :: t -&gt; <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> escaped quote
                          parseString (acc + <span class="string"><span class="delimiter">&quot;</span><span class="char">\&quot;</span><span class="delimiter">&quot;</span></span>) t
    | <span class="string"><span class="delimiter">'</span><span class="content">&quot;</span><span class="delimiter">'</span></span> :: t -&gt; <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> closing quote terminates
                  acc, t
    | c :: t -&gt; <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> otherwise accumulate
                parseString (acc + (c.ToString())) t
    | _ -&gt; failwith <span class="string"><span class="delimiter">&quot;</span><span class="content">Malformed string.</span><span class="delimiter">&quot;</span></span>

  let rec token acc = function
    | (<span class="string"><span class="delimiter">'</span><span class="content">)</span><span class="delimiter">'</span></span> :: _) as t -&gt; acc, t <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> closing paren terminates
    | (<span class="string"><span class="delimiter">'</span><span class="content">:</span><span class="delimiter">'</span></span> :: _) as t -&gt; acc, t <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> colon terminates
    | (<span class="string"><span class="delimiter">'</span><span class="content">,</span><span class="delimiter">'</span></span> :: _) as t -&gt; acc, t <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> comma terminates
    | w :: t <span class="keyword">when</span> <span class="constant">Char</span>.IsWhiteSpace(w) -&gt; acc, t <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> whitespace terminates
    | [] -&gt; acc, [] /<span class="regexp"><span class="delimiter">/</span><span class="content"> end of list terminates
    | c :: t -&gt; token (acc + (c.ToString())) t </span><span class="delimiter">/</span></span>/ otherwise accumulate chars

  let rec tokenize<span class="string"><span class="delimiter">'</span><span class="content"> acc = function
    | w :: t when Char.IsWhiteSpace(w) -&gt; tokenize</span><span class="delimiter">'</span></span> acc t   <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> skip whitespace
    | <span class="string"><span class="delimiter">'</span><span class="content">{</span><span class="delimiter">'</span></span> :: t -&gt; tokenize<span class="string"><span class="delimiter">'</span><span class="content"> (OpenBracket :: acc) t
    | </span><span class="delimiter">'</span></span>}<span class="string"><span class="delimiter">'</span><span class="content"> :: t -&gt; tokenize</span><span class="delimiter">'</span></span> (<span class="constant">CloseBracket</span> :: acc) t
    | <span class="string"><span class="delimiter">'</span><span class="content">[</span><span class="delimiter">'</span></span> :: t -&gt; tokenize<span class="string"><span class="delimiter">'</span><span class="content"> (OpenArray :: acc) t
    | </span><span class="delimiter">'</span></span>]<span class="string"><span class="delimiter">'</span><span class="content"> :: t -&gt; tokenize</span><span class="delimiter">'</span></span> (<span class="constant">CloseArray</span> :: acc) t
    | <span class="string"><span class="delimiter">'</span><span class="content">:</span><span class="delimiter">'</span></span> :: t -&gt; tokenize<span class="string"><span class="delimiter">'</span><span class="content"> (Colon :: acc) t
    | </span><span class="delimiter">'</span></span>,<span class="string"><span class="delimiter">'</span><span class="content"> :: t -&gt; tokenize</span><span class="delimiter">'</span></span> (<span class="constant">Comma</span> :: acc) t
    | <span class="string"><span class="delimiter">'</span><span class="content">&quot;</span><span class="delimiter">'</span></span> :: t -&gt; <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> start of string
      let s, t<span class="string"><span class="delimiter">'</span><span class="content"> = parseString &quot;&quot; t
      tokenize</span><span class="delimiter">'</span></span> (<span class="constant">Token</span>.String(s) :: acc) t<span class="string"><span class="delimiter">'</span><span class="content">
    | </span><span class="delimiter">'</span></span>-<span class="string"><span class="delimiter">'</span><span class="content"> :: d :: t when Char.IsDigit(d) -&gt; // start of negative number
        let n, t</span><span class="delimiter">'</span></span> = token (<span class="string"><span class="delimiter">&quot;</span><span class="content">-</span><span class="delimiter">&quot;</span></span> + d.ToString()) t
        tokenize<span class="string"><span class="delimiter">'</span><span class="content"> (Token.Number(n) :: acc) t</span><span class="delimiter">'</span></span>
    | <span class="string"><span class="delimiter">'</span><span class="content">+</span><span class="delimiter">'</span></span> :: d :: t | d :: t <span class="keyword">when</span> <span class="constant">Char</span>.IsDigit(d) -&gt; <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> start of positive number
        let n, t<span class="string"><span class="delimiter">'</span><span class="content"> = token (d.ToString()) t
        tokenize</span><span class="delimiter">'</span></span> (<span class="constant">Token</span>.Number(n) :: acc) t<span class="string"><span class="delimiter">'</span><span class="content">
    | [] -&gt; List.rev acc // end of list terminates
    | _ -&gt; failwith &quot;Tokinzation error&quot;

  tokenize</span><span class="delimiter">'</span></span> [] source
</pre></td>
</tr></table>
</div>

<p>We don’t have time for the full treatment of F#. If there’s any interest, I’ll post up some tutorials or at least links to some of the very many existing good tutorials out there already. For now, assume we have an understanding of the syntax, and the logic of tokenizing and parsing is what we’re after here.</p>

<p>One of the first things we see is that <em>tokenize</em> defines a few functions within the function. Great feature of F#, allowing definitions of inner functions; it allows the coder to partition logic without having function explosion.</p>

<p>The driving inner function is <em>tokenize’</em>, whose signature is (Token list –&gt; char list –&gt; Token list). This means it takes a Token list and a char list, and returns a Token list. The first token list (acc) is an accumulator. This list is built up as the procedure calls itself recursively. This is a common pattern in functional languages, to “thread” an accumulator through recursive calls. The second parameter is a char list, or a list of characters from the source string.</p>

<p>We don’t see the char list explicitly because of the use of the <em>function</em> keyword at like 20, this keyword means that the last parameter (the char list) is implicitly used in a match statement, the cases of which follow after the function keyword. The syntax would be equivalent to:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
</pre></td>
  <td class="code"><pre>let rec tokenize<span class="string"><span class="delimiter">'</span><span class="content"> acc sourceChars =
  match sourceChars with
  | w :: t when Char.IsWhiteSpace(w) -&gt; tokenize</span><span class="delimiter">'</span></span> acc t   <span class="regexp"><span class="delimiter">/</span><span class="delimiter">/</span></span> skip whitespace
  | <span class="string"><span class="delimiter">'</span><span class="content">{</span><span class="delimiter">'</span></span> :: t -&gt; tokenize<span class="string"><span class="delimiter">'</span><span class="content"> (OpenBracket :: acc) t
  | </span><span class="delimiter">'</span></span>}<span class="string"><span class="delimiter">'</span><span class="content"> :: t -&gt; tokenize</span><span class="delimiter">'</span></span> (<span class="constant">CloseBracket</span> :: acc) t
</pre></td>
</tr></table>
</div>

<p>The idea that the sourceChars variable being passed immediately to the match..with construct is so common in F# that the <em>function</em> keyword is used as a contraction, allowing the elimination of what is an unnecessary variable. In many cases, this construct allows for a one line function definition.</p>

<p>Most of the cases in the block matches a character which in turn maps to a token, which is appended to the accumulator (acc : Token list), and passed to a recursive call of tokenize’. This way the tokens are built up (in reverse order) as the string is traversed. This is seen in lines 22-27. Line 21 skips whitespace by calling tokenize’ without adding a token to the accumulator first.</p>

<p>Things are a bit more interesting at lines 28, 31, and 34. Line 28 detects the beginning of a string, and starts a new recursive thread with the <em>parseString</em> function, the signature of which is (string –&gt; char list –&gt; string * char list). So the accumulator is a string, the “work” is being done on a char list, to which is passed our source char list, and the return is a tuple of string * char list, which is our parsed string and the rest of the source char list. One (of I’m sure <strong>many</strong>) optimizations that could be made is to use a mutable StringBuilder as the accumulator in parseString.</p>

<p>The <em>token</em> function on line 12 does a similar job for non-string literals (numbers in this case, there are no bools in Json).</p>

<p>Lastly, line 37 handles the case where we run out of source characters. The Token list we’ve been accumulating is backwards; we’ve been “appending” to the front of the list all this time. This is a common pattern. At the end, we return the reverse of the list. When the Json at the top is put through the tokenizer, we get this:</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
</pre></td>
  <td class="code"><pre>&gt; let tk = tokenize source;;

val tk : <span class="constant">Token</span> list =
  [<span class="constant">OpenBracket</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">glossary</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>; <span class="constant">OpenBracket</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">title</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>;
   <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">example glossary</span><span class="delimiter">&quot;</span></span>; <span class="constant">Comma</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">GlossDiv</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>; <span class="constant">OpenBracket</span>;
   <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">title</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">S</span><span class="delimiter">&quot;</span></span>; <span class="constant">Comma</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">GlossList</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>;
   <span class="constant">OpenBracket</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">GlossEntry</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>; <span class="constant">OpenBracket</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">ID</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>;
   <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">SGML</span><span class="delimiter">&quot;</span></span>; <span class="constant">Comma</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">SortAs</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">SGML</span><span class="delimiter">&quot;</span></span>; <span class="constant">Comma</span>;
   <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">GlossTerm</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">Standard Generalized Markup Language</span><span class="delimiter">&quot;</span></span>;
   <span class="constant">Comma</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">Acronym</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">SGML</span><span class="delimiter">&quot;</span></span>; <span class="constant">Comma</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">Abbrev</span><span class="delimiter">&quot;</span></span>;
   <span class="constant">Colon</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">ISO 8879:1986</span><span class="delimiter">&quot;</span></span>; <span class="constant">Comma</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">GlossDef</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>; <span class="constant">OpenBracket</span>;
   <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">para</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>;
   <span class="constant">String</span>
     <span class="string"><span class="delimiter">&quot;</span><span class="content">A meta-markup language, used to create markup languages such as DocBook.</span><span class="delimiter">&quot;</span></span>;
   <span class="constant">Comma</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">GlossSeeAlso</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>; <span class="constant">OpenArray</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">GML</span><span class="delimiter">&quot;</span></span>; <span class="constant">Comma</span>;
   <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">XML</span><span class="delimiter">&quot;</span></span>; <span class="constant">CloseArray</span>; <span class="constant">CloseBracket</span>; <span class="constant">Comma</span>; <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">GlossSee</span><span class="delimiter">&quot;</span></span>; <span class="constant">Colon</span>;
   <span class="constant">String</span> <span class="string"><span class="delimiter">&quot;</span><span class="content">markup</span><span class="delimiter">&quot;</span></span>; <span class="constant">CloseBracket</span>; <span class="constant">CloseBracket</span>; <span class="constant">CloseBracket</span>; <span class="constant">CloseBracket</span>;
   <span class="constant">CloseBracket</span>]
</pre></td>
</tr></table>
</div>

<p>This list of tokens is an intermediate step. From here, we could go in several directions. For my purposes, I wanted to see it as XML. To get there, I created a parser that takes the token list and returns an XElement.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
<a href="#n24" name="n24">24</a>
<a href="#n25" name="n25">25</a>
<a href="#n26" name="n26">26</a>
<a href="#n27" name="n27">27</a>
<a href="#n28" name="n28">28</a>
<a href="#n29" name="n29">29</a>
<strong><a href="#n30" name="n30">30</a></strong>
<a href="#n31" name="n31">31</a>
<a href="#n32" name="n32">32</a>
<a href="#n33" name="n33">33</a>
<a href="#n34" name="n34">34</a>
<a href="#n35" name="n35">35</a>
<a href="#n36" name="n36">36</a>
<a href="#n37" name="n37">37</a>
<a href="#n38" name="n38">38</a>
<a href="#n39" name="n39">39</a>
<strong><a href="#n40" name="n40">40</a></strong>
<a href="#n41" name="n41">41</a>
<a href="#n42" name="n42">42</a>
<a href="#n43" name="n43">43</a>
<a href="#n44" name="n44">44</a>
<a href="#n45" name="n45">45</a>
<a href="#n46" name="n46">46</a>
<a href="#n47" name="n47">47</a>
<a href="#n48" name="n48">48</a>
<a href="#n49" name="n49">49</a>
<strong><a href="#n50" name="n50">50</a></strong>
<a href="#n51" name="n51">51</a>
<a href="#n52" name="n52">52</a>
<a href="#n53" name="n53">53</a>
<a href="#n54" name="n54">54</a>
<a href="#n55" name="n55">55</a>
<a href="#n56" name="n56">56</a>
<a href="#n57" name="n57">57</a>
<a href="#n58" name="n58">58</a>
<a href="#n59" name="n59">59</a>
<strong><a href="#n60" name="n60">60</a></strong>
</pre></td>
  <td class="code"><pre>let parseToXml source =
let map = function
  | <span class="constant">Token</span>.Number(n) -&gt; n.ToString()
  | <span class="constant">Token</span>.String(x) -&gt; x
  | v -&gt; failwith <span class="string"><span class="delimiter">&quot;</span><span class="content">Syntax Error, unrecognized token in map()</span><span class="delimiter">&quot;</span></span>

let rec parseValue (<span class="key">acc</span>:<span class="constant">XElement</span>) = function
  | <span class="constant">OpenBracket</span> :: t -&gt;
    let newElement, t<span class="string"><span class="delimiter">'</span><span class="content"> = parseElement acc t
    newElement, t</span><span class="delimiter">'</span></span>
  | <span class="constant">OpenArray</span> :: t -&gt;
    let name = acc.Name.LocalName
    <span class="keyword">if</span> name.EndsWith(<span class="string"><span class="delimiter">&quot;</span><span class="content">ies</span><span class="delimiter">&quot;</span></span>) &amp;&amp; name.Length &gt; <span class="integer">3</span> <span class="keyword">then</span>
      let childName = name.Substring(<span class="integer">0</span>, name.Length - <span class="integer">3</span>) + <span class="string"><span class="delimiter">&quot;</span><span class="content">y</span><span class="delimiter">&quot;</span></span>
      let newListElement, t<span class="string"><span class="delimiter">'</span><span class="content"> = parseArray childName acc t
      newListElement, t</span><span class="delimiter">'</span></span>
    elif name.EndsWith(<span class="string"><span class="delimiter">&quot;</span><span class="content">s</span><span class="delimiter">&quot;</span></span>) &amp;&amp; name.Length &gt; <span class="integer">1</span> <span class="keyword">then</span>
      let childName = name.Substring(<span class="integer">0</span>, name.Length - <span class="integer">1</span>)
      let newListElement, t<span class="string"><span class="delimiter">'</span><span class="content"> = parseArray childName acc t
      newListElement, t</span><span class="delimiter">'</span></span>
    <span class="keyword">else</span>
      let childName = acc.Name.LocalName
      acc.Name &lt;- <span class="constant">XName</span>.Get(childName + <span class="string"><span class="delimiter">&quot;</span><span class="content">s</span><span class="delimiter">&quot;</span></span>)
      let newListElement, t<span class="string"><span class="delimiter">'</span><span class="content"> = parseArray childName acc t
      newListElement, t</span><span class="delimiter">'</span></span>
  | h :: t -&gt;
    acc.Value &lt;- map(h)
    acc, t
  | _ -&gt; failwith <span class="string"><span class="delimiter">&quot;</span><span class="content">bad value</span><span class="delimiter">&quot;</span></span>

<span class="keyword">and</span> parseArray name acc = function
  | <span class="constant">Comma</span> :: t -&gt; parseArray name acc t
  | <span class="constant">CloseArray</span> :: t -&gt;  acc, t
  | t -&gt;
    let newElement = XElement(<span class="constant">XName</span>.Get(name))
    let acc<span class="string"><span class="delimiter">'</span><span class="content">, t</span><span class="delimiter">'</span></span> = parseValue newElement t
    acc.Add(acc<span class="string"><span class="delimiter">'</span><span class="content">)
    parseArray name acc t</span><span class="delimiter">'</span></span>

<span class="keyword">and</span> parseElement (acc : <span class="constant">XElement</span>) = function
  | <span class="constant">Comma</span> :: t -&gt;
    parseElement acc t
  | <span class="constant">Token</span>.String(n) :: <span class="constant">Colon</span> :: t -&gt;
    let newElement = XElement(<span class="constant">XName</span>.Get(n))
    let v, t<span class="string"><span class="delimiter">'</span><span class="content"> = parseValue newElement t
    acc.Add(v)
    parseElement acc t</span><span class="delimiter">'</span></span>
  | <span class="constant">CloseBracket</span> :: t -&gt;
    acc, t
  | _ -&gt; failwith <span class="string"><span class="delimiter">&quot;</span><span class="content">Malformed JSON object</span><span class="delimiter">&quot;</span></span>

let root = XElement(<span class="constant">XName</span>.Get(<span class="string"><span class="delimiter">&quot;</span><span class="content">root</span><span class="delimiter">&quot;</span></span>))
let tokens = tokenize source

match tokens with
  | <span class="constant">OpenBracket</span> :: t -&gt;
    let result, t<span class="string"><span class="delimiter">'</span><span class="content"> = parseElement root t
    result
  | _ -&gt; failwith &quot;Json did not begin with an object&quot;
</span><span class="delimiter">'</span></span>
</pre></td>
</tr></table>
</div>

<p>There is still syntax checking happening in the parse step. The tokenizer would have found illegal tokens, but the parse function will find illegal Json structure. It works in a similar way to the tokenizer, except instead of a raw stream of characters, we’ve got a stream of tokens, which is examined one by one and passed to a set of recursive functions which accumulates the XML, in this case as an XElement.</p>

<p>parseToXml defines inner functions <em>map</em>, <em>parseValue</em>, <em>parseArray</em>, and <em>parseElement.</em> It then gets to work by creating a root XElement, and getting the Token list. Json should start with an OpenBracket token. Anything else and we failwith an error (like C#’s throw). When we find that OpenBracket, the recursion begins with a call to parseElement. The root XElement serves as the accumulator, and the Token list is the “work” to be done.</p>

<p>You should be able to see what’s happening if you’re somewhat comfortable with F#. The parseValue function does some extra work to wrap arrays in nodes where the singularity / plurality of the node makes it read a bit better (in English, most of the time). The other point of interest is that the accumulator is a mutable object in parseToXml, unlike the Token list was in tokenize. At lines 37 and 46, the newly created elements are added to the accumulator using the Add(XElement) method, which mutates the accumulator and keeps using it. This is a departure from “purer” functional techniques, but that’s what’s cool about F#, you can make those departures where it makes sense. In this case, leveraging the XElement class of the .NET framework was worth it. Consuming this class from C# is that much easier and more intuitive.</p>

<p>After all is said and done, this is the XML that is emitted.</p>

<div><table class="CodeRay"><tr>
  <td class="line-numbers"><pre><a href="#n1" name="n1">1</a>
<a href="#n2" name="n2">2</a>
<a href="#n3" name="n3">3</a>
<a href="#n4" name="n4">4</a>
<a href="#n5" name="n5">5</a>
<a href="#n6" name="n6">6</a>
<a href="#n7" name="n7">7</a>
<a href="#n8" name="n8">8</a>
<a href="#n9" name="n9">9</a>
<strong><a href="#n10" name="n10">10</a></strong>
<a href="#n11" name="n11">11</a>
<a href="#n12" name="n12">12</a>
<a href="#n13" name="n13">13</a>
<a href="#n14" name="n14">14</a>
<a href="#n15" name="n15">15</a>
<a href="#n16" name="n16">16</a>
<a href="#n17" name="n17">17</a>
<a href="#n18" name="n18">18</a>
<a href="#n19" name="n19">19</a>
<strong><a href="#n20" name="n20">20</a></strong>
<a href="#n21" name="n21">21</a>
<a href="#n22" name="n22">22</a>
<a href="#n23" name="n23">23</a>
<a href="#n24" name="n24">24</a>
<a href="#n25" name="n25">25</a>
</pre></td>
  <td class="code"><pre><span class="tag">&lt;root&gt;</span>
  <span class="tag">&lt;glossary&gt;</span>
    <span class="tag">&lt;title&gt;</span>example glossary<span class="tag">&lt;/title&gt;</span>
    <span class="tag">&lt;GlossDiv&gt;</span>
      <span class="tag">&lt;title&gt;</span>S<span class="tag">&lt;/title&gt;</span>
      <span class="tag">&lt;GlossList&gt;</span>
        <span class="tag">&lt;GlossEntry&gt;</span>
          <span class="tag">&lt;ID&gt;</span>SGML<span class="tag">&lt;/ID&gt;</span>
          <span class="tag">&lt;SortAs&gt;</span>SGML<span class="tag">&lt;/SortAs&gt;</span>
          <span class="tag">&lt;GlossTerm&gt;</span>Standard Generalized Markup Language<span class="tag">&lt;/GlossTerm&gt;</span>
          <span class="tag">&lt;Acronym&gt;</span>SGML<span class="tag">&lt;/Acronym&gt;</span>
          <span class="tag">&lt;Abbrev&gt;</span>ISO 8879:1986<span class="tag">&lt;/Abbrev&gt;</span>
          <span class="tag">&lt;GlossDef&gt;</span>
            <span class="tag">&lt;para&gt;</span>A meta-markup language, used to create markup languages such as DocBook.<span class="tag">&lt;/para&gt;</span>
            <span class="tag">&lt;GlossSeeAlsos&gt;</span>
              <span class="tag">&lt;GlossSeeAlso&gt;</span>GML<span class="tag">&lt;/GlossSeeAlso&gt;</span>
              <span class="tag">&lt;GlossSeeAlso&gt;</span>XML<span class="tag">&lt;/GlossSeeAlso&gt;</span>
            <span class="tag">&lt;/GlossSeeAlsos&gt;</span>
          <span class="tag">&lt;/GlossDef&gt;</span>
          <span class="tag">&lt;GlossSee&gt;</span>markup<span class="tag">&lt;/GlossSee&gt;</span>
        <span class="tag">&lt;/GlossEntry&gt;</span>
      <span class="tag">&lt;/GlossList&gt;</span>
    <span class="tag">&lt;/GlossDiv&gt;</span>
  <span class="tag">&lt;/glossary&gt;</span>
<span class="tag">&lt;/root&gt;</span>
</pre></td>
</tr></table>
</div>

<p>It isn’t the most sophisticated, performant, or I’m sure accurate Json parser out there. But it does the trick for my immediate need, is a good starting point for more sophistication later if needed, and was an excellent exercise in parsing and F#. It was fun to write, and hopefully it stimulates some curiosities. Let me know if you’ve got any questions or comments.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Roll Your Own Language Constructs]]></title>
    <link href="http://efvincent.github.io/blog/2010/02/02/roll-your-own-language-constructs/"/>
    <updated>2010-02-02T23:24:18-05:00</updated>
    <id>http://efvincent.github.io/blog/2010/02/02/roll-your-own-language-constructs</id>
    <content type="html"><![CDATA[<p>My last couple of blog entries were ostensibly about lambda functions (<a href="http://blog.efvincent.com/c-nuts-and-bolts-lambdas/">last one</a>, <a href="http://blog.efvincent.com/c-nuts-and-bolts-lambdas02">one before</a>). With these ideas, or a general comfort level with lambdas and the Action&lt;&gt; and Func&lt;&gt; delegate types in the back of your mind, consider this.</p>

<!-- more -->

<p>I was working on a project where the development team was instructed to implement a retry logic into our data access layer. In other words, if we experience database connectivity problems, retry the operation as seems reasonable.</p>

<p>Here’s some code we’re going to use as a basis for the conversation:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
<span class="line-number">25</span>
<span class="line-number">26</span>
<span class="line-number">27</span>
<span class="line-number">28</span>
<span class="line-number">29</span>
<span class="line-number">30</span>
<span class="line-number">31</span>
<span class="line-number">32</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">class</span> <span class="nc">Program</span> <span class="p">{</span>
</span><span class="line">    <span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">
</span><span class="line">        <span class="k">try</span> <span class="p">{</span>
</span><span class="line">            <span class="n">Retry01</span><span class="p">();</span>
</span><span class="line">        <span class="p">}</span> <span class="k">catch</span> <span class="p">(</span><span class="n">Exception</span> <span class="n">ex</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">            <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="n">ex</span><span class="p">.</span><span class="n">Message</span><span class="p">);</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">        <span class="n">Console</span><span class="p">.</span><span class="n">Write</span><span class="p">(</span><span class="s">&quot;Press any key...&quot;</span><span class="p">);</span>
</span><span class="line">        <span class="n">Console</span><span class="p">.</span><span class="n">ReadKey</span><span class="p">(</span><span class="k">true</span><span class="p">);</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line">
</span><span class="line">    <span class="k">static</span> <span class="k">void</span> <span class="nf">Retry01</span><span class="p">()</span> <span class="p">{</span>
</span><span class="line">        <span class="c1">// Iterate through the directories on the C:\ drive</span>
</span><span class="line">        <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">dir</span> <span class="k">in</span> <span class="n">Directory</span><span class="p">.</span><span class="n">EnumerateDirectories</span><span class="p">(</span><span class="s">&quot;C:\\&quot;</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">            <span class="n">OccasionallyThrow</span><span class="p">(</span><span class="m">0.1d</span><span class="p">);</span>
</span><span class="line">            <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;dir: {0}&quot;</span><span class="p">,</span> <span class="n">dir</span><span class="p">);</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line">
</span><span class="line">    <span class="k">static</span> <span class="n">Random</span> <span class="n">_rnd</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Random</span><span class="p">(</span><span class="n">DateTime</span><span class="p">.</span><span class="n">Now</span><span class="p">.</span><span class="n">Millisecond</span><span class="p">);</span>
</span><span class="line">    <span class="c1">/// &lt;summary&gt;</span>
</span><span class="line">    <span class="c1">/// Occasionally throw an exception</span>
</span><span class="line">    <span class="c1">/// &lt;/summary&gt;</span>
</span><span class="line">    <span class="c1">/// &lt;param name=&quot;freq&quot;&gt;Percentage (as a fraction) of the time to</span>
</span><span class="line">    <span class="c1">/// throw an exception. Uses a random number generator, so</span>
</span><span class="line">    <span class="c1">/// this is not an exact measure&lt;/param&gt;</span>
</span><span class="line">    <span class="k">static</span> <span class="k">void</span> <span class="nf">OccasionallyThrow</span><span class="p">(</span><span class="kt">double</span> <span class="n">freq</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">        <span class="k">if</span> <span class="p">(</span><span class="n">_rnd</span><span class="p">.</span><span class="n">NextDouble</span><span class="p">()</span> <span class="p">&lt;=</span> <span class="n">freq</span><span class="p">)</span>
</span><span class="line">            <span class="k">throw</span> <span class="k">new</span> <span class="nf">InvalidOperationException</span><span class="p">(</span><span class="s">&quot;An occasional exception&quot;</span><span class="p">);</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>We’ve got a method, <code>OccasionallyThrow(freq)</code> that, occasionally throws an exception (duh). We’ve got a method that iterates through directories on the C:\ drive and pretty much can’t get through it without throwing.</p>

<p>So first pass, let’s fix <code>Retry01()</code> so it actually retries.</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
<span class="line-number">25</span>
<span class="line-number">26</span>
<span class="line-number">27</span>
<span class="line-number">28</span>
<span class="line-number">29</span>
<span class="line-number">30</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">Retry01</span><span class="p">()</span> <span class="p">{</span>
</span><span class="line">    <span class="c1">// Iterate through the directories on the C:\ drive</span>
</span><span class="line">    <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">dir</span> <span class="k">in</span> <span class="n">Directory</span><span class="p">.</span><span class="n">EnumerateDirectories</span><span class="p">(</span><span class="s">&quot;C:\\&quot;</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">
</span><span class="line">        <span class="kt">int</span> <span class="n">retryCount</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span><span class="line">        <span class="kt">bool</span> <span class="n">done</span> <span class="p">=</span> <span class="k">false</span><span class="p">;</span>
</span><span class="line">        <span class="k">do</span> <span class="p">{</span>
</span><span class="line">            <span class="k">try</span> <span class="p">{</span>
</span><span class="line">
</span><span class="line">                <span class="n">OccasionallyThrow</span><span class="p">(</span><span class="m">0.25d</span><span class="p">);</span>
</span><span class="line">                <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;dir: {0}&quot;</span><span class="p">,</span> <span class="n">dir</span><span class="p">);</span>
</span><span class="line">
</span><span class="line">                <span class="n">done</span> <span class="p">=</span> <span class="k">true</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">            <span class="p">}</span> <span class="k">catch</span> <span class="p">(</span><span class="n">Exception</span> <span class="n">ex</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">                <span class="k">if</span> <span class="p">(</span><span class="n">ex</span> <span class="k">is</span> <span class="n">InvalidOperationException</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">                    <span class="k">if</span> <span class="p">(</span><span class="n">retryCount</span><span class="p">++</span> <span class="p">&lt;</span> <span class="m">3</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">                        <span class="c1">// can try again. Under the limit</span>
</span><span class="line">                        <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;Caught exception, retry #{0}&quot;</span><span class="p">,</span> <span class="n">retryCount</span><span class="p">);</span>
</span><span class="line">                        <span class="n">done</span> <span class="p">=</span> <span class="k">false</span><span class="p">;</span>
</span><span class="line">                    <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span><span class="line">                        <span class="c1">// retried too many times already</span>
</span><span class="line">                        <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;Exceeded retry count. Throwing.&quot;</span><span class="p">);</span>
</span><span class="line">                        <span class="k">throw</span><span class="p">;</span>
</span><span class="line">                    <span class="p">}</span>
</span><span class="line">                <span class="p">}</span>
</span><span class="line">            <span class="p">}</span>
</span><span class="line">        <span class="p">}</span> <span class="k">while</span> <span class="p">(!</span><span class="n">done</span><span class="p">);</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Yikes. That’s a bunch of code. Assuming we want to make this construct generally available, some refactoring is in order. Worse, the boilerplate code that manages retries <em>surrounds</em> the code we want to apply it to, at lines 10 and 11 of a 30 line block of code. This is a similar problem to the one described in <a href="http://blog.efvincent.com/c-nuts-and-bolts-lambdas02">my last post</a>, so you may see where this is going. Here’s one approach to solving the problem.</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
<span class="line-number">25</span>
<span class="line-number">26</span>
<span class="line-number">27</span>
<span class="line-number">28</span>
<span class="line-number">29</span>
<span class="line-number">30</span>
<span class="line-number">31</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">Retry</span><span class="p">(</span><span class="n">Action</span> <span class="n">action</span><span class="p">,</span> <span class="kt">int</span> <span class="n">maxRetries</span> <span class="p">=</span> <span class="m">3</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="kt">int</span> <span class="n">retryCount</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">bool</span> <span class="n">done</span> <span class="p">=</span> <span class="k">false</span><span class="p">;</span>
</span><span class="line">    <span class="k">do</span> <span class="p">{</span>
</span><span class="line">        <span class="k">try</span> <span class="p">{</span>
</span><span class="line">            <span class="n">action</span><span class="p">();</span>
</span><span class="line">            <span class="n">done</span> <span class="p">=</span> <span class="k">true</span><span class="p">;</span>
</span><span class="line">        <span class="p">}</span> <span class="k">catch</span> <span class="p">(</span><span class="n">Exception</span> <span class="n">ex</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">            <span class="k">if</span> <span class="p">(</span><span class="n">ex</span> <span class="k">is</span> <span class="n">InvalidOperationException</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">                <span class="k">if</span> <span class="p">(</span><span class="n">retryCount</span><span class="p">++</span> <span class="p">&lt;</span> <span class="n">maxRetries</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">                    <span class="c1">// can try again. Under the limit</span>
</span><span class="line">                    <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;Caught exception, retry #{0}&quot;</span><span class="p">,</span> <span class="n">retryCount</span><span class="p">);</span>
</span><span class="line">                    <span class="n">done</span> <span class="p">=</span> <span class="k">false</span><span class="p">;</span>
</span><span class="line">                <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span><span class="line">                    <span class="c1">// retried too many times already</span>
</span><span class="line">                    <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;Exceeded retry count. Throwing.&quot;</span><span class="p">);</span>
</span><span class="line">                    <span class="k">throw</span><span class="p">;</span>
</span><span class="line">                <span class="p">}</span>
</span><span class="line">            <span class="p">}</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">    <span class="p">}</span> <span class="k">while</span> <span class="p">(!</span><span class="n">done</span><span class="p">);</span>
</span><span class="line"><span class="p">}</span>
</span><span class="line">
</span><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">Retry02</span><span class="p">()</span> <span class="p">{</span>
</span><span class="line">    <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">dir</span> <span class="k">in</span> <span class="n">Directory</span><span class="p">.</span><span class="n">EnumerateDirectories</span><span class="p">(</span><span class="s">&quot;C:\\&quot;</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">        <span class="n">Retry</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span><span class="line">            <span class="n">OccasionallyThrow</span><span class="p">(</span><span class="m">0.25d</span><span class="p">);</span>
</span><span class="line">            <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;dir: {0}&quot;</span><span class="p">,</span> <span class="n">dir</span><span class="p">);</span>
</span><span class="line">        <span class="p">},</span> <span class="m">3</span><span class="p">);</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>This approach solves many of the problems we’ve identified. The retry logic is encapsulated in a function that’s trivial to reuse. One point of interest here… if you’re not familiar with the syntax and techniques, it may look a bit strange. But it also should look a little familiar; consider the “using” block:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="kt">byte</span> <span class="n">someByte</span> <span class="p">=</span> <span class="m">100</span><span class="p">;</span>
</span><span class="line"><span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">stream</span> <span class="p">=</span> <span class="n">File</span><span class="p">.</span><span class="n">Open</span><span class="p">(</span><span class="s">&quot;C:\\data.dat&quot;</span><span class="p">,</span> <span class="n">FileMode</span><span class="p">.</span><span class="n">CreateNew</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">    <span class="k">for</span> <span class="p">(</span><span class="kt">byte</span> <span class="n">i</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="p">&lt;</span> <span class="n">someByte</span><span class="p">;</span> <span class="n">i</span><span class="p">++)</span>
</span><span class="line">        <span class="n">stream</span><span class="p">.</span><span class="n">WriteByte</span><span class="p">(</span><span class="n">i</span><span class="p">);</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>The C# using block has a similar pattern. There’s some construct (using), and then a block of code to which the construct applies. It has a similar feel to our Retry() solution. Hmmm… could we use the Retry() approach to write our own using?</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="n">Using</span><span class="p">&lt;</span><span class="n">T</span><span class="p">&gt;(</span><span class="n">T</span> <span class="n">disposableVar</span><span class="p">,</span> <span class="n">Action</span><span class="p">&lt;</span><span class="n">T</span><span class="p">&gt;</span> <span class="n">usingBlock</span><span class="p">)</span> <span class="k">where</span> <span class="n">T</span> <span class="p">:</span> <span class="n">IDisposable</span> <span class="p">{</span>
</span><span class="line">    <span class="k">try</span> <span class="p">{</span>
</span><span class="line">        <span class="n">usingBlock</span><span class="p">(</span><span class="n">disposableVar</span><span class="p">);</span>
</span><span class="line">    <span class="p">}</span> <span class="k">finally</span> <span class="p">{</span>
</span><span class="line">        <span class="n">disposableVar</span><span class="p">.</span><span class="n">Dispose</span><span class="p">();</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span><span class="line">
</span><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">UsingMyUsing</span><span class="p">()</span> <span class="p">{</span>
</span><span class="line">    <span class="kt">byte</span> <span class="n">someByte</span> <span class="p">=</span> <span class="m">100</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="n">Using</span><span class="p">(</span><span class="n">File</span><span class="p">.</span><span class="n">Open</span><span class="p">(</span><span class="s">&quot;C:\\data.dat&quot;</span><span class="p">,</span> <span class="n">FileMode</span><span class="p">.</span><span class="n">CreateNew</span><span class="p">),</span> <span class="n">stream</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span><span class="line">        <span class="k">for</span> <span class="p">(</span><span class="kt">byte</span> <span class="n">i</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="p">&lt;</span> <span class="n">someByte</span><span class="p">;</span> <span class="n">i</span><span class="p">++)</span>
</span><span class="line">            <span class="n">stream</span><span class="p">.</span><span class="n">WriteByte</span><span class="p">(</span><span class="n">i</span><span class="p">);</span>
</span><span class="line">    <span class="p">});</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>See that’s why I like coding so much… that’s definitely cool. It’s not exactly character for character like the using statement, but it’s pretty darn close (actually, mine is a couple of characters shorter). And it’s equivalent (at least it is superficially, I haven’t checked thoroughly, it’s almost 1am after all). It had to get a little fancier with the generics, but we’ve recreated a C# language construct.</p>

<p>This article is long enough, and I’m sure you get the picture. To me, this is a great example of how functional thinking can lead to interesting, robust solutions to problems. Let me know if you’ve got any questions or comments. Until then, have fun!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Lambdas – Exposing Disposable Resources in Your API]]></title>
    <link href="http://efvincent.github.io/blog/2010/02/02/c-nuts-and-bolts-lambdas02/"/>
    <updated>2010-02-02T13:51:56-05:00</updated>
    <id>http://efvincent.github.io/blog/2010/02/02/c-nuts-and-bolts-lambdas02</id>
    <content type="html"><![CDATA[<p>The <a href="http://blog.efvincent.com/c-nuts-and-bolts-lambdas/">last article</a> described the absolute (and I mean really absolute) basics of lambdas in C#. Assuming you’re continuing from there, where to next? Let’s use some lambdas. There are two approaches we can use. First is using lambdas in places you traditionally used other approaches. Second is using them in new and interesting ways. Hmmm. Which to choose.
<!-- more --></p>

<h3 id="new-and-interesting-code-constructs-using-lambdas">New and Interesting Code Constructs using Lambdas</h3>

<p>Yea that’ll do. Let’s take an example situation. You’re tasked with writing part of a data access layer. It’s a low level data access layer, we’re not using Entity Framework, no Linq to SQL. No NHibernate. Just you and the keyboard. Sweet.</p>

<p>The team decides they’re comfortable with the forward only read only data reader. Ok. So you start sketching out your code and end up with this:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">public</span> <span class="k">static</span> <span class="n">IDataReader</span> <span class="nf">GetSomeData</span><span class="p">()</span> <span class="p">{</span>
</span><span class="line">    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">con</span> <span class="p">=</span> <span class="k">new</span> <span class="n">SqlConnection</span><span class="p">(</span><span class="n">conString</span><span class="p">))</span>
</span><span class="line">    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cmd</span> <span class="p">=</span> <span class="k">new</span> <span class="n">SqlCommand</span><span class="p">(</span><span class="n">cmdString</span><span class="p">,</span> <span class="n">con</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">        <span class="n">con</span><span class="p">.</span><span class="n">Open</span><span class="p">();</span>
</span><span class="line">        <span class="n">IDataReader</span> <span class="n">rdr</span> <span class="p">=</span> <span class="n">cmd</span><span class="p">.</span><span class="n">ExecuteReader</span><span class="p">();</span>
</span><span class="line">        <span class="k">return</span> <span class="n">rdr</span><span class="p">;</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Well, this won’t work. Trying to return the reader, but you’ve got a command and a connection both in using blocks. On returning, those blocks will terminate, disposing of the connection and command (which is good). What now? Briefly consider <em>not</em> using using blocks, not disposing of anything and just returning the reader. Nah – just can’t do that. Ok, so bail on data reader and go with a data set or some other statefull representation of the data I guess.</p>

<p>But WAIT! Don’t punch out just yet. What’s happening here is we’ve got a disposable resource we want to use in a spot that’s surrounded if you will by other important code. Let’s take a look at this:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">public</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">UsingReaderGetSomeData</span><span class="p">(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">IDataReader</span><span class="p">&gt;</span> <span class="n">processor</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">con</span> <span class="p">=</span> <span class="k">new</span> <span class="n">SqlConnection</span><span class="p">(</span><span class="n">conString</span><span class="p">))</span>
</span><span class="line">    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cmd</span> <span class="p">=</span> <span class="k">new</span> <span class="n">SqlCommand</span><span class="p">(</span><span class="n">cmdString</span><span class="p">,</span> <span class="n">con</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">        <span class="n">con</span><span class="p">.</span><span class="n">Open</span><span class="p">();</span>
</span><span class="line">        <span class="k">using</span> <span class="p">(</span><span class="n">IDataReader</span> <span class="n">rdr</span> <span class="p">=</span> <span class="n">cmd</span><span class="p">.</span><span class="n">ExecuteReader</span><span class="p">())</span> <span class="p">{</span>
</span><span class="line">            <span class="n">processor</span><span class="p">(</span><span class="n">rdr</span><span class="p">);</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Now we’ve got a method that does all the right things with the data reader. The reader, its connection, and its command are all in using blocks so they’ll be properly disposed of. We ask the caller to supply an <code>Action&lt;IDataReader&gt;</code>, and we’ll apply that action to our well protected data reader.</p>

<p>This looks reasonable, but since it’s a data reader, won’t the caller always be doing the <code>while(rdr.Read())</code> thing? Let’s take care of that for them.</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">public</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">UsingReaderGetSomeData</span><span class="p">(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">IDataRecord</span><span class="p">&gt;</span> <span class="n">processor</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">con</span> <span class="p">=</span> <span class="k">new</span> <span class="n">SqlConnection</span><span class="p">(</span><span class="n">conString</span><span class="p">))</span>
</span><span class="line">    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cmd</span> <span class="p">=</span> <span class="k">new</span> <span class="n">SqlCommand</span><span class="p">(</span><span class="n">cmdString</span><span class="p">,</span> <span class="n">con</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">        <span class="n">con</span><span class="p">.</span><span class="n">Open</span><span class="p">();</span>
</span><span class="line">        <span class="k">using</span> <span class="p">(</span><span class="n">IDataReader</span> <span class="n">rdr</span> <span class="p">=</span> <span class="n">cmd</span><span class="p">.</span><span class="n">ExecuteReader</span><span class="p">())</span> <span class="p">{</span>
</span><span class="line">            <span class="k">while</span><span class="p">(</span><span class="n">rdr</span><span class="p">.</span><span class="n">Read</span><span class="p">())</span> <span class="p">{</span>
</span><span class="line">                <span class="n">processor</span><span class="p">(</span><span class="n">rdr</span><span class="p">);</span>
</span><span class="line">            <span class="p">}</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Now instead of asking for an <code>Action&lt;IDataReader&gt;</code>, we’re asking for an <code>Action&lt;IDataRecord&gt;</code> that will be called once for each record. Our function can iterate the data reader and call the processor once for each result. Here’s a sample caller that builds an HTML ordered list and writes the results to the console:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">
</span><span class="line">    <span class="n">StringBuilder</span> <span class="n">sb</span> <span class="p">=</span> <span class="k">new</span> <span class="n">StringBuilder</span><span class="p">();</span>
</span><span class="line">    <span class="n">sb</span><span class="p">.</span><span class="n">AppendLine</span><span class="p">(</span><span class="s">&quot;&lt;ol&gt;&quot;</span><span class="p">);</span>
</span><span class="line">    <span class="n">Dal</span><span class="p">.</span><span class="n">UsingReaderGetSomeData</span><span class="p">(</span><span class="n">dr</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span><span class="line">        <span class="n">sb</span><span class="p">.</span><span class="n">Append</span><span class="p">(</span><span class="s">&quot; &lt;li&gt;&quot;</span><span class="p">);</span>
</span><span class="line">        <span class="n">sb</span><span class="p">.</span><span class="n">Append</span><span class="p">(</span><span class="n">dr</span><span class="p">[</span><span class="m">0</span><span class="p">]);</span>
</span><span class="line">        <span class="n">sb</span><span class="p">.</span><span class="n">AppendLine</span><span class="p">(</span><span class="s">&quot;&lt;/li&gt;&quot;</span><span class="p">);</span>
</span><span class="line">    <span class="p">});</span>
</span><span class="line">    <span class="n">sb</span><span class="p">.</span><span class="n">AppendLine</span><span class="p">(</span><span class="s">&quot;&lt;/ol&gt;&quot;</span><span class="p">);</span>
</span><span class="line">    <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="n">sb</span><span class="p">);</span>
</span><span class="line">
</span><span class="line">    <span class="n">Console</span><span class="p">.</span><span class="n">Write</span><span class="p">(</span><span class="s">&quot;Press any key...&quot;</span><span class="p">);</span>
</span><span class="line">    <span class="n">Console</span><span class="p">.</span><span class="n">ReadKey</span><span class="p">(</span><span class="k">true</span><span class="p">);</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>A client uses our function like a loop. Everything it puts in the curly braces from line 5 – 9 is like the the body of the loop. With this approach, we’re getting the benefits of the data reader, it’s fast and forward only. The construct is similar to a loop, so the consumers (our team mates) should be able to understand how to use this. And finally, we’re taking proper care to dispose of the resources.</p>

<p>To summarize, this approach allows you define functions that accept functions as parameters, and build more complex behavior. This technique is called <em>functional composition</em>. It’s one of the core principal concepts of Functional Programming, but as we’ve seen here, it can be applied to solutions in imperative programming languages like C# to great effect. Using techniques like this help you break your code down in smaller and smaller chunks, with some functions doing little bits of work, and other functions serving as glue or framework code. All this makes your code easier to test and less prone to errors if done correctly.</p>

<h3 id="taking-it-further-or-something-more-like-real-production-code">Taking it Further, or, Something More like Real Production Code</h3>

<p>Alright, that was interesting. And as far as blog posts go, that’s all I was really trying to get across. But if you’re curious about what production code might look like that uses an approach like this, here’s an example:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
<span class="line-number">25</span>
<span class="line-number">26</span>
<span class="line-number">27</span>
<span class="line-number">28</span>
<span class="line-number">29</span>
<span class="line-number">30</span>
<span class="line-number">31</span>
<span class="line-number">32</span>
<span class="line-number">33</span>
<span class="line-number">34</span>
<span class="line-number">35</span>
<span class="line-number">36</span>
<span class="line-number">37</span>
<span class="line-number">38</span>
<span class="line-number">39</span>
<span class="line-number">40</span>
<span class="line-number">41</span>
<span class="line-number">42</span>
<span class="line-number">43</span>
<span class="line-number">44</span>
<span class="line-number">45</span>
<span class="line-number">46</span>
<span class="line-number">47</span>
<span class="line-number">48</span>
<span class="line-number">49</span>
<span class="line-number">50</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">private</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">UsingReader</span><span class="p">(</span>
</span><span class="line">    <span class="kt">string</span> <span class="n">command</span><span class="p">,</span>
</span><span class="line">    <span class="n">Action</span><span class="p">&lt;</span><span class="n">SqlCommand</span><span class="p">&gt;</span> <span class="n">preAction</span> <span class="p">=</span> <span class="k">null</span><span class="p">,</span>
</span><span class="line">    <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">IDataRecord</span><span class="p">&gt;&gt;</span> <span class="n">recordProcessors</span> <span class="p">=</span> <span class="k">null</span><span class="p">,</span>
</span><span class="line">    <span class="n">Action</span><span class="p">&lt;</span><span class="n">SqlCommand</span><span class="p">&gt;</span> <span class="n">postAction</span> <span class="p">=</span> <span class="k">null</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">
</span><span class="line">    <span class="c1">// Instantiate connection and command, open the connection</span>
</span><span class="line">    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">con</span> <span class="p">=</span> <span class="k">new</span> <span class="n">SqlConnection</span><span class="p">(</span><span class="n">conString</span><span class="p">))</span>
</span><span class="line">    <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">cmd</span> <span class="p">=</span> <span class="k">new</span> <span class="n">SqlCommand</span><span class="p">(</span><span class="n">command</span><span class="p">,</span> <span class="n">con</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">        <span class="n">con</span><span class="p">.</span><span class="n">Open</span><span class="p">();</span>
</span><span class="line">
</span><span class="line">        <span class="c1">// Execute a pre-action if specified</span>
</span><span class="line">        <span class="k">if</span> <span class="p">(</span><span class="n">preAction</span> <span class="p">!=</span> <span class="k">null</span><span class="p">)</span> <span class="n">preAction</span><span class="p">(</span><span class="n">cmd</span><span class="p">);</span>
</span><span class="line">
</span><span class="line">        <span class="c1">// If the reader processing blocks are supplied</span>
</span><span class="line">        <span class="k">if</span> <span class="p">(</span><span class="n">recordProcessors</span> <span class="p">!=</span> <span class="k">null</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">
</span><span class="line">            <span class="c1">// Get an enumerator for the processing blocks &amp; move</span>
</span><span class="line">            <span class="c1">// to the first processor</span>
</span><span class="line">            <span class="kt">var</span> <span class="n">processorEnumerator</span> <span class="p">=</span> <span class="n">recordProcessors</span><span class="p">.</span><span class="n">GetEnumerator</span><span class="p">();</span>
</span><span class="line">            <span class="k">if</span> <span class="p">(!</span><span class="n">processorEnumerator</span><span class="p">.</span><span class="n">MoveNext</span><span class="p">())</span>
</span><span class="line">                <span class="k">throw</span> <span class="k">new</span> <span class="nf">InvalidOperationException</span><span class="p">(</span>
</span><span class="line">                    <span class="s">&quot;Supply at least one record processor&quot;</span><span class="p">);</span>
</span><span class="line">
</span><span class="line">            <span class="c1">// Open the reader</span>
</span><span class="line">            <span class="k">using</span> <span class="p">(</span><span class="kt">var</span> <span class="n">reader</span> <span class="p">=</span> <span class="n">cmd</span><span class="p">.</span><span class="n">ExecuteReader</span><span class="p">(</span><span class="n">CommandBehavior</span><span class="p">.</span><span class="n">CloseConnection</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">
</span><span class="line">                <span class="k">do</span> <span class="p">{</span>
</span><span class="line">                    <span class="c1">// Get the current record processing block</span>
</span><span class="line">                    <span class="kt">var</span> <span class="n">recordProcessor</span> <span class="p">=</span> <span class="n">processorEnumerator</span><span class="p">.</span><span class="n">Current</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">                    <span class="c1">// Iterate the records of the IDataReader using the current block</span>
</span><span class="line">                    <span class="k">while</span> <span class="p">(</span><span class="n">reader</span><span class="p">.</span><span class="n">Read</span><span class="p">())</span>
</span><span class="line">                        <span class="n">recordProcessor</span><span class="p">(</span><span class="n">reader</span><span class="p">);</span>
</span><span class="line">
</span><span class="line">                    <span class="c1">// The loop condition advances both IDataReader and enumerator</span>
</span><span class="line">                    <span class="c1">// in sync continuing as long as there&#39;s a next resultSet and a</span>
</span><span class="line">                    <span class="c1">// processor to process it</span>
</span><span class="line">                <span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="n">reader</span><span class="p">.</span><span class="n">NextResult</span><span class="p">()</span> <span class="p">&amp;&amp;</span> <span class="n">processorEnumerator</span><span class="p">.</span><span class="n">MoveNext</span><span class="p">());</span>
</span><span class="line">            <span class="p">}</span>
</span><span class="line">
</span><span class="line">        <span class="p">}</span> <span class="k">else</span>
</span><span class="line">            <span class="c1">// If there are no actions to execute using data reader, just execute query</span>
</span><span class="line">            <span class="n">cmd</span><span class="p">.</span><span class="n">ExecuteNonQuery</span><span class="p">();</span>
</span><span class="line">
</span><span class="line">        <span class="c1">// Do any clean up that might be needed</span>
</span><span class="line">        <span class="k">if</span> <span class="p">(</span><span class="n">postAction</span> <span class="p">!=</span> <span class="k">null</span><span class="p">)</span>
</span><span class="line">            <span class="n">postAction</span><span class="p">(</span><span class="n">cmd</span><span class="p">);</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Here we pass optional pre- and post- actions that allow the caller to optionally manipulate the command before and after it’s executed. We also accept a set of actions we’re calling record processors, to handle the case when a stored procedure or command is returning multiple result sets. In the case of multiple result sets, we’d expect the caller to send a different record processor for each result set it expects.</p>

<p>So this seems like a lot of code. Why bother? The way I approached it was that this code is a private method of the data access layer, and the public methods would leverage this method to avoid repeating the gory details of working with data readers. Leveraging the above method, our original <code>GetSomeData()</code> now looks like:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">public</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">UsingReaderGetSomeData</span><span class="p">(</span><span class="n">Action</span><span class="p">&lt;</span><span class="n">IDataRecord</span><span class="p">&gt;</span> <span class="n">recordProcessor</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="n">UsingReader</span><span class="p">(</span><span class="n">cmdString</span><span class="p">,</span> <span class="k">null</span><span class="p">,</span> <span class="k">new</span> <span class="n">Action</span><span class="p">&lt;</span><span class="n">IDataRecord</span><span class="p">&gt;[]</span> <span class="p">{</span> <span class="n">recordProcessor</span> <span class="p">});</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>And if we had a data access method that took a couple of parameters, it would look like this:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">public</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">UsingReaderGetSearch</span><span class="p">(</span><span class="kt">string</span> <span class="n">criteria</span><span class="p">,</span> <span class="n">Action</span><span class="p">&lt;</span><span class="n">IDataRecord</span><span class="p">&gt;</span> <span class="n">resultProcessor</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="n">UsingReader</span><span class="p">(</span><span class="n">cmdString</span><span class="p">,</span>
</span><span class="line">        <span class="n">cmd</span> <span class="p">=&gt;</span> <span class="n">cmd</span><span class="p">.</span><span class="n">Parameters</span><span class="p">.</span><span class="n">Add</span><span class="p">(</span><span class="k">new</span> <span class="n">SqlParameter</span><span class="p">(</span><span class="s">&quot;@searchCriteria&quot;</span><span class="p">,</span> <span class="n">criteria</span><span class="p">)),</span>
</span><span class="line">        <span class="k">new</span> <span class="n">Action</span><span class="p">&lt;</span><span class="n">IDataRecord</span><span class="p">&gt;[]</span> <span class="p">{</span> <span class="n">resultProcessor</span> <span class="p">});</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>I hope this has proved helpful. I’ll keep throwing more of these posts out there, let me know if there’s something you’d like to see.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[C# Nuts and Bolts: Lambdas]]></title>
    <link href="http://efvincent.github.io/blog/2010/02/01/c-nuts-and-bolts-lambdas/"/>
    <updated>2010-02-01T14:19:41-05:00</updated>
    <id>http://efvincent.github.io/blog/2010/02/01/c-nuts-and-bolts-lambdas</id>
    <content type="html"><![CDATA[<p>You don’t need to use Lambdas to make a living writing code in .NET. You can probably get away with not even knowing what Linq is. You can also still find work coding in .NET 2.0. But that’s painfully BORING. So to avoid the stinging monotony of working in a 5 year reverse time-shift, let’s take a look at lambdas.</p>

<!-- more -->

<p>The (arguably) simplest lambda.</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="kt">string</span> <span class="n">message</span> <span class="p">=</span> <span class="s">&quot;Hello World&quot;</span><span class="p">;</span>
</span><span class="line"><span class="n">Action</span> <span class="n">simpleLambda</span> <span class="p">=</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="n">message</span><span class="p">);</span>
</span><span class="line">
</span><span class="line"><span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="err">“</span><span class="n">Get</span> <span class="n">ready</span> <span class="k">for</span> <span class="n">a</span> <span class="n">message</span><span class="p">!</span><span class="err">”</span><span class="p">);</span>
</span><span class="line"><span class="n">simpleLambda</span><span class="p">();</span>
</span><span class="line"><span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="err">“</span><span class="n">That</span> <span class="n">was</span> <span class="n">the</span> <span class="n">message</span><span class="p">!</span><span class="err">”</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>The the type “Action” is a delegate, which can be thought of as a function pointer. The variable “simpleLambda” is now a function. The same way that “message” is a string. In reality, there are delegates and pointers involved, but for the day to day, just think of “simpleLambda” as a function. It can be called just like you would any function, which is what we’ve done here.</p>

<p>There are two different Types that are generally used for these functions. They are “Action” and “Func”. Action, which we just saw, is a function that doesn’t return anything. It’s a void function. When we want to define a function that returns something, we use the “Func” type. Remember back to your early days of Visual Basic, Pascal, etc., when there were different keywords that you’d use to specify if there was a return value or not? Same kinda thing here. Func returns, Action doesn’t. So here’s a Func example.</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="c1">// Define a func that returns something</span>
</span><span class="line">
</span><span class="line"><span class="n">Func</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;</span> <span class="n">minutesAndSeconds</span> <span class="p">=</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="kt">string</span><span class="p">.</span><span class="n">Format</span><span class="p">(</span><span class="s">&quot;{0:mm:ss.ffff}&quot;</span><span class="p">,</span> <span class="n">DateTime</span><span class="p">.</span><span class="n">Now</span><span class="p">);</span>
</span><span class="line">
</span><span class="line"><span class="n">Console</span><span class="p">.</span><span class="n">Write</span><span class="p">(</span><span class="s">&quot;Current Minutes and seconds are: &quot;</span><span class="p">);</span>
</span><span class="line"><span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="n">minutesAndSeconds</span><span class="p">());</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Here’s a function that returns a string. It’s type is Func<string>, which you can read as a function that returns a string. Let’s break down the syntax of the lambda itself. It centers around the lambda operator “=&gt;”, which some people read as “goes to”. In both our examples, simpleLambda and minutesAndSeconds are functions that take no parameters. So on the left of the lambda operator are empty parenthesis. Means no parameters to the function. Easy. On the right is the body of the function.</string></p>

<p>There are two ways of expressing the body of the function. If the body is a single statement, you can just put that statement. This is called an Expression Lambda. If you need more than one statement on the right of the Lambda operator, you end up with something like this:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="n">Func</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">,</span> <span class="kt">string</span><span class="p">&gt;</span> <span class="n">hasher</span> <span class="p">=</span>
</span><span class="line">    <span class="n">s</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span><span class="line">        <span class="kt">var</span> <span class="n">sha</span> <span class="p">=</span> <span class="k">new</span> <span class="n">System</span><span class="p">.</span><span class="n">Security</span><span class="p">.</span><span class="n">Cryptography</span><span class="p">.</span><span class="n">SHA1CryptoServiceProvider</span><span class="p">();</span>
</span><span class="line">        <span class="k">return</span> <span class="n">Convert</span><span class="p">.</span><span class="n">ToBase64String</span><span class="p">(</span><span class="n">sha</span><span class="p">.</span><span class="n">ComputeHash</span><span class="p">(</span><span class="n">ASCIIEncoding</span><span class="p">.</span><span class="n">UTF8</span><span class="p">.</span><span class="n">GetBytes</span><span class="p">(</span><span class="n">s</span><span class="p">)));</span>
</span><span class="line">    <span class="p">};</span>
</span><span class="line">
</span><span class="line"><span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;The base64 encoded SHA1 hash of \&quot;Hello World\&quot; is {0}&quot;</span><span class="p">,</span> <span class="n">hasher</span><span class="p">(</span><span class="s">&quot;Hello World&quot;</span><span class="p">));</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>A couple of differences here… first there’s some added whitespace to make stuff more readable. Don’t let it throw you. Whitespace == good. Second, the type is now Func&lt;string, string&gt;. The key to reading the Func type is that the last generic type specification is the return type. So it reads “a function that takes a string and returns a string”. Since this lambda takes a string as a parameter, to the left of the lambda operator goes the parameter. You can name this parameter anything you want, just like when you’re defining a regular function. This parameter is bound to the input to the function.</p>

<p>The next thing that’s different is there are open and close curly brackets, just like a function definition, after the lambda operator. This is the body, it’s just like a function body. You declare local variables in here, and when you’re done, you return something. Or if this is an Action instead of a Func, you don’t need to return anything (remember, Action is like a void function). This is the same function except as a statically defined method on a class:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">public</span> <span class="k">static</span> <span class="kt">string</span> <span class="nf">Hasher</span><span class="p">(</span><span class="kt">string</span> <span class="n">s</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">sha</span> <span class="p">=</span> <span class="k">new</span> <span class="n">System</span><span class="p">.</span><span class="n">Security</span><span class="p">.</span><span class="n">Cryptography</span><span class="p">.</span><span class="n">SHA1CryptoServiceProvider</span><span class="p">();</span>
</span><span class="line">    <span class="k">return</span> <span class="n">Convert</span><span class="p">.</span><span class="n">ToBase64String</span><span class="p">(</span><span class="n">sha</span><span class="p">.</span><span class="n">ComputeHash</span><span class="p">(</span><span class="n">ASCIIEncoding</span><span class="p">.</span><span class="n">UTF8</span><span class="p">.</span><span class="n">GetBytes</span><span class="p">(</span><span class="n">s</span><span class="p">)));</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Thaaaaatts pretty much it. There’re plenty of implementation details under the covers, and there’s a whole world of design patterns and techniques to explore with regards to <em>using</em> lambdas. But as far as what they are, you’re looking at it. I’ll push it a little further in the next blog post. If you’ve got any questions or want to dive deeper into this or any other subject I write about, let me know in the comments. In the mean time, have fun!</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Applied Functional: Getting User Input]]></title>
    <link href="http://efvincent.github.io/blog/2010/01/31/applied-functional-01/"/>
    <updated>2010-01-31T22:12:13-05:00</updated>
    <id>http://efvincent.github.io/blog/2010/01/31/applied-functional-01</id>
    <content type="html"><![CDATA[<p>The thing with spending time on functional programming is that the typical .NET programmer will not likely be able to write production code in F#, and almost certainly not in Haskell. But what you are able to do is apply a new set of problem solving approaches to your every day work.
<!-- more -->
So here’s a simple problem that we see all the time; you’re writing a console application to test a component. Here’s the pseudo code:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="c1">/// While still processing</span>
</span><span class="line"><span class="c1">///     Get a string from the user</span>
</span><span class="line"><span class="c1">///     Process the string</span>
</span><span class="line"><span class="c1">/// End While</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Super duper simple. So here’s a straight forward way to code it:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
<span class="line-number">25</span>
<span class="line-number">26</span>
<span class="line-number">27</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="n">NonReusableLoop</span><span class="p">();</span>
</span><span class="line"><span class="p">}</span>
</span><span class="line">
</span><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">NonReusableLoop</span><span class="p">()</span> <span class="p">{</span>
</span><span class="line">    <span class="kt">string</span> <span class="n">input</span> <span class="p">=</span> <span class="kt">string</span><span class="p">.</span><span class="n">Empty</span><span class="p">;</span>
</span><span class="line">    <span class="kt">bool</span> <span class="n">done</span> <span class="p">=</span> <span class="k">false</span><span class="p">;</span>
</span><span class="line">    <span class="k">do</span> <span class="p">{</span>
</span><span class="line">        <span class="n">Console</span><span class="p">.</span><span class="n">Write</span><span class="p">(</span><span class="s">&quot;Enter a web site to process. Press enter to end: &quot;</span><span class="p">);</span>
</span><span class="line">        <span class="n">input</span> <span class="p">=</span> <span class="n">Console</span><span class="p">.</span><span class="n">ReadLine</span><span class="p">();</span>
</span><span class="line">        <span class="k">if</span> <span class="p">(</span><span class="kt">string</span><span class="p">.</span><span class="n">IsNullOrEmpty</span><span class="p">(</span><span class="n">input</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">            <span class="n">done</span> <span class="p">=</span> <span class="k">true</span><span class="p">;</span>
</span><span class="line">        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span><span class="line">            <span class="n">ProcessWebSite</span><span class="p">(</span><span class="n">input</span><span class="p">,</span> <span class="k">true</span><span class="p">);</span>    <span class="c1">// don&#39;t really care about second parameter</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">    <span class="p">}</span> <span class="k">while</span> <span class="p">(!</span><span class="n">done</span><span class="p">);</span>
</span><span class="line"><span class="p">}</span>
</span><span class="line">
</span><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">ProcessWebSite</span><span class="p">(</span><span class="kt">string</span> <span class="n">webSite</span><span class="p">,</span> <span class="kt">bool</span> <span class="n">someOtherParameter</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="c1">// Do some fake work</span>
</span><span class="line">    <span class="k">if</span> <span class="p">(!</span><span class="n">webSite</span><span class="p">.</span><span class="n">StartsWith</span><span class="p">(</span><span class="s">&quot;http://&quot;</span><span class="p">,</span> <span class="n">StringComparison</span><span class="p">.</span><span class="n">OrdinalIgnoreCase</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">        <span class="k">throw</span> <span class="k">new</span> <span class="nf">InvalidOperationException</span><span class="p">(</span><span class="s">&quot;Poorly formed web site name&quot;</span><span class="p">);</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line">    <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;Processing web site {0}&quot;</span><span class="p">,</span> <span class="n">webSite</span><span class="p">);</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">rnd</span> <span class="p">=</span> <span class="k">new</span> <span class="n">Random</span><span class="p">(</span><span class="n">DateTime</span><span class="p">.</span><span class="n">Now</span><span class="p">.</span><span class="n">Millisecond</span><span class="p">);</span>
</span><span class="line">    <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;Web site has {0:#,##0} pages!&quot;</span><span class="p">,</span> <span class="n">rnd</span><span class="p">.</span><span class="n">Next</span><span class="p">(</span><span class="m">1</span><span class="p">,</span> <span class="m">1000</span><span class="p">));</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>So lets say we want to extract something reusable out of this. Lets say we regularly churn up little console apps and we’re tired of writing this over and over again.</p>

<p>There are a couple of approaches that seem obvious you if you’ve got your functional thinking cap on. For example, this first pass looks like a function that does the interesting work (calls ProcessWebSite()) in the middle of a bunch of other stuff (getting user input, looping, checking for the quit condition). Let’s go with that observation:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
<span class="line-number">25</span>
<span class="line-number">26</span>
<span class="line-number">27</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="n">ProcessUserInput</span><span class="p">(</span><span class="s">&quot;Enter a web site url&quot;</span><span class="p">,</span> <span class="n">input</span> <span class="p">=&gt;</span> <span class="n">ProcessWebSite</span><span class="p">(</span><span class="n">input</span><span class="p">,</span> <span class="k">true</span><span class="p">));</span>
</span><span class="line"><span class="p">}</span>
</span><span class="line">
</span><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">ProcessUserInput</span><span class="p">(</span><span class="kt">string</span> <span class="n">prompt</span><span class="p">,</span> <span class="n">Action</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;</span> <span class="n">fn</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="k">if</span> <span class="p">(</span><span class="n">fn</span> <span class="p">==</span> <span class="k">null</span><span class="p">)</span> <span class="k">return</span><span class="p">;</span>
</span><span class="line">    <span class="kt">string</span> <span class="n">input</span> <span class="p">=</span> <span class="kt">string</span><span class="p">.</span><span class="n">Empty</span><span class="p">;</span>
</span><span class="line">    <span class="kt">bool</span> <span class="n">done</span> <span class="p">=</span> <span class="k">false</span><span class="p">;</span>
</span><span class="line">    <span class="k">do</span> <span class="p">{</span>
</span><span class="line">        <span class="n">Console</span><span class="p">.</span><span class="n">Write</span><span class="p">(</span><span class="s">&quot;{0}. Press enter to end: &quot;</span><span class="p">,</span> <span class="n">prompt</span><span class="p">);</span>
</span><span class="line">        <span class="n">input</span> <span class="p">=</span> <span class="n">Console</span><span class="p">.</span><span class="n">ReadLine</span><span class="p">();</span>
</span><span class="line">        <span class="k">if</span> <span class="p">(</span><span class="kt">string</span><span class="p">.</span><span class="n">IsNullOrEmpty</span><span class="p">(</span><span class="n">input</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">            <span class="n">done</span> <span class="p">=</span> <span class="k">true</span><span class="p">;</span>
</span><span class="line">        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span><span class="line">            <span class="k">try</span> <span class="p">{</span>
</span><span class="line">                <span class="n">fn</span><span class="p">(</span><span class="n">input</span><span class="p">);</span>
</span><span class="line">            <span class="p">}</span> <span class="k">catch</span> <span class="p">(</span><span class="n">Exception</span> <span class="n">ex</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">                <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">&quot;Exception thrown: {0}&quot;</span><span class="p">,</span> <span class="n">ex</span><span class="p">.</span><span class="n">Message</span><span class="p">);</span>
</span><span class="line">                <span class="n">Console</span><span class="p">.</span><span class="n">Write</span><span class="p">(</span><span class="s">&quot;Show exception stack? (y/N):&quot;</span><span class="p">);</span>
</span><span class="line">                <span class="kt">var</span> <span class="n">exInput</span> <span class="p">=</span> <span class="n">Console</span><span class="p">.</span><span class="n">ReadLine</span><span class="p">();</span>
</span><span class="line">                <span class="k">if</span> <span class="p">(</span><span class="n">exInput</span><span class="p">.</span><span class="n">Equals</span><span class="p">(</span><span class="s">&quot;y&quot;</span><span class="p">,</span> <span class="n">StringComparison</span><span class="p">.</span><span class="n">OrdinalIgnoreCase</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">                    <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="n">ex</span><span class="p">.</span><span class="n">ToString</span><span class="p">());</span>
</span><span class="line">                <span class="p">}</span>
</span><span class="line">            <span class="p">}</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">    <span class="p">}</span> <span class="k">while</span> <span class="p">(!</span><span class="n">done</span><span class="p">);</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Now we’ve got a function that does the collection of the user strings, checking for the quit condition, and even adds some simple error handling to catch any exceptions that the “work” might throw. The parameter is an “Action<string>”. This is the .NET way of describing a function that returns void and has a single string parameter. This is a functional way of looking at the problem, because in functional programming passing functions around and working on functions is a fundamental technique. Getting used to doing this is a powerful tool.</string></p>

<p>But there’s a better way of looking at it. What if we think of the strings the user is entering as a set of strings. We end up with something like this:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">Main</span><span class="p">(</span><span class="kt">string</span><span class="p">[]</span> <span class="n">args</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="n">ProcessStrings</span><span class="p">(</span>
</span><span class="line">        <span class="n">SetOfUserInput</span><span class="p">(</span><span class="s">&quot;Enter a web site url&quot;</span><span class="p">),</span>
</span><span class="line">        <span class="n">str</span> <span class="p">=&gt;</span> <span class="n">ProcessWebSite</span><span class="p">(</span><span class="n">str</span><span class="p">,</span> <span class="k">true</span><span class="p">));</span>
</span><span class="line"><span class="p">}</span>
</span><span class="line">
</span><span class="line"><span class="k">static</span> <span class="k">void</span> <span class="nf">ProcessStrings</span><span class="p">(</span><span class="n">IEnumerable</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;</span> <span class="n">setOfStrings</span><span class="p">,</span> <span class="n">Action</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;</span> <span class="n">fn</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="k">foreach</span> <span class="p">(</span><span class="kt">var</span> <span class="n">item</span> <span class="k">in</span> <span class="n">setOfStrings</span><span class="p">)</span> <span class="n">fn</span><span class="p">(</span><span class="n">item</span><span class="p">);</span>
</span><span class="line"><span class="p">}</span>
</span><span class="line">
</span><span class="line"><span class="k">static</span> <span class="n">IEnumerable</span><span class="p">&lt;</span><span class="kt">string</span><span class="p">&gt;</span> <span class="n">SetOfUserInput</span><span class="p">(</span><span class="kt">string</span> <span class="n">prompt</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">    <span class="kt">string</span> <span class="n">input</span> <span class="p">=</span> <span class="kt">string</span><span class="p">.</span><span class="n">Empty</span><span class="p">;</span>
</span><span class="line">    <span class="kt">bool</span> <span class="n">done</span> <span class="p">=</span> <span class="k">false</span><span class="p">;</span>
</span><span class="line">    <span class="k">do</span> <span class="p">{</span>
</span><span class="line">        <span class="n">Console</span><span class="p">.</span><span class="n">Write</span><span class="p">(</span><span class="s">&quot;{0}. Press enter to end: &quot;</span><span class="p">,</span> <span class="n">prompt</span><span class="p">);</span>
</span><span class="line">        <span class="n">input</span> <span class="p">=</span> <span class="n">Console</span><span class="p">.</span><span class="n">ReadLine</span><span class="p">();</span>
</span><span class="line">        <span class="k">if</span> <span class="p">(</span><span class="kt">string</span><span class="p">.</span><span class="n">IsNullOrEmpty</span><span class="p">(</span><span class="n">input</span><span class="p">))</span> <span class="p">{</span>
</span><span class="line">            <span class="n">done</span> <span class="p">=</span> <span class="k">true</span><span class="p">;</span>
</span><span class="line">        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span><span class="line">            <span class="k">yield</span> <span class="k">return</span> <span class="n">input</span><span class="p">;</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">    <span class="p">}</span> <span class="k">while</span> <span class="p">(!</span><span class="n">done</span><span class="p">);</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Now we’ve got a function that returns a set of strings (IEnumerable<string> is the .NET way of saying a set of strings), and a function that takes a set of strings and applies a function to each member. The yield keyword makes the SetOfUserInput() method into a set. Each time the yield return keyword is hit, the value is passed out to the caller. When the caller attempts to retrieve the next value from the set, control is passed to the line after the yield return. This construct is called a continuation, and it’s a powerful concept.</string></p>

<p>These two simple concepts, that functions can be passed around and worked on, and that you can generate sets of data using continuations, are simple and fundamental to functional programming. But as these examples show you can use these techniques to your advantage in C#, solving real, every day problems.</p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[C# Nuts and Bolts: Delegates and Functions, Part I]]></title>
    <link href="http://efvincent.github.io/blog/2009/08/24/nuts-bolts-delegates-functions-1/"/>
    <updated>2009-08-24T23:32:21-04:00</updated>
    <id>http://efvincent.github.io/blog/2009/08/24/nuts-bolts-delegates-functions-1</id>
    <content type="html"><![CDATA[<p>Two years ago I took up the <a href="http://en.wikipedia.org/wiki/OCaml">OCaml</a> programming language, purely out of intellectual curiosity. For me, <a href="http://en.wikipedia.org/wiki/OCaml">OCaml</a> was a gateway drug to functional programming in general. I’ve since spent a good bit of time with <a href="http://msdn.microsoft.com/en-us/fsharp/default.aspx">F#</a> and <a href="http://en.wikipedia.org/wiki/Haskell_(programming_language)">Haskell</a>. With the consulting work I do I don’t have the opportunity to use these languages in production, but I have found that using these languages has unlocked a new worlds of problem solving techniques.</p>

<p>This series lays down a groundwork of C# understanding upon which we can build a library of modern problem solving techniques, where we take the most useful functional approaches, and see how to apply them to C# programming in .NET. Even if you’ve not any interest in functional programming, this series can be of service helping you understand some of the less obvious aspects of C# programming.
<!-- more --></p>

<h2 id="delegates">Delegates</h2>

<p>C++ has pointers to functions. C# has delegates. A <a href="http://msdn.microsoft.com/en-us/library/ms173171(VS.80).aspx">delegate</a> is a .NET type that can be thought of as a type safe function pointer. A function pointer is a variable that instead of pointing to or containing data, points to a function. This variable can be used to invoke, or call, the function it is pointing at.</p>

<p><em>Type safe</em> refers to the fact that a delegate variable cannot point to just any function, it can only point to a function that matches the delegate’s <em>signature</em>. Signature refers to the parameters and return value of the function. Together, the parameters and return type form a fingerprint for a function which must match that the delegate.</p>

<p>In this example, a delegate is created at line 5 called <code>GetStatsDelegate </code>where the signature specifies a single <code>string</code> parameter and an <code>integer</code> return value. Judging from the name, the delegate should point to a function that gets some stats about a string.</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">class</span> <span class="nc">Program</span>
</span><span class="line"><span class="p">{</span>
</span><span class="line">    <span class="c1">// define a delegate type for a function that takes a</span>
</span><span class="line">    <span class="c1">// string and returns an int</span>
</span><span class="line">    <span class="k">delegate</span> <span class="kt">int</span> <span class="nf">GetStatsDelegate</span><span class="p">(</span><span class="kt">string</span> <span class="n">str</span><span class="p">);</span>
</span><span class="line">
</span><span class="line">    <span class="k">public</span> <span class="k">static</span> <span class="k">void</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
</span><span class="line">
</span><span class="line">        <span class="c1">// Define a variable of our new delegate type, and</span>
</span><span class="line">        <span class="c1">// assign it a value. Any method with the same signature</span>
</span><span class="line">        <span class="c1">// can be assigned to this variable.</span>
</span><span class="line">        <span class="n">GetStatsDelegate</span> <span class="n">myFunc</span> <span class="p">=</span> <span class="n">GetLengthWithoutSpaces</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">        <span class="c1">// Both these print 0</span>
</span><span class="line">        <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="n">myFunc</span><span class="p">(</span><span class="s">&quot;Hello&quot;</span><span class="p">));</span>
</span><span class="line">        <span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="n">GetLengthWithoutSpaces</span><span class="p">(</span><span class="s">&quot;Hello&quot;</span><span class="p">));</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line">
</span><span class="line">    <span class="c1">// This is a function that we can point to, because it has</span>
</span><span class="line">    <span class="c1">// the right signature for our delegate</span>
</span><span class="line">    <span class="k">public</span> <span class="k">static</span> <span class="kt">int</span> <span class="nf">GetLengthWithoutSpaces</span><span class="p">(</span><span class="kt">string</span> <span class="n">s</span><span class="p">)</span> <span class="p">{</span>
</span><span class="line">        <span class="k">return</span> <span class="m">0</span><span class="p">;</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>At line 12 the delegate we created (which is a type) is used to define a variable, <code>myFunc</code>. We then set <code>myFunc’s</code> value equal to <code>GetLengthWithoutSpaces</code>, which is a function. Lines 15 and 16 call the function, once using the delegate, and once the traditional way.<a href="http://blog.efvincent.com/wp-content/uploads/2009/08/image.png"><img src="http://blog.efvincent.com/wp-content/uploads/2009/08/image_thumb.png" alt="image" /></a></p>

<p>Here’s where it starts to get interesting. This is a snip from <a href="http://www.red-gate.com/products/reflector/">Reflector</a>, looking at how <code>GetStatsDelegate</code> is defined.  We defined it as a delegate, but the compiler has built what looks like a standard class which inherits from the MulticastDelegate framework class.</p>

<p>This is good to know. C# treats delegates in a special way. They’ve been granted their own keyword and a special unique way of declaration. The declaration declares a subclass for us, saving us the trouble of building out a subclass ourselves. If we use Reflector to dig into the base class (System.Delegate), we see these properties and fields:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="c1">// *** From Delegate ***</span>
</span><span class="line">
</span><span class="line"><span class="c1">// Properties</span>
</span><span class="line"><span class="k">public</span> <span class="n">MethodInfo</span> <span class="n">Method</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span>
</span><span class="line"><span class="k">public</span> <span class="kt">object</span> <span class="n">Target</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="p">}</span>
</span><span class="line">
</span><span class="line"><span class="c1">// Fields</span>
</span><span class="line"><span class="k">internal</span> <span class="n">MethodBase</span> <span class="n">_methodBase</span><span class="p">;</span>
</span><span class="line"><span class="k">internal</span> <span class="n">IntPtr</span> <span class="n">_methodPtr</span><span class="p">;</span>
</span><span class="line"><span class="k">internal</span> <span class="n">IntPtr</span> <span class="n">_methodPtrAux</span><span class="p">;</span>
</span><span class="line"><span class="k">internal</span> <span class="kt">object</span> <span class="n">_target</span><span class="p">;</span>
</span><span class="line">
</span><span class="line"><span class="c1">// *** From MulticastDelegate ***</span>
</span><span class="line">
</span><span class="line"><span class="c1">// Fields</span>
</span><span class="line"><span class="k">private</span> <span class="n">IntPtr</span> <span class="n">_invocationCount</span><span class="p">;</span>
</span><span class="line"><span class="k">private</span> <span class="kt">object</span> <span class="n">_invocationList</span><span class="p">;</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>These fields tell us a few things. An instance of a delegate has reflection information about the method it points to, this is what the <code>MethodInfo</code> public property. The pointer to the function itself is of type <code>IntPtr</code>, which we can think about as a pointer to memory.</p>

<p>The <code>_target</code> field is important too. In the case of a delegate that points to an instance method (ie a non-static method on a non-null object), the <code>_target</code> field points to the object with the method. This is important because it is not obvious from looking at code that a delegate holds a reference to the object with the method. It’s possible for this to be the source of memory leaks, where objects cannot be garbage collected because a delegate is holding a reference. You see this most often in events. Being delegates, events hold references that need to be <em>unregistered</em> in order to release these references.</p>

<p>Also we have something called <code>_invocationList</code>, which if we dig through the disassembly we come to find is an array of Delegates implemented as a linked list using pointers (<code>IntPtr</code>) directly for performance reasons. This means that <code>MulticastDelegates</code> are delegates that have a chain of additional delegates. This is used heavily in .NET’s event mechanism, where an <em>event</em> can have multiple <em>handlers</em>. The handlers are simply functions wrapped in delegates added to the linked list of a the event <code>MulticastDelegate</code>.</p>

<p>Next post we’ll look at using delegates, not as events (which anyone who has ever dropped a button on a form knows about), but as function pointers and objects, and start looking at some novel approaches to solving common problems.</p>

<p><em>As always if you’ve got questions or topics you’d like me to follow up on, please leave a not in the comments!</em></p>
]]></content>
  </entry>
  
  <entry>
    <title type="html"><![CDATA[Adding Concurrency Optimization in Silverlight 3]]></title>
    <link href="http://efvincent.github.io/blog/2009/08/18/concurrency-optimization-silverlight/"/>
    <updated>2009-08-18T01:33:22-04:00</updated>
    <id>http://efvincent.github.io/blog/2009/08/18/concurrency-optimization-silverlight</id>
    <content type="html"><![CDATA[<p>About a week ago Joa Ebert posted <a href="http://blog.joa-ebert.com/2009/08/10/flirting-with-silverlight/">Flirting with Silverlight</a>, in which he discussed his experiences with a cool little Lorenz attractor application. The <em>strange attractor</em> app (which you can check at his <a href="http://blog.joa-ebert.com/2009/08/10/flirting-with-silverlight/">blog</a>) was his way of playing around with the newly released Silverlight 3 (Props to Joa for some very cool work BTW). It calculates a shape in 3D defined by some 300,000 particles, and animates the spinning and rotating of this shape as the user moves the mouse across the display surface.</p>

<p>His point was to relate his first Silverlight experience, and how the non-optimized Silverlight application compared very favorably with the significantly optimized AS3 version. The HTML5 Javascript version was a non-starter, barely able to achieve a few frames per second compared to 30 for AS3 and SL3.
<!-- more -->
Joa made <a href="http://blog.joa-ebert.com/2009/08/10/flirting-with-silverlight/">his code</a> available. After looking at the SL3 source code I thought it would be trivial to add some basic concurrency that would <em>significantly</em> increase performance. Here’s a comparison of different implementations:</p>

<ul>
  <li><a href="http://www.joa-ebert.com/swf/index.php?swf=alchemy/Example03">Flash AS3 Version</a>, Optimized</li>
  <li><a href="http://www.joa-ebert.com/files/xpa/attractor/">Original Silverlight Version</a>, naive implementation</li>
  <li><a href="http://efvincent.com/poc/strangeattractor/">Silverlight Version</a>, optimized to leverage Concurrency</li>
  <li><a href="http://mediaerror.com/lab/javascript/strangeattractor">HTML 5 Version</a></li>
</ul>

<p>A point of interest, as far as I know there is <a href="http://blogs.adobe.com/aharui/2008/01/threads_in_actionscript_3.html">no way to do concurrency in Action Script 3</a>. In Joa’s application, the bulk of the hard work is done in a loop that executes every frame:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
<span class="line-number">25</span>
<span class="line-number">26</span>
<span class="line-number">27</span>
<span class="line-number">28</span>
<span class="line-number">29</span>
<span class="line-number">30</span>
<span class="line-number">31</span>
<span class="line-number">32</span>
<span class="line-number">33</span>
<span class="line-number">34</span>
<span class="line-number">35</span>
<span class="line-number">36</span>
<span class="line-number">37</span>
<span class="line-number">38</span>
<span class="line-number">39</span>
<span class="line-number">40</span>
<span class="line-number">41</span>
<span class="line-number">42</span>
<span class="line-number">43</span>
<span class="line-number">44</span>
<span class="line-number">45</span>
<span class="line-number">46</span>
<span class="line-number">47</span>
<span class="line-number">48</span>
<span class="line-number">49</span>
<span class="line-number">50</span>
<span class="line-number">51</span>
<span class="line-number">52</span>
<span class="line-number">53</span>
<span class="line-number">54</span>
<span class="line-number">55</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">void</span> <span class="nf">OnStoryboardCompleted</span><span class="p">(</span><span class="kt">object</span> <span class="n">sender</span><span class="p">,</span> <span class="n">EventArgs</span> <span class="n">eventArgs</span><span class="p">)</span>
</span><span class="line"><span class="p">{</span>
</span><span class="line">    <span class="n">targetX</span> <span class="p">+=</span> <span class="p">(</span><span class="n">mouseX</span> <span class="p">-</span> <span class="n">targetX</span><span class="p">)</span> <span class="p">*</span> <span class="m">0.1</span><span class="p">;</span>
</span><span class="line">    <span class="n">targetY</span> <span class="p">+=</span> <span class="p">(</span><span class="n">mouseY</span> <span class="p">-</span> <span class="n">targetY</span><span class="p">)</span> <span class="p">*</span> <span class="m">0.1</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="kt">var</span> <span class="n">index</span> <span class="p">=</span> <span class="n">MaxScreen</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">maxIndex</span> <span class="p">=</span> <span class="n">MaxScreen</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="k">while</span> <span class="p">(--</span><span class="n">index</span> <span class="p">&gt;</span> <span class="p">-</span><span class="m">1</span><span class="p">)</span>
</span><span class="line">        <span class="n">bitmap</span><span class="p">.</span><span class="n">Pixels</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="p">=</span> <span class="m">0</span><span class="n">x000000</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="kt">var</span> <span class="n">particle</span> <span class="p">=</span> <span class="n">particles</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">matrix</span> <span class="p">=</span> <span class="n">Matrix4x4</span><span class="p">.</span><span class="n">RotationY</span><span class="p">(</span><span class="n">targetX</span> <span class="p">*</span> <span class="m">0.05</span><span class="p">)</span> <span class="p">*</span> <span class="n">Matrix4x4</span><span class="p">.</span><span class="n">RotationX</span><span class="p">(</span><span class="n">targetY</span> <span class="p">*</span> <span class="m">0.05</span><span class="p">)</span> <span class="p">*</span> <span class="n">translationMatrix</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="kt">var</span> <span class="n">cx</span> <span class="p">=</span> <span class="m">275.0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">cy</span> <span class="p">=</span> <span class="m">200.0</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="kt">var</span> <span class="n">w</span> <span class="p">=</span> <span class="m">0.0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">xi</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">yi</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">x</span> <span class="p">=</span> <span class="m">0.0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">y</span> <span class="p">=</span> <span class="m">0.0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">z</span> <span class="p">=</span> <span class="m">0.0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">pz</span> <span class="p">=</span> <span class="m">0.0</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="k">while</span> <span class="p">(</span><span class="k">null</span> <span class="p">!=</span> <span class="n">particle</span><span class="p">)</span>
</span><span class="line">    <span class="p">{</span>
</span><span class="line">        <span class="n">x</span> <span class="p">=</span> <span class="n">particle</span><span class="p">.</span><span class="n">X</span><span class="p">;</span>
</span><span class="line">        <span class="n">y</span> <span class="p">=</span> <span class="n">particle</span><span class="p">.</span><span class="n">Y</span><span class="p">;</span>
</span><span class="line">        <span class="n">z</span> <span class="p">=</span> <span class="n">particle</span><span class="p">.</span><span class="n">Z</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">        <span class="n">pz</span> <span class="p">=</span> <span class="n">focalLength</span> <span class="p">+</span> <span class="n">x</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I02</span> <span class="p">+</span> <span class="n">y</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I12</span> <span class="p">+</span> <span class="n">z</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I22</span> <span class="p">+</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I32</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">        <span class="k">if</span> <span class="p">(</span><span class="m">0.0</span> <span class="p">&lt;</span> <span class="n">pz</span><span class="p">)</span>
</span><span class="line">        <span class="p">{</span>
</span><span class="line">            <span class="n">xi</span> <span class="p">=</span> <span class="p">(</span><span class="kt">int</span><span class="p">)(</span> <span class="p">(</span> <span class="n">w</span> <span class="p">=</span> <span class="n">focalLength</span> <span class="p">/</span> <span class="n">pz</span> <span class="p">)</span> <span class="p">*</span> <span class="p">(</span> <span class="n">x</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I00</span> <span class="p">+</span> <span class="n">y</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I10</span> <span class="p">+</span> <span class="n">z</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I20</span> <span class="p">)</span> <span class="p">+</span> <span class="n">cx</span> <span class="p">);</span>
</span><span class="line">            <span class="n">yi</span> <span class="p">=</span> <span class="p">(</span><span class="kt">int</span><span class="p">)(</span> <span class="n">w</span> <span class="p">*</span> <span class="p">(</span> <span class="n">x</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I01</span> <span class="p">+</span> <span class="n">y</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I11</span> <span class="p">+</span> <span class="n">z</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I21</span> <span class="p">)</span> <span class="p">+</span> <span class="n">cy</span> <span class="p">);</span>
</span><span class="line">
</span><span class="line">            <span class="n">index</span> <span class="p">=</span> <span class="n">xi</span> <span class="p">+</span> <span class="n">yi</span> <span class="p">*</span> <span class="n">ScreenWidth</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">            <span class="k">if</span> <span class="p">(</span><span class="n">index</span> <span class="p">&gt;</span> <span class="p">-</span><span class="m">1</span> <span class="p">&amp;&amp;</span> <span class="n">index</span> <span class="p">&lt;</span> <span class="n">maxIndex</span><span class="p">)</span>
</span><span class="line">            <span class="p">{</span>
</span><span class="line">                <span class="kt">var</span> <span class="n">color</span> <span class="p">=</span> <span class="n">bitmap</span><span class="p">.</span><span class="n">Pixels</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="p">+</span> <span class="m">0</span><span class="n">x202020</span><span class="p">;</span>
</span><span class="line">                <span class="n">bitmap</span><span class="p">.</span><span class="n">Pixels</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="p">=</span> <span class="n">color</span> <span class="p">&gt;</span> <span class="m">0</span><span class="n">xffffff</span> <span class="p">?</span> <span class="m">0</span><span class="n">xffffff</span> <span class="p">:</span> <span class="n">color</span><span class="p">;</span>
</span><span class="line">           <span class="p">}</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">
</span><span class="line">        <span class="n">particle</span> <span class="p">=</span> <span class="n">particle</span><span class="p">.</span><span class="n">Next</span><span class="p">;</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line">
</span><span class="line">    <span class="n">bitmap</span><span class="p">.</span><span class="n">Invalidate</span><span class="p">();</span>
</span><span class="line">
</span><span class="line">    <span class="n">storyboard</span><span class="p">.</span><span class="n">Begin</span><span class="p">();</span>
</span><span class="line">  <span class="p">}</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>What he’s doing here is writing pixels into a bitmap. At line 9, he sets all the pixels to zero (black), erasing the previous frame. At line 23 he starts a loop that will calculate each pixel that should be turned on for the upcoming frame. In both these cases he’s dealing with a one dimensional array of pixels. This is the perfect case for data parallelism. The work of setting pixels can be divided between processors.</p>

<p>In general, concurrency is not a simple technique to implement correctly. The number and type of problems that one can run into are <strong>way</strong> beyond the scope of anything short of a very thick book. But this perhaps the simplest case; simple <em>static composition data parallelism</em>. It’s static because you can pre-assign the amount of work each thread will do. It’s data parallelism because each thread will be doing the same kind of work (calculating and flipping pixels), as opposed to a solution where one thread does one thing (like talk on the network) while another thread does something else (like shred xml files).</p>

<p>We get this done by building a function that behaves like a <code>For()</code> loop, but executes the body in parallel between several threads. If you’ve played with the recently released Visual Studio 2010 beta that has the .NET 4.0 framework, you’ll recognize this function which is in the next version of the framework (but in a far more sophisticated and powerful form).</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">void</span> <span class="nf">ParallelFor</span><span class="p">(</span><span class="kt">int</span> <span class="n">lo</span><span class="p">,</span> <span class="kt">int</span> <span class="n">hi</span><span class="p">,</span> <span class="n">Action</span><span class="p">&lt;</span><span class="kt">int</span><span class="p">&gt;</span> <span class="n">body</span><span class="p">,</span> <span class="kt">int</span> <span class="n">p</span><span class="p">)</span>
</span><span class="line"><span class="p">{</span>
</span><span class="line">    <span class="kt">int</span> <span class="n">chunk</span> <span class="p">=</span> <span class="p">(</span><span class="n">hi</span> <span class="p">-</span> <span class="n">lo</span><span class="p">)</span> <span class="p">/</span> <span class="n">p</span><span class="p">;</span>      <span class="c1">// Iterations per thread</span>
</span><span class="line">
</span><span class="line">    <span class="n">AutoResetEvent</span><span class="p">[]</span> <span class="n">latch</span> <span class="p">=</span> <span class="k">new</span> <span class="n">AutoResetEvent</span><span class="p">[</span><span class="n">p</span><span class="p">];</span>
</span><span class="line">    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="p">&lt;</span> <span class="n">p</span><span class="p">;</span> <span class="n">i</span><span class="p">++)</span> <span class="n">latch</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="p">=</span> <span class="k">new</span> <span class="n">AutoResetEvent</span><span class="p">(</span><span class="k">false</span><span class="p">);</span>
</span><span class="line">
</span><span class="line">    <span class="c1">// Schedule the events to run in parallel</span>
</span><span class="line">    <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="p">&lt;</span> <span class="n">p</span><span class="p">;</span> <span class="n">i</span><span class="p">++)</span>
</span><span class="line">    <span class="p">{</span>
</span><span class="line">        <span class="n">ThreadPool</span><span class="p">.</span><span class="n">QueueUserWorkItem</span><span class="p">((</span><span class="n">ob</span><span class="p">)</span> <span class="p">=&gt;</span>
</span><span class="line">        <span class="p">{</span>
</span><span class="line">            <span class="kt">int</span> <span class="n">pid</span> <span class="p">=</span> <span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="n">ob</span><span class="p">;</span>
</span><span class="line">            <span class="kt">int</span> <span class="n">start</span> <span class="p">=</span> <span class="n">lo</span> <span class="p">+</span> <span class="n">pid</span> <span class="p">*</span> <span class="n">chunk</span><span class="p">;</span>
</span><span class="line">            <span class="kt">int</span> <span class="n">end</span> <span class="p">=</span> <span class="n">pid</span> <span class="p">==</span> <span class="n">p</span> <span class="p">-</span> <span class="m">1</span> <span class="p">?</span> <span class="n">hi</span> <span class="p">:</span> <span class="n">start</span> <span class="p">+</span> <span class="n">chunk</span><span class="p">;</span>
</span><span class="line">            <span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">j</span> <span class="p">=</span> <span class="n">start</span><span class="p">;</span> <span class="n">j</span> <span class="p">&lt;</span> <span class="n">end</span><span class="p">;</span> <span class="n">j</span><span class="p">++)</span>
</span><span class="line">            <span class="p">{</span>
</span><span class="line">                <span class="n">body</span><span class="p">(</span><span class="n">j</span><span class="p">);</span>
</span><span class="line">            <span class="p">}</span>
</span><span class="line">            <span class="n">latch</span><span class="p">[</span><span class="n">pid</span><span class="p">].</span><span class="n">Set</span><span class="p">();</span>
</span><span class="line">        <span class="p">},</span> <span class="n">i</span><span class="p">);</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line">    <span class="n">WaitHandle</span><span class="p">.</span><span class="n">WaitAll</span><span class="p">(</span><span class="n">latch</span><span class="p">);</span>
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>ParallelFor() takes lo and hi values, an <code>Action&lt;int&gt;</code>, and the degree of desired parallelism. The <code>Action&lt;int&gt; </code>is a delegate, which is like a pointer to a function. In this case, it’s a pointer to a function that has a single int parameter, and returns void. This function is the work that happens every iteration. Silverlight, .NET, and C# make it possible (I think it’s easy, but I’ve been doing this a while) to use anonymous methods and what amount to functional techniques to make Joa’s code multithreaded.  It may be best to illustrate by example.</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="k">while</span> <span class="p">(--</span><span class="n">index</span> <span class="p">&gt;</span> <span class="p">-</span><span class="m">1</span><span class="p">)</span>
</span><span class="line">    <span class="n">bitmap</span><span class="p">.</span><span class="n">Pixels</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="p">=</span> <span class="m">0</span><span class="n">x000000</span><span class="p">;</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>Joa’s code above, which initializes the pixels in the bitmap, becomes:</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="n">ParallelFor</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="n">buffer</span><span class="p">.</span><span class="n">Pixels</span><span class="p">.</span><span class="n">Length</span><span class="p">,</span> <span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="n">buffer</span><span class="p">.</span><span class="n">Pixels</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="p">=</span> <span class="m">0</span><span class="n">x0</span><span class="p">,</span> <span class="n">numComputationThreads</span><span class="p">);</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>The parameters of ParallelFor are zero for where to start the for loop, Pixels.Length for where to end the loop, the lambda <code>function (i) =&gt; buffer.Pixels[i] = 0x0</code>, and the number of threads to use to do the work. The lambda function is anonymous (i.e. we don’t have to create a function with a name). The type of “i” is <em>inferred</em> from context to be an int. The body of the lambda (the part after the “=&gt;”), is the work that is done each time through the loop.</p>

<p>This makes the clearing of last frame’s bitmap concurrent. To make the rendering of the next frame concurrent is a bit more invasive, but still not bad. Here’s the concurrent version.</p>

<div class="bogus-wrapper"><notextile><figure class="code"><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class="line-number">1</span>
<span class="line-number">2</span>
<span class="line-number">3</span>
<span class="line-number">4</span>
<span class="line-number">5</span>
<span class="line-number">6</span>
<span class="line-number">7</span>
<span class="line-number">8</span>
<span class="line-number">9</span>
<span class="line-number">10</span>
<span class="line-number">11</span>
<span class="line-number">12</span>
<span class="line-number">13</span>
<span class="line-number">14</span>
<span class="line-number">15</span>
<span class="line-number">16</span>
<span class="line-number">17</span>
<span class="line-number">18</span>
<span class="line-number">19</span>
<span class="line-number">20</span>
<span class="line-number">21</span>
<span class="line-number">22</span>
<span class="line-number">23</span>
<span class="line-number">24</span>
<span class="line-number">25</span>
<span class="line-number">26</span>
<span class="line-number">27</span>
<span class="line-number">28</span>
<span class="line-number">29</span>
<span class="line-number">30</span>
<span class="line-number">31</span>
<span class="line-number">32</span>
<span class="line-number">33</span>
</pre></td><td class="code"><pre><code class="C#"><span class="line"><span class="n">ParallelFor</span><span class="p">(</span><span class="m">0</span><span class="p">,</span> <span class="n">particles</span><span class="p">.</span><span class="n">Length</span><span class="p">,</span> <span class="p">(</span><span class="n">i</span><span class="p">)</span> <span class="p">=&gt;</span>
</span><span class="line"><span class="p">{</span>
</span><span class="line">    <span class="n">Particle</span> <span class="n">part</span> <span class="p">=</span> <span class="n">particles</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">x</span> <span class="p">=</span> <span class="n">part</span><span class="p">.</span><span class="n">X</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">y</span> <span class="p">=</span> <span class="n">part</span><span class="p">.</span><span class="n">Y</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">z</span> <span class="p">=</span> <span class="n">part</span><span class="p">.</span><span class="n">Z</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="kt">var</span> <span class="n">w</span> <span class="p">=</span> <span class="m">0.0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">xi</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span><span class="line">    <span class="kt">var</span> <span class="n">yi</span> <span class="p">=</span> <span class="m">0</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="kt">var</span> <span class="n">pz</span> <span class="p">=</span> <span class="n">focalLength</span> <span class="p">+</span> <span class="n">x</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I02</span> <span class="p">+</span> <span class="n">y</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I12</span> <span class="p">+</span> <span class="n">z</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I22</span> <span class="p">+</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I32</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">    <span class="k">if</span> <span class="p">(</span><span class="m">0.0</span> <span class="p">&lt;</span> <span class="n">pz</span><span class="p">)</span>
</span><span class="line">    <span class="p">{</span>
</span><span class="line">        <span class="n">xi</span> <span class="p">=</span> <span class="p">(</span><span class="kt">int</span><span class="p">)((</span><span class="n">w</span> <span class="p">=</span> <span class="n">focalLength</span> <span class="p">/</span> <span class="n">pz</span><span class="p">)</span> <span class="p">*</span> <span class="p">(</span><span class="n">x</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I00</span> <span class="p">+</span> <span class="n">y</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I10</span> <span class="p">+</span> <span class="n">z</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I20</span><span class="p">)</span> <span class="p">+</span> <span class="n">cx</span><span class="p">);</span>
</span><span class="line">        <span class="n">yi</span> <span class="p">=</span> <span class="p">(</span><span class="kt">int</span><span class="p">)(</span><span class="n">w</span> <span class="p">*</span> <span class="p">(</span><span class="n">x</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I01</span> <span class="p">+</span> <span class="n">y</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I11</span> <span class="p">+</span> <span class="n">z</span> <span class="p">*</span> <span class="n">matrix</span><span class="p">.</span><span class="n">I21</span><span class="p">)</span> <span class="p">+</span> <span class="n">cy</span><span class="p">);</span>
</span><span class="line">
</span><span class="line">        <span class="kt">var</span> <span class="n">index</span> <span class="p">=</span> <span class="n">xi</span> <span class="p">+</span> <span class="n">yi</span> <span class="p">*</span> <span class="n">ScreenWidth</span><span class="p">;</span>
</span><span class="line">
</span><span class="line">        <span class="k">if</span> <span class="p">(</span><span class="n">index</span> <span class="p">&gt;</span> <span class="p">-</span><span class="m">1</span> <span class="p">&amp;&amp;</span> <span class="n">index</span> <span class="p">&lt;</span> <span class="n">maxIndex</span><span class="p">)</span>
</span><span class="line">        <span class="p">{</span>
</span><span class="line">            <span class="kt">var</span> <span class="n">color</span> <span class="p">=</span> <span class="n">buffer</span><span class="p">.</span><span class="n">Pixels</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="p">+</span> <span class="m">0</span><span class="n">x202020</span><span class="p">;</span>
</span><span class="line">            <span class="n">buffer</span><span class="p">.</span><span class="n">Pixels</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="p">=</span> <span class="n">color</span> <span class="p">&gt;</span> <span class="m">0</span><span class="n">xffffff</span> <span class="p">?</span> <span class="m">0</span><span class="n">xffffff</span> <span class="p">:</span> <span class="n">color</span><span class="p">;</span>
</span><span class="line">        <span class="p">}</span>
</span><span class="line">    <span class="p">}</span>
</span><span class="line">
</span><span class="line"><span class="p">},</span> <span class="n">numComputationThreads</span><span class="p">);</span>
</span><span class="line">
</span><span class="line"><span class="n">buffer</span><span class="p">.</span><span class="n">Invalidate</span><span class="p">();</span>
</span><span class="line"><span class="n">lastRender</span> <span class="p">=</span> <span class="n">elapsed</span><span class="p">;</span>
</span><span class="line">
</span><span class="line"><span class="p">}</span>
</span></code></pre></td></tr></table></div></figure></notextile></div>

<p>There are a few changes that I made to make the optimization a bit easier. Joa used a linked list of particles, I captured an array, just because it was a bit easier to make concurrent. But the significant difference is the body of Joa’s loop is now in an anonymous function. Values that will change in the body of the loop are now defined in the loop (x,y,z, etc). This is because if the loop used the variables defined outside the lambda, then the different threads would try to use the same variables as one another, which is obviously a problem. Other than that, the code is pretty much the same.</p>

<p>So how much of an improvement is there? Yea, a lot. I put a frame counter on Joa’s original code and on my MBP dual Core Duo 2.4Ghz 4Gig ram running Windows 7 release, it was getting about 30 frames per second. On OS X it was about the same. With the concurrency, and set to use 4 threads, it got up to 45 fps. On my quad core Dell M6400 Core 2 Exreme Q9300 at 2.54 Ghz with 8gig ram, it went up to 65 fps. If found it was best to use more threads then you have cores. So 4 threads was good on the dual core, 8 on the quad core.</p>

<p>Of course, this means the app will absolutely peg the processor, which is good if you want max speed. But you can also throttle the frame rate back, say hold it at 30, and use less processor to get the same fps as the original.</p>

<p>Silverlight 3 has caused a bit of a splash in the RIA community if the Twitter chatter is any indication. There is some venomous talk out there; you know the such and such tech sucks, such and such tech rules, and of course Microsoft is evil. I choose to stay out of that fray, perhaps it’s hitting 40 that did it. I don’t care to argue with Fanbois. I will say that the the community will discover that the .NET framework and C# (even VB.NET) make for a serious development platform that will benefit the community at large. It’s a very good time to be a developer!</p>

<p>Here’s a link to a zip file containing my version of the project: <a href="https://skydrive.live.com/?cid=db16741b8ce498b0#">Strange Attractor Project</a></p>

<p>Would you like to see the concepts in this post expanded? Want to know more about concurrency, functional patterns, generics? Leave me a note in the comments or send me a Twitter reply at @efvincent. Oh, and thanks for reading!</p>
]]></content>
  </entry>
  
</feed>