private async Task ExecuteNonQuery(DataSItem temp)
{
using (frmparamLoad load = new frmparamLoad(_selectedProcedure))
{
if (load.ShowDialog() == DialogResult.OK)
{
if (load.Result != null)
{
_selectedProcedure = load.Result;
lblStatues.Text = "Loading NonQuery procedure ";
ExecAsyncResult result = await _selectedProcedure.ExecuteNonQueryAsync(_currentAgent);
lblStatues.Text = "Done.";
rTxtresult.AppendColorText(result.ToString(), Color.Blue);
if (_selectedProcedure.HasOutputParam)
{
rTxtresult.AppendColorText("Output Params", Color.GreenYellow);
foreach (DataParam dataParam in _selectedProcedure.OutputParams.Values)
{
rTxtresult.AppendColorText(dataParam.Name + " = " + dataParam.Value, Color.Green);
}
rTxtresult.AppendColorText(new string('-', 30), Color.GreenYellow);
}
}
}
}
}
static async void ImagesGet(int count, DbAgent agent)
{
//Images_NewINstance
DataSItem itm = new DataSItem();
itm.Schema = "general";
itm.Name = "Images_Get";
// itm.AddParam(new DataParam("@path", CustomSqlTypes.String));
itm.AddReturnParam(CustomSqlTypes.Int);
// itm.FillPRocedureParamsFromSQLAgent(agent);
// itm.Params.Add("@path",new DataParam());
Task compleateT = RunLimitedNumberAtATime(10, Enumerable.Range(1, count), async x =>
Task.Factory.StartNew(async() =>
{
// itm.Params["@path"].Value = Guid.NewGuid().ToString();
ExecAsyncResult res = await itm.ExecuteDataReaderByRefAsync <Img>(agent);
IBag <Img> images = res.Object as IBag <Img>;
Console.WriteLine("Item Count : " + images.Objects.Count.ToString() + " " + res.ToString());
// Console.WriteLine(string.Format("Starting task {0}", x));
// await Task.Delay(1000);
//Thread.Sleep(methodWait);
// Console.WriteLine(string.Format("Finishing task {0}", x));
}, TaskCreationOptions.LongRunning));
await compleateT;
}
private async Task ExecuteDs(DataSItem temp)
{
using (frmparamLoad load = new frmparamLoad(temp))
{
if (load.ShowDialog() == DialogResult.OK)
{
if (load.Result != null)
{
_selectedProcedure = load.Result;
lblStatues.Text = "Loading dataSetExecution ...";
ExecAsyncResult result = await _selectedProcedure.ExecDataSetAsync(_currentAgent);
lblStatues.Text = "Done.";
rTxtresult.AppendColorText(result.ToString(), Color.Blue);
DataSet rsSet = result.Object as DataSet;
if (rsSet.Tables.Count > 0)
{
dataGridSet.DataSource = rsSet.Tables[0];
}
if (_selectedProcedure.HasOutputParam)
{
rTxtresult.AppendColorText("Output Params", Color.GreenYellow);
foreach (DataParam dataParam in _selectedProcedure.OutputParams.Values)
{
rTxtresult.AppendColorText(dataParam.Name + " = " + dataParam.Value, Color.Green);
}
rTxtresult.AppendColorText(new string('-', 30), Color.GreenYellow);
}
}
}
}
}
static async Task ImagesGetAsyncMUltiple(DbAgent agent)
{
if (agent.ConnectionLevel == ConnectionLevel.AllInOne)
{
await agent.OpenConnectionAsync();
}
DataSItem itm = new DataSItem();
itm.Schema = "general";
itm.Name = "Images_Get";
// itm.AddParam(new DataParam("@path", CustomSqlTypes.String));
itm.AddReturnParam(CustomSqlTypes.Int);
// itm.FillPRocedureParamsFromSQLAgent(agent);
// itm.Params.Add("@path",new DataParam());
for (int i = 0; i < 1000; i++)
{
ExecAsyncResult res1 = await itm.ExecuteDataReaderByRefAsync <Img>(agent);
IBag <Img> images = res1.Object as IBag <Img>;
Console.WriteLine("Item Count : " + images.Objects.Count.ToString() + " " + res1.ToString());
}
if (agent.ConnectionLevel == ConnectionLevel.AllInOne)
{
agent.Dispose();
}
}
static async void NewImages(int count, DbAgent agent)
{
//Images_NewINstance
DataSItem itm = new DataSItem
{
// itm.Schema = "general";
Schema = "dbo",
Name = "Images_NewINstance"
};
itm.AddParam(new DataParam("@path", CustomSqlTypes.String));
itm.AddReturnParam(CustomSqlTypes.Int);
// itm.FillPRocedureParamsFromSQLAgent(agent);
// itm.Params.Add("@path",new DataParam());
Task compleateT = RunLimitedNumberAtATime(10, Enumerable.Range(1, count), async x =>
Task.Factory.StartNew(async() =>
{
itm.Params["@path"].Value = Guid.NewGuid().ToString();
ExecAsyncResult res = await itm.ExecuteNonQueryAsync(agent);
Console.WriteLine(res.ToString());
// Console.WriteLine(string.Format("Starting task {0}", x));
// await Task.Delay(1000);
//Thread.Sleep(methodWait);
// Console.WriteLine(string.Format("Finishing task {0}", x));
}, TaskCreationOptions.LongRunning));
await compleateT;
}
static async Task NewImagesViaAgent(DbAgent agent)
{
DataSItem itm = new DataSItem
{
// itm.Schema = "general";
Schema = "general",
Name = "Images_NewINstance"
};
itm.AddParam(new DataParam("@path", CustomSqlTypes.String, ParamDirection.Input, Guid.NewGuid().ToString()));
itm.AddReturnParam(CustomSqlTypes.Int);
// itm.Params["@path"].Value = Guid.NewGuid().ToString();
await agent.OpenConnectionAsync();
ExecAsyncResult res = await itm.ExecuteNonQueryAsync(agent);
Console.WriteLine(res.ToString());
itm.Params["@path"].Value = Guid.NewGuid().ToString();
res = await itm.ExecuteNonQueryAsync(agent);
Console.WriteLine(res.ToString());
agent.Dispose();
}
static async void ImagesGetAsyncNewTest(DbAgent agent)
{
if (agent.ConnectionLevel == ConnectionLevel.AllInOne)
{
await agent.OpenConnectionAsync();
}
DataSItem itm = new DataSItem();
itm.Schema = "general";
itm.Name = "Images_Get";
// itm.AddParam(new DataParam("@path", CustomSqlTypes.String));
itm.AddReturnParam(CustomSqlTypes.Int);
// itm.FillPRocedureParamsFromSQLAgent(agent);
// itm.Params.Add("@path",new DataParam());
List <Task <ExecAsyncResult> > _alltaskst = new List <Task <ExecAsyncResult> >();
for (int i = 0; i < 2; i++)
{
Task <ExecAsyncResult> t = itm.ExecuteDataReaderByRefAsync <Img>(agent);
_alltaskst.Add(t);
}
while (_alltaskst.Count > 0)
{
Task <ExecAsyncResult> fintask = await Task.WhenAny(_alltaskst);
_alltaskst.Remove(fintask);
ExecAsyncResult result = await fintask;
IBag <Img> images = result.Object as IBag <Img>;
Console.WriteLine("Item Count : " + images.Objects.Count.ToString() + " " + result.ToString());
}
// itm.Params["@path"].Value = Guid.NewGuid().ToString();
// Console.WriteLine(string.Format("Starting task {0}", x));
// await Task.Delay(1000);
//Thread.Sleep(methodWait);
// Console.WriteLine(string.Format("Finishing task {0}", x));
if (agent.ConnectionLevel == ConnectionLevel.AllInOne)
{
agent.Dispose();
}
}
public static async Task <ExecAsyncResult> ExecDataSetAsync(this DataSItem item, DbAgent agent)
{
return(await Task.Factory.StartNew(() =>
{
ExecAsyncResult result = new ExecAsyncResult();
DataSet rsSet;
ExecResult rs = ExecDataSet(item, agent, out rsSet);
result.ExecutedProcedure = item;
result.Result = rs;
result.Object = rsSet;
result.ExecutionType = AsyncExecutionType.ExecDataSet;
return result;
}));
}
static async Task ReflectionGetAsync(DbAgent agent)
{
DataSItem itm = new DataSItem();
itm.Schema = "general";
itm.Name = "Images_Get";
// itm.AddParam(new DataParam("@path", CustomSqlTypes.String));
itm.AddReturnParam(CustomSqlTypes.Int);
ExecAsyncResult res = await itm.ExecuteDataReaderByRefAsync <Img>(agent);
IBag <Img> images = res.Object as IBag <Img>;
Console.WriteLine("Item Count : " + images.Objects.Count.ToString() + " " + res.ToString());
}
static async Task ImagesGigImagesGET(int count, DbAgent agent)
{
DataSItem itm = new DataSItem();
itm.Schema = "general";
itm.Name = "Images_Get";
// itm.AddParam(new DataParam("@path", CustomSqlTypes.String));
itm.AddReturnParam(CustomSqlTypes.Int);
// itm.FillPRocedureParamsFromSQLAgent(agent);
// itm.Params.Add("@path",new DataParam());
Task compleateT = RunLimitedNumberAtATime(10, Enumerable.Range(1, count), async x =>
Task.Factory.StartNew(async() =>
{
Console.WriteLine("Start! ");
// itm.Params["@path"].Value = Guid.NewGuid().ToString();
ExecAsyncResult res = await itm.ExecuteDataReaderByRefAsync <Img>(agent);
IBag <Img> images = res.Object as IBag <Img>;
Console.WriteLine("Item Count : " + images.Objects.Count.ToString() + " " + res.ToString());
}, TaskCreationOptions.LongRunning));
await compleateT;
}
/// <summary>
/// Changed!
/// </summary>
/// <param name="item"></param>
/// <param name="agent"></param>
/// <returns></returns>
public static async Task <ExecAsyncResult> ExecuteNonQueryAsync(this DataSItem item, DbAgent agent)
{
//return Task.Factory.StartNew(() =>
//{
// ExecAsyncResult result = new ExecAsyncResult();
// ExecResult rs = ExecuteNonQuery(item, agent);
// result.ExecutedProcedure = item;
// result.Result = rs;
// return result;
//});
ExecAsyncResult result = new ExecAsyncResult();
result.ExecutedProcedure = item;
if (agent != null && agent.State)
{
///Open Connection via agent
SqlConnection con = null;
result.StartMeasure();
if (agent.ConnectionLevel == ConnectionLevel.Single)
{
con = agent.CreateConnection();
await con.OpenAsync();
}
else if (agent.ConnectionLevel == ConnectionLevel.AllInOne)
{
con = agent.Connection;
}
using (SqlCommand cmd = new SqlCommand(item.Value, con))
{
if (agent.TransactionState == TransactionState.ActiveTransaction)
{
cmd.Transaction = agent.Transaction;
}
SqlParameter param;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandTimeout = agent.RunTimeout;
foreach (var itm in item.Params.Values)
{
param = new SqlParameter();
param.ParameterName = itm.Name;
param.Value = itm.Value;
param.SqlDbType = SettingsHelperManager.DetermineSqlDbTYpe(itm.Type);
param.Direction = SettingsHelperManager.GetParametrDirection(itm.Direction);
cmd.Parameters.Add(param);
}
result.Result.AffectedRows = await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);
//set outputparams values
if (item.HasOutputParam)
{
foreach (DataParam value in item.OutputParams.Values)
{
value.Value = cmd.Parameters[value.Name].Value.ToString();
}
}
if (cmd.Parameters.Count > 0)
{
List <DataParam> returnparam = item.GetparamsByDirection(ParamDirection.Return);
if (returnparam.Count > 0)
{
string name = returnparam[0].Name;
if (cmd.Parameters[name] != null)
{
result.Result.SetCode(Convert.ToInt32(cmd.Parameters[name].Value));
}
}
}
}
if (agent.ConnectionLevel == ConnectionLevel.Single && con != null)
{
con.Dispose();
}
result.StopMeasure();
}
else
{
throw new Exception("Agent is null or state is false ");
}
return(result);
}
public static async Task <ExecAsyncResult> ExecuteDataReaderByRefAsync <T>(this DataSItem item, DbAgent agent)
{
ExecAsyncResult result = new ExecAsyncResult();
result.ExecutedProcedure = item;
IBag <T> container;
if (agent != null && agent.State)
{
// return ExecuteProcedureDRByReflection<T>(item, out container, agent.ConnectionString);
//---
SqlCommand cmd = null;
container = new RefBag <T>();
result.StartMeasure();
try
{
//using (_conn = new SqlConnection(constr))
//{
SqlConnection con = null;
if (agent.ConnectionLevel == ConnectionLevel.Single)
{
con = agent.CreateConnection();
await con.OpenAsync();
// con = agent.CreateConnection();
//_shouldBeSync use
}
else if (agent.ConnectionLevel == ConnectionLevel.AllInOne)
{
con = agent.Connection;
}
cmd = new SqlCommand(item.Value, con)
{
CommandType = CommandType.StoredProcedure,
CommandTimeout = agent.RunTimeout
};
if (agent.TransactionState == TransactionState.ActiveTransaction)
{
cmd.Transaction = agent.Transaction;
}
SqlParameter param;
cmd.CommandType = CommandType.StoredProcedure;
foreach (var itm in item.Params.Values)
{
param = new SqlParameter();
param.ParameterName = itm.Name;
param.Value = itm.Value;
param.SqlDbType = SettingsHelperManager.DetermineSqlDbTYpe(itm.Type);
param.Direction = SettingsHelperManager.GetParametrDirection(itm.Direction);
cmd.Parameters.Add(param);
}
using (_reader = await cmd.ExecuteReaderAsync().ConfigureAwait(false))
{
while (await _reader.ReadAsync().ConfigureAwait(false))
{
container.SetFromReader(ref _reader);
}
}
//set outputparams values
if (item.HasOutputParam)
{
foreach (DataParam value in item.OutputParams.Values)
{
value.Value = cmd.Parameters[value.Name].Value.ToString();
}
}
if (cmd.Parameters.Count > 0)
{
List <DataParam> ret = item.GetparamsByDirection(ParamDirection.Return);
if (ret.Count > 0)
{
if (cmd.Parameters[ret[0].Name] != null)
{
result.Result.SetCode(
Convert.ToInt32(
cmd.Parameters[item.GetparamsByDirection(ParamDirection.Return)[0].Name].Value));
}
}
}
// } end of using
if (agent.ConnectionLevel == ConnectionLevel.Single && con != null)
{
con.Dispose();
}
result.Object = container;
}
catch (Exception exc)
{
throw exc;
}
result.StopMeasure();
result.ExecutionType = AsyncExecutionType.ExecByRef;
return(result);
//----
}
else
{
throw new Exception("Agent is null or the state is false ");
}
}
public static async Task <ExecAsyncResult> ExecDataReadByInheritanceAsync <T>(this DataSItem item, DbAgent agent) where T : DbObject
{
//return Task.Factory.StartNew(() =>
// {
// ExecAsyncResult result = new ExecAsyncResult();
// IBag<T> container;
// ExecResult rs = ExecDataReadByInheritance<T>(item, agent, out container);
// result.ExecutedProcedure = item;
// result.Result = rs;
// result.Object = container;
// result.ExecutionType=AsyncExecutionType.ExecByINheritance;
// return result;
// });
ExecAsyncResult result = new ExecAsyncResult();
result.ExecutedProcedure = item;
IBag <T> container;
if (agent != null && agent.State)
{
// return ExecuteProcedureDRByReflection<T>(item, out container, agent.ConnectionString);
//---
SqlCommand cmd = null;
container = new Bag <T>();
result.StartMeasure();
try
{
// create and open a connection object "Data Source=FARID-PC;Initial Catalog=InsuranceFactory;Integrated Security=True"
//using (_conn = new SqlConnection(constr))
//{
SqlConnection con = null;
if (agent.ConnectionLevel == ConnectionLevel.Single)
{
con = agent.CreateConnection();
await con.OpenAsync();
}
else if (agent.ConnectionLevel == ConnectionLevel.AllInOne)
{
con = agent.Connection;
}
// check state of connection
cmd = new SqlCommand(item.Value, con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandTimeout = agent.RunTimeout;
if (agent.TransactionState == TransactionState.ActiveTransaction)
{
cmd.Transaction = agent.Transaction;
}
SqlParameter param;
foreach (var itm in item.Params.Values)
{
param = new SqlParameter();
param.ParameterName = itm.Name;
param.Value = itm.Value;
param.SqlDbType = SettingsHelperManager.DetermineSqlDbTYpe(itm.Type);
param.Direction = SettingsHelperManager.GetParametrDirection(itm.Direction);
cmd.Parameters.Add(param);
}
using (_reader = await cmd.ExecuteReaderAsync().ConfigureAwait(false))
{
while (await _reader.ReadAsync().ConfigureAwait(false))
{
container.SetFromReader(ref _reader);
}
}
//set outputparams values
if (item.HasOutputParam)
{
foreach (DataParam value in item.OutputParams.Values)
{
value.Value = cmd.Parameters[value.Name].Value.ToString();
}
}
if (cmd.Parameters.Count > 0)
{
List <DataParam> ret = item.GetparamsByDirection(ParamDirection.Return);
if (ret.Count > 0)
{
if (cmd.Parameters[ret[0].Name] != null)
{
result.Result.SetCode(
Convert.ToInt32(
cmd.Parameters[item.GetparamsByDirection(ParamDirection.Return)[0].Name].Value));
}
}
}
// }end of using
if (agent.ConnectionLevel == ConnectionLevel.Single && con != null) //&& agent.AgentState != AgentState.Disconnected)
{
con.Dispose();
}
result.Object = container;
}
catch (Exception exc)
{
throw exc;
}
result.StopMeasure();
result.ExecutionType = AsyncExecutionType.ExecByINheritance;
return(result);
//----
}
else
{
throw new Exception("Agent is null or the state is false ");
}
}
