Extienda una clase de entidad LINQ con métodos de construcción y haga que esa clase de entidad herede de su clase DataContext

Question

¿Es posible extender las clases de entidad LINQ-to-SQL con métodos-constructor y al mismo tiempo? ¿Hacer que esa clase de entidad se herede de su clase de contexto de datos? En esencia, convertir la clase de entidad en un objeto de negocio.

Este es el patrón que estoy usando actualmente:

namespace Xxx
{
    public class User : Xxx.DataContext
    {
        public enum SiteAccessRights
        {
            NotRegistered = 0,
            Registered = 1,
            Administrator = 3
        }

        private Xxx.Entities.User _user;

        public Int32 ID
        {
            get
            {
                return this._user.UsersID;
            }
        }

        public Xxx.User.SiteAccessRights AccessRights
        {
            get
            {
                return (Xxx.User.SiteAccessRights)this._user.UsersAccessRights;
            }

            set
            {
                this._user.UsersAccessRights = (Int32)value;
            }
        }

        public String Alias
        {
            get
            {
                return this._user.UsersAlias;
            }

            set
            {
                this._user.UsersAlias = value;
            }
        }


        public User(Int32 userID)
        {
            var user = (from u in base.Users
                        where u.UsersID == userID
                        select u).FirstOrDefault();

            if (user != null)
            {
                this._user = user;
            }
            else
            {
                this._user = new Xxx.Entities.User();

                base.Users.InsertOnSubmit(this._user);
            }
        }


        public User(Xxx.User.SiteAccessRights accessRights, String alias)
        {
            var user = (from u in base.Users
                        where u.UsersAccessRights == (Int32)accessRights && u.UsersAlias == alias
                        select u).FirstOrDefault();

            if (user != null)
            {
                this._user = user;
            }
            else
            {
                this._user = new Xxx.Entities.User
                {
                    UsersAccessRights = (Int32)accessRights,
                    UsersAlias = alias
                };

                base.Users.InsertOnSubmit(this._user);
            }
        }


        public void DeleteOnSubmit()
        {
            base.Users.DeleteOnSubmit(this._user);
        }
    }
}

Actualización :

Observe que tengo dos métodos de constructor en mi clase User . Me gustaría transferirlos a la clase de entidad Usuario y extender la clase de entidad Usuario en su clase de contexto de datos, para que el contexto de datos está disponible para la clase de entidad en " new-up " ;.

Espero que esto tenga sentido.

Answer 1

No parece tener sentido hacer de una entidad un tipo de DataContext. No es necesario que sea un DataContext para ser considerado un objeto de negocio, ni necesariamente tiene que crear un tipo que contenga la entidad original. Podría ser mejor simplemente extender la clase de entidad y contener una referencia a un DataContext usando la composición:

namespace Xxx.Entities
{
  public partial class User : IDisposable
   { DataContext ctx;

     public static GetUserByID(int userID)
      {  var ctx  = new DataContext();
         var user = ctx.Users.FirstOrDefault(u=>u.UsersID == userID);

         if (user == null)
          {
             user = new User();
             ctx.Users.InsertOnSubmit(user);
          }

         user.ctx = ctx;
         return user;          
      }      

     public void Dispose() { if (ctx != null) ctx.Dispose(); }
   }
}

Si solo desea que los nombres de las propiedades sean diferentes a los nombres de las columnas de la base de datos, hágalo en el archivo de asignación.

Answer 2

Rick Strahl tiene una serie de artículos realmente buenos que tratan sobre lo que creo que estás buscando. Echa un vistazo a su lista de Linq Articles Here

Answer 3

Heredar una entidad de un contexto de datos es una mala idea. Son dos objetos discretos y están diseñados para funcionar de esa manera. Hacer esto causará todo tipo de problemas, al menos, todos los problemas al tratar de enviar varios cambios relacionados al mismo tiempo; el hecho de atravesar múltiples contextos de datos hará que esto falle ya que cada uno intenta trabajar de forma independiente.