System.Net.WebRequest类，是通过HTTP协议与Web服务器进行交互的实现。 开发工具：VS2012，控制台应用程序 以下通过实例代码进行讲解，先不使用代理进行GET和POST调用；然后通过指定代理、本地IE代理进行GET和POST调用，循序渐进的学习。 GET和POST调用实现类： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 […]
View DetailsThread (ParameterizedThreadStart) 初始化 Thread 类的新实例，指定允许对象在线程启动时传递给线程的委托。 Thread (ThreadStart) 初始化 Thread 类的新实例。 由 .NET Compact Framework 支持。 Thread (ParameterizedThreadStart, Int32) 初始化 Thread 类的新实例，指定允许对象在线程启动时传递给线程的委托，并指定线程的最大堆栈大小。 Thread (ThreadStart, Int32) 初始化 Thread 类的新实例，指定线程的最大堆栈大小。 由 .NET Compact Framework 支持。 我们如果定义不带参数的线程，可以用ThreadStart,带一个参数的用ParameterizedThreadStart。带多个参数的用另外的方法，下面逐一讲述。 一、不带参数的 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 using System; using System.Collections.Generic; using System.Text; using System.Threading; namespace AAAAAA { class AAA { public static void Main() { Thread t = new Thread(new ThreadStart(A)); t.Start(); Console.Read(); } private static void A() { Console.WriteLine("Method A!"); } } } 结果显示Method A! 二、带一个参数的 由于ParameterizedThreadStart要求参数类型必须为object,所以定义的方法B形参类型必须为object。 1 […]
View Details有人会说：IP验证是在TCP层完成的，不是HTTP层完成的，如果伪造IP的话可能连TCP的三次握手都完不成。我这里说的不是完全意义的伪造。如果你使用透明代理上网，那么在透明代理发送给服务器端的HTTP请求中会包含x-forward-for信息。例如：X-Forwarded-For: 162.150.10.16 那么我们只要在发给服务器端的http请求中加入X-Forwarded-For: 162.150.10.16信息即可。 例如下边一个请求: GET http://www.ahjinzhai.gov.cn/sdyxnx/vote.php?id=1 HTTP/1.1 Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */* Referer: http://www.ahjinzhai.gov.cn/sdyxnx/ Accept-Language: zh-cn Accept-Encoding: gzip, deflate User-Agent: Mozilla/4.0 (compatible; MSIE 5.0; Windows 98; DigExt; TencentTraveler ) Host: www.ahjinzhai.gov.cn Cookie: PHPSESSID=1847fc15020bc16b47ce250f457daab4 Cache-Control: no-cache X-Forwarded-For: 162.150.10.16 Pragma: no-cache from:https://www.cnblogs.com/sanler/p/7248952.html
View Details验证视图状态 MAC 失败。如果此应用程序由网络场或群集承载，请确保 <machineKey> 配置指定了相同的 validationKey 和验证算法。不能在群集中使用 AutoGenerate。 说明: 执行当前 Web 请求期间，出现未处理的异常。请检查堆栈跟踪信息，以了解有关该错误以及代码中导致错误的出处的详细信息。 异常详细信息: System.Web.HttpException: 验证视图状态 MAC 失败。如果此应用程序由网络场或群集承载，请确保 <machineKey> 配置指定了相同的 validationKey 和验证算法。不能在群集中使用 AutoGenerate。 分析： 分析后找到了问题的根源。首先，文章中提到，如果用GridView，并且指定了DataKeyNames属性，则出于安全的理由（因为DataKeyNames指定的字段代表数据的主键，且该主键值需要保存在视图状态中发送到客户端，用户如果篡改主键值，会导致安全问题），GridView会要求加密视图状态。为此会自动在页面表单</forms>之前添加一个
|
1 |
<input type="hidden" name="__VIEWSTATEENCRYPTED" id="__VIEWSTATEENCRYPTED" value="" /> |
。 然而，Atlas的UpdatePanel要求放置在<form></form>内部，也就是</form>之前。这就意味着添加的隐藏input控件没有被放置在UpdatePanel内，而是放置在UpdatePanel和</form>之间。 当UpdatePanel更新时，UpdatePanel内部的控件被提交到服务器进行处理（Patrial Rendering），而整个页面并没有被提交。也就是说隐藏的input控件没有随着一起提交。因此服务器并不知道提交的ViewState被加密了，从而导致MAC验证错误。 解决方法有二，仅供参考： 1.可以在当前页面的<page …>里加两个属性： enableEventValidation="false" viewStateEncryptionMode ="Never" 2.当然还可以在web.config里加入：（<system.web>之间）
|
1 |
<pages enableEventValidation="false" viewStateEncryptionMode ="Never" /> |
其余方法 在web.config中的pages节点上添加enableviewstatemac=false 附带： 一般而言是因为你的某些操作修改了视图状态，我猜测你可能使用了ajax并在客户端用javascript动态添加了某些项 1. 在出错页面的 <%@ page %>中加enableviewstatemac="false"无效。 2. 在web.config的 <system.web>节中加
|
1 |
<machineKey validationKey="3FF1E929BC0534950B0920A7B59FA698BD02DFE8" decryptionKey="280450BB36319B474C996B506A95AEDF9B51211B1D2B7A77" decryption="3DES" validation="SHA1"/> |
我的问题是加入：
|
1 |
<machineKey validationKey="d41d8cd98f00b204e9800998ecf8427e0e5798a7e2c46b2fd4f0277bceaf08e1" validation="SHA1"/> |
解决 最重要的是检查自己的页面，很可能是你的页面中的问题，多注意下，肯定能发现问题，而这个问题并没有报出你想要的错误 ！！！ 所以，不一定所有的解决方案都适合你！！！ from:https://www.cnblogs.com/Setme/archive/2012/06/05/2537084.html
View Detailsstring aFirstName = aFile.Substring(aFile.LastIndexOf("\\") + 1, (aFile.LastIndexOf(".") – aFile.LastIndexOf("\\") – 1)); //文件名 string aLastName = aFile.Substring(aFile.LastIndexOf(".") + 1, (aFile.Length – aFile.LastIndexOf(".") – 1)); //扩展名 string strFilePaht="文件路径"; Path.GetFileNameWithoutExtension(strFilePath);这个就是获取文件名的 还有的就是用Substring截取 strFilePaht.Substring(path.LastIndexOf("\\") + 1, path.Length – 1 – path.LastIndexOf("\\")); strFilePaht.Substring(path.LastIndexOf("."), path.Length – path.LastIndexOf(".")); 或者用openFileDialog1.SafeFileName 这样就能取到该文件的所在目录路径 string path1 = System.IO.Path.GetDirectoryName(openFileDialog1.FileName) + @"\"; string path = Path.GetFileName("C:\My Document\path\image.jpg"); //只获取文件名image.jpg ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// string fullPath = @"\WebSite1\Default.aspx"; string filename = System.IO.Path.GetFileName(fullPath);//文件名 “Default.aspx” string extension = System.IO.Path.GetExtension(fullPath);//扩展名 “.aspx” string fileNameWithoutExtension = System.IO.Path.GetFileNameWithoutExtension(fullPath);// 没有扩展名的文件名 “Default” ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// System.IO.Path.GetFileNam(filePath) //返回带扩展名的文件名 System.IO.Path.GetFileNameWithoutExtension(filePath) //返回不带扩展名的文件名 System.IO.Path.GetDirectoryName(filePath) //返回文件所在目录 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //获取当前进程的完整路径，包含文件名(进程名)。 string str = this.GetType().Assembly.Location; […]
View Details简述 适用特性 使用Dapper流程 代码示例 简述 Dapper是一个轻量级的ORM工具:ORM框架的核心思想是对象关系映射，ORM是将表与表之间的操作，映射成对象和对象之间的操作，就是通过操作实体类来达到操作表的目的。从数据库提取的数据会自动按你设置的映射要求封装成特定的对象。之后你就可以通过对对象进行操作来修改数据库中的数据。这时候你面对的不是信息的碎片，而是一个形象鲜明的对象。 ORM 框架很多: Dapper、 Mybatis.Net、EntityFramework 和 NHibernate。如果你在小的项目中，使用Entity Framework、NHibernate 来处理大数据访问及关系映射，未免有点杀鸡用牛刀。而Mybatis.Net需要配置XML文件，综合考虑你会觉得觉得ORM省时省力。 适用特性 1、Dapper是一个轻型的ORM类。代码就一个SqlMapper.cs文件，编译后就70K。 2、Dapper很快。Dapper的速度接近与IDataReader，取列表的数据超过了DataTable。 3、Dapper支持多数据库。Dapper支持Mysql,SqlLite,SqlServer,Oracle等一系列的数据库。 4、Dapper支持多表并联的对象。支持一对多 多对多的关系。并且没侵入性，想用就用，不想用就不用。无XML无属性。代码以前怎么写现在还怎么写。 5、Dapper原理通过Emit反射IDataReader的序列队列，来快速的得到和产生对象。性能很高(性能和原生ado.net相近)。 6、Dapper支持net2.0,3.0,3.5,4.0。【如果想在Net2.0下使用，可以去网上找一下Net2.0下如何配置运行Net3.5即可。】 7、Dapper语法十分简单,快捷添加到项目，容易上手。并且无须迁就数据库的设计。 适用Dapper流程 流程一： 通过NuGet程序包进行Dapper安装引用： 这个引用的Dapper DLL文件是对前面说的SqlMapper.cs 源文件的封装。 流程二： 我们这里用Mysql数据库，那么用到的MySql.Data.dll在官网下载.net驱动包（已经附加在此教程demo中） mysql .net连接驱动下载地址：http://dev.mysql.com/downloads/connector/net/ 示例代码 1、定义一个Person类对应数据库的Person表
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
CREATE TABLE person ( idint(11) NOT NULL AUTO_INCREMENT, usernamevarchar(255) NOT NULL, passwordvarchar(20) NOT NULL, ageint(11) DEFAULT NULL, registerDatedatetime DEFAULT NULL, addressvarchar(255) DEFAULT NULL, PRIMARY KEY (id) ); //Person类 publicclassPerson { publicint id { get; set; } publicstring username { get; set; } publicstring password { get; set; } publicint age { get; set; } publicDateTimeregisterDate { get; set; } publicstring address { set; get; } } |
2、定义连接数据库字符串
|
1 2 3 4 |
public static string ConnString = "server=localhost;port=3306;user id=root;password=123456;database=test"; //SQL Server public static string ConnString = "server=localhost;user id=sa;password=123456;database=Dormitory"; |
3、 新增、修改、删除的 Execute 方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
public static int Execute(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null, int? commandTimeout = null, CommandType? commandType = null); //新增 var conn = MySqlDBHelper.CreateMySqlConnection(); try { var result = conn.Execute("Insert into Person(username,password,age,registerDate,address) values (@username,@password,@age,@registerDate,@address)", new { username = txtUserName.Text, password = txtPassword.Text, age = numAge.Value, registerDate = dptRegisterDate.Value, address = txtAddress.Text }); if (result > 0) { MessageBox.Show("添加成功！"); LoadDBInfoToDgvFirst(); } } catch (Exception ex) { throw ex; } finally { if (conn.State == System.Data.ConnectionState.Open) { conn.Close(); } } |
批量新增 和新增一条语句是一样的，后面的param 是object 对象,单个模型数据和集合都可以支持。执行上面方法会插入多条记录，这样sql可以灵活的控制，参数不用像ADO.Net那样声明每个参数，最后还要把参数集合赋值给ADO的命令。可以看出这样简洁多了。 4、 查询的Query 方法
|
1 2 3 |
public static IEnumerable<T> Query<T>(this IDbConnection cnn, string sql, object param = null, IDbTransaction transaction = null, bool buffered = true, int? commandTimeout = null, CommandType? commandType = null); 实际运用： var result = conn.Query<Person>("select * from Person order by id desc limit @indx", new { indx = num }); |
5、存储过程调用
|
1 2 3 4 5 6 7 8 |
var param = new DynamicParameters(); param.Add("@idIn", numUpdateId.Value, DbType.Int32, ParameterDirection.Input); param.Add("@Inusername", txtUserName.Text, DbType.String, ParameterDirection.Input); param.Add("@res", 0, DbType.Int32, ParameterDirection.Output); var res2 = conn.Execute("prUpdatePersion", param, null, null, CommandType.StoredProcedure); int res = param.Get<Int32>("@res"); |
6、多个数据库插入数据
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
private void button4_Click(object sender, EventArgs e) { MySqlConnection mySqlConn = MySqlDBHelper.CreateMySqlConnection(); MySqlTransaction tranMySql = mySqlConn.BeginTransaction(); SqlConnection SqlServerConn = SqlServerDBHelper.CreateSqlServerConnection(); SqlTransaction tranSqlServer = SqlServerConn.BeginTransaction(); try { var persion = new Person { username = txtUserName.Text, password = txtPassword.Text, age = numAge.Value, registerDate = dptRegisterDate.Value, address = txtAddress.Text }; int result = mySqlConn.Execute("Insert into Person(username,password,age,registerDate,address) values (@username,@password,@age,@registerDate,@address)", persion, tranMySql); persion.username += "Sqlserver"; result = SqlServerConn.Execute("Insert into Person(username,password,age,registerDate,address) values (@username,@password,@age,@registerDate,@address)", persion, tranSqlServer); MessageBox.Show("添加成功！"); tranMySql.Commit(); tranSqlServer.Commit(); } catch (Exception ex) { tranMySql.Rollback(); tranSqlServer.Rollback(); throw ex; } finally { if (mySqlConn.State == System.Data.ConnectionState.Open) { mySqlConn.Close(); } if (SqlServerConn.State == System.Data.ConnectionState.Open) { SqlServerConn.Close(); } tranSqlServer.Dispose(); tranMySql.Dispose(); } tabControl.SelectedTab = tabPage2; //加载信息 LoadDBInfoToDoubleDgvFirst(); } |
通过上面的代码演示主要常用的是：封装后 Query 方法、Excute 方法。（其底层的封装的方法可以见源码：513 from:https://blog.csdn.net/laokang426/article/details/77885137
View Details项目右键 Manage NuGet Packages for Solution 搜索Dapper -> Install
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 |
using System; using System.Collections.Generic; using System.Configuration; using System.Data; using System.Data.SqlClient; using System.Linq; namespace Dapper.Repository { public class DapperDemo { public static string ConnectionString { get { string _connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString(); return _connectionString; } } public SqlConnection OpenConnection() { SqlConnection connection = new SqlConnection(ConnectionString); connection.Open(); return connection; } /// <summary> /// 添加 /// </summary> /// <returns></returns> public bool Add() { int row = 0; ED_Data model = new ED_Data(); model.TableName = "123"; model.DataKey = "123"; model.FieldName = "123"; model.Value = "123"; model.Reference = "123"; model.Branch = 1; model.InActive = false; model.Updated = DateTime.Now; string query = "INSERT INTO ED_Data(TableName,DataKey,FieldName,Value,Reference,Branch,InActive,Updated) VALUES (@TableName,@DataKey,@FieldName,@Value,@Reference,@Branch,@InActive,@Updated)"; using (IDbConnection conn = OpenConnection()) { row = conn.Execute(query, model); } if (row > 0) return true; else return false; } /// <summary> /// 修改 /// </summary> /// <returns></returns> public int Update() { int row = 0; ED_Data model = new ED_Data(); model.TableName = "123"; model.DataKey = "123"; model.Updated = DateTime.Now; using (IDbConnection conn = OpenConnection()) { const string query = "UPDATE ED_Data SET DataKey=@DataKey,Updated=@Updated WHERE TableName=@TableName"; row = conn.Execute(query, model); } return row; } /// <summary> /// 删除 /// </summary> /// <returns></returns> public int Delete() { int row = 0; ED_Data model = new ED_Data(); model.TableName = "123"; using (IDbConnection conn = OpenConnection()) { const string query = "DELETE FROM ED_Data WHERE TableName=@TableName"; row = conn.Execute(query, model); } return row; } /// <summary> /// 查询一条数据 /// </summary> /// <param name="columnCatId"></param> /// <returns>ED_Data</returns> public ED_Data GetModel(string TableName) { using (IDbConnection conn = OpenConnection()) { const string query = "SELECT * FROM ED_Data WHERE TableName = @TableName"; return conn.Query<ED_Data>(query, new { tableName = TableName }).SingleOrDefault<ED_Data>(); } } /// <summary> /// 查询list集合 /// </summary> /// <returns>List</returns> public List<ED_Data> GetED_DataList() { using (IDbConnection conn = OpenConnection()) { const string query = "SELECT * FROM ED_Data"; return conn.Query<ED_Data>(query, null).ToList(); } } /// <summary> /// 事务处理 /// 删除 /// </summary> /// <param name="cat"></param> /// <returns></returns> public int DeleteColumnCatAndColumn(ED_Data cat) { try { using (IDbConnection conn = OpenConnection()) { string delete1 = "DELETE FROM ED_Data WHERE TableName=@TableName"; string delete2 = "DELETE FROM ED_Data WHERE TableName=@TableName"; IDbTransaction transaction = conn.BeginTransaction(); int row = conn.Execute(delete1, new { TableName = cat.TableName }, transaction, null, null); row += conn.Execute(delete2, new { TableName = cat.TableName }, transaction, null, null); transaction.Commit(); return row; } } catch (Exception) { throw; } } /// <summary> /// 执行存储过程 /// </summary> public void ExecuteStoredProcedure() { try { DynamicParameters para = new DynamicParameters(); para.Add("@param1", 1); para.Add("@param2", 2); using (IDbConnection conn = OpenConnection()) { int row = conn.Execute("存储过程名称", para, null, null, CommandType.StoredProcedure); } } catch (Exception) { throw; } } /// <summary> /// 批量添加 /// </summary> public void InsertBatch() { try { string sqlStr = "INSERT INTO ED_Data(TableName,DataKey,FieldName,Value,Reference,Branch,InActive,Updated) VALUES (@TableName,@DataKey,@FieldName,@Value,@Reference,@Branch,@InActive,@Updated)"; using (IDbConnection conn = OpenConnection()) { conn.Execute(sqlStr, new[] { new { TableName = "user1", DataKey = "a", FieldName = "name", Value = "000001", Reference = "", Branch = "", InActive = "", Updated = DateTime.Now }, new { TableName = "user2", DataKey = "b", FieldName = "age", Value = "000002", Reference = "", Branch= "", InActive = "", Updated = DateTime.Now }, new { TableName = "user3", DataKey = "c", FieldName = "phone", Value = "000003", Reference= "", Branch= "", InActive= "", Updated= DateTime.Now }, }, null, null, null); } } catch (Exception) { throw; } } } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
using System; using System.Collections.Generic; using System.Configuration; using System.Data; using System.Data.SqlClient; using System.Linq; namespace Dapper.Repository { public class ED_Data { public string TableName { get; set; } public string DataKey { get; set; } public string FieldName { get; set; } public string Value { get; set; } public string Reference { get; set; } public int Branch { get; set; } public bool InActive { get; set; } public DateTime Updated { get; set; } } } |
Base基类
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 |
using Dapper.CoreLibrary; using Dapper.Entity; using System; using System.Collections.Generic; using System.Data; using System.Linq; using System.Reflection; using System.Text; using System.Transactions; namespace Dapper.Repository { public abstract class RepositoryBase<T> : DbConnectionFactory, IRepositoryBase<T> where T : IEntityBase<T> { public RepositoryBase(IDbConnection db) : base(db) { } /// <summary> /// /// </summary> /// <param name="model"></param> /// <returns></returns> public virtual int Add(T model) { int result = 0; try { var ps = model.GetType().GetProperties(); List<string> @colms = new List<string>(); List<string> @params = new List<string>(); foreach (var p in ps) { if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)) && !p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute))) { @colms.Add(string.Format("[{0}]", p.Name)); @params.Add(string.Format("@{0}", p.Name)); } } var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2}); SELECT @@IDENTITY;", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params)); result = _conn.ExecuteScalar<int>(sql, model); } catch (Exception ex) { throw; } return result; } /// <summary> /// /// </summary> /// <param name="listModel"></param> public virtual void Add(List<T> listModel) { try { using (var scope = new TransactionScope()) { listModel.ForEach(model => { var ps = model.GetType().GetProperties(); List<string> @colms = new List<string>(); List<string> @params = new List<string>(); foreach (var p in ps) { if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)) && !p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute))) { @colms.Add(string.Format("[{0}]", p.Name)); @params.Add(string.Format("@{0}", p.Name)); } } var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2}); SELECT @@IDENTITY;", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params)); _conn.ExecuteScalar<int>(sql, model); }); scope.Complete(); } } catch (Exception ex) { } } /// <summary> /// /// </summary> /// <param name="model"></param> /// <returns></returns> public virtual int AddWithGuid(T model) { int result = 0; try { var ps = model.GetType().GetProperties(); List<string> @colms = new List<string>(); List<string> @params = new List<string>(); foreach (var p in ps) { if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute))) { @colms.Add(string.Format("[{0}]", p.Name)); @params.Add(string.Format("@{0}", p.Name)); } } var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2});", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params)); result = _conn.Execute(sql, model); } catch (Exception ex) { throw; } return result; } /// <summary> /// /// </summary> /// <param name="model"></param> public virtual void Update(T model) { PropertyInfo pkInfo = null; var ps = model.GetType().GetProperties(); List<string> @params = new List<string>(); foreach (var p in ps) { if (p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute))) { continue; } if (p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute))) { pkInfo = p; } else { @params.Add(string.Format("[{0}]=@{0}", p.Name)); } } var sql = string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = @{2}", typeof(T).Name, string.Join(", ", @params), pkInfo.Name); _conn.Execute(sql, model); } /// <summary> /// /// </summary> /// <param name="listModel"></param> public virtual void Update(List<T> listModel) { using (var scope = new TransactionScope()) { listModel.ForEach(model => { PropertyInfo pkInfo = null; var ps = model.GetType().GetProperties(); List<string> @params = new List<string>(); foreach (var p in ps) { if (p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute))) { continue; } if (p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute))) { pkInfo = p; } else { @params.Add(string.Format("[{0}] = @{0}", p.Name)); } } var sql = string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = @{2}", typeof(T).Name, string.Join(", ", @params), pkInfo.Name); _conn.Execute(sql, model); }); scope.Complete(); } } /// <summary> /// /// </summary> /// <param name="primaryValue">主键ID</param> /// <param name="tableName">表名</param> /// <returns></returns> public virtual T GetModel(string primaryValue, string tableName = "") { try { string primaryWhere = string.Empty; var ps = typeof(T).GetProperties(); if (string.IsNullOrEmpty(tableName)) { tableName = typeof(T).Name; } var primary = ps.Single(p => p.CustomAttributes.FirstOrDefault(c => c.AttributeType == typeof(PrimaryKeyAttribute)) != null); primaryWhere = (string.Format("[{0}] = @primarykey", primary.Name)); var sql = string.Format("SELECT * FROM [{0}] WHERE {1}", tableName, primaryWhere); return _conn.Query<T>(sql, new { primarykey = primaryValue }).FirstOrDefault(); } catch (Exception) { throw; } } /// <summary> /// /// </summary> /// <param name="strWhere">where条件</param> /// <param name="tableName">表名</param> /// <returns></returns> public virtual T GetModelQuery(string strWhere, string tableName = "") { try { var sql = string.Format("SELECT * FROM [{0}] WHERE {1}", tableName, strWhere); return _conn.Query<T>(sql, new { where = strWhere }).FirstOrDefault(); } catch (Exception) { throw; } } /// <summary> /// 根据主键删除 /// </summary> /// <param name="primaryValue"></param> public virtual void Delete(string primaryValue) { try { string primaryWhere = string.Empty; var ps = typeof(T).GetProperties(); var primary = ps.Single(p => p.CustomAttributes.FirstOrDefault(c => c.AttributeType == typeof(PrimaryKeyAttribute)) != null); var sql = string.Format("DELETE FROM [{0}] WHERE {1} = @primarykey", typeof(T).Name, primary.Name); _conn.Execute(sql, new { primarykey = primaryValue }); } catch (Exception) { throw; } } /// <summary> /// /// </summary> /// <param name="strWhere"></param> public void DeleteStrWhere(string strWhere) { try { var sql = string.Format("DELETE FROM [{0}] WHERE {1}", typeof(T).Name, strWhere); _conn.Execute(sql); } catch (Exception) { throw; } } /// <summary> /// /// </summary> /// <param name="strWhere"></param> /// <param name="tableName"></param> /// <returns></returns> public virtual List<T> GetList(string strWhere, string tableName = "") { try { if (string.IsNullOrEmpty(tableName)) tableName = typeof(T).Name; var sql = string.Format("SELECT * FROM [{0}] " + (strWhere == "" ? "" : " WHERE " + " {1} "), tableName, strWhere); return _conn.Query<T>(sql).ToList(); } catch (Exception) { throw; } } /// <summary> /// /// </summary> /// <param name="param"></param> /// <returns></returns> public virtual PagerListResult<List<T>> GetPageList(PagerRequestParam param) { PagerListResult<List<T>> result = null; List<T> list = new List<T>(); int pageTotal = 1; int recordTotal = 0; int startIndex = 1; int endIndex = param.PageSize; try { if (param.PageIndex - 1 > 0) { startIndex = (param.PageIndex - 1 <= 0 ? 1 : param.PageIndex - 1) * param.PageSize + 1; endIndex = param.PageIndex * param.PageSize; } if (string.IsNullOrEmpty(param.TableName)) param.TableName = typeof(T).Name; StringBuilder strSql = new StringBuilder(); strSql.Append("SELECT * FROM ( "); strSql.Append(" SELECT ROW_NUMBER() OVER ("); if (!string.IsNullOrEmpty(param.OrderBy)) { strSql.Append("ORDER BY T." + param.OrderBy); } else { strSql.Append("ORDER BY T.ID DESC"); } strSql.Append(")AS Row, T.* FROM " + param.TableName + " T "); if (!string.IsNullOrEmpty(param.StrWhere)) { strSql.Append(" WHERE " + param.StrWhere); } strSql.Append(" ) TT"); strSql.AppendFormat(" WHERE TT.Row BETWEEN {0} AND {1}", startIndex, endIndex); list = _conn.Query<T>(strSql.ToString(), param.StrWhere).ToList(); if (list.Count > 0) { recordTotal = this.GetRecordCount(param.StrWhere, param.TableName); pageTotal = PagerRequestParam.Tool.PageTotal(param); } result = new PagerListResult<List<T>>(list, pageTotal, recordTotal); } catch (Exception ex) { result = new PagerListResult<List<T>>(ex); } return result; } /// <summary> /// 事务处理 /// Demo /// </summary> /// <returns></returns> public int DeleteTransaction() { try { const string delete1 = "DELETE FROM ED_Data WHERE TableName=@TableName"; const string delete2 = "DELETE FROM ED_Data WHERE TableName=@TableName"; IDbTransaction transaction = _conn.BeginTransaction(); int row = _conn.Execute(delete1, new { TableName = "user" }, transaction, null, null); row += _conn.Execute(delete2, new { TableName = "customer" }, transaction, null, null); transaction.Commit(); return row; } catch (Exception) { throw; } } /// <summary> /// 获取记录数 /// </summary> /// <param name="strWhere">Where条件</param> /// <returns></returns> public virtual int GetRecordCount(string strWhere, string tableName = "") { int count = 0; try { if (string.IsNullOrEmpty(tableName)) tableName = typeof(T).Name; StringBuilder strSql = new StringBuilder(); strSql.Append("SELECT COUNT(1) FROM " + tableName); if (!string.IsNullOrEmpty(strWhere)) { strSql.Append(" WHERE " + strWhere); } count = _conn.ExecuteScalar<int>(strSql.ToString()); } catch (Exception) { throw; } return count; } } } |
from:https://blog.csdn.net/kingcruel/article/details/52848950
View DetailsCQRS架构简介 前不久，看到博客园一位园友写了一篇文章，其中的观点是，要想高性能，需要尽量：避开网络开销（IO），避开海量数据，避开资源争夺。对于这3点，我觉得很有道理。所以也想谈一下，CQRS架构下是如何实现高性能的。 关于CQRS（Command Query Responsibility Segration）架构，大家应该不会陌生了。简单的说，就是一个系统，从架构上把它拆分为两部分：命令处理（写请求）+查询处理（读请求）。然后读写两边可以用不同的架构实现，以实现CQ两端（即Command Side，简称C端；Query Side，简称Q端）的分别优化。CQRS作为一个读写分离思想的架构，在数据存储方面，没有做过多的约束。所以，我觉得CQRS可以有不同层次的实现，比如： CQ两端数据库共享，CQ两端只是在上层代码上分离；这种做法，带来的好处是可以让我们的代码读写分离，更好维护，且没有CQ两端的数据一致性问题，因为是共享一个数据库的。我个人认为，这种架构很实用，既兼顾了数据的强一致性，又能让代码好维护。 CQ两端数据库和上层代码都分离，然后Q的数据由C端同步过来，一般是通过Domain Event进行同步。同步方式有两种，同步或异步，如果需要CQ两端的强一致性，则需要用同步；如果能接受CQ两端数据的最终一致性，则可以使用异步。采用这种方式的架构，个人觉得，C端应该采用Event Sourcing（简称ES）模式才有意义，否则就是自己给自己找麻烦。因为这样做你会发现会出现冗余数据，同样的数据，在C端的db中有，而在Q端的db中也有。和上面第一种做法相比，我想不到什么好处。而采用ES，则所有C端的最新数据全部用Domain Event表达即可；而要查询显示用的数据，则从Q端的ReadDB（关系型数据库）查询即可。 我觉得要实现高性能，可以谈的东西还有很多。下面我想重点说说我想到的一些设计思路： 避开资源争夺 秒杀活动的例子分析 我觉得这是很重要的一点。什么是资源争夺？我想就是多个线程同时修改同一个数据。就像阿里秒杀活动一样，秒杀开抢时，很多人同时抢一个商品，导致商品的库存会被并发更新减库存，这就是一个资源争夺的例子。一般如果资源竞争不激烈，那无所谓，不会影响性能；但是如果像秒杀这种场景，那db就会抗不住了。在秒杀这种场景下，大量线程需要同时更新同一条记录，进而导致MySQL内部大量线程堆积，对服务性能、稳定性造成很大伤害。那怎么办呢？我记得阿里的丁奇写过一个分享，思路就是当MySQL的服务端多个线程同时修改一条记录时，可以对这些修改请求进行排队，然后对于InnoDB引擎层，就是串行的。这样排队后，不管上层应用发过来多少并行的修改同一行的请求，对于MySQL Server端来说，内部总是会聪明的对同一行的修改请求都排队处理；这样就能确保不会有并发产生，从而不会导致线程浪费堆积，导致数据库性能下降。这个方案可以见下图所示： 如上图所示，当很多请求都要修改A记录时，MySQL Server内部会对这些请求进行排队，然后一个个将对A的修改请求提交到InnoDB引擎层。这样看似在排队，实际上会确保MySQL Server不会死掉，可以保证对外提供稳定的TPS。 但是，对于商品秒杀这个场景，还有优化的空间，就是Group Commit技术。Group Commit就是对多个请求合并为一次操作进行处理。秒杀时，大家都在购买这个商品，A买2件，B买3件，C买1件；其实我们可以把A,B,C的这三个请求合并为一次减库存操作，就是一次性减6件。这样，对于A,B,C的这三个请求，在InnoDB层我们只需要做一次减库存操作即可。假设我们Group Commit的每一批的size是50，那就是可以将50个减操作合并为一次减操作，然后提交到InnoDB。这样，将大大提高秒杀场景下，商品减库存的TPS。但是这个Group Commit的每批大小不是越大越好，而是要根据并发量以及服务器的实际情况做测试来得到一个最优的值。通过Group Commit技术，根据丁奇的PPT，商品减库存的TPS性能从原来的1.5W提高到了8.5W。 从上面这个例子，我们可以看到阿里是如何在实际场景中，通过优化MySQL Server来实现高并发的商品减库存的。但是，这个技术一般人还真的不会！因为没多少人有能力去优化MySQL的服务端，排队也不行，更别说Group Commit了。这个功能并不是MySQL Server自带的，而是需要自己实现的。但是，这个思路我想我们都可以借鉴。 CQRS如何实现避免资源竞争 那么对于CQRS架构，如何按照这个思路来设计呢？我想重点说一下我上面提到的第二种CQRS架构。对于C端，我们的目标是尽可能的在1s内处理更多的Command，也就是数据写请求。在经典DDD的四层架构中，我们会有一个模式叫工作单元模式，即Unit of Work（简称UoW）模式。通过该模式，我们能在应用层，一次性以事务的方式将当前请求所涉及的多个对象的修改提交到DB。微软的EF实体框架的DbContext就是一个UoW模式的实现。这种做法的好处是，一个请求对多个聚合根的修改，能做到强一致性，因为是事务的。但是这种做法，实际上，没有很好的遵守避开资源竞争的原则。试想，事务A要修改a1,a2,a3三个聚合根；事务B要修改a2,a3,a4；事务C要修改a3,a4,a5三个聚合根。那这样，我们很容易理解，这三个事务只能串行执行，因为它们要修改相同的资源。比如事务A和事务B都要修改a2,a3这两个聚合根，那同一时刻，只能由一个事务能被执行。同理，事务B和事务C也是一样。如果A,B,C这种事务执行的并发很高，那数据库就会出现严重的并发冲突，甚至死锁。那要如何避免这种资源竞争呢？我觉得我们可以采取三个措施： 让一个Command总是只修改一个聚合根 这个做法其实就是缩小事务的范围，确保一个事务一次只涉及一条记录的修改。也就是做到，只有单个聚合根的修改才是事务的，让聚合根成为数据强一致性的最小单位。这样我们就能最大化的实现并行修改。但是你会问，但是我一个请求就是会涉及多个聚合根的修改的，这种情况怎么办呢？在CQRS架构中，有一个东西叫Saga。Saga是一种基于事件驱动的思想来实现业务流程的技术，通过Saga，我们可以用最终一致性的方式最终实现对多个聚合根的修改。对于一次涉及多个聚合根修改的业务场景，一般总是可以设计为一个业务流程，也就是可以定义出要先做什么后做什么。比如以银行转账的场景为例子，如果是按照传统事务的做法，那可能是先开启一个事务，然后让A账号扣减余额，再让B账号加上余额，最后提交事务；如果A账号余额不足，则直接抛出异常，同理B账号如果加上余额也遇到异常，那也抛出异常即可，事务会保证原子性以及自动回滚。也就是说，数据一致性已经由DB帮我们做掉了。 但是，如果是Saga的设计，那就不是这样了。我们会把整个转账过程定义为一个业务流程。然后，流程中会包括多个参与该流程的聚合根以及一个用于协调聚合根交互的流程管理器（ProcessManager，无状态），流程管理器负责响应流程中的每个聚合根产生的领域事件，然后根据事件发送相应的Command，从而继续驱动其他的聚合根进行操作。 转账的例子，涉及到的聚合根有：两个银行账号聚合根，一个交易（Transaction）聚合根，它用于负责存储流程的当前状态，它还会维护流程状态变更时的规则约束；然后当然还有一个流程管理器。转账开始时，我们会先创建一个Transaction聚合根，然后它产生一个TransactionStarted的事件，然后流程管理器响应事件，然后发送一个Command让A账号聚合根做减余额的操作；A账号操作完成后，产生领域事件；然后流程管理器响应事件，然后发送一个Command通知Transaction聚合根确认A账号的操作；确认完成后也会产生事件，然后流程管理器再响应，然后发送一个Command通知B账号做加上余额的操作；后续的步骤就不详细讲了。大概意思我想已经表达了。总之，通过这样的设计，我们可以通过事件驱动的方式，来完成整个业务流程。如果流程中的任何一步出现了异常，那我们可以在流程中定义补偿机制实现回退操作。或者不回退也没关系，因为Transaction聚合根记录了流程的当前状态，这样我们可以很方便的后续排查有状态没有正常结束的转账交易。具体的设计和代码，有兴趣的可以去看一下ENode源代码中的银行转账的例子，里面有完整的实现。 对修改同一个聚合根的Command进行排队 和上面秒杀的设计一样，我们可以对要同时修改同一个聚合根的Command进行排队。只不过这里的排队不是在MySQL Server端，而是在我们自己程序里做这个排队。如果我们是单台服务器处理所有的Command，那排队很容易做。就是只要在内存中，当要处理某个Command时，判断当前Command要修改的聚合根是否前面已经有Command在处理，如果有，则排队；如果没有，则直接执行。然后当这个聚合根的前一个Command执行完后，我们就能处理该聚合根的下一个Command了；但是如果是集群的情况下呢，也就是你不止有一台服务器在处理Command，而是有十台，那要怎么办呢？因为同一时刻，完全有可能有两个不同的Command在修改同一个聚合根。这个问题也简单，就是我们可以对要修改聚合根的Command根据聚合根的ID进行路由，根据聚合根的ID的hashcode，然后和当前处理Command的服务器数目取模，就能确定当前Command要被路由到哪个服务器上处理了。这样我们能确保在服务器数目不变的情况下，针对同一个聚合根实例修改的所有Command都是被路由到同一台服务器处理。然后加上我们前面在单个服务器里面内部做的排队设计，就能最终保证，对同一个聚合根的修改，同一时刻只有一个线程在进行。 通过上面这两个设计，我们可以确保C端所有的Command，都不会出现并发冲突。但是也要付出代价，那就是要接受最终一致性。比如Saga的思想，就是在最终一致性的基础上而实现的一种设计。然后，基于以上两点的这种架构的设计，我觉得最关键的是要做到：1）分布式消息队列的可靠，不能丢消息，否则Saga流程就断了；2）消息队列要高性能，支持高吞吐量；这样才能在高并发时，实现整个系统的整体的高性能。我开发的EQueue就是为了这个目标而设计的一个分布式消息队列，有兴趣的朋友可以去了解下哦。 Command和Event的幂等处理 CQRS架构是基于消息驱动的，所以我们要尽量避免消息的重复消费。否则，可能会导致某个消息被重复消费而导致最终数据无法一致。对于CQRS架构，我觉得主要考虑三个环节的消息幂等处理。 Command的幂等处理 这一点，我想不难理解。比如转账的例子中，假如A账号扣减余额的命令被重复执行了，那会导致A账号扣了两次钱。那最后就数据无法一致了。所以，我们要保证Command不能被重复执行。那怎么保证呢？想想我们平时一些判断重复的操作怎么做的？一般有两个做法：1）db对某一列建唯一索引，这样可以严格保证某一列数据的值不会重复；2）通过程序保证，比如插入前先通过select查询判断是否存在，如果不存在，则insert，否则就认为重复；显然通过第二种设计，在并发的情况下，是不能保证绝对的唯一性的。然后CQRS架构，我认为我们可以通过持久化Command的方式，然后把CommandId作为主键，确保Command不会重复。那我们是否要每次执行Command前线判断该Command是否存在呢？不用。因为出现Command重复的概率很低，一般只有是在我们服务器机器数量变动时才会出现。比如增加了一台服务器后，会影响到Command的路由，从而最终会导致某个Command会被重复处理，关于这里的细节，我这里不想多展开了，呵呵。有问题到回复里讨论吧。这个问题，我们也可以最大程度上避免，比如我们可以在某一天系统最空的时候预先增加好服务器，这样可以把出现重复消费消息的情况降至最低。自然也就最大化的避免了Command的重复执行。所以，基于这个原因，我们没有必要在每次执行一个Command时先判断该Command是否已执行。而是只要在Command执行完之后，直接持久化该Command即可，然后因为db中以CommandId为主键，所以如果出现重复，会主键重复的异常。我们只要捕获该异常，然后就知道了该Command已经存在，这就说明该Command之前已经被处理过了，那我们只要忽略该Command即可（当然实际上不能直接忽略，这里我由于篇幅问题，我就不详细展开了，具体我们可以再讨论）。然后，如果持久化没有问题，说明该Command之前没有被执行过，那就OK了。这里，还有个问题也不能忽视，就是某个Command第一次执行完成了，也持久化成功了，但是它由于某种原因没有从消息队列中删除。所以，当它下次再被执行时，Command Handler里可能会报异常，所以，健壮的做法时，我们要捕获这个异常。当出现异常时，我们要检查该Command是否之前已执行过，如果有，就要认为当前Command执行正确，然后要把之前Command产生的事件拿出来做后续的处理。这个问题有点深入了，我暂时不细化了。有兴趣的可以找我私聊。 Event持久化的幂等处理 然后，因为我们的架构是基于ES的，所以，针对新增或修改聚合根的Command，总是会产生相应的领域事件（Domain Event）。我们接下来的要做的事情就是要先持久化事件，再分发这些事件给所有的外部事件订阅者。大家知道，聚合根有生命周期，在它的生命周期里，会经历各种事件，而事件的发生总有确定的时间顺序。所以，为了明确哪个事件先发生，哪个事件后发生，我们可以对每个事件设置一个版本号，即version。聚合根第一个产生的事件的version为1，第二个为2，以此类推。然后聚合根本身也有一个版本号，用于记录当前自己的版本是什么，它每次产生下一个事件时，也能根据自己的版本号推导出下一个要产生的事件的版本号是什么。比如聚合根当前的版本号为5，那下一个事件的版本号则为6。通过为每个事件设计一个版本号，我们就能很方便的实现聚合根产生事件时的并发控制了，因为一个聚合根不可能产生两个版本号一样的事件，如果出现这种情况，那说明一定是出现并发冲突了。也就是一定是出现了同一个聚合根同时被两个Command修改的情况了。所以，要实现事件持久化的幂等处理，也很好做了，就是db中的事件表，对聚合根ID+聚合根当前的version建唯一索引。这样就能在db层面，确保Event持久化的幂等处理。另外，对于事件的持久化，我们也可以像秒杀那样，实现Group Commit。就是Command产生的事件不用立马持久化，而是可以先积累到一定的量，比如50个，然后再一次性Group Commit所有的事件。然后事件持久化完成后，再修改每个聚合根的状态即可。如果Group Commit事件时遇到并发冲突（由于某个聚合根的事件的版本号有重复），则退回为单个一个个持久化事件即可。为什么可以放心的这样做？因为我们已经基本做到确保一个聚合根同一时刻只会被一个Command修改。这样就能基本保证，这些Group Commit的事件也不会出现版本号冲突的情况。所以，大家是否觉得，很多设计其实是一环套一环的。Group Commit何时出发？我觉得可以只要满足两个条件了就可以触发：1）某个定时的周期到了就可以触发，这个定时周期可以根据自己的业务场景进行配置，比如每隔50ms触发一次；2）要Commit的事件到达某个最大值，即每批可以持久化的事件个数的最大值，比如每50个事件为一批，这个BatchSize也需要根据实际业务场景和你的存储db的性能综合测试评估来得到一个最适合的值；何时可以使用Group Commit？我觉得只有是在并发非常高，当单个持久化事件遇到性能瓶颈时，才需要使用。否则反而会降低事件持久化的实时性，Group Commit提高的是高并发下单位时间内持久化的事件数。目的是为了降低应用和DB之间交互的次数，从而减少IO的次数。不知不觉就说到了最开始说的那3点性能优化中的，尽量减少IO了，呵呵。 Event消费时的幂等处理 CQRS架构图中，事件持久化完成后，接下来就是会把这些事件发布出去（发送到分布式消息队列），给消费者消费了，也就是给所有的Event Handler处理。这些Event Handler可能是更新Q端的ReadDB，也可能是发送邮件，也可能是调用外部系统的接口。作为框架，应该有职责尽量保证一个事件尽量不要被某个Event Handler重复消费，否则，就需要Event Handler自己保证了。这里的幂等处理，我能想到的办法就是用一张表，存储某个事件是否被某个Event Handler处理的信息。每次调用Event Handler之前，判断该Event Handler是否已处理过，如果没处理过，就处理，处理完后，插入一条记录到这个表。这个方法相信大家也都很容易想到。如果框架不做这个事情，那Event Handler内部就要自己做好幂等处理。这个思路就是select if not exist, then handle, and at last insert的过程。可以看到这个过程不像前面那两个过程那样很严谨，因为在并发的情况下，理论上还是会出现重复执行Event Handler的情况。或者即便不是并发时也可能会造成，那就是假如event handler执行成功了，但是last insert失败了，那框架还是会重试执行event handler。这里，你会很容易想到，为了做这个幂等支持，Event Handler的一次完整执行，需要增加不少时间，从而会最后导致Query Side的数据更新的延迟。不过CQRS架构的思想就是Q端的数据由C端通过事件同步过来，所以Q端的更新本身就是有一定的延迟的。这也是CQRS架构所说的要接收最终一致性的原因。 关于幂等处理的性能问题的思考 关于CommandStore的性能瓶颈分析 大家知道，整个CQRS架构中，Command，Event的产生以及处理是非常频繁的，数据量也是非常大的。那如何保证这几步幂等处理的高性能呢？对于Command的幂等处理，如果对性能要求不是很高，那我们可以简单使用关系型DB即可，比如Sql Server, MySQL都可以。要实现幂等处理，只需要把主键设计为CommandId即可。其他不需要额外的唯一索引。所以这里的性能瓶颈相当于是对单表做大量insert操作的最大TPS。一般MySQL数据库，SSD硬盘，要达到2W […]
View DetailsDapper高级玩法1： 数据库中带下划线的表字段自动匹配无下划线的Model字段。 Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true; 备注： 这个对使用Mysql数据库的朋友最有帮助，因为Mysql默认都是小写，一般字段都带下划线，比如：user_name之类。 具体效果如下演示 1，首先创建一张表并插入数据 2，创建Model模型
|
1 2 3 4 5 6 7 8 |
public class User { public int UserID { get; set; } public string UserName { get; set; } public int RoleID { get; set; } } |
3，扩写抽取数据逻辑代码. select * from [user]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
static Program() { var config = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); var data = config.Build(); DapperExtension.DBConnectionString = data.GetConnectionString("DefaultConnection"); } static void Main(string[] args) { IDbConnection dbconnection = null; using (dbconnection = dbconnection.OpenConnection()) { var users = dbconnection.List("select * from [user]", null); foreach (var user in users) { Console.WriteLine($"{user.UserID}-{user.UserName}-{user.RoleID}"); } } Console.ReadKey(); } |
4，无MatchNamesWithUnderscores设置时的数据抽取 没有绑定成功？？ 这是因为用了Select * from的缘故，取出来的字段是带下划线的与Model的字段不匹配。 5，设置MatchNamesWithUnderscores再次数据抽取
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
static void Main(string[] args) { Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true; IDbConnection dbconnection = null; using (dbconnection = dbconnection.OpenConnection()) { var users = dbconnection.List("select * from [user]", null); foreach (var user in users) { Console.WriteLine($"{user.UserID}-{user.UserName}-{user.RoleID}"); } } Console.ReadKey(); } |
数据绑定成功。 就一句Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true，让我们少写了不少AS语句。 Dapper高级玩法2： 法力无边的Query,由于带有Function功能，可以自由设置模型绑定逻辑。 1，创建两张有关联的表，并填入数据。 2，抽取user和它关联的role数据。 select 1 as table1,T1.*,1 as table2,T2.* from [user] T1 inner join [role] T2 on T1.role_id = T2.role_id 扩展方法：
|
1 2 3 4 |
public static IEnumerable QueryT(this IDbConnection dbconnection, string sql, Func map, object param = null, IDbTransaction transaction = null, string splitOn = "Id") { return dbconnection.Query(sql, map, param, transaction, splitOn: splitOn); } |
使用：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
static void QueryTest() { Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true; IDbConnection dbconnection = null; using (dbconnection = dbconnection.OpenConnection()) { var result = dbconnection.QueryT( @"select 1 as table1,T1.*,1 as table2,T2.* from [user] T1 inner join [role] T2 on T1.role_id = T2.role_id", (user, role) => { user.Role = role; return user; }, null, splitOn: "table1,table2"); foreach (var user in result) { Console.WriteLine($"{user.UserID}-{user.UserName}-{user.Role.RoleID}-{user.Role.RoleName}"); } } Console.ReadKey(); } |
成功取到数据。 splitOn解释：模型绑定时的字段分割标志。table1到table2之间的表字段绑定到User，table2之后的表字段绑定到Role。 3，特殊Function逻辑。比如抽取role_id对应的user一览。 select 1 as table1,T1.*,1 as table2,T2.* from [role] T1 left join [user] T2 on T1.role_id = T2.role_id 外部定义了一个字典类型，Query内部模型绑定的时候每次调用Function函数，Function函数中将数据添加到外部字典中，这在复杂数据处理时很有用。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
static void QueryTest2() { Dapper.DefaultTypeMap.MatchNamesWithUnderscores = true; IDbConnection dbconnection = null; using (dbconnection = dbconnection.OpenConnection()) { Dictionary> dic = new Dictionary>(); dbconnection.QueryT( @"select 1 as table1,T1.*,1 as table2,T2.* from [role] T1 left join [user] T2 on T1.role_id = T2.role_id", (role, user) => { if (dic.ContainsKey(role.RoleID)) { dic[role.RoleID].Add(user); } else { dic.Add(role.RoleID, new List { user }); } return true; }, null, splitOn: "table1,table2"); foreach (var data in dic) { Console.WriteLine($"role:{data.Key}"); foreach (var user in data.Value) { Console.WriteLine($"user:{user.UserID}-{user.UserName}"); } } } Console.ReadKey(); } |
[…]
View Details我们都知道ORM全称叫做Object Relationship Mapper，也就是可以用object来map我们的db，而且市面上的orm框架有很多，其中有一个框架 叫做dapper，而且被称为the king of ORM。 一：为什么选择Dapper 1. 性能优越： 其实在各大网站上，我们大概都会看到这样的一个对比效果图，在超过500次poco serialization的过程中所表现的性能，我们发现dapper是第二名， 当然第一名谁也无法超越，越底层的当然久越快，同时也就越麻烦。就好像谁能超过“01代码”呢？？？ 2. 支持多数据库 支持多数据库的本质是因为Dapper是对IDBConnection接口进行了方法扩展，比如你看到的SqlMapper.cs，一旦你这样做了，我们也知道， SqlConnection,MysqlConnection,OracleConnection都是继承于DBConnection，而DBConnection又是实现了IDBConnection的接口，对吧。。。 二：安装Dapper install dapper的方式通常有两种： 1. 通过nuget进行安装 如果你不知道怎么用nuget进行安装，或者不知道install-package是什么，可以在browser上找一下，比如下面这样： 然后我们copy到package console 试试看。 2. 在github上获取源码。 为什么要获取源码，是因为用ilspy调试dapper的源码太费劲了，毕竟现在都是异步编程了，从ilspy中看都是匿名方法很多都无法渗透，废话不多 说，我们只要把Dapper文件夹拉出来然后copy到我们的solution就可以了，如下图： 三：快速CURD操作 其实对数据库的操作莫过于CURD,在进行操作之前我们再配一个Users表。 1. 配置Users表
|
1 2 3 4 5 6 7 8 9 10 |
CREATE TABLE [dbo].[Users]( [UserID] [int] IDENTITY(1,1) NOT NULL, [UserName] [varchar](50) NULL, [Email] [varchar](100) NULL, [Address] [varchar](100) NULL, CONSTRAINT [PK_Users] PRIMARY KEY CLUSTERED ( [UserID] ASC )WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY] ) ON [PRIMARY] |
2. Insert操作 通常来说，有两种insert操作： <1>单条insert操作 这是一个简单的参数化insert，而且还可以塞入匿名类型，对吧，跟原始的SqlParameter相比，是不是简单的多？？？
|
1 2 3 4 5 6 7 |
static void Main(string[] args) { IDbConnection connection = new SqlConnection("Data Source=.;Initial Catalog=DataMip;Integrated Security=True;MultipleActiveResultSets=True"); var result = connection.Execute("Insert into Users values (@UserName, @Email, @Address)", new { UserName = "jack", Email = "380234234@qq.com", Address = "上海" }); } |
<2> InsertBulk操作 既然是Bulk操作，那肯定就是批量插入了，我们要做的就是将上面这个 ”匿名对象" 变成 ”匿名对象集合“ 就可以了。。。为了方便操作，这里定义 一个Users类，比如下面这样。。。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
static void Main(string[] args) { IDbConnection connection = new SqlConnection("Data Source=.;Initial Catalog=DataMip;Integrated Security=True;MultipleActiveResultSets=True"); //var result = connection.Execute("Insert into Users values (@UserName, @Email, @Address)", // new { UserName = "jack", Email = "380234234@qq.com", Address = "上海" }); var usersList = Enumerable.Range(0, 10).Select(i => new Users() { Email = i + "qq.com", Address = "安徽", UserName = i + "jack" }); var result = connection.Execute("Insert into Users values (@UserName, @Email, @Address)",usersList); } |
2. Query操作 其实在Dapper在query上提供的的文章太多了。。。这篇我们就按照最简单的参数化查询就好了。。。比如我要找到username=jack的记录，如下：
|
1 2 3 4 5 6 7 |
1 static void Main(string[] args) 2 { 3 IDbConnection connection = new SqlConnection("Data Source=.;Initial Catalog=DataMip;Integrated Security=True;MultipleActiveResultSets=True"); 4 5 var query = connection.Query<Users>("select * from Users where UserName=@UserName", new { UserName = "jack" }); 6 7 } |
图上的亮点就在于能够自动化mapper到我们object上面来，这是我们DataReader所不能办到的，对吧~~ 3.update操作 这种操作方式，我们还是使用Execute方法来实现，和insert是一种套路的哦。 4. delete操作 这里我还是采用参数化的形式来删除UserID=10这条记录，方式如下： 最终sql的table展示如下，可以看到已经正确的修改了UserID=11的记录，删除了UserID=10的record。。。。当然Dapper好玩的地方多着呢， 这篇只是一个入门而已。。。希望本篇对大家有帮助~~~
View Details