public T ExecuteInterfaceMethod <T>(MethodInformation method, Action <T> action)
{
DataOptType dataOptType = ((IDataInterface)this).dataOptType;
method.dataProviderNamespace = dataProviderNamespace;
method.dataProviderClassName = dataProviderClassName;
method.fields = fields;
method.fieldsType = fieldsType;
method.ResultExecMethod = ResultExecMethod;
method.sqlExecType = sqlExecType;
string sqlVarName = "sql";
DynamicCodeAutoCall dynamicCodeAutoCall = new DynamicCodeAutoCall();
sql = dynamicCodeAutoCall.ExecReplaceForSqlByFieldName(sql, sqlVarName, method);
DynamicCodeChange dynamicCodeChange = new DynamicCodeChange();
try
{
dynamicCodeChange.AnalyzeSql(method, dataOptType, sqlVarName, ref sql);
}
catch (Exception ex)
{
e(ex.ToString(), ErrorLevels.severe);
throw ex;
}
DynamicEntity dynamicEntity = new DynamicEntity();
T result = dynamicEntity.Exec <T>(method, dataOptType, action, sql);
return(result);
}
public T Exec <T>(MethodInformation method, DataOptType dataOptType, Action <T> action, string sql)
{
T result = default(T);
AutoCall autoCall = (AutoCall)method.AutoCall;
dynamicWhere(method, ref sql);
IList <DataEntity <DataElement> > dataElements = null;
DataEntity <DataElement> dataElements1 = null;
DbList <DbParameter> dbParameters = null;
if (0 < method.paraList.Count)
{
foreach (Para item in method.paraList)
{
if (null != item.ParaValue)
{
if (null != item.ParaValue as IList <DataEntity <DataElement> > )
{
dataElements = item.ParaValue as IList <DataEntity <DataElement> >;
break;
}
else if (null != item.ParaValue as DataEntity <DataElement> )
{
dataElements = new List <DataEntity <DataElement> >();
dataElements1 = item.ParaValue as DataEntity <DataElement>;
dataElements.Add(dataElements1);
break;
}
}
}
}
if (null == dataElements)
{
dataElements = new List <DataEntity <DataElement> >();
}
string err = "";
bool EnabledBuffer = method.methodComponent.EnabledBuffer;
EnabledBuffer = method.methodComponent.IsAsync ? true : EnabledBuffer;
if (DataOptType.select == dataOptType ||
DataOptType.count == dataOptType ||
DataOptType.procedure == dataOptType)
{
if (0 < dataElements.Count)
{
dataElements1 = dataElements[0];
}
dbParameters = GetDbParameters(method, dataElements1, sql);
GetSqlByProvider(method, dbParameters, ref sql);
dbHelper.query(autoCall, sql, dbParameters, EnabledBuffer, (dt) =>
{
DynamicCodeAutoCall dynamicCodeAutoCall = new DynamicCodeAutoCall();
string execClassPath = "";
string execMethodName = "";
bool paraExsit = false;
Type returnType = dynamicCodeAutoCall.GetParaTypeOfResultExecMethod(method, ref execClassPath, ref execMethodName, ref paraExsit);
if (paraExsit)
{
Type resultExecMethodType = execClassPath.GetClassTypeByPath();
if (null == resultExecMethodType)
{
err = "The ClassPath '" + execClassPath + "' is not exist.";
autoCall.e(err, ErrorLevels.dangerous);
throw new Exception(err);
}
object clsObj = null;
MethodInfo methodInfo = resultExecMethodType.GetMethod(execMethodName);
if (null != methodInfo)
{
if (methodInfo.ReturnType != typeof(T))
{
err = "";
string msg = "The return value type of the method '{0}' of the class '{1}' and the method '{2}' of the interface '{3}' are not the same.";
method.append(ref err, 0, msg, execMethodName, execClassPath, method.methodInfo.Name, method.methodInfo.DeclaringType.FullName);
autoCall.e(err, ErrorLevels.dangerous);
throw new Exception(err);
}
object vData = dataTableTo(method, dt, returnType);
try
{
clsObj = Activator.CreateInstance(resultExecMethodType);
result = (T)methodInfo.Invoke(clsObj, new object[] { vData });
}
catch (Exception ex)
{
autoCall.e(ex.ToString(), ErrorLevels.dangerous);
//throw;
}
}
}
else
{
result = dataTableTo <T>(method, dt);
}
if (null != action)
{
action(result);
}
}, ref err);
}
else
{
int n = 0;
Func <int, T> funcResult = n1 =>
{
object v = n1;
if (typeof(bool) == typeof(T))
{
v = 0 < n1;
}
return((T)v);
};
foreach (DataEntity <DataElement> item in dataElements)
{
dbParameters = GetDbParameters(method, item, sql);
switch (dataOptType)
{
case DataOptType.insert:
dbHelper.insert(autoCall, sql, dbParameters, EnabledBuffer, (num) =>
{
n += num;
result = funcResult(n);
if (null != action)
{
action(result);
}
}, ref err);
break;
case DataOptType.update:
dbHelper.update(autoCall, sql, dbParameters, EnabledBuffer, (num) =>
{
n += num;
result = funcResult(n);
if (null != action)
{
action(result);
}
}, ref err);
break;
case DataOptType.delete:
dbHelper.delete(autoCall, sql, dbParameters, EnabledBuffer, (num) =>
{
n += num;
result = funcResult(n);
if (null != action)
{
action(result);
}
}, ref err);
break;
}
}
result = funcResult(n);
}
return(result);
}