采用异步来实现重新连接服务器或者重新启动服务
开启异步监听，不会导致主线程的堵塞，在服务异常断开后一直检测重新连接服务，成功连接服务后通知各个注册的客户端！
#region 检测断线并重连OPC服务 可以强制启动OPC服务程序
/// <summary>
/// 提供外部使用
/// 重新连接事件
/// </summary>
public event LinkStateChangedEvent OnLinkStateChanged;
/// <summary>
/// 当前连接状态
/// </summary>
volatile ELinkState curLinkState = ELinkState.Unkown;
/// <summary>
/// 获取或设置当前连接状态
/// </summary>
ELinkState CurLinkState
{
get
{
lock (this)
{
return curLinkState;
}
}
set
{
lock (this)
{
curLinkState = value;
}
}
}
/// <summary>
/// 检测间隔毫秒数
/// </summary>
const int _checkInterval = 3000;
/// <summary>
/// 空闲心跳时间
/// </summary>
AutoResetEvent _waitCheckAndTryReLinkEvent = new AutoResetEvent(false);
/// <summary>
/// 是否正在检测并尝试重连
/// </summary>
volatile bool _isCheckingAndTryReLink = false;
/// <summary>
/// 获取或设置是否正在检测并尝试重连
/// </summary>
bool IsCheckingAndTryReLink
{
get
{
lock (this)
{
return _isCheckingAndTryReLink;
}
}
set
{
lock (this)
{
_isCheckingAndTryReLink = value;
}
}
}
/// <summary>
/// 启动检测并尝试重连
/// </summary>
void StartCheckAndTryReLink()
{
IsCheckingAndTryReLink = true;
BeginWaitCheckAndTryReLink();
}
/// <summary>
/// 开始等待检测并尝试重连
/// </summary>
void BeginWaitCheckAndTryReLink()
{
//开始异步等待
ThreadPool.RegisterWaitForSingleObject(_waitCheckAndTryReLinkEvent, WaitCheckAndTryReLinkCallBack, null, _checkInterval, true);
}
/// <summary>
/// 等待检测并尝试重连回调函数
/// </summary>
/// <param name="state"></param>
/// <param name="timedOut"></param>
void WaitCheckAndTryReLinkCallBack(Object state, Boolean timedOut)
{
//检测断线并重连
try
{
OPCAutomation.OPCServer service = GetOPCServer();
if (service != null)
{//连接正常
if (CurLinkState != ELinkState.Connected)
{
ELinkState oldState = CurLinkState;
CurLinkState = ELinkState.Connected;
OutLinkStateChanged(oldState, CurLinkState);
}
}
else
{//连接已断开
if (CurLinkState != ELinkState.Disconnected)
{
ELinkState oldState = CurLinkState;
CurLinkState = ELinkState.Disconnected;
OutLinkStateChanged(oldState, CurLinkState);
}
#region 尝试重连
//先注销
//try
//{
// service.Disconnect();
// // remotingClient.UnregisterChannel();
//}
//catch(Exception ex)
//{
//}
//等待一下
System.Threading.Thread.Sleep(3000);
//再重新注册
try
{
// remotingClient.RegisterChannel();
Server = new OPCAutomation.OPCServer();//重新初始化服务
Server.Connect(ServerName, IP);
//Server = service;
OPCIsConnected = true;
Task.Factory.StartNew(CreateGroupsInfos);
}
catch
{
OPCIsConnected = false;
}
#endregion
}
}
catch
{
}
//进入下一轮
if (IsCheckingAndTryReLink)
{
BeginWaitCheckAndTryReLink();
}
}
/// <summary>
/// 停止检测并尝试重连
/// </summary>
void StopCheckAndTryReLink()
{
IsCheckingAndTryReLink = false;
_waitCheckAndTryReLinkEvent.Set();
}
/// <summary>
/// 委托:连接状态发生变化
/// </summary>
/// <param name="oldState">旧状态</param>
/// <param name="newState">新状态</param>
void OutLinkStateChanged(ELinkState oldState, ELinkState newState)
{
if (OnLinkStateChanged != null)
{
//广播
LinkStateChangedEvent tempEvent = null;
foreach (Delegate del in OnLinkStateChanged.GetInvocationList())
{
try
{
tempEvent = (LinkStateChangedEvent)del;
tempEvent.BeginInvoke(oldState, newState, null, null);
}
catch
{
}
}
}
}
#endregion
public enum ELinkState
{
/// <summary>
/// 未知状态
/// </summary>
[Description("未知状态")]
Unkown = -1,
/// <summary>
/// 断开
/// </summary>
[Description("已断开")]
Disconnected = 0,
/// <summary>
/// 已连接
/// </summary>
[Description("已连接")]
Connected = 1
}
C#中类的属性的获取
/// <summary>
/// 将多个实体转换成一个DataTable
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
/// <returns></returns>
public static DataTable EntityToDataTable<T>(List<T> list)
{
DataTable dt = new DataTable();
string res = typeof(T).ToString();
int start = res.IndexOf('.') + 1;
//初始化DataTable的值 包括表名、列
dt.TableName = res.Substring(start, res.Length - start);
Dictionary<string, object> dic = Utils.GetAllAttributes<T>(list[0]);
if (dic==null||dic.Count==0)
{
throw new Exception("无法转换数据！");
}
foreach (string key in dic.Keys)
{
// Type type = dic[key].GetType();
dt.Columns.Add(key, dic[key].GetType());
}
foreach (T t in list)
{
dic = new Dictionary<string, object>();
dic = Utils.GetAllAttributes<T>(t);
List<object> lists = new List<object>();
foreach (object item in dic.Values)
{
lists.Add(item);
}
DataRow dr = dt.NewRow();
dr.ItemArray = lists.ToArray();
dt.Rows.Add(dr);
}
return dt;
}
/// <summary>
/// 获取实体的所有属性
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="t"></param>
/// <returns></returns>
public static Dictionary<string, object> GetAllAttributes<T>(T t)
{
Dictionary<string, object> dic = new Dictionary<string, object>();
if (t == null)
{
return dic;
}
PropertyInfo[] infos = t.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
if (infos == null || infos.Length <= 0)
{
return dic;
}
foreach (PropertyInfo info in infos)
{
string Name = info.Name;
object value = info.GetValue(t, null);
if (info.PropertyType.IsValueType || info.PropertyType.Name.StartsWith("String")||info.PropertyType.FullName.Contains("System"))
{
if (dic.ContainsKey(Name))
{
continue;
}
dic.Add(Name, value);
}
//else
//{
// GetAllAttributes(value);
//}
}
return dic;
}
SignalR2简易数据看板演示
软件环境：
1、vs2015、windows7、.net4.5
演示说明：
当点击按钮的时候，柱状图数值加1并实时变化
1、首先打开vs2015创建一个mvc项目，并安装SignalR2，具体操作可参见：http://net-yuan.com/Article/Detail/e407a472-338a-458d-9d7a-4a9e43fd2da5
2、右键项目，新建文件夹，命名为Hubs，添加命名为ChartHub的SignalR集线器类
3、右键项目，新建文件夹，命名为Services，添加命名为ChartService的新类
4、ChartService类中创建一个方法NotifyUpdates，代码如下：
|
1
2
3
4
5
6
7
8
9
|
public
async Task NotifyUpdates()
{
var
hubContext = GlobalHost.ConnectionManager.GetHubContext<ChartHub>();
if
(hubContext !=
null
)
{
var
stats = await
this
.<br>GetCount();
hubContext.Clients.All.updateChart(stats);
}
}
|
5、再创建两个方法，分别模拟获取计数和增长计数的过程，实际中，可以从数据库查询和数据写入数据库。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/// <summary>
/// 模拟数据类
/// </summary>
public
static
class
D
{
public
static
int
Count {
get
;
set
; }
}
public
async Task<
int
> GetCount()
{
return
D.Count;
}
public
async Task<
int
> IncreaceCount()
{
D.Count = D.Count + 1;
return
D.Count;
}
|
6、创建ApiController，命名为DataController，代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
class
DataController : ApiController
{
private
ChartService chartService;
public
DataController()
{
this
.chartService =
new
ChartService();
}
// POST api/<controller>
public
async Task<HttpResponseMessage> Post()
{
var
isCorrect = await
this
.chartService.IncreaceCount();
await
this
.chartService.NotifyUpdates();
return
Request.CreateResponse(HttpStatusCode.Created, isCorrect);
}
}
|
7、视图Home/Index，代码如下：
|
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
|
<
br
/>
<
p
><
button
class="btn btn-info" onclick="clkTest();">数据模拟</
button
></
p
>
<
p
>1、本示例只是一个最小场景的演示</
p
>
<
p
>2、当点击按钮的时候，柱状图数值加1并实时变化</
p
>
<
p
>3、拆开来看，将点击操作看作服务器对数据的变化的发布；将柱状图数据变化看作是对服务器数据的订阅。这就是典型的数据推送，数据看板就是其中的一项应用。</
p
>
<
p
>4、可以有好多变化：如果将点击按钮的动作替换为每n(s)自动触发一次；如果能感知数据库某个表的数据变化来触发图表变化</
p
>
<!-- 为 ECharts 准备一个具备大小（宽高）的 DOM -->
<
div
id="main" style="width: 600px;height:400px;"></
div
>
<
script
src="~/Scripts/jquery-1.10.2.js"></
script
>
<
script
src="~/Scripts/echarts.simple.min.js"></
script
>
@section Scripts {
<
script
src="@Url.Content("~/Scripts/jquery.signalR-2.4.0.min.js")"></
script
>
<
script
src="@Url.Content("~/signalr/hubs")" type="text/javascript"></
script
>
<
script
>
// 基于准备好的dom，初始化echarts实例
var myChart = echarts.init(document.getElementById('main'));
// 指定图表的配置项和数据
option = {
color: ['#3398DB'],
tooltip: {
trigger: 'axis',
axisPointer: { // 坐标轴指示器，坐标轴触发有效
type: 'shadow' // 默认为直线，可选为：'line' | 'shadow'
}
},
grid: {
left: '3%',
right: '4%',
bottom: '3%',
containLabel: true
},
xAxis: [
{
type: 'category',
data: ['SignalR'],
axisTick: {
alignWithLabel: true
}
}
],
yAxis: [
{
type: 'value'
}
],
series: [
{
name: '直接访问',
type: 'bar',
label: {
normal: {
show: true,
position: 'inside'
}
},
barWidth: '30%',
data: [0]
}
]
};
var connection = $.hubConnection();
var hub = connection.createHubProxy("ChartHub");
hub.on("updateChart", function (chart) {
statisticsData = chart;
console.log(statisticsData);
option.series[0].data[0] = statisticsData;
// 使用刚指定的配置项和数据显示图表。
myChart.setOption(option);
//$("#spCount").text(statisticsData);
});
connection.start();
</
script
>
}
<
script
>
$(function () {
myChart.setOption(option);
})
var clkTest = function () {
$.post("/api/Data", null, function (res) {
console.log(res);
//$("#spClicks").text(res);
}, "json")
}
</
script
>
|
8、演示如下，打开两个客户端，可以看到，当点击按钮的时候，两个客户端的柱状图都会变化
GitHub：https://github.com/net-yuan/SignalR-RealTime
C#动态调用泛型类、泛型方法
在制作一个批量序列化工具时遇到了如下问题，在此记录一下，仅供参考。
主程序加载另一个程序集，将其中的所有类取出，然后对这些类分别调用泛型类或泛型方法。控制台程序解决方案如下：
- Main工程：提供Worker类进行数据操作，XMLTool<T>泛型类将数据集序列化为.xml文档，RootCollection<T>类封装数据集
- Worker类
提供成员方法void DoWork<T>()、List<T> GetList<T>()、静态成员方法StaticDoWork<T>()，代码如下：
1 public class Worker
2 {
3 public Worker()
4 {
5 }
6
7 public void DoWork<T>()
8 {
9 Type t = typeof(T);
10 Console.WriteLine("Get Class: {0}", t.Name);
11 PropertyInfo[] properties = t.GetProperties();
12 foreach (PropertyInfo property in properties)
13 {
14 Console.WriteLine("\tproperty.Name: " + property.Name + "\tproperty.MemberType: " + property.PropertyType);
15 }
16 }
17
18 public static void StaticDoWork<T>()
19 {
20 Type t = typeof(T);
21 Console.WriteLine("Get Class: {0}", t.Name);
22 PropertyInfo[] properties = t.GetProperties();
23 foreach (PropertyInfo property in properties)
24 {
25 Console.WriteLine("\tproperty.Name: " + property.Name + "\tproperty.MemberType: " + property.PropertyType);
26 }
27 }
28
29 public List<T> GetList<T>()
30 {
31 Console.WriteLine("Generate List for [{0}]", typeof(T).Name);
32 return new List<T>()
33 {
34 Activator.CreateInstance<T>(),
35 Activator.CreateInstance<T>()
36 };
37 }
38 }
- XMLTool<T>类
1publicclass XMLTool<T>
2 {
3publicstaticvoid XmlSerialize_Save(List<T> needSerializedList, string xmlDirPath, string xmlFileName)
4 {
5 RootCollection<T> collection = new RootCollection<T>();
6 collection.ItemList = needSerializedList;
7if (!Directory.Exists(xmlDirPath))
8 Directory.CreateDirectory(xmlDirPath);
9using (System.IO.FileStream stream = new System.IO.FileStream(xmlFileName, System.IO.FileMode.Create))
10 {
11 System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(collection.GetType());
12 serializer.Serialize(stream, collection);
13 }
14 }
15 }
- RootCollection<T>类：
1 [Serializable]
2 public class RootCollection<T>
3 {
4 public RootCollection()
5 {
6 itemList = new List<T>();
7 }
8
9 private List<T> itemList;
10
11 public List<T> ItemList
12 {
13 get { return itemList; }
14 set { itemList = value; }
15 }
16 }
- MockClassLib工程：提供BaseEntity、Apple、Cat和Person类
- BaseEntity类：抽象类，负责初始化类成员
1 public abstract class BaseEntity
2 {
3 public BaseEntity()
4 {
5 InitiaWithNull();
6 }
7
8 private void InitiaWithNull()
9 {
10 Type type = this.GetType();
11 PropertyInfo[] properties = type.GetProperties();
12 string[] PropNames = new string[properties.Length];
13 Dictionary<string, PropertyInfo> PropNameToInfo = new Dictionary<string, PropertyInfo>();
14 for (int i = 0; i < properties.Length; i++)
15 {
16 PropNames[i] = properties[i].Name;
17 PropNameToInfo.Add(PropNames[i], properties[i]);
18 }
19
20 foreach (string propname in PropNames)
21 {
22 string proptype = PropNameToInfo[propname].PropertyType.Name;
23
24 object value = null;
25 if (NullValue.Keys.Contains(proptype))
26 value = NullValue[proptype];
27
28 type.GetProperty(propname).SetValue(this, value, null);
29 }
30 }
31
32 private static readonly Dictionary<string, object> NullValue = new Dictionary<string, object>()
33 {
34 { "String", String.Empty },
35 { "DateTime", DateTime.MinValue},
36 { "Decimal", Decimal.MinValue}
37 };
38 }
- Apple、Cat和Person类：测试类，继承于BaseEntity
1 public class Apple : BaseEntity
2 {
3 public string Color { get; set; }
4 }
5
6 public class Cat : BaseEntity
7 {
8 public string Type { get; set; }
9 }
10
11 public class Person : BaseEntity
12 {
13 public int ID { get; set; }
14 public string Name { get; set; }
15 }
- BaseEntity类：抽象类，负责初始化类成员
Main工程的Program的Main方法中，一般情况下，调用Worker的泛型方法来处理测试类的话，可以写为：
Worker worker = new Worker();
worker.DoWork<Apple>();
worker.DoWork<Cat>();
worker.DoWork<Person>();
但是，如果MockClassLib中需要处理的类型非常多时，这样显示调用必然是不灵活的，应当怎样向泛型方法DoWork<T>()的尖括号中动态传入类型呢？
考虑代码：
//Load assembly
Assembly mockAssembly = Assembly.LoadFrom("MockClassLibrary.dll");
Type[] typeArray = mockAssembly.GetTypes();
//Create instance of Worker
Worker worker = new Worker();
foreach(Type curType in typeArray)
{
worker.DoWork<curType>(); //Error
}
可以看到，Type类型的实例是无法直接传入泛型方法的尖括号中的，T要求显式指明类型名。
下面通过反射方式来获取泛型方法，并创建特定类型的泛型方法。
- 对于非静态方法：public void DoWork<T>()
对于非静态方法，调用MethodInfo.Invoke(object, object[])时，第一个参数需要指明泛型方法的所有者（即这里创建的worker对象），第二个参数为泛
型方法的参数列表，DoWork<T>()没有输入参数，所以设为null
//Create an instance of Worker
Worker worker = new Worker();
//Get type of Worker
Type workerType = typeof(Worker);
//Get Generic Method
MethodInfo doWorkMethod = workerType.GetMethod("DoWork");
//Invoke DoWork<T> with different Type
foreach (Type curType in typeArray)
{
if (curType.IsClass && !curType.IsAbstract)//Filter BaseEntity
{
MethodInfo curMethod = doWorkMethod.MakeGenericMethod(curType);
curMethod.Invoke(worker, null);//Member method，use instance
}
}
- 对于静态方法：public static void StaticDoWork<T>()
不同于非静态方法，这里直接反射的类静态方法，所以Invoke()的第一个参数设为null
//Get type of Worker
Worker worker = new Worker();
//Get Generic Method
MethodInfo staticDoWorkMethod = workerType.GetMethod("StaticDoWork");
//Invoke StaticDoWork<T>
foreach (Type curType in typeArray)
{
if (curType.IsClass && !curType.IsAbstract)
{
MethodInfo curMethod = staticDoWorkMethod.MakeGenericMethod(curType);
curMethod.Invoke(null, null);//Static method
}
}
- 对于有返回值的非静态方法：public List<T> GetList()
如同动态调用DoWork<T>()方法一样，只是在处理返回值时，可以使用下面的方法
1 IList tempList = (IList)curMethod.Invoke(worker, null);
2 //Or
3 IEnumerable tempList = (IEnumerable)curMethod.Invoke(worker, null);
- 对于泛型类：XMLTool<T>
下面要使用泛型类XMLTool<T>的静态方法public static void XmlSerialize_Save(List<T> list, string dirPath, string fileName)方法。
首先应通过反射构造出指定类型的泛型类XMLTool<T>，再反射出其中的XmlSerialize_Save方法并使用。
1 //Use Generic Class
2 Type xmlToolType = typeof(XMLTool<>).MakeGenericType(curType);
3
4 //Get method
5 MethodInfo saveMethod = xmlToolType.GetMethod("XmlSerialize_Save");
6
7 //Invoke
8 saveMethod.Invoke
9 (
10 null, //Static method
11 new object[] { resultList, @"c:\", @"c:\Test_" + curType.Name + ".xml" }
12 );
Program-->Main()方法的全部代码：
1 namespace RetrieveUnknownClass
2 {
3 class Program
4 {
5 static void Main(string[] args)
6 {
7 //Load assembly
8 Assembly mockAssembly = Assembly.LoadFrom("MockClassLibrary.dll");
9 Type[] typeArray = mockAssembly.GetTypes();
10
11 //Create instance of Worker
12 Type workerType = typeof(Worker);
13 Worker worker = new Worker();
14
15 #region Member method
16
17 Console.WriteLine(">>>>>>>>>Use Generic Method：");
18 MethodInfo doWorkMethod = workerType.GetMethod("DoWork");
19
20 //Invoke DoWork<T>
21 foreach (Type curType in typeArray)
22 {
23 if (curType.IsClass && !curType.IsAbstract)
24 {
25 MethodInfo curMethod = doWorkMethod.MakeGenericMethod(curType);
26 curMethod.Invoke(worker, null);//Member method，use instance
27 }
28 }
29
30 #endregion
31
32 #region Static method
33
34 Console.WriteLine("\r\n>>>>>>>>>Use Static Generic Method：");
35 MethodInfo staticDoWorkMethod = workerType.GetMethod("StaticDoWork");
36
37 //Invoke StaticDoWork<T>
38 foreach (Type curType in typeArray)
39 {
40 if (curType.IsClass && !curType.IsAbstract)
41 {
42 MethodInfo curMethod = staticDoWorkMethod.MakeGenericMethod(curType);
43 curMethod.Invoke(null, null);//Static method
44 }
45 }
46
47 #endregion
48
49 #region Get A List & Serialize It to Xml File With Generic
50
51 Console.WriteLine("\r\n>>>>>>>>>Get List By Generic Method：");
52 MethodInfo getListMethod = workerType.GetMethod("GetList");
53
54 foreach (Type curType in typeArray)
55 {
56 if (curType.IsClass && !curType.IsAbstract)
57 {
58 MethodInfo curMethod = getListMethod.MakeGenericMethod(curType);
59 //Generate List
60 IList resultList = (IList)curMethod.Invoke(worker, null);
61 //Show List
62 ShowList(resultList);
63 //Use Generic Class
64 Type xmlToolType = typeof(XMLTool<>).MakeGenericType(curType);
65 MethodInfo saveMethod = xmlToolType.GetMethod("XmlSerialize_Save");
66
67 saveMethod.Invoke
68 (
69 null, //Static method
70 new object[] { resultList, @"c:\", @"c:\Test_" + curType.Name + ".xml" }
71 );
72 }
73 }
74
75 Console.WriteLine("Serialization Completed...\r\n");
76 #endregion
77 }
78
79 public static void ShowList(IList list)
80 {
81 Console.WriteLine("Type of list: {0}\r\nCount of current list: {1}\r\nType of item in list: {2}\r\n",
82 list.GetType(),
83 list.Count,
84 list[0].GetType());
85 }
86 }
87 }
asp .net core Get raw request.
小弟初来乍到，分享一些工作学习中遇到的问题和解决方式，如有不准确或是有错误的地方，希望不吝赐教，谢过了。 --Dogtwo
背景：
一个代理服务器BK，接收前端A发送的请求，记录log，并转发给另外的服务器B。
请求中有类似这样的模块:
Person：
{
name:abc,
age: 20,
address:
{
home: xxx,
company: yyy
}
}
其中home,company以及address为可选字段，服务器B要求如果为空则不传递该字段。
对于前端A来说，如果客户没有填入某字段则json中将不包含该字段。
例如若不包含home，则前端A的request中内容为：
Person：
{
name:abc,
age: 20,
address:
{
company: yyy
}
}
前文所述，A的请求会经过BK再转发给B,BK使用ASP.NETCORE，读取A发送来的请求方式如下public Task Test([FromBody] Model model)
框架本身已经封装很好，会将request.body中内容自动转化为model对象。对于可选字段home来说，如果前端未发送，
则model.person.address.home的值为""。若请求中address整体都未发送，则model.address为null.
一般来说，这样的处理不会有什么问题。但这次的坑中，我们需要把model再当作内容转发给B,原来使用的方法为(RestRequest) request.addJsonBody(model);
此时会使A发送的请求与B接收的请求出现差异！
此时会使A发送的请求与B接收的请求出现差异！
此时会使A发送的请求与B接收的请求出现差异！（重要的事情说三遍）
例如
A发送的：
Person：
{
name:abc,
age: 20
}
B接收的：
Person：
{
name:abc,
age: 20,
address:null
}
对于基本类型，若某字段可选我们可以这样处理
public int？ a { get; set; }
对于内嵌的address来说，经由BK处理后无法取消掉address。(或者是我没找到方法，有办法的话请不吝赐教)
解决办法：
既然框架转化的model不能满足要求，第一思路是直接去取原生的request来获取request.body，转发给B.
但此时在方法为取到的request.body中内容居然为""。明明可以通过[FromBody]来获取model，直接取原生内容居然为空，很费解.
网络求助后发现：
ASP NET Core不允许我们仅仅通过方法参数以任何有意义的方式捕获“原始”数据。因此我们需要通过处理Request.Body来获取原始数据，然后反序列化它。
我们可以捕获原始的Request.Body并从原始缓冲区中读取参数。最简而有效的方法是接受不带参数的POST或PUT数据，然后从Request.Body读取原始数据：
例：
1 [HttpPost("api/blog/jsonstring")]
2 public async Task Index()
3 {
4 var result = string.Empty;
5
6 using (var reader = new StreamReader(Request.Body,Encoding.UTF8))
7 {
8 result = await reader.ReadToEndAsync();
9 }
10
11 return result;
12 }
但在该项目中，使用上述代码取得的result仍为空,笔者代码类似于：
1 [HttpPost("api/blog/jsonstring")]
2 public async Task Index([FromBody] Model model)
3 {
4 var result = string.Empty;
5
6 using (var reader = new StreamReader(Request.Body, Encoding.UTF8))
7 {
8 result = await reader.ReadToEndAsync();
9 }
10
11 return result;
12 }
区别在于多了这个[FromBody] Model model，将其去掉之后result可以成功取得对应值。
继续求助网络发现：
ASP.NET Core 中的 Request.Body 虽然是一个 Stream ，但它是一个与众不同的 Stream —— 不允许 Request.Body.Position=0 ，这就意味着只能读取一次。
解决办法为
引用命名空间 Microsoft.AspNetCore.Http.Internal ，调用方法 Request.EnableRewind() (但尝试时该方法无效，需要进一步研究)
另外，成功取得request.body值以后要用这个方法将其加入到新的request中：request.AddParameter("application/json", result, ParameterType.RequestBody);
参考:
1. ASP.NET Core Web API获取原始请求内容
2. ASP.NET Core 中读取 Request.Body 的正确姿势
3.Returning only useful fields from the API && Consuming an API that accepts a comma-separated list of fields.
从壹开始前后端分离[.NetCore 不定期更新] 38 ║自动初始化数据库
正文
缘起
哈喽大家好呀，我们又见面啦，这里先祝大家圣诞节快乐哟，昨天的红包不知道有没有小伙伴抢到呢。今天的这篇内容灰常简单，只是对我们的系统的数据库进行CodeFirst，然后就是数据处理，因为这几个月来，还是有小伙伴陆陆续续的向我索要数据，本来想着都是很简单的数据，就不给了，然后仅仅是提供了一个Sql的表结构，但是想想一个完整的项目，怎么能没有一个初始化的功能呢（不仅仅是表结构，还是要一些简单的数据）？所以就想着写今天这篇文章了，这篇文章虽然可能看起来很简单，不过也是给大家提供了一个思路，就是自己以后在写项目的时候，如何添加一个初始化的Seed Data，我也是参考其他小伙伴的，这里重点表扬下QQ群里，@初久童鞋，没有他的博客园地址，就没办法放他的首页了。
投稿作者：初久，个人地址：null，实现项目启动的时候，自动初始化数据，其中会涉及到上下文、SqlSugar、依赖注入等知识。
好啦，话不多说，直接开始动手。
一、对Mode实体类进行配置
因为要使用到了CodeFirst了，所以我们必须要对我们的实体类 Model 进行配置，当然也有很多的小伙伴，使用的是EFCore，当然是可以的，EFCore的我就不多少了，很简单，如果有不会的小伙伴，可以看我的第二个系列的《让你明白DDD的小故事 & EFCore初探》和《剪不断理还乱的 值对象和Dto》这两篇文章都有对EFCore的配置有提到，有需要的可以看看。那咱们就配置下我们的SqlSugar吧。
这里只用 Advertisement.cs 来举例吧，其他的，大家可以自行去查看我的Github上的code：
public class Advertisement : RootEntity
{
/// <summary>
/// 广告图片
/// </summary>
[SugarColumn(Length = 512, IsNullable = true)]
public string ImgUrl { get; set; }
/// <summary>
/// 广告标题
/// </summary>
[SugarColumn(Length = 64, IsNullable = true)]
public string Title { get; set; }
/// <summary>
/// 广告链接
/// </summary>
[SugarColumn(Length = 256, IsNullable = true)]
public string Url { get; set; }
/// <summary>
/// 备注
/// </summary>
[SugarColumn(Length = int.MaxValue, IsNullable = true)]
public string Remark { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime Createdate { get; set; } = DateTime.Now;
}
public class RootEntity
{
/// <summary>
/// ID
/// </summary>
[SugarColumn(IsNullable = false, IsPrimaryKey = true, IsIdentity = true)]
public int Id { get; set; }
}
这个就很简单的了，主要就是属性 SugarColumn() ，里边有一些属性，可以自行配置，这里给大家简单注释一下：
public class SugarColumn : Attribute
{
public SugarColumn();
public string ColumnName { get; set; }//列名
public bool IsIgnore { get; set; }//是否忽略
public bool IsPrimaryKey { get; set; }//是否是主键
public bool IsIdentity { get; set; }//是否自增
public string MappingKeys { get; set; }//映射key
public string ColumnDescription { get; set; }//列描述
public int Length { get; set; }//长度
public bool IsNullable { get; set; }//是否为空
public string OldColumnName { get; set; }//旧的列名
public string ColumnDataType { get; set; }//列类型，自定义
public int DecimalDigits { get; set; }//dicimal精度
public string OracleSequenceName { get; set; }//Oracle序列名
public bool IsOnlyIgnoreInsert { get; set; }//是否仅对添加忽略
public bool IsEnableUpdateVersionValidation { get; set; }
}
这里我已经配置完成了，而且是尽量的仿照着我的数据库来的，可能会有细微的差别，如果你要想使用的话，可以用一个测试的数据库来实验。
二、配置上下文与初始数据
大家是否还记得之前在仓储Repository中，我们创建了一个上下文，这里可以直接拿来用，不过因为我们的 API 层已经和 Repository 层解耦分割了，所以我就在 Mode 层来实现这个功能吧。如果你不解耦，可以直接使用仓储层的上下文即可。
1、建立 SqlSugar 上下文
在 Blog.Core.Model 层新建一个 Seed 文件夹，然后把仓储层中的 context 拷贝过去，我重命名为 MyContext.cs：
重点就是构造函数，要实现实例化 SqlSugarClient 的作用：
public MyContext()
{
if (string.IsNullOrEmpty(_connectionString))
throw new ArgumentNullException("数据库连接字符串为空");
_db = new SqlSugarClient(new ConnectionConfig()
{
ConnectionString = _connectionString,//数据库字符串
DbType = DbType.SqlServer,//数据库类型
IsAutoCloseConnection = true,//自动关闭数据库
IsShardSameThread = false,//启用异步多线程
InitKeyType = InitKeyType.Attribute,//mark
ConfigureExternalServices = new ConfigureExternalServices()
{
//DataInfoCacheService = new HttpRuntimeCache()
},
MoreSettings = new ConnMoreSettings()
{
//IsWithNoLockQuery = true,
IsAutoRemoveDataCache = true
}
});
}
2、实现初始化种子数据的功能
上边咱们创建了好上下文，那接下来咱们就应该实现 CodeFirst 功能了，
还是再 Seed 文件夹，新建 DBSeed.cs 类：
public class DBSeed
{
/// <summary>
/// 异步添加种子数据
/// </summary>
/// <param name="myContext"></param>
/// <returns></returns>
public static async Task SeedAsync(MyContext myContext)
{
try
{
// 注意！一定要先手动创建一个空的数据库
// 会覆盖，可以设置为true，来备份数据
// 如果生成过了，第二次，就不用再执行一遍了,注释掉该方法即可
myContext.CreateTableByEntity(false, typeof(Advertisement), typeof(BlogArticle), typeof(Guestbook), typeof(Module), typeof(ModulePermission), typeof(OperateLog),
typeof(PasswordLib), typeof(Permission), typeof(Role), typeof(RoleModulePermission), typeof(sysUserInfo), typeof(Topic), typeof(TopicDetail), typeof(UserRole));
// 下边的就是种子数据
#region Advertisement
if (!await myContext.Db.Queryable<Advertisement>().AnyAsync())
{
myContext.GetEntityDB<Advertisement>().Insert(
new Advertisement()
{
Createdate = DateTime.Now,
Remark = "mark",
Title = "good"
});
}
#endregion
#region BlogArticle Guestbook
if (!await myContext.Db.Queryable<BlogArticle>().AnyAsync())
{
int bid = myContext.GetEntityDB<BlogArticle>().InsertReturnIdentity(
new BlogArticle()
{
bsubmitter = "admins",
btitle = "老张的哲学",
bcategory = "技术博文",
bcontent = "<p>1。。。。。。",
btraffic = 1,
bcommentNum = 0,
bUpdateTime = DateTime.Now,
bCreateTime = DateTime.Now
});
if (bid > 0)
{
if (!await myContext.Db.Queryable<Guestbook>().AnyAsync())
{
myContext.GetEntityDB<Guestbook>().Insert(
new Guestbook()
{
blogId = bid,
createdate = DateTime.Now,
username = "user",
phone = "110",
QQ = "100",
body = "很不错",
ip = "127.0.0.1",
isshow = true,
});
}
}
}
#endregion
#region Module
int mid = 0;
if (!await myContext.Db.Queryable<Module>().AnyAsync())
{
mid = myContext.GetEntityDB<Module>().InsertReturnIdentity(
new Module()
{
IsDeleted = false,
Name = "values的接口信息",
LinkUrl = "/api/values",
OrderSort = 1,
IsMenu = false,
Enabled = true,
});
}
#endregion
#region Role
int rid = 0;
if (!await myContext.Db.Queryable<Role>().AnyAsync())
{
rid = myContext.GetEntityDB<Role>().InsertReturnIdentity(
new Role()
{
IsDeleted = false,
Name = "Admin",
Description = "我是一个admin管理员",
OrderSort = 1,
CreateTime = DateTime.Now,
Enabled = true,
ModifyTime = DateTime.Now
});
}
#endregion
#region RoleModulePermission
if (mid > 0 && rid > 0)
{
if (!await myContext.Db.Queryable<RoleModulePermission>().AnyAsync())
{
myContext.GetEntityDB<RoleModulePermission>().Insert(
new RoleModulePermission()
{
IsDeleted = false,
RoleId = rid,
ModuleId = mid,
CreateTime = DateTime.Now,
ModifyTime = DateTime.Now
});
}
}
#endregion
#region sysUserInfo
int uid = 0;
if (!await myContext.Db.Queryable<sysUserInfo>().AnyAsync())
{
uid = myContext.GetEntityDB<sysUserInfo>().InsertReturnIdentity(
new sysUserInfo()
{
uLoginName = "admins",
uLoginPWD = "admins",
uRealName = "admins",
uStatus = 0,
uCreateTime = DateTime.Now,
uUpdateTime = DateTime.Now,
uLastErrTime = DateTime.Now,
uErrorCount = 0
});
}
#endregion
#region UserRole
if (uid > 0 && rid > 0)
{
if (!await myContext.Db.Queryable<UserRole>().AnyAsync())
{
myContext.GetEntityDB<UserRole>().Insert(
new UserRole()
{
IsDeleted = false,
UserId = uid,
RoleId = rid,
CreateTime = DateTime.Now,
ModifyTime = DateTime.Now
});
}
}
#endregion
#region Topic TopicDetail
if (!await myContext.Db.Queryable<Topic>().AnyAsync())
{
int tid = myContext.GetEntityDB<Topic>().InsertReturnIdentity(
new Topic()
{
tLogo = "/Upload/20180626/95445c8e288e47e3af7a180b8a4cc0c7.jpg",
tName = "《罗马人的故事》",
tDetail = "这是一个荡气回肠的故事",
tIsDelete = false,
tRead = 0,
tCommend = 0,
tGood = 0,
tCreatetime = DateTime.Now,
tUpdatetime = DateTime.Now,
tAuthor = "laozhang"
});
if (tid > 0)
{
if (!await myContext.Db.Queryable<TopicDetail>().AnyAsync())
{
myContext.GetEntityDB<TopicDetail>().Insert(
new TopicDetail()
{
TopicId = tid,
tdLogo = "/Upload/20180627/7548de20944c45d48a055111b5a6c1b9.jpg",
tdName = "第一章 罗马的诞生 第一节 传说的年代",
tdContent = "<p>第一节 传说的年代</时代走出，近入了历史时代。</p><p><br></p>",
tdDetail = "第一回",
tdIsDelete = false,
tdRead = 1,
tdCommend = 0,
tdGood = 0,
tdCreatetime = DateTime.Now,
tdUpdatetime = DateTime.Now,
tdTop = 0,
});
}
}
}
#endregion
}
catch (Exception ex)
{
}
}
}
是不是很简单，上边的 CreateTableByEntity 是用来创建数据库的表结构的，第一次执行完成后，剩下的就可以不用执行了。下边的是添加种子数据，我增加了判断，其他的大家可以自定义处理。
这个时候我们已经把初始化表结构，和添加种子数据完成了，那我们应该怎么用呢，别慌，请往下看。
三、在项目启动的时候，执行初始化
1、将上边的类注入服务
这个很简单，相信大家都能看懂，我就直接注入到服务，然后服务会自动注入到Autofac：
2、在主程序 Main 中启动初始化
相信大家都应该知道，其实 .net core 本身是一个控制台程序，所以项目启动是在 Program.cs 中的 Main主程序方法中的，我们做一下修改：
public class Program
{
public static void Main(string[] args)
{
// 生成承载 web 应用程序的 Microsoft.AspNetCore.Hosting.IWebHost。Build是WebHostBuilder最终的目的，将返回一个构造的WebHost。
var host = CreateWebHostBuilder(args).Build();
// 创建可用于解析作用域服务的新 Microsoft.Extensions.DependencyInjection.IServiceScope。
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
var loggerFactory = services.GetRequiredService<ILoggerFactory>();
try
{
// 从 system.IServicec提供程序获取 T 类型的服务。
var myContext = services.GetRequiredService<MyContext>();
DBSeed.SeedAsync(myContext).Wait();
}
catch (Exception e)
{
var logger = loggerFactory.CreateLogger<Program>();
logger.LogError(e, "Error occured seeding the Database.");
}
}
// 运行 web 应用程序并阻止调用线程, 直到主机关闭。
// 创建完 WebHost 之后，便调用它的 Run 方法，而 Run 方法会去调用 WebHost 的 StartAsync 方法
// 将Initialize方法创建的Application管道传入以供处理消息
// 执行HostedServiceExecutor.StartAsync方法
host.Run();
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
//使用预配置的默认值初始化 Microsoft.AspNetCore.Hosting.WebHostBuilder 类的新实例。
WebHost.CreateDefaultBuilder(args)
//指定要由 web 主机使用的启动类型。相当于注册了一个IStartup服务。
.UseStartup<Startup>();
}
执行流程就是，我们项目启动，首先会创建一个初始化WebHostBuilder 实例，然后使用启动默认的 Startup 服务，当然你也可以自定义这个启动服务，比如 StatupDevelopment 。
这样写 .UseStartup(typeof(StartupDevelopment).GetTypeInfo().Assembly.FullName)
接下来，就是 Build 我们的刚刚实例化的 webhostbuilder ，生成一个 WebHost 宿主主机。
中间我们就可以对宿主下的服务进行配置，
最后就是执行 Run() 方法，启动应用程序，直到主机关闭。
四、测试结果
1、用动图来演示效果
经过配置，我这里先建立了一个空的数据库 DBInitTest ，然后看看效果：
这里要注意下：根据数据库大小的不同，中间可能经历的时间不一样，我们已经成功的生成了数据库，并初始化出来了数据。
好啦，今天的这个小技巧就说到这里了，你也可以根据自己的情况，根据自己的ORM来设计哟，特别适用于一个给别人展示的Demo项目，和自己的小项目。
2、如果用EFCore是更简单
try
{
// TODO: Only run this if using a real database
myContext.Database.Migrate();
if (!myContext.Posts.Any())
{
myContext.Posts.AddRange(
new List<Post>{
new Post{
Title = "Post Title 1",
Body = "Post Body 1",
Author = "Dave",
LastModified = DateTime.Now
}
}
);
await myContext.SaveChangesAsync();
}
}
扫一扫
3709
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
