空对象引用设置后

Question

我尝试用一​​些代码来解释我的情况：

Class A
{
   private IDBTransaction trans;
   private IDBConnection conn;

   void Main()
   {
       B test = new B(trans)
       [some instruction]
       trans = conn.BeginTrans();
       test.Save();
   }
}

Class B
{
   private IDBTransaction trans;

   public B(IDBTransaction transaction)
   {
      trans = transaction;
   }

   void Save()
   {
      [some instruction that use transaction]
   }
}

调用Save（）时，将变量B.trans设置为null，因为在A传递参数时该变量为null。 然后，A.trans更改其值，调用BeginTrans（），但B.trans仍保持为空。 我该如何解决？

Answer 1

您可以将交易保留在单独的对象中，例如

class TransactionInfo
{
    public IDbTransaction Transaction;  
    public IDbConnection conn;
}

然后以这种方式使用

class A
{
    private static TransactionInfo info = new TransactionInfo();        

    static void Main()
    {
        B test = new B(info);
        //[some instruction]
        info.Transaction = info.conn.BeginTransaction();
        test.Save();
    }
}

class B
{
    private TransactionInfo _info;

    public B(TransactionInfo info)
    {
        _info = info;
    }

    public void Save()
    {
        //[some instruction that use transaction]
        _info.Transaction;
    }
}

或者，您可以延迟想要交易的时间

public class ValueSource<T>
{
    private Func<T> _acessor;
    public ValueSource(Func<T> acessor)
    {
        _acessor = acessor;
    }

    public T Value
    {
        get 
        { 
            try 
            {
                return _acessor();
            }
            catch
            {
                return default(T);
            }
        }
    }
}

然后将上述任何解决方案传递给构造函数。 延迟示例（用于保存在单独的类中的示例相同）

class A
{
    private static IDbTransaction trans;
    private static IDbConnection conn;

   static void Main()
   {
        B test = new B(new ValueSource<IDbTransaction>(()=>trans));
        //[some instruction]
        trans = conn.BeginTransaction();        
        test.Save();
    }
}

class B
{
    private ValueSource<IDbTransaction> trans;

    public B(ValueSource<IDbTransaction> transactionSource)
   {
        trans = transactionSource;
    }

   public void Save()
   {
      //[some instruction that use transaction]
      trans.Value;
   }
}

但。 上面的所有示例仅在出于某种原因要将事务引用保留在B类中时适用。 如果没有必要，我建议（如问题注释中所建议）将事务作为Save方法参数传递。

class A
{
    private static  IDbTransaction Transaction;
    private static  IDbConnection conn;

    static void Main()
    {
        B test = new B();
        //[some instruction]
        Transaction = conn.BeginTransaction();
        test.Save(Transaction);
    }
}

class B
{
    public B()
    {       
    }

    public void Save(IDbTransaction transaction)
    {
        //[some instruction that use transaction]
        transaction
    }
}

只是要记住：如果没有必要，不要在数据结构中存储任何内容。 没有状态的类包含较少的错误，并且更易于测试。

Answer 2

我会将trans作为参数传递给Save()方法而不是构造函数，将事务引用保留在生命周期更长的对象上有点用。 （至少长于事务），这样您可以对不同/多个事务使用Save(trans)方法。

void Main()
{
    B test = new B();
    [some instruction]
    trans = conn.BeginTrans();
    test.Save(trans);
}

---

 Class B
 {
    void Save(IDBTransaction transaction)
    {

    }
}

---