如何在实例方法中使用反射

Question

If i create the following method concerning transaction :

public static int Insert(string processMethod, object[] processParameters, Type processType, object process, UserTransactionDTO transObj, string spPostConfirm, int toEmpNum,int confirmState)
        {
            int affectedRows = -7;
            using (IfxConnection conn = new IfxConnection(ConfigurationManager.ConnectionStrings["crms"].ToString() + " Enlist=true;"))
            {
                if (conn.State == ConnectionState.Closed)
                {
                    conn.Open();
                }
                using (IfxTransaction tran = conn.BeginTransaction())
                {

                    if (!string.IsNullOrEmpty(processMethod))//business Method
                    {
                        processParameters[1] = conn;
                        processParameters[2] = tran;
                        MethodInfo theMethod = processType.GetMethod(processMethod, new[] { processParameters.First().GetType(), typeof(IfxConnection), typeof(IfxTransaction) });
                        object res = theMethod.Invoke(process, processParameters);
                        transObj.ValuesKey = res.ToString();
                    }
                    if (!string.IsNullOrEmpty(transObj.ValuesKey))
                    {
                        affectedRows = RunPreConfirm(transObj.TaskCode, transObj.UserStateCode, transObj.ValuesKey, conn, tran, confirmState);//sp_confirm
                        if (affectedRows != 1)
                        {
                            tran.Rollback();
                            tran.Dispose();//Dispose
                            conn.Close();
                            conn.Dispose();
                            return -1;//Fail
                        }
                        affectedRows = InsertTrans(transObj, conn, tran);//MainTransaction --->df2usertrans

                        if (affectedRows == 1)//Success
                        {

                            if (!string.IsNullOrEmpty(spPostConfirm))
                            {
                                affectedRows = RunPostConfirm(spPostConfirm, transObj.ValuesKey, conn, tran);//sp_post_confirm
                                if (affectedRows != 0)
                                {
                                    tran.Rollback();
                                    tran.Dispose();//Dispose
                                    conn.Close();
                                    conn.Dispose();
                                    return -2;//Fail 
                                }

                            }

                            affectedRows = RunAfterTrans(transObj.TaskCode, transObj.OldStatusCode, transObj, toEmpNum, conn, tran);//sp_after_trans
                            if (affectedRows != 1)
                            {
                                tran.Rollback();
                                tran.Dispose();//Dispose
                                conn.Close();
                                conn.Dispose();
                                return -3;//Fail
                            }

                            tran.Commit();
                            tran.Dispose();
                            conn.Close();
                            conn.Dispose();
                            return 1;

                        }
                        else
                        {
                            tran.Rollback();
                            tran.Dispose();//Dispose
                            conn.Close();
                            conn.Dispose();
                            return -1;//Fail 
                        }
                    }
                    else
                    {
                        tran.Rollback();
                        tran.Dispose();//Dispose
                        conn.Close();
                        conn.Dispose();
                        return -1;//Fail 
                    }
                }
            }
            return affectedRows;
        }

---

I want to ask three questions :

1-if one of my internal methods failed to insert before } Does the connection and the transaction disposed and closed automatically or not ?I mean should i call the following block of code :

tran.Dispose();
conn.Close();
conn.Dispose();

---

2-Could i invoke an instance method with its properties instead of fill the object and passing it as a parameter again ?

 object res = theMethod.Invoke(process, processParameters);

I mean : I want to use this(with its object state) because it's instance method:

 public string InsertRequest(IfxConnection conn,IfxTransaction trans)

instead of this current method :

 public string InsertRequest(EnhancementRequest obj, IfxConnection conn,IfxTransaction trans)

---

3-Is the following code written well? I mean, no redundant steps and no logical errors.?

Answer 1

The code has some redundancies and some possible issues.

First of all if you are narrowing scope of connection and transaction objects with using statement, you don't need to call Dispose on any of these objects as using will take care of it for you.

If your functions calling stored procedures are not handling database exceptions you should add try .. except aroung your transaction scope:

   using (IfxTransaction tran = conn.BeginTransaction())
   {
      try
      {
         // All db operations here
         tran.Commit();
      }
      catch(Exception e)
      {
         tran.Rollback();
         throw; // Or return error code
      }
   }

So effectively if some non-exception validation condition fails you just need to call trans.Rollback() and return your error code.

Regarding your question 2 I would suggest adding generic call as your function parameter:

public static int Insert(Func<IfxConnection, IfxTransaction, object> callback)
{
   // ...
   object res = callback(conn, tran);
   // ...
}

In the code above I used generic delegate Func, you can call your insert function like this:

Insert((conn, tran) =>
{
    // do something here with conn and tran and return object
});

Alternatively you can declare your own delegate signature which can be helpful if you plan to change it in the future:

public delegate object MyDelegateType(IfxConnection conn, IfxTransaction tran);

Then when calling insert just pass the object and method of your choice as an argument:

public class SomeClass
{
    public static object ProcessOnInsert(IfxConnection conn, IfxTransaction tran)
    {
        // do something here with conn and tran
    }

    public static int Insert(MyDelegateType callback)
// or
//    public static int Insert(Func<IfxConnection,IfxTransaction,object> callback)
    {
        // ...
        callback(conn, tran);
        // ...
    }

    public static void RunInsert()
    {
        Insert(ProcessOnInsert);
    }
}

The method after some changes:

public static int Insert(Func<IfxConnection, IfxTransaction, object> processMethod, UserTransactionDTO transObj, string spPostConfirm, int toEmpNum, int confirmState)
{
    int affectedRows = -7;
    using (IfxConnection conn = new IfxConnection(ConfigurationManager.ConnectionStrings["crms"].ToString() + " Enlist=true;"))
    {
        if (conn.State == ConnectionState.Closed)
        {
            conn.Open();
        }
        using (IfxTransaction tran = conn.BeginTransaction())
        {
            try
            {
                if (processMethod != null)//business Method
                {
                    object res = processMethod(conn, tran);
                    transObj.ValuesKey = res.ToString();
                }
                if (string.IsNullOrEmpty(transObj.ValuesKey)) //Fail
                {
                    tran.Rollback();
                    return -1;//Fail 
                }

                affectedRows = RunPreConfirm(transObj.TaskCode, transObj.UserStateCode, transObj.ValuesKey, conn, tran, confirmState);//sp_confirm
                if (affectedRows != 1)
                {
                    tran.Rollback();
                    return -1;//Fail
                }

                affectedRows = InsertTrans(transObj, conn, tran);//MainTransaction --->df2usertrans
                if (affectedRows != 1)//Fail
                {
                    tran.Rollback();
                    return -1;//Fail 
                }

                if (!string.IsNullOrEmpty(spPostConfirm))
                {
                    affectedRows = RunPostConfirm(spPostConfirm, transObj.ValuesKey, conn, tran);//sp_post_confirm
                    if (affectedRows != 0)
                    {
                        tran.Rollback();
                        return -2;//Fail 
                    }
                }

                affectedRows = RunAfterTrans(transObj.TaskCode, transObj.OldStatusCode, transObj, toEmpNum, conn, tran);//sp_after_trans
                if (affectedRows != 1)
                {
                    tran.Rollback();
                    return -3;//Fail
                }

                tran.Commit();
                return 1;
            }
            catch
            {
                trans.Rollback();
                throw;
            }
        }
    }
    return affectedRows;
}

When calling this function just pass any instance method with matching signature as processMethod.

Another suggestion is to change all functions to use the similar callback syntax and instead of passing string and object arguments, call the method directly as strong typing in this case gives more readability.

Regarding readability as you run of series of operations in a transaction and if either one fails, whole transaction needs to fail, it's better to reduce nested conditions and check for fail first (see above).