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.

In addition, I added Inversion of Control (IOC) using Castle Windsor and implemented a repository pattern.

My database generation script and test data now look like this.

databasefactory.Create();
var repository = new HolidayRepository(databasefactory);

//... build up test data for xmas and newyear

repository.Add(xmas);
repository.Add(newYear);

//commit changes
var unitOfWork = new UnitOfWork(databasefactory);
unitOfWork.Commit();

The other interesting part of this sample project is using WCF and EF together and WCF dependency injection using Castle Windsor.

First I setup my interfaces and configuration files for EF and WCF.

[DataContract]
public class Holiday : IEntity
{
    public long Id { get; set; }

    [DataMember]
    public string HolidayName { get; set; }

    [DataMember]
    public DateTime HolidayDate { get; set; }

    [DataMember]
    public ICollection<holidayevent> HolidayEvents {get; set;}
}

[DataContract]
public class HolidayEvent : IEntity
{
    public long Id { get; set; }

    [DataMember]
    public string EventName { get; set; }

    [DataMember]
    public Holiday Holiday { get; set; }

    [DataMember]
    public long HolidayId { get; set; }
}

public HolidayConfiguration()
{
    Property(h => h.Id).IsIdentity();
    Property(h => h.HolidayName).HasMaxLength(1000).IsRequired();

    Relationship(e => e.HolidayEvents).FromProperty(h => h.Holiday);
}

public HolidayEventConfiguration()
{
    Property(e => e.Id).IsIdentity();
    Property(e => e.EventName).HasMaxLength(1000).IsRequired();

    //HolidayId is a FK property and Holiday is a navigation property backed by this FK
    Relationship(e => e.Holiday).FromProperty(h => h.HolidayEvents).HasConstraint((e, h) => e.HolidayId == h.Id);
}

In my .svc file I use a custom factory to do dependency injection

Factory="Castle.Facilities.WcfIntegration.WindsorServiceHostFactory, Castle.Facilities.WcfIntegration"

On startup, I add my HolidayService as a component and add the DatabaseFactory as a parameter. The DatabaseFactory is used to setup my EF Object Context.

container.Register(Component.For<iholidayservice>().ImplementedBy<holidayservices>().DependsOn
    (Property.ForKey("databaseFactory").Eq(databaseFactory)));

A great resource for seeing many of the new features in EF CTP3 is the shrinker project. This is where I found many great examples of property facets and relationships using Entity Framework.

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;
}

My head is spinning from looking at Odata tonight. I keep going back and forth on if this is the coolest thing in the world or just a way to browse data via the URI. Either way it’s fun. Below are my notes and examples showing some limitations and features of Odata.

The first area I had some misunderstandings was when working with collections. Take a look at this question on StackOverflow “use linq to query nested odata collection“. This pretty much sums up the issue I was stuck on for awhile. How do relationships work and how can I query collections. This blog post helped me start to understand how keys and collections work.

Then, I find this post and this collection of resources. Now, I’m back to being sold on oData. The ease of filtering data is amazing. Filters also support functions if needed. Thanks to this tip for pointing that out.

Here is a set of examples for the Odata Netflix feed. I’ve listed the URI with the corresponding C# expression below.

http://odata.netflix.com/Catalog/Titles?$filter=Name eq ‘The Name of The Rose’

(from t in Titles
where t.Name == "The Name of The Rose"
select t)

http://odata.netflix.com/Catalog/Titles?$filter=AverageRating lt 2 and Instant/Available eq true

(from t in Titles
where t.AverageRating < 2 && t.Instant.Available == true
select t)

http://odata.netflix.com/Catalog/Titles?$filter=ReleaseYear le 1989 and ReleaseYear ge 1980 and AverageRating gt 4&$expand=Awards

(from t in Titles.Expand("Awards")
where t.ReleaseYear < 1989 && t.ReleaseYear > 1980 && t.AverageRating > 4
select t)

http://odata.netflix.com/Catalog/Titles?$filter=Type eq ‘Movie’ and Instant/Available eq true and (Rating eq ‘G’ or Rating eq ‘PG-13′)

(from t in Titles
where t.Type == "Movie" && t.Instant.Available == true && (t.Rating == "G" || t.Rating == "PG-13")
select t)

http://odata.netflix.com/Catalog/Titles?$filter=Type eq ‘Movie’ and Instant/Available eq true and (Rating ne ‘R’ and Rating ne ‘NC-17′ and Rating ne ‘UR’ and Rating ne ‘NR’)

(from t in Titles
where t.Type == "Movie" && t.Instant.Available == true && (t.Rating != "R" && t.Rating != "NC-17" && t.Rating != "UR" && t.Rating != "NR")
select t)

http://odata.netflix.com/Catalog/People?$filter=Name eq ‘James Cameron’&$expand=Awards,TitlesDirected

(from p in People.Expand("Awards").Expand("TitlesDirected")
where p.Name == "James Cameron"
select p)

http://odata.netflix.com/Catalog/Languages(‘Japanese’)/Titles?$filter=Type eq ‘Movie’”

(from l in Languages
from t in l.Titles
where l.Name == "Japanese" && t.Type == "Movie"
select t)

http://odata.netflix.com/Catalog/Languages(‘French’)/Titles?$filter=Type eq ‘Movie’ and Rating eq ‘UR’

(from l in Languages
from t in l.Titles
where l.Name == "French" && t.Type == "Movie" && t.Rating == "UR"
select t)

http://odata.netflix.com/Catalog/Genres(‘Horror’)/Titles/$count?$filter=Type eq ‘Movie’

(from g in Genres
from t in g.Titles
where g.Name == "Horror" && t.Type == "Movie"
select t).Count();

http://odata.netflix.com/Catalog/Genres(‘Horror’)/Titles?$filter=ReleaseYear le 1979 and ReleaseYear ge 1970

(from g in Genres
from t in g.Titles
where g.Name == "Horror" && t.ReleaseYear < 1979 && t.ReleaseYear > 1970
select t)

http://odata.netflix.com/Catalog/Titles(‘BVIuO’))

(from t in Titles
where t.Id == "BVIuO"
select t)

http://odata.netflix.com/Catalog/Genres(‘Romantic Comedies’)/Titles?$filter=Type%20eq%20′Movie’ and round(AverageRating) ge 5&$orderby=year(Instant/AvailableFrom)

(from g in Genres
from t in g.Titles
where g.Name == "Romantic Comedies" && t.Type == "Movie" && Math.Round(t.AverageRating.Value) > 5
orderby t.Instant.AvailableFrom
select t)

This weekend I drove to Chicago for Microsoft Web Camps not knowing what to expect. I definitely didn’t think I would win a purse and a cool t-shirt. So how did this happen?

Web Camps is a two day event. The first day is all learning and was presented by James Senior and Jon Galloway who did an excellent job.

The second day was a build day. You get into groups and build an application. Then at the end of the day all the teams got to demo. Thanks to my team members Mark Greenway and Tim McManemy, we got first place!

Our application was called Fact or Crap. Basically you could submit a statement and others could vote if it is true or false. We used MVC2, JQuery templating, and Entity Framework.

Hopefully Microsoft will do this again next year. This was probably the most fun I have had programming in awhile. Everyone learned a ton and made some new friends.

Binding is a fundamental part of Silverlight and allows developers to create a relationship between a UI property and a CLR object. Unfortunately, it can be a little confusing at first. Is it worth the trouble getting use to the syntax?

<object property=”{Binding}” …/>

It’s entirely possible to update the Silverlight presentation layer without using binding. Although with the use of binding you can make your code more reusable and easier to extend. Especially if you have multiple web requests that update the view. I’m not saying binding is a silver bullet. It can be very frustrating to track down issues and getting the syntax correct. But used in the right situations it can be very useful.

I’m not a Silverlight expert and I won’t be able to cover every detail of binding. I’ll start by covering some basic syntax. Then give an example using notification properties and dependencies properties. Then I will finish with a list of links and resources to find more information about MVVM and Silverlight 4.

Basic Binding Syntax

Let’s look at an example using an object named Cat and we will bind to the Speak property.

namespace BindingPatterns.ViewModel
{
    public class Cat
    {
        public string Speak { get; set; }
    }
}

From now on I won’t include this much XAML detail but I wanted to be clear on the first example. Notice the name space of where the Cat class is located is added.

<usercontrol x:Class="BindingPatterns.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:data="clr-namespace:BindingPatterns.ViewModel"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">

    </usercontrol><usercontrol .Resources>
        <data :Cat x:Key="ViewModel" Speak="meow" />
    </usercontrol>

    <grid x:Name="LayoutRoot">
        <textblock x:Name="CatSound" Text="{Binding Path=Speak, Source={StaticResource ViewModel}}"></textblock>
    </grid>

I know this isn’t very useful but it’s only to demonstrate the binding. What happens first in this example is the Cat class is instantiate as a static Resource. Then we set the Speak property to “meow”. Finally we bind the TextBlock to the Speak property of that class. We have to include the Source attribute to tell where the CLR binding is located.

Another way we could do this is using the data context. Once “ViewModel” (which is the Cat class) is added to the DataContext we can reference directly in the TextBlock via the public property “Speak”.

<grid x:Name="LayoutRoot" DataContext="{Binding Source={StaticResource ViewModel}}">
    <textblock x:Name="CatSound" Text="{Binding Path=Speak}"></textblock>
</grid>

To simplify more you can leave off the Path and just use the following.

<textblock x:Name="CatSound" Text="{Binding Speak}"></textblock>

Notice the TextBlock no longer needs a Source extension because it looks in the DataContext by default. A reason to use the DataContext is child controls can also access this. When you add a binding to that control first it will check the current UserControl and if it can’t be found it will check the parents DataContext. For example, let’s move the TextBlock into a separate user control called CatControl. Then we could get the same result as above using this.

<grid x:Name="LayoutRoot" DataContext="{Binding Source={StaticResource ViewModel}}">
        <control :CatControl></control>
</grid>

Instead of using the Static Resource you can set the DataContext in C# as long as the control is initialized by doing the following.

public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();
            DataContext = new Cat { Speak = "meow in C#" };
        }
    }

The binding syntax also supports drilling into properties of properties using dot notation.

<textblock x:Name="CatActivity" Text="{Binding CatActivity.Scratch}"></textblock>

var activity = new CatActivity(){Scratch="scratchy"};
DataContext = new Cat { Speak = "meow in C#", CatActivity = activity };

Binding with Notification and Dependency Properties

An example where binding, notifications, and dependency properties show their power is when you need to make multiple Async web requests which have dependencies.

To use notifications you need to inherit from INotifyPropertyChanged. Then you can setup properties that will notify a binding when they change. For example, to update the quote we could have a notification property setup that would get updated by the request callback.

        private Quote _quote;
        public Quote Quote
        {
            get { return _quote; }
            set
            {
                _quote = value;
                NotifyPropertyChanged("Quote");
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;

        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }

<textblock x:Name="Price" Text="{Binding Quote.Price}"/>
<textblock x:Name="Price" Text="{Binding Quote.PercentChange }"/>

For the Chart State we can setup a dependency property that will change the chart user control as needed. In this case we do some drawing and background changes.

public static readonly DependencyProperty ChartStateProperty = DependencyProperty.Register(
            "ChartState",
            typeof(StateIndicator),
            typeof(LineChartControl),
            new PropertyMetadata(StateIndicator.NoChange, OnChartStateChanged));

        private static void OnChartStateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var lineChart = (LineChartControl)d;
            lineChart.CreateStateBackground((StateIndicator)e.NewValue);
            lineChart.ChangeLineColor((StateIndicator)e.NewValue);
        }

For a simpler example of notification binding we can go back to the cat example. Let’s setup the notification.

  public class Cat : INotifyPropertyChanged
    {
        public string Speak { get; set; }

        private CatActivity _catActivity;
        public CatActivity CatActivity
        {
            get { return _catActivity; }
            set
            {
                _catActivity = value;
                NotifyPropertyChanged("CatActivity");
            }
        }

        private void NotifyPropertyChanged(String info)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(info));
            }
        }

         public event PropertyChangedEventHandler PropertyChanged;

     }

Then let’s make a button and a few fields to bind to the CatActivity property. Don’t take this as good coding practice. This is just a simplistic example to show how the notifications can be triggered.

        public Cat MyCat { get; set; }
        public MainPage()
        {
            InitializeComponent();

            var activity = new CatActivity(){Scratch="scratchy", Run="scramble"};
            MyCat = new Cat { Speak = "meow in C#", CatActivity = activity };
            DataContext = MyCat;
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            var newActivity = new CatActivity() { Scratch = "scratchy again", Run = "scramble again too" };
            MyCat.CatActivity = newActivity;
        }

When you click the button the following bindings will show “scratch again” and “scramble again too”.

<stackpanel>
    <button Click="Button_Click"></button>
    <textblock x:Name="CatSound" Text="{Binding Speak}"></textblock>

    <textblock x:Name="CatActivityScratch" Text="{Binding CatActivity.Scratch}"></textblock>

    <textblock x:Name="CatActivityRun" Text="{Binding CatActivity.Run}"></textblock>
</stackpanel>

SL4 and MVVM Links

• An early approach to MVVM on MSDN (http://msdn.microsoft.com/en-us/magazine/dd458800.aspx)
• Prism MVVM SL and WPF http://compositewpf.codeplex.com/
• SL4 Command Binding MVVM http://www.silverlight.net/community/samples/silverlight-samples/command-binding-in-silverlight-4-35238/

The major differences are the Mouse event names are different and you need to use a dispatcher to avoid cross thread issues. Check the Rx forums for more recent and efficient ways to do this for use in production code.

You will also need to add the System.CoreEx, System.Observable, and System.Reactive .Net references.

[raw]

// Observe MouseMove Events <!--

var mouseMove = from evt in Observable.FromEvent<mouseeventargs>(this, "MouseMove")
select evt.EventArgs.GetPosition(this);

// Observe Mouse LeftButtonUp Event --> // <!--

var mouseUp = from evt in Observable.FromEvent<mousebuttoneventargs>(this, "MouseLeftButtonUp")
select evt.EventArgs.GetPosition(this);

// Observe MouseLeftButtonDown Event --> <!--

var mouseDown = from evt in Observable.FromEvent<mousebuttoneventargs>(this, "MouseLeftButtonDown")
select evt.EventArgs.GetPosition(this);

// Calculate Movement and Display -->

var q = from start in mouseDown
        from delta in mouseMove.StartWith(start).TakeUntil(mouseUp)
            .Let(mm => mm.Zip(mm.Skip(1), (prev, cur) =>
                new { X = cur.X - prev.X, Y = cur.Y - prev.Y }))
        select delta;

q.Subscribe(value => textblock.Dispatcher.BeginInvoke(() =>
{
  Canvas.SetLeft(image,Canvas.GetLeft(image) + value.X);
  Canvas.SetTop(image,Canvas.GetTop(image) + value.Y);
}));

[/raw]

For a better explanation of this code check out John Skeets RX video at NDC 2010.

Photo of cake icing to make some odd point.

After watching this great video Controlling concurrency in Rx on the RX team blog. I was inspired to start trying out the scheduler. Below are my basic code snippets that would be the equivalent of a hello world.

The first code snippet below uses the “Now” and “Later” schedulers that are provided. They follow this pattern respectively. Schedule(Action); Schedule(Action, TimeSpan);.

 static void Main(string[] args)
        {
            var timespan = new TimeSpan(0, 0, 5);

            using (Scheduler.Later.Schedule(DoSomeActionLater, timespan))
            {
                using (Scheduler.Now.Schedule(DoSomeAction))
                {
                    Console.WriteLine("type q to quit");

                    while (Console.ReadLine() != "q")
                    {
                        Thread.Sleep(1000);
                        Console.WriteLine("...");
                    }

                }
            }
        }

        public static void DoSomeActionLater()
        {
            Console.WriteLine("Later");
        }

        public static void DoSomeAction()
        {
            Console.WriteLine("Now");
        }

This will give you some output similar to this.

The next snippet uses fixed point recursive scheduling. It follows this format Schedule(Action,TimeSpan)

        static void Main(string[] args)
        {
            var timespan = new TimeSpan(0, 0, 5);
            var scheduler = Scheduler.Default;

            using (scheduler.Schedule(Self =>
               {
                   Console.WriteLine("recursive");
                   Self(timespan);

               }, timespan))
            {

                Console.WriteLine("type q to quit");
                while (Console.ReadLine() != "q")
                {
                    Thread.Sleep(1000);
                    Console.WriteLine("...");
                }
            }
        }

Here is the result from the recursive scheduler.

In the video on IScheduler, it’s mentioned that a scheduler could be written to abstract away time. On CodePlex you can find a simple implementation of a virtual time scheduler TimeMachineScheduler.

In my initial post I tried out the “Code First” methodology of Entity Framework. Taking the code only experiment a step further, I built a sample WCF service that queries and updates a table for holidays. You can browse and download the project via github.

The console application “HolidayService.GenerateSchema” is very similar to the first post. It’s used to create the initial sqlexpress database and put in some initial test data. I did try out a simple configuration using some best practices from this site.

The WCF service has two methods.


[ServiceContract]
public interface IHolidays
{
[OperationContract]
IList GetHolidayDetails(DateTime startDate, DateTime endDate);

[OperationContract]
int AddHolidayDetails(DateTime date, string name);
}


In the HolidayService I created a HolidayManager class for CRUD operations. It uses a GlobalContext class to build an EF HolidayModel ObjectContext. For example, this is what that GetHolidays method looks like in the manager.


using (holidayContext)
{
var holidayQueryResult = (from h in holidayContext.Holidays
where h.HolidayDate < endDate & h.HolidayDate > startDate select h);

foreach (var item in holidayQueryResult)
{
holidays.Add(item);
}
}


In the GlobalContext class, is where my simple project started to feel some pain. It doesn’t feel right to be using a concrete version of the HolidayModel in the ContextBuilder which returns the ObjectContext. I also don’t like that the sql connection string and connection are all in this class. In another post, I’ll use some of the suggestions below to try to make this area more flexible.


var builder = new ContextBuilder();
builder.Configurations.Add(new HolidayConfiguration());
var connStr = ConfigurationManager.ConnectionStrings["UserDBConn"].ConnectionString;
var connection = new SqlConnection(connStr);
return builder.Create(connection);


Since this is a small project I didn’t go any further to clean up the GlobalContext class. I’ll leave that for next time I look into code only. Below are some links which investigate managing ObjectContext, dynamic models, and using EF in a business architecture.

1. Managing Entity Framework ObjectContext
2. how to create a dynamic model using code only
3. Daniel Wertheim – EfEntityStore
4. Putting Entity framework 4 to use in a business architecture
5. Repository implementation – Entity Framework 4.0: a fresh start