public Task <T> FirstOrDefaultAsync <T>(CancellationToken CancellationToken)
{
using (SqlCommand command = connection.GetCommand(commandText))
{
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
return(command.ExecuteReaderAsync(CommandBehavior.SingleRow, CancellationToken)
.ContinueWith(task =>
{
T callback = default;
using (SqlDataReader reader = task.Result)
{
if (reader.HasRows)
{
callback = DatabaseReaderSelect <T> .FirstAsync(reader, CancellationToken);
}
reader.Close();
}
return callback;
}));
}
}
public T FirstOrDefault <T>()
{
T callback = default;
using (SqlCommand command = connection.GetCommand(commandText))
{
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
using (SqlDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow))
{
if (reader.HasRows)
{
callback = DatabaseReaderSelect <T> .First(reader);
}
reader.Close();
}
}
return(callback);
}
public int Execute()
{
SqlCommand command = connection.GetCommand(commandText);
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
return(command.ExecuteNonQuery());
}
public Task <int> ExecuteAsync(CancellationToken CancellationToken)
{
SqlCommand command = connection.GetCommand(commandText);
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
return(command.ExecuteNonQueryAsync(CancellationToken));
}
public T SingleOrDefault <T>()
{
T result = default;
using (SqlCommand command = connection.GetCommand(commandText))
{
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
object o = command.ExecuteScalar();
result = Cast <T> .Scalar(o);
}
return(result);
}
public Task <T> FirstAsync <T>(CancellationToken CancellationToken)
{
using (SqlCommand command = connection.GetCommand(commandText))
{
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
return(command.ExecuteReaderAsync(CommandBehavior.SingleRow, CancellationToken)
.ContinueWith(task =>
{
bool read = false;
T callback = default;
using (SqlDataReader reader = task.Result)
{
if (reader.HasRows)
{
read = true;
}
if (read)
{
callback = DatabaseReaderSelect <T> .FirstAsync(reader, CancellationToken);
}
reader.Close();
if (!read)
{
throw new EntityDatabaseException($"Database Select FirstAsync {typeof(T).Name} Failed, Nothing Returned With Query : \n\n {commandText}");
}
return callback;
}
}));
}
}
public Task <T> SingleAsync <T>(CancellationToken CancellationToken)
{
using (SqlCommand command = connection.GetCommand(commandText))
{
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
return(command.ExecuteScalarAsync(CancellationToken)
.ContinueWith(task =>
{
bool read = false;
T result = default;
object o = task.Result;
if (o != null)
{
read = true;
}
if (read)
{
result = Cast <T> .Scalar(o);
}
if (!read)
{
throw new EntityDatabaseException($"Database Select Single {typeof(T).Name} Failed, Nothing Returned With Query : \n\n {commandText}");
}
return result;
}));
}
}
public T[] ToArray <T>()
{
T[] callback;
using (SqlCommand command = connection.GetCommand(commandText))
{
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
using (SqlDataReader reader = command.ExecuteReader(CommandBehavior.Default))
{
callback = DatabaseReaderSelect <T> .ToArray(reader);
reader.Close();
}
}
return(callback);
}
public T First <T>()
{
bool read = false;
T callback = default;
using (SqlCommand command = connection.GetCommand(commandText))
{
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
using (SqlDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow))
{
if (reader.HasRows)
{
read = true;
}
if (read)
{
callback = DatabaseReaderSelect <T> .First(reader);
}
reader.Close();
}
}
if (!read)
{
throw new EntityDatabaseException($"Database Select First {typeof(T).Name} Failed, Nothing Returned With Query : \n\n {commandText}");
}
return(callback);
}
public void Refresh(EntitySet <TEntity> EntitySet)
{
if (EntitySet.Context.ContextType != typeof(TEntityContext))
{
throw new EntityDatabaseException($"{this}, Write Failed, {EntitySet} Context Must Be Type Of {typeof(TEntityContext)}");
}
using (SqlCommand command = connection.GetCommand(commandText))
{
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
using (SqlDataReader reader = command.ExecuteReader(CommandBehavior.Default))
{
EntityDatabaseReaderSelect <TEntityContext, TEntity, TEntityCallBack> .Refresh(reader, EntitySet);
reader.Close();
}
}
}
public Task <T> SingleOrDefaultAsync <T>(CancellationToken CancellationToken)
{
using (SqlCommand command = connection.GetCommand(commandText))
{
DatabaseTrace.Append(command.CommandText, Constant.Query);
if (connection.HasTransaction)
{
command.Transaction = connection.Transaction;
}
return(command.ExecuteScalarAsync(CancellationToken)
.ContinueWith(task =>
{
T result = default;
object o = task.Result;
result = Cast <T> .Scalar(o);
return result;
}));
}
}
static DatabaseTrace()
{
tracer = new DatabaseTrace();
}
public void BeginTransaction(IsolationLevel Isolation)
{
Transaction = Provider.BeginTransaction(Isolation); DatabaseTrace.Append($"{Isolation} Transaction Begin");
}
public void CommitTransaction()
{
Transaction.Commit(); DatabaseTrace.Append($"Transaction Committd");
}
public void RollbackTransaction()
{
Transaction.Rollback(); DatabaseTrace.Append($"Transaction Rollbacked");
}
public void Open()
{
Provider.Open(); DatabaseTrace.Append($"Connection Opened");
}
public void Close()
{
Provider.Close(); DatabaseTrace.Append($"Connection Closed");
}
