Правильное использование переменной уровня экземпляра

Question

У меня есть объект с несколькими методами, которые обращаются к объекту EntityFramework, используя его для обновления полей объекта перед его обновлением (которое сохраняется в базе данных) Поскольку несколько методов использовали объект EF , Я сделал сущность переменной уровня экземпляра, чтобы все могли ее использовать.

Проблема в том, что перед использованием переменной Entity она должна быть создана. В настоящее время это обрабатывается отлично, так как существует один открытый метод для объекта, который создает объект в начале.

Im пытается выяснить, правильно ли это использование переменной уровня экземпляра, или если есть лучший способ сделать что-то. Проблема с этим текущим способом делать вещи - это если следующий человек, чтобы работать над этим проектом, вызывает вызовы переменной до ее создания.

public class TestClass{ 

private EntityObject entObject; 

public void DoSomething{ 

    InitObject(); 
    DoSomethingElse(); 

} 

private void InitObject(){ 

//initialise the entity object here 

} 

private void DoSomethingElse(){ 

    //do things here, which use the entObject 
    } 
} 

Answer 1

Обычная картина старой школы для такого рода сценария является создание EnsureXXX() метод, а затем вызвать его из любого места, где требуется инициализация. Например:

class A 
{ 
    private B _b; 

    private void EnsureB() 
    { 
     if (_b == null) 
     { 
      _b = new B(); // or whatever; 
     } 
    } 

    public void Method1() 
    { 
     EnsureB(); 
     // Do stuff with _b 
    } 

    public void Method2() 
    { 
     EnsureB(); 
     // Do stuff with _b 
    } 

    public void Method3() 
    { 
     EnsureB(); 
     // Do stuff with _b 
    } 
} 

Свежий подход, воспользовавшись «довольно нового» Lazy<T> класса будет выглядеть следующим образом:

class A 
{ 
    private readonly Lazy<B> _b = new Lazy<B>(() => new B()); 

    public void Method1() 
    { 
     B b = _b.Value; 
     // Do stuff with b 
    } 

    public void Method2() 
    { 
     B b = _b.Value; 
     // Do stuff with b 
    } 

    public void Method3() 
    { 
     B b = _b.Value; 
     // Do stuff with b 
    } 
} 

В версии Lazy<T>, то Value свойства завершаться делает обязанность EnsureXXX() способ.

Середина дорожной версии выполняет ленивую инициализацию явно, но инкапсулирует значение в свойстве:

class A 
{ 
    private B _b; 

    private B B 
    { 
     get 
     { 
      if (_b == null) 
      { 
       _b = new B(); 
      } 

      return _b; 
     } 
    } 

    public void Method1() 
    { 
     // Do stuff with B 
    } 

    public void Method2() 
    { 
     // Do stuff with B 
    } 

    public void Method3() 
    { 
     // Do stuff with B 
    } 
} 

Вы даже можете смешивать и соответствовать Lazy<T> и имущественными подходы:

class A 
{ 
    private readonly Lazy<B> _b = new Lazy<B>(() => new B()); 

    private B B { get { return _b.Value; } } 
}