The core of the issue is that ClientBase<T> implements IDisposable. With this knowledge, just about any programmer would naturally wrap its usage in a using{} block. Digging deeper, you'll find that the ClientBase<T> Dispose() method simply calls Close() on the underlying connection. This is problematic because in certain connection states (such as "Faulted"), the Close() will fail. As I said, this is well documented elsewhere, for example: on MSDN, Stack Overflow, and here.

There are a few different solutions to this issue. I went with a simple Disposable wrapper...

// Get a disposable MyClientWrapper object
using(var clientWrapper = ClientFactory.GetMyClientWrapper())
{
    clientWrapper.Client.DoSomething();
}
 
public class MyClientWrapper : IDisposable
{
    private readonly MyClient _client;
 
    public MyClientWrapper(Binding binding, Uri endpoint)
    {
        // creates an instance of MyClient, which is derived from ClientBase<T>
        _client = new MyClient(binding, new EndpointAddress(endpoint.ToString()));
    }
 
    public MyClient Client
    {
        get { return _client; }
    }
 
    public void Dispose()
    {
        // safe dispose with extension method (below)
        _client.CloseProxy();
    }
}
 
// extension method for safe Close() on ClientBase<T>
public static void CloseProxy(this ClientBase<T> proxy) where T : class
{
    try
    {
        if (proxy.State != CommunicationState.Closed 
                && proxy.State != CommunicationState.Faulted)
        {
            proxy.Close(); // may throw exception while closing
        }
        else
        {
            proxy.Abort();
        }
    }
    catch (CommunicationException)
    {
        proxy.Abort();
        throw;
    }
}

The first thing I was doing...
> ps aux | grep Foo
find the process ID (PID) with my eyes, and then kill it...
> kill -9 123456

Next, I started finding complex piped commands to find and extract the PID. For instance...
> pid=`ps -eo pid,args | grep Foo | grep -v grep | cut -c1-6`

and slightly simpler...
> ps aux | grep Foo | grep -v grep | awk '{print $2}'

Finally, I discovered pgrep and pkill. There are quite a few options for each command, but simply put:

To get the PID for a process with a name containing 'Foo'...
> pgrep Foo

To get the PID for a process with a command line containing 'Bar' (as in > Foo -n Bar)...
> pgrep -f Bar

Bren has canning fever. It all started with a canning book that she received as a Christmas present. Now, she has canned (or jarred as I like to call it) Salsa, Pasta Sauce, Blueberry Jam, and Sweet Pickles. The nice thing is that we'll be well stocked with food that we know is locally grown and chemical free.

This summer is getting off to a slow start, as are our vegetables. We planted tomatoes, cucumbers, zucchini, various peppers, and carrots. So far we haven't picked a thing. We've barely reached the 80s in temperature, and we've had more rain than usual. However, despite the lack of veggies, I'm personally enjoying the cool summer.

Let's say we have a repository that gets documents from a database.  The assumption is that a repository interface, IDocumentRepository, is being implemented.

In my case, I found it easier to deserialize results from file, rather than building the results by hand for each mocked response.  I used System.Xml.Serialization to serialize real responses to file.

Let's Moq it...

var mockRepository = new Mock<IDocumentRepository>();
 
// if the query is for text/plain documents only, mock a response for that
mockRepository.Setup(p => p.FindDocuments(
	It.Is<DocumentQueryParams>(q => q.MimeType == "text/plain")))
	.Returns(DeSerializeResults<List<Document>>("TextDocuments.xml"));
 
// use It.IsAny to return the same result regardless of the parameters
mockRepository.Setup(p => p.FindDocuments(
	It.IsAny<DocumentQueryParams>()))
	.Returns(DeSerializeResults<List<Document>>("AllDocuments.xml"));

The Record by FEAR

This is old school punk from the early 80s, when punk rock was a means of expression and rebellion.  This particular album is humorous and offensive, as punk should be.

Gothic Kabbalah by Therion

This isn't my favorite Therion album, but I've been listening to it a lot lately because of some catchy songs.  I find it good to write code to because it takes you to another world.

Soviet Kitsch by Regina Spektor

This is something that's generally outside of my musical tastes, but I like her quirky voice and odd lyrics.  She reminds me of a disturbed version of Tori Amos.

The Other Side of Time by Mary Fahl

I once claimed that Tarja has the greatest female voice, but I actually meant Mary Fahl.  This album is completely not my style of music (folk/new age/soft rock), but her voice is irresistible and addictive.

Implement a custom XmlUrlResolver to find schema references as embedded resources.

public class ManifestResourceResolver : XmlUrlResolver
{
    private readonly Assembly _resourceAssembly;
    private readonly string _baseNamespaceForReferences;
 
    public ManifestResourceResolver(Assembly resourceAssembly, string baseNamespaceForReferences)
    {
        _resourceAssembly = resourceAssembly;
        _baseNamespaceForReferences = baseNamespaceForReferences.EndsWith(".") ? baseNamespaceForReferences : baseNamespaceForReferences + ".";
    }
 
    override public object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn)
    {
        if (absoluteUri.IsFile)
        {
            var file = Path.GetFileName(absoluteUri.AbsolutePath);
            var stream = _resourceAssembly.GetManifestResourceStream(_baseNamespaceForReferences + file);
            return stream;
        }
        return null;
    }
}

Create a XmlSchemaSet, and set the XmlResolver property to the custom resolver implemented above. Then, load up the main XSD schema.

var xmlSchemaSet = new XmlSchemaSet();
xmlSchemaSet.XmlResolver = new ManifestResourceResolver(Assembly.GetExecutingAssembly(), "MyApp.Schemas");
using (var stream = Assembly.GetCallingAssembly().GetManifestResourceStream("MyApp.Schemas.MainSchema.xsd"))
{
    var xmlSchema = XmlSchema.Read(stream, null);
    xmlSchemaSet.Add(xmlSchema);
}

Create a XmlReaderSettings object and set the Schemas property to the schema set loaded above. Lastly, load up an XML file with an XmlReader and read it.

XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas = xmlSchemaSet;
settings.ValidationEventHandler += new ValidationEventHandler (ValidationCallBack);
 
XmlReader reader = XmlReader.Create("SomeXml.xml", settings);
while (reader.Read());

The validation callback function will be invoked on each validation error while reading the file with the XmlReader.

private static void ValidationCallBack(object sender, ValidationEventArgs e)
{
    Console.WriteLine("Validation Error: {0}", e.Message);
}

References:

• Validation Using the XmlSchemaSet
• Loading XmlSchema files out of Assembly Resources
  (contains some obsoleted code, but it was still helpful)

First, we'll want to create an interface for our database session.  The implementation of this interface can be swapped out depending on the backing store.

1
2
3
4

public interface ISession : IDisposable
{
    System.Linq.IQueryable<T> All<T>() where T : class, new();
}

Add a MongoDB implementation of ISession.  This implementation will eventually be used in our repository.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class MongoSession : ISession
{
    private readonly IMongo _provider;
 
    public MongoSession()
    {
        //this looks for a connection string in your Web.config
        //<connectionStrings>
        //  <add name="db" connectionString="mongodb://localhost/testdb?strict=true"/>
        //</connectionStrings>
        _provider = Mongo.Create("db");
    }
 
    public IQueryable<T> All<T>() where T : class, new()
    {
        return _provider.GetCollection<T>().AsQueryable();
    }
 
    public void Dispose()
    {
        _provider.Dispose();
    }
}

Create an interface for the repository.  This is what the controller will expect to be injected via it's constructor.

1
2
3
4

public interface IRecipeRepository
{
    IEnumerable<RecipeCard> GetAll(int page = 1, int pageSize = 10);
}

Add the IRecipeRepository implementation, which is created with a new()-able type of ISession.  Why didn't I just inject an ISession into the repository?  It's because Mongo sessions are expected to be disposed of after use, as connections are pooled and reused.  Therefore we have to create and dispose of our sessions when using them.  This might require some workarounds if you really did switch repositories (do nothing on Dispose(), etc).

1
2
3
4
5
6
7
8
9
10

public class RecipeRepository<SessionT> : IRecipeRepository where SessionT : ISession, new()
{
    public IEnumerable<RecipeCard> GetAll(int page = 1, int pageSize = 10)
    {
        using (var session = new SessionT())
        {
            return session.All<RecipeCard>().OrderByDescending(r => r.UpdatedDate).Skip(pageSize * (page - 1)).Take(pageSize).ToList();
        }
    }
}

Now it's time set up our IoC container.  We'll do this in the Global.asax.cs.  Here we are registering a recipe repository of type MongoSession such that any controller that expects an IRecipeRepository in the constructor will get this.  We're letting Autofac handle controller creation and dependency injection.  See the Autofac MVC3 integration page for more details.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

protected void Application_Start()
{
    var builder = new ContainerBuilder();
    builder.Register(r => new RecipeRepository<MongoSession>()).As<IRecipeRepository>().InstancePerLifetimeScope();
    builder.RegisterControllers(Assembly.GetExecutingAssembly());
 
    var container = builder.Build();
    DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
 
    AreaRegistration.RegisterAllAreas();
 
    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);
}

Finally, here is our controller.  Notice we never have to create a repository object - one was injected for us.

1
2
3
4
5
6
7
8
9
10
11

private readonly IRecipeRepository recipeRepository;
 
public RecipesController(IRecipeRepository recipeRepository)
{
    this.recipeRepository = recipeRepository;
}
 
public ViewResult Index()
{
    return View(recipeRepository.GetAll());
}

That's it.

I decided this was a good time to give MVC3 and MongoDB a test drive.  After diving in, I realized that I could benefit from some dependency injection via MVC3's DependencyResolver.  I've been wanting to learn Autofac, so I threw that in as the container.  This was sweet, as it injected my repository implementations into my controllers with very little setup.

At this point, I've learned all about the Razor view engine, DI with Autofac and DependencyResolver, MongoDB with the NoRM driver, jQuery, jQuery-ui, and some other MVC3 goodness.

For various reasons, including the fact that my web hosting provider is a Linux/non-ASP.NET provider, I ported the whole thing to Rails/MySql.  I'm glad I went through the MVC3 process, because I learned a lot, but in the end, Rails is just simpler.  As for MongoDB, and NoSQL in general, I think it's best served as an edge case storage medium for fast read operations.  Data is relational.

Alas, here is a screenshot of the recipe database.  I'll be adding lots of features, including menus and weight management.  You can't see it here, but it has a cool tag cloud feature and theme switching.

My Winter Storm by Tarja

Tarja used to sing with Nightwish, but has recently gone solo.  She has one of the greatest female voices that I've ever heard.

Beautiful Death by Bella Morte

This is still one of the best albums I've heard in the past 10 years or so.

Danger Days: The True Lives of the Fabulous Killjoys by My Chemical Romace

I was pleasantly surprised by this new album from MCR.  I didn't think it would be possible to live up to The Black Parade, but they did.

Kein Schwein Ruft Mich An by Palast Orchester mit Max Raabe

This is some great 20s/30s era German music.  It's very upbeat and probably humorous (I don't understand German).

King for a Day, Fool for a Lifetime by Faith No More

This is one of the most underrated, overlooked albums of the 90s.  This is Faith No More at their best, in my opinion.

The Order of the Reptile by Ego Likeness

I saw Ego Likeness when they opened up for The Cruxshadows.  It's some good, hard-hitting electronic/industrial/dance music.

Summer came and went.  It was a mild summer, but I'm happy to feel cooler weather.

Spring was here for a few days, but the cool, wet weather is returning this week. We planted some veggies in the few spots where we get sunlight. Hopefully we'll get something out of them.

1. Beautiful Death by Bella Morte
2. Years of Refusal by Morrissey
3. Walking with Strangers by The Birthday Massacre
4. My Winter Storm by Tarja
5. Oceanborn by Nightwish
6. Banned in D.C. by Bad Brains