Links

msmq wcf and iis getting them to play nice

AutoFac WAS Hosting and Non-HTTP Activation

Windows Components Installed

Microsoft Message Queue (MSMQ) Server > MSMQ Server Core

Microsoft .NET Framework > Windows Communication Foundation Non-HTTP Activation

IIS 7 Configuration

1. Add net.msmq to the list of enabled protocols. In IIS, Web App -> Advanced Settings -> Enabled Protocols. It is a comma separated list (http,net.msmq).
2. Make sure Client and Service have correct permissions to access the private queue

MSMQ Config

Add NETWORK SERVICE to the new MSMQ (windows 7 that is in Computer Managment -> Services and Applications -> Message Queuing

C# code to create initialize private queue

The queue name must match the URI of your service’s .svc file according to this

  // Create and connect to a private Message Queuing queue.
if (!MessageQueue.Exists(@".\Private$\JangoFettClient/CloneService.svc"))
{
    // Create the queue if it does not exist.
    MessageQueue.Create(@".\Private$\JangoFettClient/CloneService.svc");
}

Example Service Config

<bindings>
    <netMsmqBinding>
        <binding name="MsmqBindingNonTransactionalNoSecurity"
                        exactlyOnce="false">
            <security mode="None"/>
        </binding>
    </netMsmqBinding>
</bindings>
<services>
<service name="JangoFettClient.CloneService">
    <endpoint name="msmq" 
              address="net.msmq://localhost/private/JangoFettClient/CloneService.svc"
              binding="netMsmqBinding" 
              bindingConfiguration="MsmqBindingNonTransactionalNoSecurity"
              contract="JangoFettClient.ICloneOrderProcessor" />
</service>
</services>

Example Service

Example of data contract that would automatically become the listener and pull the items from MSMQ via WCF

namespace JangoFettClient
{
    public class CloneService : ICloneOrderProcessor
    {
        private readonly ILog _logger;

        public CloneService(ILog logger)
        {
            _logger = logger;
        }

        public void SendMessage(CloneOrder request)
        {
            _logger.Info("Message received from MSMQ");
        }
    }
}

Errors with easy fixes

The protocol ‘net.msmq’ is not supported. Add net.msmq to the list of enabled protocols. See IIS 7 Configuration above for more information.

I do lots of installs on my windows machine and got tired of having to change the path environment variables manually. I created a AddPath.exe that will do this for me and added a short cut to the right click context menu.

In one right click I can get this result:

Here is how it works if you are interested:

1. Compile Code Via – git@github.com:JasonRowe/AddPath.git or Download the zip file.
2. Put the executable (AddPath.exe) and the dependency file (System.dll) into C:\tools\
3. This executable needs to run as Admin. Right click on AddPath.exe, click compatibility tab and select “run this program as an administrator”

To add the right click context menu you need to add a new key to the registry

1. open the registry editor (Start -> Run -> regedit.exe)
2. Find the key HKEY_CLASSES_ROOT\Folder. Create a new key named shell if its not already there (HKEY_CLASSES_ROOT\Folder\shell)
3. In the shell key (possibly just created) create a new key and change its name AddPath or whatever you want to show in the context menu
4. Under the new key create a new key named command (HKEY_CLASSES_ROOT\Folder\shell\AddPath\command) and change its default value C:\tools\AddPath.exe “%1″

 public static void AddPathSegments(Options options)
        {
            try
            {
                string allPaths = Environment.GetEnvironmentVariable("PATH", options.Target);
                if (allPaths != null)
                    allPaths = options.PathSegment + "; " + allPaths;
                else
                    allPaths = options.PathSegment;
                Environment.SetEnvironmentVariable("PATH", allPaths, options.Target);

                Console.WriteLine("Added path segment: {0}", options.PathSegment);
            }
            catch (Exception ex)
            {
                Console.WriteLine("could not add path segment: {0} -  error {1}", 
                                   options.PathSegment, ex);
            }
        }

Why use ejabberd which is written in a wacky language called Erlang? Well… you will have to decide for yourself. Erlang is a functional programming language which is known for concurrency and high reliability. Also, it’s the 24th most popular language on GitHub as of writting this so it can’t be that bad. :)

If you don’t have ejabberd setup yet see my previous post on getting strophejs, ejabberd, and IIS all working together.

Step one, take a deep breath and get up to speed on XMPP, ejabberd, and Erlang. Easy right? Don’t worry, it will all come together by the end of this post. Well, at least you will write some Erlang by the end of the post. Here are some resource to have handy.

Books:

1. Learn You Some Erlang
2. XMPP, the definitive guide

Let’s start with getting the Erlang environment up and running. You need Erlang to compile the new module. The Erlang version is important because it should match the one used in the installed ejabberd server. What version of Erlang was used with your installed ejabberd? You can find that information here using your ejabberd version number (if you don’t know the version number skip ahead to the next section before following this link): http://www.ejabberd.im/erlang.

If you don’t know your ejabberd version here is how to get it.

Go to start, run, and type cmd to open a command prompt. CD to your ejabberd\bin folder. Mine in “D:\Program Files (x86)\ejabberd-2.1.9\bin”. Then run the following command:

You should see something like this “The node ejabberd@localhost is started with status: started ejabberd 2.1.9 is running in that node”

If you you get an error like the following “Failed RPC connection to the node ejabberd@localhost: nodedown” Try to run the start command:

If you get the same error when trying to start you might have a “.erlang.cookie” mismatch. On my box ejabberd runs using the erlang cookie from “C:\Windows\.erlang.cookie”. This needs to match the one in your user folder. My Erlang cookie is located here: “C:\Users\rowej\.erlang.cookie”. If you are getting the error mentioned, copy your erlang cookie from the windows folder into your user folder.

Now that you have the ejabberd version go to ejabberd official site and see which version of erlang was used. This is important so you are using the same version when you compile your module.

Now open your favorite text editor. I recommend Sublime Text 2 with Erlang syntax highlighting turned on. Also, there are several choices of plugins for NetBeans or Eclipse. The officially recommended IDE is Erlang mode for Emacs.

The next step is to get a basic module installed and make sure it is working. Lets start with a very simple module that does nothing but logs out information. Finally, time to start coding!

Create a file named mod_http_offline.erl.

Lets start with a very simple module that just does logging. This should give us a good idea of how ejabberd handles modules. Fill in the file you created “mod_http_offline.erl” with the following code:

%% name of module must match file name
-module(mod_http_offline).

-author("Earl The Squirrel").

%% Every ejabberd module implements the gen_mod behavior
%% The gen_mod behavior requires two functions: start/2 and stop/1
-behaviour(gen_mod).

%% public methods for this module
-export([start/2, stop/1, create_message/3]).

%% included for writing to ejabberd log file
-include("ejabberd.hrl").

%% ejabberd functions for JID manipulation called jlib.
-include("jlib.hrl").

start(_Host, _Opt) -> 
		post_offline_message("testFrom", "testTo", "testBody"),
		?INFO_MSG("mod_http_offline loading", []),
		ejabberd_hooks:add(offline_message_hook, _Host, ?MODULE, create_message, 50).   



stop (_Host) -> 
		?INFO_MSG("stopping mod_http_offline", []),
		ejabberd_hooks:delete(offline_message_hook, _Host, ?MODULE, create_message, 50).



create_message(_From, _To, Packet) ->
		Type = xml:get_tag_attr_s("type", Packet),
		FromS = xml:get_tag_attr_s("from", Packet),
		ToS = xml:get_tag_attr_s("to", Packet),
		Body = xml:get_path_s(Packet, [{elem, "body"}, cdata]),
		if (Type == "chat") ->
			post_offline_message(FromS, ToS, Body)
		end.



post_offline_message(From, To, Body) ->
		?INFO_MSG("Posting From ~p To ~p Body ~p~n",[From, To, Body]),
		?INFO_MSG("post request sent (not really yet)", []).

Now lets get the necessary include files to compile the code. You will have to go to the ejabberd site and download the src.

select “source code” from the drop down list. Then use a tool like TarTool to unzip it. Copy jlib.hrl and ejabberd.hrl into the same folder where where you created the module source mod_http_offline.erl

Now open the erlang shell (programs > Erlang), type in:

Remember you must use a slash (forward slash). If you cut and paste from windows explorer you will get back slashes and you won’t be able to change directories.

Then compile by doing the following:

You should see this result and a .beam file now created in the directory:

Shut down ejabberd server and copy the resulting .beam file to the directory where all the other ejabberd .beam files are. \ejabberd-2.1.9\lib\ejabberd-2.1.9\ebin

Configure ejabberd to enable this module via the ejabberd.cfg. Add it to the list of modules in the Module section.

Start up eJabberd.

After it starts lets examine the log files to see if our module loaded. example\path\ejabberd-2.1.9\logs\ejabberd.log

You should see the following log entries:

Now we can have fun and send some offline messages. Get two XMPP clients running logged in with two different users. I used my admin account created during the ejabberd setup and a new test account created via the ejabberd Web Admin. I used the agxXMPP client to send messages back and forth but you can use which ever XMPP client is easier for you. You can find a list of them on the official XMPP website client list. Send a few message to a user who is not connected (offline) and check your ejabberd.log file.(example\path\ejabberd-2.1.9\logs\ejabberd.log). Here is what mine looks like after sending a Hello world message.

Shut down ejabberd and setup a page to handle HTTP POST’s via Erlang. use your favorite web framework for the page it really doesn’t matter. If you are using MVC .Net it might look somethign like this.

 [HttpPost]
        public ActionResult Process()
        {
            var formValues = Request.Form;

            string from;
            string to;
            string body;

            if (!string.IsNullOrEmpty(formValues["From"]))
            {
                from = formValues["From"];
            }

            if (!string.IsNullOrEmpty(formValues["To"]))
            {
                to = formValues["To"];
            }

            if (!string.IsNullOrEmpty(formValues["Body"]))
            {
                body = formValues["Body"];
            }

Then from the Erlang console send a post to make sure everything is working with this command:

If you see a response starting with this you are good to go.

{ok,{{"HTTP/1.1",200,"OK"},

Now lets change the module to send the post adding in a few more lines of code.

%% name of module must match file name
-module(mod_http_offline).

-author("Earl The Squirrel").

%% Every ejabberd module implements the gen_mod behavior
%% The gen_mod behavior requires two functions: start/2 and stop/1
-behaviour(gen_mod).

%% public methods for this module
-export([start/2, stop/1, create_message/3]).

%% included for writing to ejabberd log file
-include("ejabberd.hrl").

%% ejabberd functions for JID manipulation called jlib.
-include("jlib.hrl").

start(_Host, _Opt) -> 
		?INFO_MSG("mod_http_offline loading", []),
		inets:start(),
		?INFO_MSG("HTTP client started", []),
		post_offline_message("testFrom", "testTo", "testBody"),
		ejabberd_hooks:add(offline_message_hook, _Host, ?MODULE, create_message, 50).   



stop (_Host) -> 
		?INFO_MSG("stopping mod_http_offline", []),
		ejabberd_hooks:delete(offline_message_hook, _Host, ?MODULE, create_message, 50).



create_message(_From, _To, Packet) ->
		Type = xml:get_tag_attr_s("type", Packet),
		FromS = xml:get_tag_attr_s("from", Packet),
		ToS = xml:get_tag_attr_s("to", Packet),
		Body = xml:get_path_s(Packet, [{elem, "body"}, cdata]),
		if (Type == "chat") ->
			post_offline_message(FromS, ToS, Body)
		end.



post_offline_message(From, To, Body) ->
		?INFO_MSG("Posting From ~p To ~p Body ~p~n",[From, To, Body]),
		 http:request(post, {"http://localhost/OfflineDemoWebhost/Message/Process",[], 
		 "application/x-www-form-urlencoded",
		 lists:concat(["From=", From,"&To=", To,"&Body=", Body])}, [], []),
		?INFO_MSG("post request sent", []).

Shut down ejabberd again and recompile. Copy the beam file overitting the old version. Now start up the server and you should have offline messages posting to your web application.

  
kernel.Register(
    Component.For<IMyImageComponent>()
        .ImplementedBy<MyImageComponent>()
        .Named("SomeImage"));

  
Interface example:

    public interface IMyImageComponent
    {
        Bitmap BuildImage();

        string GetFileName();
    }

  
var type = typeof(IMyImageComponent);
var styles = AppDomain.CurrentDomain.GetAssemblies().ToList()
        .SelectMany(s => s.GetTypes())
        .Where(type.IsAssignableFrom);

    foreach (var style in styles)
    {
        if (!style.IsClass || style.IsNotPublic || style.IsAbstract) 
            continue;

        object o = Activator.CreateInstance(style);
        var propertyInfo = style.GetMethod("GetFileName");
        var name = (string)propertyInfo.Invoke(o, null);
        container.Register(Component.For<IMyImageComponent>()
                    .ImplementedBy(o.GetType()).Named(name));

  

container.Register(AllTypes.FromAssembly(typeof(YourClassNameHere).Assembly)
               .BasedOn<IMyImageComponent>());

var myImageStyles = container.ResolveAll<IMyImageComponent>();

var myImageTypes = myImageStyles .Select(style => style.GetType()).ToList();

foreach (var type in myImageTypes )
{
    object o = container.Resolve(type);
    var propertyInfo = type.GetMethod("GetFileName");
    var name = (string)propertyInfo.Invoke(o, null);
    container.Register(Component.For<IMyImageComponent>()
        .ImplementedBy(o.GetType()).Named(name));
}

  
container.Register(Component.For<ITypedFactoryComponentSelector>()
         .ImplementedBy<ImageStyleFactorySelector>().Named("ImageStyleFactorySelector"));

container.Register(Component.For<IMyImageTemplateFactory>()
         .AsFactory(c => c.SelectedWith("ImageStyleFactorySelector")));

  
public class ImageStyleFactorySelector : DefaultTypedFactoryComponentSelector
{
   protected override string GetComponentName(MethodInfo method, object[] arguments)
   {
       if (method.Name == "GetByFileName" && arguments.Length == 1 && arguments[0] is string)
       {
           return arguments[0].ToString();
       }
       return base.GetComponentName(method, arguments);
   }
}

   
var imageComponent = _ImageTemplateFactory.GetByFileName(fileName);

To try out F#I decided to make a function to calculate  simple moving average (SMA) and exponential moving average (EMA).  The SMA and EMA have enough math to try many of the features of F# and functional programming.

The first thing I learned was F# has a way to quickly execute code. If you haven’t played with F#’s Interactive it’s sort of like a REPL loop. While coding you can highlight the code and do a Alt-Enter to execute it. It’s very convenient.

To keep with the functional style of programming I put the SMA and EMA into a type. In OO this would be the equivalent of using a base class for moving averages and then creating classes for SMA and EMA. As you can see in F# this is a very small amount of code using type declaration / discriminators. You can see comments in my code below for things I learned and picked up while doing this exercise.

 

type movingAverage =
  | Simple of int * seq<float>
  | Exponential of int * float list



// sma is an example of using a private / utility function
// pipelining operator |> allows execution of a series of operations
let sma(size, seq) =                                  
    Seq.windowed size seq
    |> Seq.map Array.average  



// example of Matching on discriminated unions
let calculate(movingAverage) =
    match movingAverage with

    |Simple(size, seq) -> sma(size, seq)

    |Exponential(period, data) -> 

            let multiplier =  2.0 / (1.0 + (float period))
            
//Calc a sum to use in the SMA to prime the EMA calculation
//http://bit.ly/bG73sx Slice like functionality from a List
            let iniSum =  
                data 
                |> List.toSeq 
                |> Seq.take (int period) 
                |> Seq.sum

//first float from list using period as the start
            let firstItem = 
                data 
                |> List.toSeq 
                |> Seq.skip (int period)  
                |> Seq.head 

//setup first ema with sma
            let firstEma = (iniSum / (float period))

            let out : float array = Array.zeroCreate (List.length data)

//setup initial Ema to previous day
            out.[period - 2] <- firstEma

//calculate the rest of the Ema's
            for i in period - 1 .. (List.length data - 1) do
                let close = data.[i]
                let prev = out.[i - 1]
                out.[i] <- multiplier * (close - prev) + prev

            Array.toSeq out

// F# Note - intrinsic type extensions adds the calculate member to the movingAverage type
type movingAverage with                                                
   member x.calculate() = calculate(x)  


//Test Simple
let simpleMovingAverage = Simple(10, (Seq.map float [|1..30|]))

let avgs = simpleMovingAverage.calculate();

for avg in avgs do
    printfn "%f" avg

//Test Exponential
let expMovingAverage = Exponential(10, [1.0..30.0])

let expAvgs = expMovingAverage.calculate();

for e in expAvgs do
    printfn "%f" e

Last week in the office I thought to my self, “Holiday weekend coming! I’ll have time to play with WP7 or maybe I’ll play with HTML5”. Then I saw this tweet on twitter.

We as developers spend too much time playing with baubles and shiny new tools and not enough time on core skills and fundamentals

I thought well, instead of using some free time this holiday weekend to build something why not do a little research. I happened to have a problem at work which someone suggested using the Visitor Pattern. So I spent some time looking over a few resources and Wikipedia has a great explanation. I won’t try to repeat that. One area I was stuck on though was the concept of double dispatch. I found this example on StackOverflow.com which solidified the concept. For some reason learning by spaceship and rebel alliance works for me.

So now that I had a good understand all I needed to was implement it right? I thought about it and figured that could wait. Now is an opportunity to work on my fundamentals. The Wikipedia article mentioned Common Lisp and how the Visitor Pattern simplified when using dynamic languages. This got me to thinking what would this look like in F# or a functional language?

While looking into functional languages I came across this Stack Overflow question “I am a C# developer, Should I start looking more on F# [closed]”.  Jon Skeet’s answer influenced me and I figured I would pick up a book Real World Functional Programming. It fits into the category of fundamentals because it’s using C# and F# to teach functional programming. Which I haven’t used in many years.

So I start reading with the goal in mind that I would make a quick example of the visitor pattern in F#. Don’t think I am a super geek (not that you would be confused because of my skills). I did take time to drink a few of these and go to the Crowded House concert this weekend. By the fourth chapter or so things started to sink in with F# and functional programming.

If I were using a declarative functional style of programming, I wouldn’t even need the visitor pattern at all!  I don’t have objects that would need to be separated from the algorithm. I would only have types and could use pattern matching and discriminated unions to perform my algorithm. The visitor pattern is needed in my current project because I’m using an implicit OO coding approach.

It was really shocking to me that this wasn’t obvious right away. I’ve been doing OO for so long now I’ve completely become accustomed to dealing with objects and state. A programming world without objects had completely slipped from my mind. Glad I took the time to get started on this book as it’s already giving me new ideas and techniques I can use in my daily C# and OO programming. Now to start working on some of the other programmer competencies.

Today I went to the WP7 boot camp in Minneapolis. Not many people have actually seen a Windows Phone 7 yet. I was hoping to see the real thing but it wasn’t available. Although, the dev tools are ready and very robust.

Getting started is easy using the developer tools and developer training kit. After downloading and playing around I really hope WP7 is a success. The development experience is slick if you are willing to embrace XAML or XNA.

A note about the install. If you have a full version of Visual Studio it will integrate with that. Otherwise it will install Visual Studio express. A few people in the group were confused when they opened express and the tools were not available as they already had VS2010 installed. (Note, it might be safer to use VS Express for now with this beta if you can. The presenter was having issues adding service references with VS Pro but it works in express.)

Below are a list of notes that caught my attention during the talk. This is all based on a beta product so some of this may change. For the latest information download the WP7 Training Kit and visit the wp7 developer site.

Basics

• $100 fee to upload apps to market place. You get paid after you make the first $100 but Microsoft will take a cut for each sale.
• Has ability to upload app in trial mode
• Silverlight capabilities is basically Silverlight 3 plus additional features.

Known Issues with Emulator:

• Sometimes Emulator will not change from portrait to landscape if keyboard is enabled to be used. Hit PageDown to disable it
• When using VS Pro some users have not been able to add service references correctly. They didn’t generate the full proxy.

Tips and Tricks:

• Use PageUp and PageDown keys to enable keyboard in emulator.
• Emulator can be kept running and will store all opened apps.
• Blend can be used to test light and dark template available to phone users.

Tooling

• Code from Silverlight 3 should work on the phone with maybe only small tweaks for things like navigation and UI sizes.
• List Application (list and details page paradigm)
• Binding works just like in Silverlight
• DataContext works like Silverlight
• Input scopes “TelephoneAreaCode” and “EmailSMTPAdress”  allow you to change keyboard layout. Developer Note: You can use Verbose XAML syntax for intellisense. You can’t create your own input scopes right now. Demo in SDK uses reflection to explore input scopes.
• Accelerometer – can be used with emulator if laptop that has one built one in. Otherwise you can use accelerometer emulator using RX.
• Audio – leverage raw data override BufferReady event at regular intervals save and manipulate audio. About a 10ms delay. All available in SDK.
• Video elements – Media support is on the hardware – video decoding is down on the hardware. Only one media element on the page at the time. No video media brush. DRM
• XNA API can be used to bring in sounds and background sounds.
• JavaScript can talk to Silverlight in control – Silverlight to script wb.InvokeScript  – script to Silverlight wb_ScriptNotify. Window.external.Notify(string)

3rd Party Tools and Links

• MVVM light for wp7. Design Pattern.
•  Developer Note: Bing Maps Control not yet available but being developed.

Design

• All elements can be animated
• Elements can be projected onto 3d plane
• Templating – taking a control and laying a XAML rendering over the code base. Microsoft encourages using the metro theme but they did show a puzzle application that used templating to change buttons and panels.
• Styling can be set in the Application XAML resources or page resources.
• Two screen resolutions will be available.
• User can change the Theme
• Blend can be used to test dark and light themes available to users. Would only need to be done if you go off and build your own template. But if you use the metro theme you get the changes for free. For example, your applications buttons and backgrounds would be updated.
• App bar should be used to create consistent navigation and controls. How to: Add an Application Bar to Your Application on MSDN.
• App bar Icon set can be downloaded here.

Application Components

• Host (TaskHost)
• XAP file
• Pages (Silverlight)
• Content (Silverlight)
• Games (XNA)

Application Structure

• Apps are built like web sites
• Functionality is split into pages
• Forward navigation via links
• Backward navigation via Back (should use hardware button).
• Users can navigate across different applications
• Previous app (pages) are in the back stack. No multi tasking for third party apps. The back stack means your app is shut down.

Hardware buttons

• Back (only one you can inject into when it fires right now)
• Start
• Search
• Volume
• Camera

Feels like web design.

• Application state can be passed between pages by querystring and frame context.
• hyperlinks can be used to navigate to other pages.
• UriMapping which is similar to MVC URL routing.

Push Notification Service via the cloud (Microsoft Notification service)

• Developer Note: When the emulator starts it takes 30 seconds to instantiate notification service.
• Phones subscribe to a service on your server for events via a Uri.
• All communication pushed to phone is via Microsoft.
• Events are sent from a server to Microsoft push service.

Location Service:

• Developer Note: No Emulator Support – MSDN RX emulator can be created.
• Cell Tower, Satellite GPS, or WIFI can be used
• Developer Note: Use cell tower to save battery but less accurate

Types of Notifications on the Phone

• Tile Notifications –  Tile on homepage which has an image, number, and simple text.
• Toast – pop-up will link back to app.
• If the app is running raw data can be accessed and displayed.

Handling Life Time Events: Obscure VS Deactivated

Hidden By Shell UI: Obscured

• On Obscure you need to handle it gracefully then when un obscure you need to start.

Moved to background: Deactivated

• Deactivate event fires
• Your app becomes suspended (you have a limited time to handle but not specified yet)
• State will be destroyed eventually if user doesn’t go back. Assume your app is killed.
• If user goes back to application Activate event will be fired
• You can load state via isolated storage and resume where you left off

Interesting Questions asked during the presentation:

• Question: Are ODBC drivers available or ported? Answer: Someone suggested using isolated storage for this instead.
• Question: Does page Navigation come with default animation? Answer: It doesn’t come with a default animation. But you can add them in by intercepting the navigation event.
• Question: How is back stack clean up done and can it be prioritized? Answer: Presenter guessed that it might be resource based but not sure yet.
• Question: Can you control the Antenna for GPS? Can you turn it off or on and receive notifications when it is ready? Answer: Start and Stop service might be used for this but not sure. It looks like the API only tries to use it if available. Look at Location example in SDK.

Links

• http://www.silverlight.net/
• http://developer.windowsphone.com/
• http://slickthought.net/ Jeff Brand’s Site
• Programming Windows 7 Phone 

The latest release of Entity Framework CTP4 has some nice but unexpected changes. They introduced DbContext and DbSet to simplify model caching, database provisioning, schema creation and connection management. Here are my top 5 favorite features of the release.

1. Less code and fewer Concepts. The coolest part is the use of convention over configuration. See the Productivity Improvements walk through and Conventions for code first. I like the extra touch that DbContext  will create the database for you if you want. No code to write. Just use the default CreateDatabaseOnlyIfNotExists.
2. Simplified Database Experience. With the introduction of DbContext and DbSet. EF now takes care of database provisioning, schema creation and connection management. Nice! My favorite part is the Interface IDbConnectionFactory to allow creation of your own conventions.
3. Backwards Compatible. Yes, this is a feature when it comes to CTP’s and Betas. Some projects might just throw stuff away or completely change things on you. EF allows you to still use ObjectContext or Data Annotations for advanced scenarios where common conventions don’t work for you.
4. Simplified Configuration Experience. As I mentioned you can use annotations for this but you also have another cool option. DbContext includes a virtual method that can be overridden to do configuration right in the class. This means no need for separate configuration classes now. I definitely like having it all in one place. Much cleaner and easy to read.
5. Testability IDbSet<TEntity> allows you to define an interface that can be implemented by your derived context. This allows the context to be replaced with an in-memory test double for testing.

MemoryIndex, contributed by Wolfgang Hoschek, is a fast RAM-only index designed to test whether a single document matches a query. InstantiatedIndex, contributed by Karl Wettin, is similar, except it’s able to index and search multiple documents. Unfortunately, neither of these are yet ported to .Net. I thought about trying to port these but figured I would see if I could build a simple reverse search using the slower built in RamDirectory in Lucene and Lucene.net.

So what I want to create is a reverse search or on-the-fly matchmaking for documents. A simpler way to say that is I take a list of queries and check if they match a data object each time a data object is created. For simplicity sake I’m only working with the already ported Lucene code.

One cool features in Lucene version 2.9 was the addition of Near Real Time (NRT) searching. This seemed like a good fit for my scenario of trying to create a faster reverse search. It provides a way to search for documents that have not been committed yet. This helps take some of the overhead off when I need to add the one document to the index before running all the queries to test for matches. The explanation from the book says NRT enables you to rapidly search changes made to the index with an open IndexWriter, without having to first close or commit changes to that writer.

The NRT features allows me to do something like this:

It seems to be a big memory hog though so I made it disposable.

   
 public class QueryProcessor : IDisposable
    {
        private readonly RAMDirectory _directory;
        private readonly IndexWriter _writer;

        public MetaQueryProcessor()
        {
            _directory = new RAMDirectory();
            _writer = new IndexWriter(_directory, 
                                      new StandardAnalyzer(
                                          Lucene.Net.Util.Version.LUCENE_CURRENT),
                                          IndexWriter.MaxFieldLength.UNLIMITED);
            _writer.SetMergeFactor(2);
        }

        public void Optimize()
        {
            _writer.Optimize();
        }

        public List<string> Search(List<metaqueryrequest> requests, Document doc)
        {
            _writer.AddDocument(doc);

            var results = new List<string>();

            foreach (var request in requests)
            {
                var reader = _writer.GetReader();//Near-real-time search not commited

                var indexSearcher = new IndexSearcher(reader);

                var primitiveQuery = request.LuceneQuery.Rewrite(reader);

                var hits = indexSearcher.Search(primitiveQuery, 1);

                if (hits.totalHits > 0)
                {
                    results.Add(request.QueryName);
                }
            }

            _writer.DeleteAll();

            return results;
        }

        #region IDisposable Members

        public void Dispose()
        {
            _directory.Close();
        }

        #endregion
    }

If you know of a faster way to accomplish this please let me know. For more background information on this topic see these resources.

• MemoryIndex contrib project Lucene
• InstantiatedIndex contrib project Lucene

I started reading Lucene in Action by Otis Gospodnetic´ and Erik Hatcher.  Lucene is a high performance, scalable Information Retrieval (IR) library. The library is in Java but I’m using the book to understand the Lucene .Net port.

Why buy a Java book to learn a .net Library? I couldn’t find a book specifically for the .Net version. Also, I wanted a 1000 foot level view of search technologies and because this is my first time working with IR. I was pleased to find the .net version is akin to the Java version presented in the book.

In some ways, learning from a different language has been beneficial. I invested more time converting the presented samples to C#. I’ve also read Mathematics and Physics for Programmers which was completely written in a pseudo language. Again, lots of fun to convert the presented samples to a language I was more comfortable with.

It was also nice to find that the open source project Subtext is using Lucene .Net. They’ve worked out some locking issue recently and seem to be getting things setup in a nice way. Also, my co workers Kevin and Tim put together a nice library for Lucene .Net called ActiveLucene.Net – Attributed Lucene.Net. The largest project seems to be Linq to Lucene but I haven’t looked at it yet. It was helpful to see how others are integrating Lucene into the Microsoft Web Platform.

Anyway, here are the indexer and searcher in my C# interpretation. These are the first snippets presented in the book. These are a great way to get a jump start into understanding the basics.

Indexer

   
readonly static SimpleFSLockFactory _LockFactory = new SimpleFSLockFactory();

static void Main(string[] args)
{

    var dataPath = ConfigurationManager.AppSettings["DataDirectory"];

    var indexPath = ConfigurationManager.AppSettings["IndexDirectory"];

    if (!System.IO.Directory.Exists(dataPath))
    {
        throw new IOException(dataPath + " directory does not exist");
    }

    DirectoryInfo indexInfo = new DirectoryInfo(indexPath);

    DirectoryInfo dataInfo = new DirectoryInfo(dataPath);

    Lucene.Net.Store.Directory indexDir = Lucene.Net.Store.FSDirectory.Open(
                                                     indexInfo, _LockFactory);

    var start = DateTime.Now.TimeOfDay;
    var numIndexed = Index(indexDir, dataInfo);
    var end = DateTime.Now.TimeOfDay;

    var delta = end.TotalMilliseconds - start.TotalMilliseconds;

    Console.WriteLine(
       "Indexing " + numIndexed + " files took " + delta.ToString() + " milliseconds
                      );
}

public static int Index(Lucene.Net.Store.Directory indexDir, DirectoryInfo dataInfo)
{
    var writer = new IndexWriter(indexDir, new StandardAnalyzer(
                                      Lucene.Net.Util.Version.LUCENE_29), 
                                      IndexWriter.MaxFieldLength.UNLIMITED);
    writer.SetMergePolicy(new LogDocMergePolicy(writer));
    writer.SetMergeFactor(5);

    try
    {
        var paths = dataInfo.EnumerateFiles("*.txt");

        foreach (var path in paths)
        {
            IndexFile(writer, path);
        }
    }
    catch (Exception ex)
    {
        writer.Close();
        throw ex;
    }

    var numIndexed = writer.MaxDoc();
    writer.Optimize();
    writer.Close();

    return numIndexed;
}

private static void IndexFile(IndexWriter writer, FileInfo file)
{
    if (!file.Exists)
    {
        return;
    }

    Console.WriteLine("Indexing " + file.Name);

    Document doc = new Document();

    var path = file.FullName;

    System.IO.TextReader readFile = new StreamReader(path);

    doc.Add(new Field("contents", readFile));

    doc.Add(new Field("filename", file.Name,
        Field.Store.YES,
        Field.Index.ANALYZED,
        Field.TermVector.YES));

    writer.AddDocument(doc);
}

Searcher

   
public static SimpleFSLockFactory _LockFactory = new SimpleFSLockFactory();

static void Main(string[] args)
{
    if (args.Length < 2)
    {
        Console.WriteLine("Searcher takes two parameters");
        Console.WriteLine("Usage: ConsoleSearcher <index dir> <query>");
    }

    var indexInfo = new DirectoryInfo(args[0]);
    var query = args[1];

    if (!System.IO.Directory.Exists(args[0]))
    {
        throw new IOException(args[0] + " directory does not exist");
    }

    SearchOption(indexInfo, query);
}

private static void SearchOption(DirectoryInfo indexInfo, string query)
{
    Lucene.Net.Store.Directory indexDir = Lucene.Net.Store.FSDirectory.Open(
                                                     indexInfo, _LockFactory);

    IndexSearcher indexSearcher = new IndexSearcher(indexDir, true);

    QueryParser parser = BuildQueryParser();
    var luceneQuery = parser.Parse(query);

    var start = DateTime.Now.TimeOfDay;

    var hits = indexSearcher.Search(luceneQuery);
    var end = DateTime.Now.TimeOfDay;

    var delta = end.TotalMilliseconds - start.TotalMilliseconds;

    Console.WriteLine("Found " + hits.Length() + 
        " document (s) (in " + delta.ToString() + 
        " milliseconds) that matched query '" + query + "':");

    for (int i = 0; i < hits.Length(); i++)
    {
        Document doc = hits.Doc(i);

        Console.WriteLine(doc.Get("filename"));
    }
}

private static QueryParser BuildQueryParser()
{
var parser = new QueryParser(
    Lucene.Net.Util.Version.LUCENE_29, "contents", 
     new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29));

    parser.SetDefaultOperator(QueryParser.Operator.AND);
    return parser;
}