C # унаследованные члены кастинга

Question

Я работаю над базовым классом для контекстных классов базы данных моей сущности.В базовом классе мне нужен доступ к DbContext, а в производном классе мне нужен доступ к производному DbContext.На данный момент у меня есть следующий код:

 public abstract class BaseClass: IDisposable   
{
    protected abstract DbContext BaseContext { get; }

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

public class DerivedClass : BaseClass
{
    DerivedContext context; // public class DerivedContext: DbContext

    protected override DbContext BaseContext 
    {
        get
        {
            return context;
        }           
    }
}

Это правильный подход?

Answer 1

Я бы предложил что-то более похожее на

public abstract class BaseClass<TContext> : IDisposable 
    where TContext : DbContext
{
    //not abstract
    protected TContext Context { get; private set; }
}

public class DerivedClass : BaseClass<DerivedContext>
{
    ....
}

В вашем базовом классе вы можете получить доступ ко всем членам DbContext, а в вашем DerivedClass вы можете получить доступ ко всем членам DerviedContext без необходимости приведения.

Answer 2

В зависимости от того, сколько вам нужно сделать очень особенных вещей в вашем производном классе, вы также можете использовать универсальный подход.От этого вы также можете наследовать.

public class BaseClass<TContext> : IDisposable   
   where TContext : IContext
{

    public TContext Context { get; private set; }

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

    public BaseClass(TContext context)
    {
       this.Context = context;
    }
}

public interface IContext : IDisposable
{

}

public ChildClass : BaseClass<MyContext>
{
   public ChildClass(MyContext context)
     : base(context)
   {
   }
}

Answer 3

По крайней мере, ваша IDisposable реализация должна быть улучшена.Вы должны сделать следующее:

IDisposable пример:

public class BaseClass : IDisposable
{
    private bool _disposed = false;
    protected DbContext Context { get; }

    public void Dispose()
    {
        this.Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        // Check to see if Dispose has already been called.
        if (!this._disposed)
        {
            // If disposing equals true, dispose all managed
            // and unmanaged resources.
            if (disposing)
            {
                // Disposes managed resources here
                if (this.Context != null)
                {
                    this.Context.Dispose();
                }
            }

            // Disposes unmanaged resources here
            // NOTHING HERE

            // Note disposing has been done.
            this._disposed = true;
        }
    }
}

Для самого DBContext это зависит от того, как вы собираетесь его использовать.

Answer 4

вам не нужен объект домена в зависимости от dbcontext.домен не должен знать о dbcontex.чтобы ответить на ваш вопрос: нет, это не «правильно».

то, что у вас может быть, это ряд компонентов, наслоенных вокруг объектов домена, которые используют dbcontext для загрузки / сохранения объектов.

Answer 5

Это зависит от того, как вы собираетесь его использовать.Код, который вы опубликовали, всегда будет использовать производный контекст с экземпляром производного класса, а базовый контекст - с базовым классом.

// This code gets an instance of the DerivedContext.
BaseClass myBase = new DerivedClass();
DbContext myContext = myBase.BaseContext;

Если вы намерены работать таким образом, вы используетеправильный подход.