Question

I have a series of objects that I have mapped into a database with LINQ to SQL. The tables are highly normalized. I’m going to abstract my problem. I have five central entities that I have implemented in the database. I then have a series of other objects which I want to implement one or all of these five entities.

Suppose I am implementing a sort of stadium class (think sports teams). These five entities are the five major sports; Baseball, Basketball, Football, Hockey, Soccer. I want to explicitly implement a class for each stadium.

This is an example, Yankee Stadium has hosted Baseball, Hockey and Football games. I want it to implement each of those 3 interfaces. The StadiumBaseClass is my abstract base class that interfaces with my database. The StadiumBaseClass implements all 5 major sports interfaces. I don’t want to have the same code for implementing the IBaseball interface in all possible stadiums, I want it to be implemented once in StadiumBaseClass.

I this example, I only want to implement 3, is this the best way of doing this? Its sort of singletonish, but not quite?

class YankeeStadium : IBaseball, IHockey, IFootball
{
    StadiumBaseClass _Stadium {get; set;}

   // IBaseball
   public IBaseball.Whatever {get { return _Stadium.Baseball;} }

   // IFootball
   public IFootball.Whatever {get { return _Stadium.Hockey;} }

  // IHockey
   public IHockey.Whatever {get { return _Stadium.Hockey;} }
}  

Answer 1

Here’s an alternative approach (we have used something similar, but not sure how well it will correspond with your linq implementation):

Have StadiumBaseClass implement each of the interfaces with base functionality, then expose virtual properties that the implementing classes can use to a) indicate which interfaces it supports and b) alter the default behavior as needed.

For example, assuming the following interfaces:

    public interface IBaseball
    {
        void Whatever();
    }
    public interface IHockey
    {
        void Whatever();
    }
    public interface IFootball
    {
        void Whatever();
    }
    public interface IBasketball
    {
        void Whatever();
    }
    public interface ISoccer
    {
        void Whatever();
    }

Your base class would look something like:

    public class StadiumBaseClass : IBaseball, IBasketball, IHockey, IFootball, ISoccer
    {

        #region IBaseball Members

        public virtual bool IBaseballImplemented
        {
            get
            {
                return false;
            }
        }

        void IBaseball.Whatever()
        {
            // Do something
        }

        #endregion

        #region IBasketball Members

        public virtual bool IBasketballImplemented
        {
            get
            {
                return false;
            }
        }

        void IBasketball.Whatever()
        {
            // Do something
        }

        #endregion

        #region IHockey Members

        public virtual bool IHockeyImplemented
        {
            get
            {
                return false;
            }
        }

        void IHockey.Whatever()
        {
            // Do something
        }

        #endregion

        #region IFootball Members

        public virtual bool IFootballImplemented
        {
            get
            {
                return false;
            }
        }

        void IFootball.Whatever()
        {
            // Do something
        }

        #endregion

        #region ISoccer Members

        public virtual bool ISoccerImplemented
        {
            get
            {
                return false;
            }
        }

        void ISoccer.Whatever()
        {
            // Do something
        }

        #endregion
    }

Which would leave your individual stadium class as:

    class YankeeStadium : StadiumBaseClass
    {
        public override bool  IBaseballImplemented
        {
            get 
            { 
                return true;
            }
        }
        public override bool IHockeyImplemented
        {
            get
            {
                return true;
            }
        }
        public override bool IFootballImplemented
        {
            get
            {
                return true;
            }
        }
    }