private void btnSend_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtInfo.Text.Trim()))
{
MessageBox.Show("请输入发送日志内容");
return;
}
string queuePath = txtUrl.Text.Trim();
LogInfo loginfo = new LogInfo();
loginfo.ID = Guid.NewGuid().ToString();
loginfo.Info = txtInfo.Text.Trim();
loginfo.CreateDate = DateTime.Now;
bool isPass = false;
if (cboSW.Checked == true)
{
MessageQueueTransaction myTran = new MessageQueueTransaction();
try
{
myTran.Begin();
isPass = QueueManger.SendMessage <LogInfo>(loginfo, queuePath, System.Messaging.MessagePriority.High, myTran);
myTran.Commit();
}
catch (Exception ex)
{
myTran.Abort();
}
}
else
{
isPass = QueueManger.SendMessage <LogInfo>(loginfo, queuePath, System.Messaging.MessagePriority.High);
}
MessageBox.Show("发送状态:" + isPass);
}
/// <summary>
/// 插入
/// </summary>
/// <param name="lst">实体类</param>
public int Insert(List <TEntity> lst)
{
Check.NotNull(lst, "插入操作时，lst参数不能为空！");
// 加入队列
return(QueueManger.CommitLazy(SetMap, (queue) =>
{
// 如果是MSSQLSER，则启用BulkCopy
switch (Context.Executeor.DataBase.DataType)
{
case eumDbType.SqlServer:
Context.Executeor.DataBase.ExecuteSqlBulkCopy(SetMap.Name, lst.ToTable());
break;
case eumDbType.OleDb:
lst.ForEach(entity => QueueManger.CommitLazy(SetMap, (queueLazy) => Context.Executeor.Execute(queueLazy.SqlBuilder.Insert()), false));
break;
default:
lst.ForEach(entity =>
{
// 实体类的赋值，转成表达式树
queue.ExpBuilder.AssignInsert(entity);
Context.Executeor.Execute(queue.SqlBuilder.Insert());
});
break;
}
return lst.Count;
}, false));
}
/// <summary>
/// 添加或者减少某个字段（支持延迟加载）
/// </summary>
public int AddUp()
{
Check.NotNull(Queue.ExpBuilder.ExpAssign, "+=字段操作时，必须先执行AddUp的另一个重载版本！");
// 加入队列
return(QueueManger.CommitLazy(SetMap, (queue) => Context.Executeor.Execute(queue.SqlBuilder.AddUp()), true));
}
private void button1_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtInfo.Text.Trim()))
{
MessageBox.Show("请输入发送日志内容");
return;
}
try
{
string queuePath = txtUrl.Text.Trim();
LogInfo loginfo = new LogInfo();
loginfo.ID = Guid.NewGuid().ToString();
loginfo.Info = txtInfo.Text.Trim();
loginfo.CreateDate = DateTime.Now;
MessageQueueTransaction mqt = new MessageQueueTransaction();
mqt.Begin();
bool isPass = QueueManger.SendMessage <LogInfo>(loginfo, queuePath, MessagePriority.High, mqt);
mqt.Commit();
MessageBox.Show("发送状态:" + isPass);
}
catch (Exception ex)
{
MessageBox.Show("发生异常:" + ex.Message);
}
}
//发送邮件
private void btnSend_Click(object sender, EventArgs e)
{
MailInfo mi = new MailInfo();
mi.StmpServer = txtSMTP.Text.Trim();
mi.SendAddress = txtFJRDZ.Text.Trim();
mi.SendPwd = txtFJRMM.Text.Trim();
mi.ReceiveAddress = txtSJRDZ.Text.Trim();
mi.Title = txtYJZT.Text.Trim();
mi.Content = txtYJZW.Text.Trim();
if (mi != null)
{
string queuePath = AppConfig.QueuePath;
bool isPass = QueueManger.Createqueue(queuePath);//创建队列
if (isPass == true)
{
isPass = QueueManger.SendMessage <MailInfo>(mi, queuePath, MessagePriority.Highest);//发送消息到队列
if (isPass == true)
{
MessageBox.Show("成功");
}
else
{
MessageBox.Show("失败");
}
}
}
}
/// <summary>
/// 查询多条记录（不支持延迟加载）
/// </summary>
/// <param name="pageSize">每页显示数量</param>
/// <param name="pageIndex">分页索引</param>
/// <param name="isDistinct">返回当前条件下非重复数据</param>
/// <returns></returns>
public virtual Task <List <TEntity> > ToListAsync(int pageSize, int pageIndex, bool isDistinct = false)
{
// 计算总页数
Check.IsTure(pageIndex < 1, $"参数{nameof(pageSize)}，不能小于1");
Check.IsTure(pageSize < 1, $"参数{nameof(pageSize)}，不能小于1");
return(QueueManger.CommitAsync(SetMap, (queue) => Context.Executeor.ToListAsync <TEntity>(queue.SqlBuilder.ToList(pageSize, pageIndex, isDistinct)), true));
}
/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="entity">传入被设置好参数赋值的实体</param>
public int Execute(TEntity entity = null)
{
// 加入委托
var isExitsOutParam = SetMap.PhysicsMap.MapList.Any(o => o.Value.Field.IsOutParam);
Func <Queue, int> act = (queue) => Context.Executeor.Execute(Queue.ProcBuilder, entity);
return(isExitsOutParam ? QueueManger.Commit(SetMap, act, false) : QueueManger.CommitLazy(SetMap, act, false));
}
/// <summary>
/// 修改（支持延迟加载）
/// 如果设置了主键ID，并且entity的ID设置了值，那么会自动将ID的值转换成条件 entity.ID == 值
/// </summary>
/// <param name="entity"></param>
public int Update(TEntity entity)
{
Check.IsTure(entity == null && Queue.ExpBuilder.ExpAssign == null, "更新操作时，参数不能为空！");
// 实体类的赋值，转成表达式树
Queue.ExpBuilder.AssignUpdate(entity);
// 加入队列
return(QueueManger.CommitLazy(SetMap, (queue) => Context.Executeor.Execute(queue.SqlBuilder.Update()), true));
}
/// <summary> 查询多条记录（不支持延迟加载） </summary>
/// <param name="pageSize">每页显示数量</param>
/// <param name="pageIndex">分页索引</param>
/// <param name="isDistinct">返回当前条件下非重复数据</param>
/// <returns></returns>
public virtual DataTable ToTable(int pageSize, int pageIndex, bool isDistinct = false)
{
// 计算总页数
Check.IsTure(pageIndex < 1, $"参数{nameof(pageSize)}，不能小于1");
Check.IsTure(pageSize < 1, $"参数{nameof(pageSize)}，不能小于1");
return(QueueManger.Commit(SetMap, (queue) => Context.Executeor.ToTable(queue.SqlBuilder.ToList(pageSize, pageIndex, isDistinct)), true));
}
/// <summary>
/// 累计和（不支持延迟加载）
/// </summary>
public virtual Task <T> SumAsync <T>(Expression <Func <TEntity, T> > fieldName, T defValue = default(T))
{
if (fieldName == null)
{
throw new ArgumentNullException("fieldName", "查询Sum操作时，fieldName参数不能为空！");
}
Select(fieldName);
return(QueueManger.CommitAsync(SetMap, (queue) => Context.Executeor.GetValueAsync(queue.SqlBuilder.Sum(), defValue), true));
}
/// <summary>
/// 查询最小数（不支持延迟加载）
/// </summary>
public virtual T Min <T>(Expression <Func <TEntity, T> > fieldName, T defValue = default(T)) where T : struct
{
if (fieldName == null)
{
throw new ArgumentNullException("fieldName", "查询Min操作时，fieldName参数不能为空！");
}
Select(fieldName);
return(QueueManger.Commit(SetMap, (queue) => Context.Executeor.GetValue(queue.SqlBuilder.Min(), defValue), true));
}
/// <summary>
/// 查询单个值（不支持延迟加载）
/// </summary>
public T GetValue <T>(Expression <Func <TEntity, object> > fieldName, T defValue = default(T))
{
if (fieldName == null)
{
throw new ArgumentNullException("fieldName", "查询Value操作时，fieldName参数不能为空！");
}
Select(fieldName);
QueueManger.SqlQuery <TEntity>(Queue).GetValue();
return(QueueManger.ExecuteQuery(Queue, defValue));
}
//本地接收
private void button3_Click(object sender, EventArgs e)
{
string queuePath = txtBDUrl.Text.Trim();
List <string> list = QueueManger.GetAllMessage <string>(queuePath);
for (int i = 0; i < list.Count; i++)
{
string mi = QueueManger.ReceiveMessage <string>(queuePath);
MessageBox.Show(mi);
}
}
/// <summary>
/// 删除
/// </summary>
public int Delete()
{
if (SetMap.SortDelete != null)
{
Queue.ExpBuilder.AddAssign(SetMap.SortDelete.AssignExpression);
return(Update(null));
}
// 加入队列
return(QueueManger.CommitLazy(SetMap, (queue) => Context.Executeor.Execute(queue.SqlBuilder.Delete()), false));
}
/// <summary>
/// 插入（不支持延迟加载）
/// </summary>
/// <param name="entity">实体类</param>
/// <param name="identity">返回新增的</param>
public TEntity Insert(TEntity entity, out int identity)
{
if (entity == null)
{
throw new ArgumentNullException("entity", "插入操作时，参数不能为空！");
}
QueueManger.SqlOper <TEntity>(Queue).InsertIdentity(entity);
identity = QueueManger.ExecuteQuery <int>(Queue);
return(entity);
}
//远程接收
private void button2_Click(object sender, EventArgs e)
{
try
{
string strMes = QueueManger.ReceiveMessage <string>(txtURL.Text.Trim());
txtResponse.Text = strMes;
}
catch (Exception ex)
{
MessageBox.Show("发生异常:" + ex.Message);
}
}
//http://www.cnblogs.com/lori/archive/2012/02/10/2345203.html
static void Main(string[] args)
{
string queuePath = AppConfig.QueuePath;
//QueueManger.GetAllMessage<List<LogInfo>>(queuePath);
while (1 == 1)
{
LogInfo loginfo = QueueManger.ReceiveMessage <LogInfo>(queuePath);
if (loginfo != null)
{
Console.WriteLine("ID:" + loginfo.ID + " 内容：" + loginfo.Info + " 时间:" + loginfo.CreateDate);
}
}
}
/// <summary>
/// 删除（支持延迟加载）
/// </summary>
public void Delete()
{
// 判断是否启用合并提交
if (_context.IsMergeCommand)
{
Queue.LazyAct = (queryQueue) => QueueManger.SqlOper <TEntity>(queryQueue).Delete();
QueueManger.Append();
}
else
{
QueueManger.SqlOper <TEntity>(Queue).Delete();
QueueManger.Execute(Queue);
}
}
/// <summary> 查询多条记录（不支持延迟加载） </summary>
/// <param name="pageSize">每页显示数量</param>
/// <param name="pageIndex">分页索引</param>
/// <param name="isDistinct">返回当前条件下非重复数据</param>
/// <returns></returns>
public virtual DataTable ToTable(int pageSize, int pageIndex, bool isDistinct = false)
{
#region 计算总页数
if (pageIndex < 1)
{
pageIndex = 1;
}
if (pageSize < 0)
{
pageSize = 20;
}
#endregion
return(QueueManger.Commit(SetMap, (queue) => Context.Executeor.ToTable(queue.SqlBuilder.ToList(pageSize, pageIndex, isDistinct)), true));
}
//远程发送
private void button1_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtRequest.Text.Trim()))
{
MessageBox.Show("请先输入传入参数！！");
return;
}
try
{
bool isPass = QueueManger.SendMessage <string>(txtRequest.Text.Trim(), txtURL.Text.Trim());
MessageBox.Show("发送状态:" + isPass);
}
catch (Exception ex)
{
MessageBox.Show("发生异常:" + ex.Message);
}
}
/// <summary>
/// 添加或者减少某个字段（支持延迟加载）
/// </summary>
public void AddUp()
{
if (Queue.ExpAssign == null)
{
throw new ArgumentNullException("ExpAssign", "+=字段操作时，必须先执行AddUp的另一个重载版本！");
}
// 判断是否启用合并提交
if (_context.IsMergeCommand)
{
Queue.LazyAct = (queryQueue) => QueueManger.SqlOper <TEntity>(queryQueue).AddUp();
QueueManger.Append();
}
else
{
QueueManger.SqlOper <TEntity>(Queue).AddUp();
QueueManger.Execute(Queue);
}
}
/// <summary>
/// 插入（支持延迟加载）
/// </summary>
/// <param name="entity"></param>
public TEntity Insert(TEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity", "插入操作时，参数不能为空！");
}
// 判断是否启用合并提交
if (_context.IsMergeCommand)
{
Queue.LazyAct = (queryQueue) => QueueManger.SqlOper <TEntity>(queryQueue).Insert(entity);
QueueManger.Append();
}
else
{
QueueManger.SqlOper <TEntity>(Queue).Insert(entity);
QueueManger.Execute(Queue);
}
return(entity);
}
/// <summary>
/// 插入
/// </summary>
/// <param name="lst">实体类</param>
public int Insert(List <TEntity> lst)
{
Check.NotNull(lst, "插入操作时，lst参数不能为空！");
// 如果是MSSQLSER，则启用BulkCopy
if (Context.Executeor.DataBase.DataType == eumDbType.SqlServer)
{
QueueManger.Commit(SetMap, (queue) =>
{
Context.Executeor.DataBase.ExecuteSqlBulkCopy(SetMap.Name, lst.ToTable());
return(lst.Count);
}, false);
}
else
{
lst.ForEach(entity => Insert(entity));
}
return(lst.Count);
}
//发送邮件(含事务)
private void btnSWSend_Click(object sender, EventArgs e)
{
MailInfo mi = new MailInfo();
mi.StmpServer = txtSMTP.Text.Trim();
mi.SendAddress = txtFJRDZ.Text.Trim();
mi.SendPwd = txtFJRMM.Text.Trim();
mi.ReceiveAddress = txtSJRDZ.Text.Trim();
mi.Title = txtYJZT.Text.Trim();
mi.Content = txtYJZW.Text.Trim();
if (mi != null)
{
string queuePath = AppConfig.QueuePathTran;
bool isPass = QueueManger.Createqueue(queuePath, true);//创建事务队列
if (isPass == true)
{
MessageQueueTransaction myTran = new MessageQueueTransaction();
try
{
myTran.Begin();
isPass = QueueManger.SendMessage <MailInfo>(mi, queuePath, MessagePriority.Highest, myTran);//发送消息到队列
//QueueManger.SendMessage<MailInfo>(mi, queuePath, MessagePriority.Highest, myTran);//发送消息到队列
if (isPass == true)
{
myTran.Commit();
MessageBox.Show("成功");
}
else
{
myTran.Abort();
MessageBox.Show("失败");
}
}
catch (Exception ex)
{
myTran.Abort();
MessageBox.Show("失败原因:" + ex.Message);
}
}
}
}
/// <summary>
/// 插入
/// </summary>
/// <param name="lst">实体类</param>
public async Task <int> InsertAsync(List <TEntity> lst)
{
Check.NotNull(lst, "插入操作时，lst参数不能为空！");
// 如果是MSSQLSER，则启用BulkCopy
if (Context.Executeor.DataBase.DataType == eumDbType.SqlServer)
{
return(await QueueManger.CommitAsync(SetMap, async (queue) =>
{
await Context.Executeor.DataBase.ExecuteSqlBulkCopyAsync(SetMap.Name, lst.ToTable());
return lst.Count;
}, false));
}
foreach (var entity in lst)
{
await InsertAsync(entity);
}
return(lst.Count);
}
/// <summary>
/// 插入（不支持延迟加载）
/// </summary>
/// <param name="lst"></param>
public List <TEntity> Insert(List <TEntity> lst)
{
if (lst == null)
{
throw new ArgumentNullException("lst", "插入操作时，lst参数不能为空！");
}
// 如果是MSSQLSER，则启用BulkCopy
if (QueueManger.DataBase.DataType == Data.DataBaseType.SqlServer)
{
QueueManger.DataBase.ExecuteSqlBulkCopy(_name, lst.ToTable());
return(lst);
}
lst.ForEach(entity =>
{
QueueManger.SqlOper <TEntity>(Queue).Insert(entity);
QueueManger.Execute(Queue);
});
return(lst);
}
/// <summary>
/// 插入
/// </summary>
/// <param name="entity"></param>
/// <param name="isReturnLastID">是否需要返回标识字段（如果设置的话）</param>
public int Insert(TEntity entity, bool isReturnLastID = false)
{
Check.NotNull(entity, "插入操作时，参数不能为空！");
// 实体类的赋值，转成表达式树
Queue.ExpBuilder.AssignInsert(entity);
// 需要返回值时，则不允许延迟提交
if (isReturnLastID && SetMap.PhysicsMap.DbGeneratedFields.Key != null)
{
// 赋值标识字段
return(QueueManger.Commit(SetMap, (queue) =>
{
PropertySetCacheManger.Cache(SetMap.PhysicsMap.DbGeneratedFields.Key, entity, Context.Executeor.GetValue <int>(queue.SqlBuilder.InsertIdentity()));
return 1;
}, false));
}
// 不返回标识字段
return(QueueManger.CommitLazy(SetMap, (queue) => Context.Executeor.Execute(queue.SqlBuilder.Insert()), false));
}
/// <summary>
/// 插入
/// </summary>
/// <param name="entity"></param>
/// <param name="isReturnLastID">是否需要返回标识字段（如果设置的话）</param>
public Task <int> InsertAsync(TEntity entity, bool isReturnLastID = false)
{
Check.NotNull(entity, "插入操作时，参数不能为空！");
// 实体类的赋值，转成表达式树
Queue.ExpBuilder.AssignInsert(entity);
// 需要返回值时，则不允许延迟提交
if (isReturnLastID && SetMap.PhysicsMap.DbGeneratedFields.Key != null)
{
// 赋值标识字段
return(QueueManger.CommitAsync(SetMap, async(queue) =>
{
var sourceValue = await Context.Executeor.GetValueAsync <object>(queue.SqlBuilder.InsertIdentity());
PropertySetCacheManger.Cache(SetMap.PhysicsMap.DbGeneratedFields.Key, entity, ConvertHelper.ConvertType(sourceValue, SetMap.PhysicsMap.DbGeneratedFields.Key.PropertyType));
return 1;
}, false));
}
// 不返回标识字段
return(QueueManger.CommitAsync(SetMap, (queue) => Context.Executeor.ExecuteAsync(queue.SqlBuilder.Insert()), false));
}
private void btnSend_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(txtInfo.Text.Trim()))
{
MessageBox.Show("请输入发送日志内容");
return;
}
try
{
string queuePath = txtUrl.Text.Trim();
LogInfo loginfo = new LogInfo();
loginfo.ID = Guid.NewGuid().ToString();
loginfo.Info = txtInfo.Text.Trim();
loginfo.CreateDate = DateTime.Now;
bool isPass = QueueManger.SendMessage <LogInfo>(loginfo, queuePath);
MessageBox.Show("发送状态:" + isPass);
}
catch (Exception ex)
{
MessageBox.Show("发生异常:" + ex.Message);
}
}
/// <summary>
/// 保存修改
/// IsMergeCommand=true时：只提交一次SQL到数据库
/// </summary>
/// <param name="isOlation">默认启用事务操作</param>
public int SaveChanges(bool isOlation = true)
{
// 开启或关闭事务
if (isOlation)
{
QueueManger.DataBase.OpenTran(IsolationLevel.Serializable);
}
else
{
QueueManger.DataBase.CloseTran();
}
var result = QueueManger.Commit();
// 如果开启了事务，则关闭
if (isOlation)
{
QueueManger.DataBase.Commit();
QueueManger.DataBase.CloseTran();
}
return(result);
}
/// <summary>
/// 初始化数据库环境、实例化子类中，所有Set属性
/// </summary>
public void Initializer()
{
if (IsInitializer) { return; }
// 数据库提供者
DbProvider = AbsDbProvider.CreateInstance(ContextConnection.DbType, ContextConnection.DataVer);
// 默认SQL执行者
Executeor = new ExecuteSql(new DbExecutor(ContextConnection.ConnectionString, ContextConnection.DbType, ContextConnection.CommandTimeout, !IsUnitOfWork && DbProvider.IsSupportTransaction ? IsolationLevel.RepeatableRead : IsolationLevel.Unspecified), this);
// 代理SQL记录
if (SystemConfigs.ConfigEntity.IsWriteSqlRunLog) { Executeor = new ExecuteSqlLogProxy(Executeor); }
// 代理异常记录
if (SystemConfigs.ConfigEntity.IsWriteSqlErrorLog) { Executeor = new ExecuteSqlExceptionLogProxy(Executeor); }
// 队列管理者
QueueManger = new QueueManger(this);
// 手动编写SQL
ManualSql = new ManualSql(this);
// 上下文映射关系
this.ContextMap = new ContextDataMap(ContextType);
IsInitializer = true;
}
/// <summary>
/// 初始化数据库环境、实例化子类中，所有Set属性
/// </summary>
public void Initializer()
{
if (IsInitializer) { return; }
// 默认SQL执行者
Executeor = new ExecuteSql(new DbExecutor(_contextConnection.ConnectionString, _contextConnection.DbType, _contextConnection.CommandTimeout, IsMergeCommand ? IsolationLevel.Serializable : IsolationLevel.Unspecified), this);
// 代理SQL记录
if (SystemConfigs.ConfigEntity.IsWriteDbLog) { Executeor = new ExecuteSqlLogProxy(Executeor); }
// 代理异常记录
if (SystemConfigs.ConfigEntity.IsWriteDbExceptionLog) { Executeor = new ExecuteSqlExceptionLogProxy(Executeor); }
// 数据库提供者
DbProvider = AbsDbProvider.CreateInstance(Executeor.DataBase.DataType, _contextConnection.DataVer);
// 队列管理者
QueueManger = new QueueManger(this);
// 手动编写SQL
ManualSql = new ManualSql(this);
// 上下文映射关系
this.ContextMap = new ContextDataMap(ContextType);
IsInitializer = true;
}