private GenDataDef AddDef(string def)
{
var f = def.ToLowerInvariant().Replace('/', '\\');
GenDataDef d;
if (f.Equals("minimal"))
{
if (!LocalCache.ContainsKey(f))
{
d = GenDataDef.CreateMinimal();
LocalCache.Add(f, d);
}
else
{
d = LocalCache[f];
}
}
else if (!LocalCache.ContainsKey(f))
{
d = GenDataBase.DataLoader.LoadData(f).AsDef();
LocalCache.Add(f, d);
}
else
{
d = LocalCache[f];
}
return(d);
}
public async Task PublishInput(MbapHeader header, ushort transactionId)
{
if (!NativeEnabled && !AppInsightsEnabled)
{
return;
}
DiagnosticsEvent telem = new DiagnosticsEvent(name, header.UnitId, transactionId, header.TransactionId,
DateTime.UtcNow.ToString("dd-MM-yyyyThh:mm:ss.ffff"));
cache.Add(transactionId.ToString(), new Tuple <byte, long>(header.UnitId, DateTime.Now.Ticks), 20);
if (NativeEnabled && mqttClient.IsConnected)
{
string jsonString = JsonConvert.SerializeObject(telem);
byte[] msg = Encoding.UTF8.GetBytes(jsonString);
await mqttClient.PublishAsync(QualityOfServiceLevelType.AtMostOnce, outputPiSystem, "application/json",
msg);
}
if (AppInsightsEnabled)
{
tclient?.TrackEvent(name, telem.GetEventProperties(), telem.GetEventMetrics());
}
}
public void LocalCache_AddThrowsExceptionIfNoLocalCacheProviderIsRegistered()
{
using (new MunqContext())
{
var exception = Assert.Throws <KeyNotFoundException>(() => LocalCache.Add("x", "y", TimeSpan.Zero));
Assert.Contains(typeof(ILocalCache).Name, exception.Message);
}
}
/// <summary>
/// Cache a data file programatically.
/// </summary>
/// <param name="name">The name of the cached data.</param>
/// <param name="genDataDef">The data being cached.</param>
/// <returns></returns>
public void Internal(string name, GenDataDef genDataDef)
{
var n = name.ToLowerInvariant().Replace('/', '\\');
if (n.Equals("self"))
{
throw new ArgumentException("The 'self' generator data cannot be added explicitly to the cache", "name");
}
if (!LocalCache.ContainsKey(n))
{
LocalCache.Add(n, genDataDef);
}
}
public void LocalCache_AddUsesRegisteredLocalCacheProvider()
{
using (new MunqContext())
{
var registrar = Dependency.Resolve <IDependencyRegistrar>();
var cache = A.Fake <ILocalCache>();
registrar.RegisterInstance(cache);
LocalCache.Add("SomeKey", 1, TimeSpan.FromHours(1));
A.CallTo(() => cache.Add("SomeKey", 1, TimeSpan.FromHours(1)))
.MustHaveHappened(Repeated.Exactly.Once);
}
}
public async Task SendAsync(byte[] message)
{
if (client == null || !client.IsConnected)
{
logger?.LogWarning("MQTT client is not available to forward message.");
return;
}
try
{
MbapHeader header = MbapHeader.Decode(message);
if (map.HasItem(header.UnitId))
{
if (!subscriptions.Contains(header.UnitId))
{
string resource = map.GetItem(header.UnitId).RtuOutputEvent;
await client.SubscribeAsync(resource, QualityOfServiceLevelType.AtMostOnce,
ModbusMessageReceived);
logger?.LogInformation(
$"MQTT client channel subscribed {resource} with Unit ID = {header.UnitId}");
subscriptions.Add(header.UnitId);
}
cache.Add(GetCacheKey(header), new Tuple <ushort, byte[]>(header.TransactionId, message), 20.0);
string pisystem = map.GetItem(header.UnitId).RtuInputEvent;
await client.PublishAsync(QualityOfServiceLevelType.AtMostOnce, pisystem,
"application/octet-stream", message);
logger?.LogDebug($"VRTU published to {pisystem}");
await diag?.PublishInput(header);
}
else
{
logger?.LogWarning($"Unit Id = {header.UnitId} in Modbus message not found in RTU map.");
}
}
catch (Exception ex)
{
logger?.LogError(ex, "Fault sending MQTT client channel.");
}
}
private void button1_Click(object sender, EventArgs e)
{
HttpWebHelper httpWebHelper = new HttpWebHelper();
ExceptionMsg exceptionMsg = new ExceptionMsg();
try
{
string R_result = httpWebHelper.Get("http://baidu.com", Encoding.UTF8);
MessageBox.Show(exceptionMsg.IP);
}
catch (Exception ex) {
MessageBox.Show(ex.Message);
}
//localCache.Add("mykey", "123", 10);
localCache.Add("mykey", "123");
localCache.Set("11", DataBindingByList1());
ThreadStart threadStart = new ThreadStart(refresh);
Thread thread = new Thread(threadStart);
thread.Start();
new Thread(() =>
{
while (true)
{
Thread.Sleep(1000);
SetText($"9999\r\n");
}
})
{
IsBackground = true
}.Start();
dynamic d = 1;
int c = d + 1;
//MessageBox.Show(c.ToString());
//Greeting("Make", ChineseGreeting);
}
/// <summary>
/// Check if the cache does not contain the data, and adds it then returns the cached data.
/// </summary>
/// <param name="defPath">The data's definition location.</param>
/// <returns></returns>
public GenDataDef this[string defPath]
{
get
{
if (defPath.Equals("self", StringComparison.InvariantCultureIgnoreCase))
{
return(Self);
}
var f = AddDef(defPath);
return(f);
}
set
{
var path = defPath.ToLowerInvariant();
if (!defPath.Equals("self", StringComparison.InvariantCultureIgnoreCase) && !LocalCache.ContainsKey(path))
{
LocalCache.Add(path, value);
}
}
}
public void Add <T>(string key, string dependencyKey, T obj, TimeSpan timeSpan)
{
if (obj == null)
{
return;
}
var policy = new CacheItemPolicy {
AbsoluteExpiration = DateTime.Now + timeSpan
};
LocalCache.Add(new CacheItem(key, obj), policy);
HostFileChangeMonitor monitor = new HostFileChangeMonitor(new List <string>()
{
dependencyKey
});
monitor.NotifyOnChanged(new OnChangedCallback((o) =>
{
LocalCache.Remove(key);
}));
policy.ChangeMonitors.Add(monitor);
}
public void Add <T>(string key, string dependencyKey, T obj)
{
if (obj == null)
{
return;
}
var policy = new CacheItemPolicy {
Priority = CacheItemPriority.NotRemovable
};
LocalCache.Add(new CacheItem(key, obj), policy);
HostFileChangeMonitor monitor = new HostFileChangeMonitor(new List <string>()
{
dependencyKey
});
monitor.NotifyOnChanged(new OnChangedCallback((o) =>
{
LocalCache.Remove(key);
}));
policy.ChangeMonitors.Add(monitor);
}
public byte[] MapIn(byte[] message, byte?alias)
{
MbapHeader header = MbapHeader.Decode(message);
ModbusTransaction tx = ModbusTransaction.Create();
ushort actualTx = header.TransactionId;
ushort proxyTx = tx.Id;
Tuple <ushort, byte> tuple = new Tuple <ushort, byte>(actualTx, header.UnitId);
byte unitId = header.UnitId == (alias ?? header.UnitId) ? header.UnitId : alias.Value;
header.UnitId = unitId;
header.TransactionId = proxyTx;
cache.Add(GetProxyMap(unitId, proxyTx), tuple, 20.0);
byte[] buffer = new byte[message.Length];
byte[] src = header.Encode();
Buffer.BlockCopy(src, 0, buffer, 0, src.Length);
Buffer.BlockCopy(message, src.Length, buffer, src.Length, message.Length - src.Length);
return(buffer);
}
/// <summary>
/// Adds an element with the provided key and value to the
/// <b>IDictionary</b> object.
/// </summary>
public virtual void Add(object key, object value)
{
LocalCache.Add(key, value);
}
