private static void TestList()
{
using (var client = new RedisClient("127.0.0.1", 6379))
{
#region "List类型"
client.AddItemToList("HQF.Tutorial.Redis:userInfoId1", "123");
client.AddItemToList("HQF.Tutorial.Redis:userInfoId1", "1234");
Console.WriteLine("List数据项条数:" + client.GetListCount("HQF.Tutorial.Redis:userInfoId1"));
Console.WriteLine("List数据项第一条数据:" + client.GetItemFromList("HQF.Tutorial.Redis:userInfoId1", 0));
Console.WriteLine("List所有数据");
client.GetAllItemsFromList("HQF.Tutorial.Redis:userInfoId1").ForEach(e => Console.WriteLine(e));
#endregion
#region "List类型做为队列和栈使用"
Console.WriteLine(client.GetListCount("HQF.Tutorial.Redis:userInfoId1"));
//队列先进先出
//Console.WriteLine(client.DequeueItemFromList("userInfoId1"));
//Console.WriteLine(client.DequeueItemFromList("userInfoId1"));
//栈后进先出
Console.WriteLine("出栈" + client.PopItemFromList("HQF.Tutorial.Redis:userInfoId1"));
Console.WriteLine("出栈" + client.PopItemFromList("HQF.Tutorial.Redis:userInfoId1"));
#endregion
}
}
// Saving top rated posts
public void PushTopRatedPosts(IEnumerable <Post> posts)
{
foreach (var post in posts)
{
redis.AddItemToList("topratedposts", JsonSerializer.SerializeToString(post, typeof(Post)));
}
// List will expire every 60min so data is always up to date
redis.Expire("topratedposts", 60);
}
public void dodajUListuPrekrsaja(string prekrsajId, string pravLiceId)
{
try
{
redis.AddItemToList("ListaPrekrsaja:" + pravLiceId, prekrsajId);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public void AddGame(int gameID)
{
redis.AddItemToList(activeGamesKey, gameID.ToString());
if (!loadedActiveGames)
{
LoadGames(true, false);
}
else
{
activeGames.Add(ParseGameInfo(gameID));
}
}
static void Main(string[] args)
{
try
{
using (RedisClient redisClient = new RedisClient("redis://*****:*****@localhost:6379"))
{
IRedisTypedClient <Person> redisUser = redisClient.As <Person>();
var rick = new Person {
Id = "Rick", Name = "Rick @ code with intent"
};
var backy = new Person {
Id = "Backy", Name = "Backy @ becy,com"
};
//var chen = new Person { Id = redisUser.GetNextSequence(), Name = "Chen @ becy,com" };
redisUser.Store(rick);
redisUser.Store(backy);
var allThePeople = redisUser.GetAll();
Console.WriteLine("--- Get All People ---");
foreach (var people in allThePeople)
{
Console.WriteLine($"Id: {people.Id}- Name: {people.Name} ");
}
//Console.WriteLine(allThePeople.Dump()); //return json format
Console.WriteLine("--- GetByUser ---");
redisClient.SetValue("ChenName", "Worameth Semapat", TimeSpan.FromSeconds(50));
Console.WriteLine("Get Result: " + redisClient.GetValue("ChenName"));
Console.WriteLine("--- Get Int ---");
redisClient.Set("testInt", 1);
var getInt = redisClient.Get <int>("testInt");
Console.WriteLine($"Type: {getInt.GetType().Name} - Value: {getInt}");
// Set Expire
redisClient.AddItemToList("ChenList", "Test1");
redisClient.AddItemToList("ChenList", "Test2");
redisClient.Expire("ChenList", 30);
}
}
catch (RedisException ex) //When server down or invalid password
{
Console.WriteLine("RedisException");
Console.WriteLine(ex.Message);
}
}
public void AddItemToList(string listId, string value)
{
using (RedisClient rc = new RedisClient(_option.Server, _option.Port, _option.Password))
{
rc.AddItemToList(listId, value);
}
}
public ActionResult Redis()
{
RedisClient redisClient = new RedisClient("127.0.0.1", 6379);
redisClient.AddItemToList("list", "sqlserver"); //添加列表
var list = redisClient.GetAllItemsFromList("list"); //获取列表
var set = redisClient.GetAllItemsFromSet("myset"); //获取集合
redisClient.SetEntryInHash("myhash", "sex", "remale"); //添加哈希键值对
var dic = redisClient.GetAllEntriesFromHash("myhash"); //获取哈希集
var name = redisClient.GetValueFromHash("myhash", "name");
//发布消息
var msg = System.Text.UTF8Encoding.Default.GetBytes("thanks");
redisClient.Publish("redischat", msg);
redisClient.PublishMessage("redischat", "my name is llm");
//事务
using (var trans = redisClient.CreateTransaction())
{
trans.QueueCommand(r => r.Set("name", "gg"));
trans.Commit();
}
return(JsonOK(redisClient.Get <string>("myname")));
}
public static void Get_XAGL_WM2000YXGT_IndicatorDiagram_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var indicatorDiagram = new IotDataOilWellIndicatorDiagram()
{
AlarmCode = 0,
AlarmMsg = "正常"
};
indicatorDiagram.WellId = par.DeviceId;
indicatorDiagram.DeviceTypeId = par.DeviceTypeId;
indicatorDiagram.DateTime = DateTime.Now;
indicatorDiagram.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_IndicatorDiagram", indicatorDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:IndicatorDiagram", indicatorDiagram);
redisClient.Set($"Single:OilWell:IndicatorDiagram:{par.DeviceName}-{par.DeviceId}", indicatorDiagram);
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static void AddItemToList(string listId, string value)
{
using (RedisClient client = GetClient())
{
client.AddItemToList(listId, value);
}
}
public static void Get_XAGL_WM2000KZG_ControllerStatus_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var iotDataOilWellControllerState = new IotDataOilWellControllerState()
{
NetworkNode = ClientInfo.ManyIpAddress,
AlarmCode = 0,
AlarmMsg = "正常"
};
iotDataOilWellControllerState.WellId = par.DeviceId;
iotDataOilWellControllerState.DeviceTypeId = par.DeviceTypeId;
iotDataOilWellControllerState.DateTime = DateTime.Now;
iotDataOilWellControllerState.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_ControllerState", iotDataOilWellControllerState.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:ControllerState", iotDataOilWellControllerState);
redisClient.Set($"Single:OilWell:ControllerState:{par.DeviceName}-{par.DeviceId}", iotDataOilWellControllerState);
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
/// <summary>
/// 添加value 到现有List
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void AddItemToList(string key, string value)
{
using (RedisClient redisClient = GetRedisClient())
{
redisClient.AddItemToList(key, value);
}
}
/// <summary>
/// 添加至list
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="val"></param>
public static void AddEntityToList <T>(string key, T val)
{
using (var client = new RedisClient(Host))
{
string value = JsonConvert.SerializeObject(val);
client.AddItemToList(key, value);
}
}
public static void lpush(String key, String value)
{
using (RedisClient redisClient = new RedisClient(host, port))
{
redisClient.AddItemToList(key, value);
redisClient.Dispose();
}
}
public static async Task Get_LYQH_GJL_Pressure(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
IotDataOilWellPressure oillPress = new IotDataOilWellPressure
{
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
var modbusAddress = par.ModbusAddress;
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
oillPress.WellId = par.DeviceId;
oillPress.DeviceTypeId = par.DeviceTypeId;
oillPress.Mock = false;
var failed = await SetPressure(redisClient, client, modbusAddress, oillPress, logIotModbusPoll, par);
oillPress.NetworkNode = ClientInfo.ManyIpAddress;
//用于将读取的结果写入Redis队列
if (!failed || par.UseMockData)
{
oillPress.Mock = par.UseMockData;
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_Pressure", oillPress.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:Pressure", oillPress);
redisClient.Set($"Single:OilWell:Pressure:{par.DeviceName}-{par.DeviceId}", oillPress);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, failed ? -2 : 0, oillPress.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
private void btnWriteToReids_Click(object sender, RoutedEventArgs e)
{
var appSettings = new AppSettings();
var redisCon = appSettings.GetString("TestRedis");
using var redisClient = new RedisClient(redisCon);
var json = this.txtJson.Text;
var listId = this.txtListId.Text;
redisClient.AddItemToList(listId, json.IndentJson());
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
string listkey = "listlog";
while (1 == 1)
{
Console.WriteLine("请输入发送的内容");
var message = Console.ReadLine();
using (RedisClient client = new RedisClient("127.0.0.1"))
{
client.AddItemToList(listkey, message);
}
}
}
public static void Add(string name)
{
//Task.Factory.StartNew(() =>
//{
OrderInfo mod = new OrderInfo()
{
Name = name,
OrderTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
};
string c = JsonConvert.SerializeObject(mod);
Console.WriteLine($"{c}下单成功！");
string listKey = "orderlist";
rc.AddItemToList(listKey, c);
//});
}
public void Run()
{
var db = new RedisClient("127.0.0.1", 6379, "lottak2014", 0);
Console.WriteLine(db.GetAll <string>());
db.AddItemToList("listid", "1");
Console.WriteLine("请输入设置的键：");
var _key = Console.ReadLine();
Console.WriteLine("请输入设置的值：");
var _value = Console.ReadLine();
db.Set <string>(_key, _value);
Console.WriteLine("设置完成=>{0}:{1}", _key, db.Get <string>(_key));
Console.WriteLine(db.Exists(_key));
}
protected override void RealTestOutPut()
{
RedisClient client = new RedisClient("localhost", 6379);
"tac's value is: ".Write();
client.Get <object>("tac").WriteLine();
client.Increment("tac", 1);
"now changed, tac's value is: ".Write();
client.Get <object>("tac").WriteLine();
"ltac's value is: ".WriteLine();
client.GetRangeFromList("ltac", 0, -1).WriteLineEach();
client.AddItemToList("ltac", "test" + client.Get <object>("tac"));
"now changed, ltac's value is: ".WriteLine();
client.GetRangeFromList("ltac", 0, -1).WriteLineEach();
}
static void Main(string[] args)
{
string strKey = "addItemToList";
List <string> ls = new List <string>()
{
"one", "two", "three"
};
ls.ForEach(x => rc.AddItemToList(strKey, x));
ls = rc.GetAllItemsFromList(strKey);
ls.ForEach(s => Console.WriteLine(strKey + ":" + s));
var rcs = rc.Lists[strKey];
rcs.Clear();
rcs.Remove("Two");
Console.ReadKey();
}
public void AddToList(string key, string element)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException("key");
}
if (element == null)
{
throw new ArgumentNullException("element");
}
if (this.IsDisposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
this.operation.QueueCommand(client => client.AddItemToList(key, element));
this.IsEmpty = false;
}
/// <summary>
/// 读取配水间干压mock
/// </summary>
/// <param name="client"></param>
/// <param name="redisClient"></param>
/// <param name="messageString"></param>
public static void Get_ZJJH_WTPM_TrunkPressure_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var waterStation = new IotDataWaterStation();
waterStation.DeviceTypeId = par.DeviceTypeId;
try
{
waterStation.AlarmCode = 0;
waterStation.AlarmMsg = "mock数据";
waterStation.StationId = par.DeviceId; //注水间ID
waterStation.Mock = par.UseMockData;
waterStation.Mock = par.UseMockData;
waterStation.DateTime = DateTime.Now;
//用于将读取的结果写入Redis队列
redisClient.AddItemToList("YCIOT:IOT_Data_WaterStation", waterStation.ToJson().IndentJson());
redisClient.Set($"Group:WaterStation:{par.DeviceName}-{par.DeviceId}", waterStation);
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, waterStation.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static void Get_XAGL_PumpPressure_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var pumpPressure = new IotDataPumpPressure();
pumpPressure.DeviceTypeId = par.DeviceTypeId;
try
{
pumpPressure.AlarmCode = 0;
pumpPressure.AlarmMsg = "mock数据";
pumpPressure.Mock = par.UseMockData;
pumpPressure.PumpId = par.DeviceId; //泵编号
pumpPressure.Mock = par.UseMockData;
pumpPressure.DateTime = DateTime.Now;
//用于将读取的结果写入Redis队列
redisClient.AddItemToList("YCIOT:IOT_Data_PumpPressure", pumpPressure.ToJson().IndentJson());
redisClient.Set($"Group:PumpPressure:{par.DeviceName}-{par.DeviceId}", pumpPressure);
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, pumpPressure.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
public static void Get_XAGY_WII_WaterInjectingInstrument_Mock(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
var waterWell = new IotDataWaterWell
{
AlarmCode = 0,
AlarmMsg = ""
};
try
{
waterWell.AlarmCode = 0;
waterWell.AlarmMsg = "Mock数据";
waterWell.Mock = par.UseMockData;
waterWell.WellId = par.DeviceId;
waterWell.DateTime = DateTime.Now;
redisClient.AddItemToList("YCIOT:IOT_Data_WaterWell", waterWell.ToJson().IndentJson());
redisClient.Set($"Group:WaterWell:{par.DeviceName}-{par.DeviceId}", waterWell);
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0, waterWell.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
private void RegisterMove(string move, int stateAfterMove)
{
AlgebraicMove algMove = new AlgebraicMove();
algMove.move = move;
//TODO: If it's a game ending move
//Turn to another player
//Enter the move first
redis.AddItemToList(movesKey, algMove.move);
if (movesLoaded)
{
moves.Add(algMove);
}
UpdateTimeAfterMove();
SetDataEntry(gameStateKey, stateAfterMove.ToString());
GameState newGameState = (GameState)stateAfterMove;
if (newGameState == GameState.Tie || newGameState == GameState.WhiteWin || newGameState == GameState.BlackWin)
{
FinishGame();
}
}
public static void Write(RedisClient redisClient, ControlRequest par, dynamic table, LogIotModbusPoll logIotModbusPoll, string method, string message)
{
string errorMsg = table.AlarmMsg;
string msg = $"{par.DeviceName}-{par.DeviceId}-{par.ModbusAddress}";
table.AlarmCode = -1;
table.AlarmMsg = "数据异常";
if (errorMsg == "正常")
{
errorMsg = table.AlarmMsg;
}
table.Mock = par.UseMockData;
logIotModbusPoll.Type = method;
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = $"{msg}:{message}[{errorMsg}]";
logIotModbusPoll.Result.Info();
redisClient.AddItemToList("YCIOT:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
public static void Show(string id, int minute)
{
#region
//开启10个线程去抢购
Console.WriteLine($"在{minute}分0秒正式开启秒杀！");
var flag = true;
while (flag)
{
if (DateTime.Now.Minute == minute)
{
flag = false;
for (int i = 1; i <= 100; i++)
{
string name = $"客户端{id}号:{i}";
Task.Run(() =>
{
using (RedisClient client = new RedisClient("127.0.0.1", 6379))
{
OrderInfo orderInfo = new OrderInfo()
{
ID = name,
OrderTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
};
string listkey = "orderlist";
client.AddItemToList("orderlist", Newtonsoft.Json.JsonConvert.SerializeObject(orderInfo));
Console.WriteLine($"{name}下单成功");
}
});
Thread.Sleep(10);
}
}
Thread.Sleep(10);
}
Console.ReadLine();
#endregion
}
public void WriteToDatabase(List <SampleCode> codes)
{
const Int32 SampleDataReserve = 10000;
try
{
using (RedisClient LocalClient = getClient(_RedisLocalPort))
{
if (LocalClient == null)
{
return;
}
if (LocalClient != null)
{
LocalClient.Db = _CurrentDB;
}
Int32 len = LocalClient.LLen("SampleData");
if (SampleDataReserve < len + codes.Count) //当本地缓存大于1万条记录时，减小数据库。将来可以做本地磁盘缓存。
{
LocalClient.LTrim("SampleData", len + codes.Count - SampleDataReserve, -1);
}
for (int i = 0; i < codes.Count; i++)
{
String value = Newtonsoft.Json.JsonConvert.SerializeObject(codes[i]);
LocalClient.AddItemToList("SampleData", value);
}
}
}
catch (Exception ex)
{
Console.Write("WriteToDatabase" + ex.Message);
}
finally
{
}
}
public static async Task Get_XAGL_WM1000DLT_CurrentDiagram(ModbusRtuOverTcp client, RedisClient redisClient, string messageString)
{
var par = messageString.FromJson <ControlRequest>();
try
{
var currentDiagram = new IotDataOilWellCurrentDiagram()
{
NetworkNode = ClientInfo.ManyIpAddress,
AlarmCode = 0,
AlarmMsg = "正常"
};
var logIotModbusPoll = par.ConvertTo <LogIotModbusPoll>();
logIotModbusPoll.State = 0;
logIotModbusPoll.Result = "ok";
var modbusAddress = par.ModbusAddress;
var jo1 = (JObject)JsonConvert.DeserializeObject(par.CommandParameter);
currentDiagram.Displacement = Convert.ToDouble(jo1["0"].ToString());
ClientInfo.CurrentModbusPoolAddress = modbusAddress;
currentDiagram.D = new List <double>(); //位移
currentDiagram.C = new List <double>(); //电流
currentDiagram.DateTime = DateTime.Now;
currentDiagram.WellId = par.DeviceId;
currentDiagram.DeviceTypeId = par.DeviceTypeId;
currentDiagram.Mock = false;
var flag = true;
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
var read = await client.ReadAsync($"s={par.ModbusAddress};x=3;4117", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
if (value == 0)
{
currentDiagram.NetworkNode = ClientInfo.ManyIpAddress;
currentDiagram.AlarmCode = 3;
currentDiagram.AlarmMsg = "停井";
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_CurrentDiagram", currentDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:CurrentDiagram", currentDiagram);
redisClient.Set($"Single:OilWell:CurrentDiagram:{par.DeviceName}-{par.DeviceId}", currentDiagram);
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, 0,
currentDiagram.ToJson().IndentJson());
}
return;
}
}
else
{
flag = false;
currentDiagram.AlarmCode = -1;
currentDiagram.AlarmMsg = "数据异常";
currentDiagram.Mock = par.UseMockData;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取采样间隔数据异常！";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
if (flag)
{
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;8097", 1);
if (read.IsSuccess)
{
var value = client.ByteTransform.TransInt16(read.Content, 0);
currentDiagram.Count = 250;
currentDiagram.Interval = Math.Round(value * 0.01, 3);
}
else
{
flag = false;
currentDiagram.AlarmCode = -1;
currentDiagram.AlarmMsg = "数据异常";
logIotModbusPoll.Type = "Get_XAGL_WM1000DLT_CurrentDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
currentDiagram.Mock = par.UseMockData;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "读取采样间隔数据异常！";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
}
ushort step = 100;
if (flag && currentDiagram.Count <= 300 && currentDiagram.Count >= step)
{
var regAddress = 37768;//读取电流数据
for (ushort i = 0; i < currentDiagram.Count && flag; i += step)
{
var itemCount = (i + step > currentDiagram.Count) ? (ushort)(currentDiagram.Count - i) : step;
if (isDebug)
{
Logger.Info($"{i}:{itemCount}:{(ushort)(regAddress + i)}");
}
lock (ClientInfo.locker)
{
ClientInfo.RequestTime = DateTime.Now;
ClientInfo.ExpectedType = 0x03;
ClientInfo.ExpectedDataLen = itemCount * 2;
}
read = await client.ReadAsync($"s={par.ModbusAddress};x=3;{(regAddress + i)}", itemCount);
if (read.IsSuccess)
{
for (var j = 0; j < itemCount; j++)
{
var value = client.ByteTransform.TransInt16(read.Content, j++);
if (value != 0)
{
var C = Math.Round(((value - 800) * 5 / 3200.0) * 15, 2);
currentDiagram.C.Add(C);
}
else
{
currentDiagram.C.Add(value);
}
}
}
else
{
flag = false;
currentDiagram.AlarmCode = -1;
currentDiagram.AlarmMsg = "数据异常";
currentDiagram.Mock = par.UseMockData;
logIotModbusPoll.Type = "Get_XAGL_WM1000DLT_CurrentDiagram";
logIotModbusPoll.DateTime = DateTime.Now;
logIotModbusPoll.State = -1;
logIotModbusPoll.Result = "从 " + (regAddress + i).ToString() + " 个开始，读取 " + itemCount.ToString() + " 个电流图电流数据异常!";
redisClient.AddItemToList("YCIOT:ERROR:Log_IOT_Modbus_Poll", logIotModbusPoll.ToJson().IndentJson());
}
Thread.Sleep(100);
}
currentDiagram.MaxCurrent = currentDiagram.C.Max(); //最大电流
currentDiagram.MinCurrent = currentDiagram.C.Min(); //最小电流
currentDiagram.AvgCurrent = Math.Round(currentDiagram.C.Average(), 2); //平均电流
}
else
{
flag = false;
}
currentDiagram.NetworkNode = ClientInfo.ManyIpAddress;
if (flag == true || par.UseMockData)
{
currentDiagram.Mock = par.UseMockData;
if (currentDiagram.Count != null)
{
currentDiagram.D = DisplacementUtils.FitDisplacement((ushort)currentDiagram.Count,
(double)currentDiagram.Displacement);
}
redisClient.AddItemToList("YCIOT:IOT_Data_OilWell_CurrentDiagram", currentDiagram.ToJson().IndentJson());
redisClient.Set($"Group:OilWell:{par.DeviceName}-{par.DeviceId}:CurrentDiagram", currentDiagram);
redisClient.Set($"Single:OilWell:CurrentDiagram:{par.DeviceName}-{par.DeviceId}", currentDiagram);
}
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, flag ? 0 : -2, currentDiagram.ToJson().IndentJson());
}
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error(ex.StackTrace);
Logger.Error(ex.Source);
//用于通过ServerEvent给调用着返回消息
if (!par.UserName.IsNullOrEmpty())
{
ServerEventHelper.SendSseMessage(par.UserName, par.SessionId, -1, ex.Message);
}
}
}
static void Main(string[] args)
{
using (IRedisClient client = new RedisClient("127.0.0.1", 6379, null, 0))
{
//删除当前数据库中的所有Key
client.FlushDb();
string hashId = "stu";
Dictionary <string, string> dic = new Dictionary <string, string>();
dic.Add("name", "Micahel Shen");
dic.Add("age", "18");
dic.Add("address", "anyue");
#region 添加、获取字符串
//新增Key,默认是做了序列化存储
client.Set <string>("name", "clay");
//读取key 一般不建议这个方法
var value0 = client.GetValue("name");
Console.WriteLine(JsonConvert.DeserializeObject <string>(value0));
//读取二 推荐试用，帮我们作了反序列
var value1 = client.Get <string>("name");
Console.WriteLine(value1);
Dictionary <string, string> disc = new Dictionary <string, string>();
disc.Add("id", "001");
disc.Add("name", "michaelshen");
disc.Add("address", "anyuexian");
#endregion
#region 批量的写
//批量的写
client.SetAll(disc);
var list = client.GetAll <string>(new string[] { "id", "name" });
foreach (var item in list)
{
Console.WriteLine(item);
}
#endregion
#region 设置过期时间
client.FlushDb();
client.Set <string>("name", "Michael Shen", TimeSpan.FromSeconds(10));
client.Set <string>("key", "Shen", DateTime.Now.AddSeconds(10));
//如果读不到key则返回一个"";
#endregion
#region 追加字符串
client.FlushDb();
//client.Set("name", "Michael Shen");
client.AppendToValue("name", "Michael Shen");
client.AppendToValue("name", " is SPY");
Console.WriteLine(client.Get <string>("name"));
#endregion
#region 自增自减
client.FlushDb();
var a = client.Increment("count", 1);
client.Increment("count", 100);
//自减
client.Decrement("count", 1);
var b = client.Decrement("count", 5);
Console.WriteLine(client.Get <int>("count"));
#endregion
#region Add和Set
//Add会先判断数据库中是否存在对应的key，如果存在，再Add的话，会失败，并返回false，否则成功并返回true
client.FlushDb();
Console.WriteLine(client.Add <string>("name", "michael Shen")); //true
Console.WriteLine(client.Add <string>("name", "michael Shen")); //false
Console.WriteLine(client.Add <string>("name", "Shen")); //false
//Set
Console.WriteLine(client.Add <int>("age", 18)); //true
Console.WriteLine(client.Add <int>("age", 19)); //true
Console.WriteLine(client.Add <int>("age", 20)); //true
#endregion
#region 判断Redis中是否包含某一个Key
Console.WriteLine(client.ContainsKey("name")); //true
Console.WriteLine(client.ContainsKey("NoKey")); //true
#endregion
#region 获取类型
client.FlushDb();
client.Set <string>("name", "MichaelShen");
var type = client.GetEntryType("name");
Console.WriteLine(type); //String
client.AddItemToList("list1", "asdga");
Console.WriteLine(client.GetEntryType("list1")); //List
#endregion
#region Hash
client.FlushDb();
Console.WriteLine("Hash");
client.SetEntryInHash(hashId, "name", "Michael Shen");
client.SetEntryInHash(hashId, "age", "18");
var value = client.GetValueFromHash(hashId, "name");
Console.WriteLine(value);
//批量操作
Dictionary <string, string> stu1 = new Dictionary <string, string>();
stu1.Add("name", "Michael Shen1");
stu1.Add("Id", "2017060528");
stu1.Add("age", "19");
client.SetRangeInHash(hashId, stu1);
var result = client.GetAllEntriesFromHash(hashId);
foreach (var item in result)
{
Console.WriteLine(item.Key + ":" + item.Value);
}
//如果hash集合中存在对应的key，则新增失败，否则新增成功
var res = client.SetEntryInHashIfNotExists(hashId, "Nkey", "new value"); //true
var res1 = client.SetEntryInHashIfNotExists(hashId, "name", "new value"); //false
Console.WriteLine(res);
Console.WriteLine(res1);
#endregion
#region 存用户信息
client.FlushDb();
Console.Clear();
//用String去存储用户信息对象
//用户信息，首先把对象做一个json序列化，然后存储再Redis的string里，
//但是如果需要修改这个对象中的其中一个属性值的时候，先把这个对象json字符串读取出来反序列化，
//然后修改属性值，修改完后再继续序列化再存储进去
//用hash存储用户信息对象
client.StoreAsHash <User>(new User {
ID = "001", Age = "22", Name = "MichaelShen"
});
Console.WriteLine(client.GetFromHash <User>("001").ToString());
#endregion
#region Hash里面Key总数
Console.Clear();
client.FlushDb();
client.SetRangeInHash(hashId, dic);
Console.WriteLine(client.GetHashCount(hashId));
#endregion
#region 获取所有的Keys和Values
Console.Clear();
client.FlushDb();
client.SetRangeInHash(hashId, dic);
var keys = client.GetHashKeys(hashId);
var values = client.GetHashValues(hashId);
foreach (var item in keys)
{
Console.WriteLine(item);
}
foreach (var item in values)
{
Console.WriteLine(item);
}
#endregion
#region 除Hash里的key
//接上
Console.WriteLine(client.RemoveEntryFromHash(hashId, "age"));
foreach (var item in client.GetHashKeys(hashId))
{
Console.WriteLine(item);
}
client.SetEntryInHash(hashId, "age", "22");
#endregion
#region 判断Hash里是否包含某个Key项
Console.Clear();
Console.WriteLine(client.HashContainsEntry(hashId, "name"));
Console.WriteLine(client.HashContainsEntry(hashId, "Nokey"));
#endregion
#region 给Hash里的数字自增
client.SetEntryInHash(hashId, "count", "1");
client.IncrementValueInHash(hashId, "count", 1);
Console.WriteLine(client.GetValueFromHash(hashId, "count"));
#endregion
#region List
client.FlushDb();
Console.Clear();
{
var libai = new User
{
ID = "001",
Name = "李白",
Age = "22"
};
var guanyu = new User
{
Age = "23",
Name = "关于",
ID = "002"
};
client.AddItemToList("list0", JsonConvert.SerializeObject(libai));
client.AddItemToList("list0", JsonConvert.SerializeObject(guanyu));
#region 从前面、后面插入
//从前面插入
client.PrependItemToList("list0", JsonConvert.SerializeObject(new User {
ID = "003", Age = "25", Name = "花木兰"
}));
//从后面插入
client.PushItemToList("list0", JsonConvert.SerializeObject(new User {
ID = "004", Age = "26", Name = "鲁班"
}));
#endregion
#region List设置过期时间
client.ExpireEntryAt("list0", DateTime.Now.AddSeconds(10));
#endregion
#region 批量操作
//批量增加
client.AddRangeToList("list1", new List <string> {
"fdasf", "sadfa", "fdsafsagdfs", "1354213"
});
var results = client.GetRangeFromList("list1", 0, 2);
foreach (var item in results)
{
Console.WriteLine(item);
}
#endregion
#region 当数据结构操作
//当栈来操作(后进先出)
client.AddItemToList("listNum", "1");
client.AddItemToList("listNum", "2");
client.AddItemToList("listNum", "3");
client.AddItemToList("listNum", "4");
//从尾部删除并返回对应的值
Console.WriteLine(client.RemoveEndFromList("listNum")); //4
Console.WriteLine(client.RemoveEndFromList("listNum")); //3
Console.WriteLine(client.RemoveEndFromList("listNum")); //2
Console.WriteLine(client.RemoveEndFromList("listNum")); //1
//当队列来操作（先进先出）
client.AddItemToList("listNum", "1");
client.AddItemToList("listNum", "2");
client.AddItemToList("listNum", "3");
client.AddItemToList("listNum", "4");
//从头部删除并返回对应的值
Console.WriteLine(client.RemoveStartFromList("listNum"));
Console.WriteLine(client.RemoveStartFromList("listNum"));
Console.WriteLine(client.RemoveStartFromList("listNum"));
Console.WriteLine(client.RemoveStartFromList("listNum"));
//Pop和Push（栈数据结构的操作-先进后出）
client.PushItemToList("listStack", "1");
client.PushItemToList("listStack", "2");
client.PushItemToList("listStack", "3");
client.PushItemToList("listStack", "4");
Console.WriteLine(client.PopItemFromList("listStack"));
Console.WriteLine(client.PopItemFromList("listStack"));
Console.WriteLine(client.PopItemFromList("listStack"));
Console.WriteLine(client.PopItemFromList("listStack"));
//从一个List中pop出来添加到另一个List的头部中
client.PushItemToList("fromList", "1");
client.PushItemToList("fromList", "2");
client.PushItemToList("fromList", "3");
client.PushItemToList("fromList", "4");
Console.WriteLine(client.PopAndPushItemBetweenLists("fromList", "toList"));
Console.WriteLine(client.PopAndPushItemBetweenLists("fromList", "toList"));
Console.WriteLine(client.PopAndPushItemBetweenLists("fromList", "toList"));
#endregion
#region 其他
//获取key的过期时间
Console.WriteLine(client.GetTimeToLive("fromList"));
client.ExpireEntryAt("fromList", DateTime.Now.AddSeconds(60));
Console.WriteLine(client.GetTimeToLive("fromList"));
#endregion
}
#endregion
}
}
