CODEWITHSUNDEEP
c#asp.netoopsoa
loyalflow
loyalflow

Reputation: 14899

Is anything wrong with using static readonly references for a service class?

I have inherited this piece of code, and the original author for some reason really liked static readonly references.

I have outlined the general pattern below, what ramifications does having these static readonly references have? 

public class DbAccess
{
    private static readonly ISomethingFactory = SomethingFactories.GetFactory("1");
    private static IThing1Dao Thing1Dao { get {return ISomethingFactory.Thing1Dao; }}
    private static IThing2Dao Thing2Dao { get {return ISomethingFactory.Thing2Dao; }}
}

public class SomethingFactories
{
   public static ISomethingFactory GetFactory(string key) 
   {
      switch(key)
      {
         case "...":
         return new SomeFactory();
      }
   }
}    

public class SomeFactory : ISomeFactory
{    
    public IThing1Dao Thing1Dao
    {
       get { return new Thing1Dao(); }
    }
}    

public class SomeService : ISomeService
{
    private static readonly IThing1Dao thing1Dao = DbAccess.Thing1Dao
    private static readonly IThing2Dao thing2Dao = DbAccess.Thing2Dao

    public Thing1Object1 GetObject1(int id)
    {
        return thing1Dao.GetObject1(id);    
    }

    public Thing1Object2 GetObject2(int id)
    {
        return thing1Dao.GetObject2(id);
    }
}

The usage in the .aspx pages is like:

public class MyBasePage : System.Web.UI.Page
{
    protected static readonly SomeService someService = new SomeService();     
}    

public class SomeAspxPage : MyBasePage
{
   void btnAddObject1(...)
   {
      Thing1Object1 obj1 = someService.GetObject(1);
   }
}

Upvotes: 3

Views: 164

Answers (2)

Guffa
Guffa

Reputation: 700432

Web applications are multi-threaded, so static members are of limited use.

If you have a static reference to an object, the object has to be thread safe, or you have to synchronise the use of it so that only a single thread can use it at any time.

Making the static reference read-only means that the reference itself is thread safe, as it can't be changed once it's set, but that doesn't automatically make the object that it's referencing thread safe.

Upvotes: 3

Eric J.
Eric J.

Reputation: 150118

static means that only one instance of ISomethingFactory exists, and that instance can be accessed through the type (not one instance per instance of DbAccess).

readonly means that, after initialization, the value cannot be overwritten.

This is a fairly normal pattern for performing initialization based on startup-time data (e.g. data from app.config).

Upvotes: 3

Related Questions