Sergey Barskiy's Blog

As I am working on my Entity Framework extras project, I found myself needing to determine table name in the database based on class name used with DbSet in my context.  I was unable to find a way to query entity framework for this information, so I resorted to brute force approach, having to query database based on class name or pluralized class name.  I ready this blog post by Scott Hanselman about pluralization.  However, this class has been made internal, and I could not use it directly.  Having enough experience with reflection, I wrote a wrapper class that used internal class via reflection.  This code will break if API changes, but the fix at that point should be trivial.  The code of course is super easy, and looks as following:

    public static class Pluralizer
    {
        private static object _pluralizer;
        private static MethodInfo _pluralizationMethod;
 
        public static string Pluralize(string word)
        {
            CreatePluralizer();
            return (string)_pluralizationMethod.Invoke(_pluralizer, new object[] {word});
        }
 
        public static void CreatePluralizer()
        {
            if (_pluralizer == null)
            {
                Assembly aseembly = typeof(DbContext).Assembly;
                var type =
                    aseembly.GetType(
                        "System.Data.Entity.ModelConfiguration.Design.PluralizationServices.EnglishPluralizationService");
                _pluralizer = Activator.CreateInstance(type, true);
                _pluralizationMethod = _pluralizer.GetType().GetMethod("Pluralize");
            }
        }
    }

As you can see, I am loading assembly class by picking a random class from Entity Framework assembly, DbContext in my case.  Then I am getting a type corresponding to English pluralization service.  Once that is done, I am getting a handle of Pluralize method based on name.

Pretty easy, hah?  Here is how I am testing (using) my new class:

        [TestMethod]
        public void PluralizationTest()
        {
            Assert.AreEqual("people", Pluralizer.Pluralize("person"));
            Assert.AreEqual("people", Pluralizer.Pluralize("people"));
        }

Ah, the magic of reflection!

Something I was pondering about today.  Say, I have a class and I would like to subscribe to an event it raises, handle it once, and unsubscribe.  Pretty easy scenario, and the code is just as simple.

Here is my simple class with event arguments:

using System;

namespace EventsDemo

{

  public class EventProvider

  {

    public string RandomData { get; set; }

    public void RaiseEvent()

    {

      OnRandomEvent(RandomData);

    }

    public event EventHandler<RandomEventArgs> RandomEvent;

    protected void OnRandomEvent(string data)

    {

      if (RandomEvent != null)

      {

        RandomEvent(this, new RandomEventArgs(data));

      }

    }

  }

}

using System;

namespace EventsDemo

{

  public class RandomEventArgs : EventArgs

  {

    private RandomEventArgs() { }

    public RandomEventArgs(string data)

    {

      Data = data;

    }

    public string Data { get; private set; }

  }

}

Of course, my console sample application is just as easy:

using System;

namespace EventsDemo

{

  class Program

  {

    static void Main(string[] args)

    {

      string extraData = "extra data";

      EventProvider provider = new EventProvider() { RandomData = "something" };

      provider.RandomEvent += new EventHandler<RandomEventArgs>(provider_RandomEvent);

      provider.RaiseEvent();

      Console.ReadKey();

    }

    static void provider_RandomEvent(object sender, RandomEventArgs e)

    {

      Console.WriteLine(e.Data);

      EventProvider provider = sender as EventProvider;

      provider.RandomEvent -= new EventHandler<RandomEventArgs>(provider_RandomEvent);

    }

  }

}

However, I am accustomed to just handle events as lambda expressions as I find that syntax much cleaner and easier to follow:

using System;

namespace EventsDemo

{

  class Program

  {

    static void Main(string[] args)

    {

      string extraData = "extra data";

      EventProvider provider = new EventProvider() { RandomData = "something" };

      provider.RandomEvent += (o, e) => { Console.WriteLine(e.Data); };

      provider.RaiseEvent();

      Console.ReadKey();

    }

  }

}

Now is the question.  How do I unsubscribe from the event in my lambda expression?  I cannot do what I did before, since I do not have a handler to use for –= call.  So, I have to declare my handler separately.  Here is modified code:

using System;

namespace EventsDemo

{

  class Program

  {

    static void Main(string[] args)

    {

      string extraData = "extra data";

      EventProvider provider = new EventProvider() { RandomData = "something" };

      EventHandler<RandomEventArgs> handler = null;

      handler = (o, e) => { Console.WriteLine(e.Data); provider.RandomEvent -= handler; };

      provider.RandomEvent += handler;

      provider.RaiseEvent();

      provider.RaiseEvent();

      Console.ReadKey();

    }

  }

}

I am calling RaiseEvent twice to ensure I did indeed unsubscribe.  Now what is the advantage to this approach you say?  Closures is my number one reason along with clean code as close second.  Here is the final version:

using System;

namespace EventsDemo

{

  class Program

  {

    static void Main(string[] args)

    {

      string extraData = "extra data";

      EventProvider provider = new EventProvider() { RandomData = "something" };

      EventHandler<RandomEventArgs> handler = null;

      handler = (o, e) => { Console.WriteLine(e.Data + "-" + extraData); provider.RandomEvent -= handler; };

      provider.RandomEvent += handler;

      provider.RaiseEvent();

      provider.RaiseEvent();

      Console.ReadKey();

    }

  }

}

As you can see, I use closure and take advantage of the scope in which my extraData variable is declared, thus combining data in the event with that variable.  I could not do this in my first example without making extraData variable public.  In this quick post I demonstrated how to unsubscribe from events where handlers are implemented as lambda expression as well as outlined the reasons why one might want to use this approach.  Why would you want to unsubscribe?  Typically, your handlers would be cleaned up, but what if your code throws an exception inside lambda expression?  In this case next time you raise the event, it will be handled twice.  Also, I am a big fan of cleaning up event handlers as they are a major source of potential memory leaks.

Thanks.

This is really short post, more a tip.

If you need to determine if your application is running in IIS or Developer Web Server (Cassini) that comes with Visual Studio, you can test the process name you are running in.  For example, the following code:

System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName

will return the name of the running process.  In case of developer web server in Visual Studio 2010 it returns

"C:\\Program Files\\Common Files\\Microsoft Shared\\DevServer\\10.0\\WebDev.WebServer40.exe"

So, if you for example want to scan Bin folder, code that you run in IIS will not work running in Cassini.  This simple one line of code will let you know what you are running.

Today I was faced with an issue.  I had an interface based implementation of a specific functionality.  All classes that implemented this interface had different implementation of course.  What I had to add is ability to run certain checks on each implementation that would need to analyze the data defined in the interface and return a Boolean result of this check.

The problem was that the checks were all the same and I hated to add this check to the interface and write identical code in all implementations.  As everyone knows interfaces cannot contain implementation code though.  So, what should I do?

So, a particular .NET 3.5 feature came to my rescue.  I am referring to extension methods.  As you may or may not know extension methods are tied to a type.  Well, interface is a type too.  Here is some code to look at.

Here is the interface definition:

Here is my class definition that implements this interface

Finally, here is my extension method

    public static class ISupportCustomActionExtensions

    {

        public static bool Check(this ISupportCustomAction action)

        {

            if (action.CustomAction == null)

            {

                return false;

            }

            else

            {

                return true;

            }

        }

    }

Here is my test code to confirm that everything works

How useful this is?  Pretty useful in my case.  Saved me some typing and resulted in consistent coding.  My point is that is good to know what features .NET has and use them as a need arises.  As you can see I have a hybrid here of a base (abstract) class and an interface.  As a result, I am able to use features that belong to both concepts.

What does this code remind you of?  Can you say “Multiple Inheritance in C#?”  Well, not exactly, but pretty close.

Thanks.