public async Task Handle(OnlinePushEvent p_event) { StringCache sc = new StringCache(p_event.PrefixKey); if (p_event.Receivers != null && p_event.Receivers.Count > 0) { foreach (var id in p_event.Receivers) { if (Online.All.TryGetValue(id, out var ls) && ls != null && ls.Count > 0) { // 在线推送,直接放入推送队列 if (p_event.PushFirstSession) { ls[0].AddMsg(p_event.Msg); await sc.Set(null, true); } else { foreach (var ci in ls) { ci.AddMsg(p_event.Msg); } // 设置处理标志: msg:Push:6位id前缀:userid = true await sc.Set(id, true); } } } } // 统计总数+1 await sc.Increment("cnt"); }
public async Task <string> CacheStr(string p_key, string p_val) { var cache = new StringCache("Test:Str"); await cache.Set(p_key, p_val); return(await cache.Get <string>(p_key)); }
/// <summary> /// Insert a ingle row /// </summary> /// <typeparam name="T"></typeparam> /// <param name="connection"></param> /// <param name="param">object</param> /// <param name="table">Optional table name</param> /// <param name="commandTimeout">commandTimeout</param> /// <param name="transaction">transaction</param> /// <returns>Numbers of rows affected</returns> public static int InsertSingle <T>(this IDbConnection connection, T param, int?commandTimeout = null, IDbTransaction transaction = null) { if (param == null) { throw new ArgumentNullException("param can not be null."); } if (param is IEnumerable) { throw new ArgumentException("param can not be a IEnumerable. Call InsertMany instead."); } var type = typeof(T); string cachedCommand; var value = StringCache.TryGetCommand(type, Operation.Insert, out cachedCommand); if (string.IsNullOrEmpty(cachedCommand)) { cachedCommand = InsertGenerator.GenerateSingle(param); StringCache.Add(type, Operation.Insert, cachedCommand); } return(connection.Execute(cachedCommand, param, commandTimeout: commandTimeout, transaction: transaction)); }
public void GetOrAdd_DisposesReleasedReferencesOnExpand() { // Arrange var cache = new StringCache(2); // Act StringArea(); // Force a collection GC.Collect(); var str1 = $"{1}"; var result = cache.GetOrAddValue(str1); // Assert Assert.Equal(1, cache.ApproximateSize); Assert.Same(result, str1); void StringArea() { var first = $"{1}"; var test = cache.GetOrAddValue(first); Assert.Same(first, test); Assert.Equal(1, cache.ApproximateSize); GC.KeepAlive(first); } }
public BindingEntry(int errorCode, Match match, StringCache stringCache) { this.stringCache = stringCache; this.ErrorCode = errorCode; this.Count = 1; if (Constants.IsXamlDesigner) { this.Description = nameof(this.Description); this.SourceProperty = nameof(this.SourceProperty); this.SourcePropertyType = nameof(this.SourcePropertyType); this.SourcePropertyName = nameof(this.SourcePropertyName); this.BindingPath = nameof(this.BindingPath); this.DataItemType = nameof(this.DataItemType); this.DataItemName = nameof(this.DataItemName); this.TargetElementType = nameof(this.TargetElementType); this.TargetElementName = nameof(this.TargetElementName); this.TargetProperty = nameof(this.TargetProperty); this.TargetPropertyType = nameof(this.TargetPropertyType); } else { this.Description = stringCache.Get(match.Value); this.SourceProperty = stringCache.Get(match.Groups[nameof(this.SourceProperty)].Value); this.SourcePropertyType = stringCache.Get(match.Groups[nameof(this.SourcePropertyType)].Value); this.SourcePropertyName = stringCache.Get(match.Groups[nameof(this.SourcePropertyName)].Value); this.BindingPath = stringCache.Get(match.Groups[nameof(this.BindingPath)].Value); this.DataItemType = stringCache.Get(match.Groups[nameof(this.DataItemType)].Value); this.DataItemName = stringCache.Get(match.Groups[nameof(this.DataItemName)].Value); this.TargetElementType = stringCache.Get(match.Groups[nameof(this.TargetElementType)].Value); this.TargetElementName = stringCache.Get(match.Groups[nameof(this.TargetElementName)].Value); this.TargetProperty = stringCache.Get(match.Groups[nameof(this.TargetProperty)].Value); this.TargetPropertyType = stringCache.Get(match.Groups[nameof(this.TargetPropertyType)].Value); } }
public static void ExecuteAsync( string cacheKey, string queueName, string executeable ) { // Get Cache to see if we already did this var cachedValues = StringCache.getCache(cacheKey); if (cachedValues == null) { // Get queue lock var queueLock = StringCache.getCache(queueName); if (queueLock != "true") { StringCache.setCache(queueName, "true"); QueueManager.addToQueue(queueName, () => { try { var results = executeable; StringCache.setCache(cacheKey, results); } catch (Exception e) { //StringCache.AppendCache(this.InstanceGuid.ToString(), e.ToString() + "\n"); } StringCache.setCache(queueName, ""); }); //ExpireSolution(true); } } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { var launch = false; if (!DA.GetData(0, ref launch)) { return; } DA.DisableGapLogic(); const string url = "https://energyplus.net/weather"; if (launch) { QueueManager.addToQueue(url, () => { try { Process.Start(url); } catch (Exception e) { StringCache.setCache(InstanceGuid.ToString(), e.Message); } }); } var errors = StringCache.getCache(InstanceGuid.ToString()); if (errors != null) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, errors); } }
/// <summary> /// UploadXML in string string Cache /// </summary> /// <param name="companyCode"></param> /// <param name="userId"></param> /// <param name="fnolParametersXml"></param> /// <param name="serviceName"></param> private static void UploadXML(string companyCode, string userId, string fnolParametersXml, string serviceName) { string message = string.Empty; string zippedfnolXmlString = string.Empty; string stringCachekey = string.Empty; try { if (!string.IsNullOrEmpty(companyCode) && !string.IsNullOrEmpty(fnolParametersXml)) { //creating string cache key stringCachekey = companyCode.ToUpper() + "_" + userId.ToUpper() + "_" + serviceName.ToUpper(); StringCache stringCache = new StringCache(); zippedfnolXmlString = FNOLHelper.GZip(fnolParametersXml); stringCache.SetString(stringCachekey, cacheVersion, zippedfnolXmlString); } else { throw new Exception("Either Company Code or User Id is empty."); } } catch (Exception) { throw; } }
public void GetOrAdd(string input) { StringCache stringCache = new StringCache(); string added = stringCache.GetOrAdd(input); Assert.AreEqual(added, input); }
public void SetUp() { containingObject = new GameObject(); #pragma warning disable 0618 subject = containingObject.AddComponent <StringCache>(); #pragma warning restore 0618 }
private void PollDownloadContent( string inputJson, string downloadPath, string localPath, string overrides, bool reload, string cacheKey ) { var queueName = "Download" + cacheKey; // Get queue lock var queueLock = StringCache.getCache(queueName); var downloaded = false; var inputData = new Inputs().FromJson(inputJson); if (reload) { StringCache.setCache(InstanceGuid.ToString(), ""); } if (queueLock != "true" && inputData.Task != null) { StringCache.setCache(queueName, "true"); StringCache.setCache(cacheKey, null); QueueManager.addToQueue(queueName, () => { try { while (!downloaded) { StringCache.setCache(cacheKey + "progress", "Downloading..."); ExpireSolutionThreadSafe(true); downloaded = DownloadContent.Download(inputJson, downloadPath, localPath, overrides); StringCache.setCache(cacheKey, downloaded.ToString()); if (!downloaded) { StringCache.setCache(cacheKey + "progress", "Waiting for results..."); ExpireSolutionThreadSafe(true); Thread.Sleep(60000); } else { StringCache.setCache(cacheKey + "progress", "Downloaded files"); } ExpireSolutionThreadSafe(true); } } catch (Exception e) { StringCache.setCache(InstanceGuid.ToString(), e.Message); StringCache.setCache(cacheKey, "error"); } ExpireSolutionThreadSafe(true); Thread.Sleep(2000); StringCache.setCache(queueName, ""); }); } }
internal RouteHandler Find(string httpMethod, char[] buffer, int len, out RouteMatch routeMatch) { RouteHandler handler; var reqHash = StringCache.CalcHash(httpMethod, buffer, len); int askSign = -1; for (int i = 0; i < len; i++) { if (buffer[i] == '?') { askSign = i; break; } } if (askSign == -1 && Cache.TryGetValue(reqHash, out handler)) { if (handler.Pattern.IsStatic) { routeMatch = handler.Pattern.ExtractMatch(handler.Url, 0); return(handler); } } var rawUrl = new string(buffer, 0, len); return(FindRoute(httpMethod, rawUrl, reqHash, out routeMatch)); }
public void GetOrAdd(string?input) { var stringCache = new StringCache(); var added = stringCache.GetOrAdd(input); Assert.AreEqual(added, input); }
public void StringCacheRemembersItemsUniquely() { StringCache cache = new StringCache(2000000, 10); cache.Add(key0, value0); cache.Add(key1, value1); cache.Add(key2, value2); cache.Add(key3, value3); Assert.AreEqual(value0, cache.Get(key0)); Assert.AreEqual(value1, cache.Get(key1)); Assert.AreEqual(value2, cache.Get(key2)); Assert.AreEqual(value3, cache.Get(key3)); // Test unmapped inputs Assert.IsNull(cache.Get(null)); Assert.IsNull(cache.Get("")); Assert.IsNull(cache.Get("I Do Not Exist as a Key")); // Test that null can be used as a key or as a value cache.Add(null, "I'm with null"); cache.Add("I have a null value", null); Assert.AreEqual("I'm with null", cache.Get(null)); Assert.IsNull(cache.Get("I have a null value")); // Test that null can be used as a key and as a value cache.Add(null, null); Assert.IsNull(cache.Get(null)); // Test that adding a key after failing to retrieve it causes correct behavior cache.Add("", "I am a new value"); Assert.AreEqual("I am a new value", cache.Get("")); }
public async Task <long> CacheLong(string p_key, long p_val) { var cache = new StringCache("Test:Long"); await cache.Set(p_key, p_val); return(await cache.Get <long>(p_key)); }
public void GetStringCachingMultipleStrings() { string[] expected = new[] { "Hello", "hello", "World", "World ", "foo", "bar", "baz", "qux", "0", "1", " ", String.Empty, }; string[] actual = new string[expected.Length]; for (int i = 0; i < expected.Length; ++i) { byte[] buffer = Encoding.Unicode.GetBytes(expected[i]); actual[i] = StringCache.GetString(buffer, 0, buffer.Length); Assert.AreEqual(expected[i], actual[i], "First conversion is incorrect"); } for (int i = 0; i < expected.Length; ++i) { byte[] buffer = Encoding.Unicode.GetBytes(expected[i]); string cached = StringCache.GetString(buffer, 0, buffer.Length); Assert.AreEqual(expected[i], cached, "Cached value is incorrect"); Assert.AreSame(actual[i], cached, "Value {0} was not cached", expected[i]); } }
public void GetStringCaching() { byte[] buffer = Encoding.Unicode.GetBytes("Hello"); string s1 = StringCache.GetString(buffer, 0, buffer.Length); string s2 = StringCache.GetString(buffer, 0, buffer.Length); Assert.AreSame(s1, s2); }
public void GetOrAdd_NullReturnsNull() { // Arrange var cache = new StringCache(); // Act & Assert Assert.Throws <ArgumentNullException>(() => cache.GetOrAddValue(null)); }
/// <summary> /// Adds the string point. /// </summary> /// <param name="stringCache">The string cache.</param> /// <param name="index">The index.</param> /// <param name="stringPointNumericVal">The string point numeric val.</param> protected static void AddStringPoint(StringCache stringCache, int index, string stringPointNumericVal) { StringPoint stringPoint = new StringPoint(); stringPoint.Index = new UInt32Value((uint)index); stringPoint.NumericValue = new NumericValue(stringPointNumericVal); stringCache.Append(stringPoint); }
public Search(IEnumerable <TreeNode> roots, IEnumerable <string> strings, int maxResults, bool markResultsInTree, StringCache stringTable = null) { this.roots = roots; this.strings = strings; this.maxResults = maxResults; this.markResultsInTree = markResultsInTree; this.stringTable = stringTable; }
public void Adds_and_retrieves_short_content_safely() { const string input = "This will not compress"; var cache = new StringCache(); var added = cache.Add("short", input); Assert.IsTrue(added); var retrieved = cache.Get("short"); Assert.AreEqual(input, retrieved); }
public BindingPaneViewModel(Telemetry telemetry, StringCache stringCache) { this.Telemetry = telemetry; this.stringCache = stringCache; this.countedEntries = new HashSet <ICountedTableEntry>(new CountedTableEntryComparer()); this.entries = new ObservableCollection <ITableEntry>(); this.entries.CollectionChanged += this.OnEntryCollectionChanged; this.traceLevel = nameof(SourceLevels.Error); }
//public override GH_Exposure Exposure => GH_Exposure.hidden; //public override bool Obsolete => true; protected void HandleErrors() { var errors = StringCache.getCache(InstanceGuid.ToString()); if (!string.IsNullOrEmpty(errors)) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, errors); } }
private void Init(int bufferSize) { _max = bufferSize - 1; _starts = new int[bufferSize]; _lens = new int[bufferSize]; if (_tagCache == null) { _tagCache = new StringCache(); // unit testing } }
public RouteMatch?Find(string httpMethod, string rawUrl, string absolutePath, out RouteHandler handler) { var reqHash = StringCache.CalcHash(httpMethod, absolutePath); if (Cache.TryGetValue(reqHash, out handler)) { return(handler.Pattern.ExtractMatch(rawUrl, handler.Service.Length)); } return(FindRoute(httpMethod, rawUrl, reqHash, out handler)); }
public void ClearStrCache() { var cache = new StringCache("Test:Str"); int cnt = cache.Count(); if (cnt > 0) { cache.Clear(); } }
public void VerifyLongStringIsNotCached() { string expected = Any.StringOfLength(8192); byte[] buffer = Encoding.Unicode.GetBytes(expected); string actual = StringCache.GetString(buffer, 0, buffer.Length); Assert.AreEqual(expected, actual); Assert.AreNotSame(actual, StringCache.GetString(buffer, 0, buffer.Length)); }
public void GetStringCachingRandomStrings() { for (int i = 0; i < 250000; ++i) { string expected = Any.String; byte[] buffer = Encoding.Unicode.GetBytes(expected); string actual = StringCache.GetString(buffer, 0, buffer.Length); Assert.AreEqual(expected, actual); Assert.AreSame(actual, StringCache.GetString(buffer, 0, buffer.Length)); } }
public BindingEntryParser(StringCache stringCache) { this.stringCache = stringCache; this.processTextRegex = new Regex(@"^System.Windows.Data Error: (?<code>\d+) : (?<text>.+?)$", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture | RegexOptions.Singleline | RegexOptions.Multiline); // BindingEntryType.PathError this.pathErrorRegex = new Regex($@"BindingExpression path error: '(?<{nameof(BindingEntry.SourceProperty)}>.+?)' property not found on '(object|current item of collection)' '{BindingEntryParser.CaptureItem(nameof(BindingEntry.SourcePropertyType), nameof(BindingEntry.SourcePropertyName))}'. BindingExpression:Path=(?<{nameof(BindingEntry.BindingPath)}>.+?); DataItem={BindingEntryParser.CaptureItem(nameof(BindingEntry.DataItemType), nameof(BindingEntry.DataItemName))}; target element is {BindingEntryParser.CaptureItem(nameof(BindingEntry.TargetElementType), nameof(BindingEntry.TargetElementName))}; target property is '(?<{nameof(BindingEntry.TargetProperty)}>.+?)' \(type '(?<{nameof(BindingEntry.TargetPropertyType)}>.+?)'\)", RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.ExplicitCapture); }
// used for last string from console text static string tryCompleteString(string str, StringCache stringCache) { var matched = stringCache.findByPrefix(str); if (matched.Count > 1) { showMessages(matched, L10n.str("ids_matched")); } return(getCommonPrefix(matched, str)); }
/// <summary> /// Modify/Add series into chart XML /// </summary> /// <param name="column_index">Corresponds to the column index that needs to be modified in chart spreadsheet (Ex: A, B, C, ...)</param> /// <param name="row_index">Corresponds to the column index that needs to be modified in excel </param> /// <param name="new_value">Corresponds to the new value we need to insert to the cell </param> protected override void ModifyChartXML_Series(string column_index, uint row_index, string new_value) { LineChartSeries linechart_series = chart_part.ChartSpace.Descendants <LineChartSeries>().Where(s => string.Compare(s.InnerText, worksheet_name + "!$" + column_index + "$1", true) > 0).FirstOrDefault(); if (linechart_series != null) // There exists data on the series --> We only need to modify it { SeriesText st = linechart_series.Descendants <SeriesText>().FirstOrDefault(); StringReference sr = st.Descendants <StringReference>().First(); StringCache sc = sr.Descendants <StringCache>().First(); StringPoint sp = sc.Descendants <StringPoint>().First(); NumericValue nv = sp.Descendants <NumericValue>().First(); nv.Text = new_value; } else // No such series exists --> Consider create a new series { /* * // Find location in XML to append the BarChartSeries * Chart chart = chart_part.ChartSpace.Descendants<Chart>().FirstOrDefault(); * PlotArea plot = chart.PlotArea; * * // Create new BarChartSeries * barchart_series = new BarChartSeries(); * uint index = (uint)plot.Descendants<BarChartSeries>().ToList().Count; * * barchart_series.Append(new Index() { Val = index }); * barchart_series.Append(new Order() { Val = index }); * * SeriesText seriesText = new SeriesText(); * seriesText.Append(new NumericValue() { Text = new_value }); * * barchart_series.Append(seriesText); * * * // Append data * Bar3DChart bar_3dchart = plot.Descendants<Bar3DChart>().FirstOrDefault(); * if (bar_3dchart != null) // Chart is 3D * bar_3dchart.Append(barchart_series); * else // Chart is not 3d * { * BarChart barchart = plot.Descendants<BarChart>().FirstOrDefault(); * barchart.Append(barchart_series); * } * * // Append other settings * BarChartSeries barchart_series_template = chart_part.ChartSpace.Descendants<BarChartSeries>().LastOrDefault(); * * CategoryAxisData cateAxisData = new CategoryAxisData(); * StringReference string_ref = new StringReference(); * string_ref.Append(new DocumentFormat.OpenXml.Drawing.Charts.Formula() { Text = barchart_series.Descendants<DocumentFormat.OpenXml.Drawing.Charts.Formula>().FirstOrDefault().Text}); * StringCache string_cache = new StringCache(); * string_cache.Append(new PointCount() { Val = count }); */ } }
private void Init() { lock (this) { caches = new HashMap<Type, Cache>(7); caches[typeof(sbyte)] = new ByteCache(this); caches[typeof(short)] = new ShortCache(this); caches[typeof(int)] = new IntCache(this); caches[typeof(float)] = new FloatCache(this); caches[typeof(long)] = new LongCache(this); caches[typeof(double)] = new DoubleCache(this); caches[typeof(string)] = new StringCache(this); caches[typeof(StringIndex)] = new StringIndexCache(this); } }
public void Adds_and_retrieves_long_content_safely() { var sb = new StringBuilder(); for(var i = 0; i < 1000; i++) { sb.Append("I will not write loops in unit tests."); } var input = sb.ToString(); var cache = new StringCache(); var added = cache.Add("long", input); Assert.IsTrue(added); var retrieved = cache.Get("long"); Assert.AreEqual(input, retrieved); }
private void Init() { lock (this) { Support.Dictionary<Type, Cache> caches2 = new Support.Dictionary<Type, Cache>(); caches2[typeof(sbyte)] = new ByteCache(this); caches2[typeof(short)] = new ShortCache(this); caches2[typeof(int)] = new IntCache(this); caches2[typeof(float)] = new FloatCache(this); caches2[typeof(long)] = new LongCache(this); caches2[typeof(double)] = new DoubleCache(this); caches2[typeof(string)] = new StringCache(this); caches2[typeof(StringIndex)] = new StringIndexCache(this); caches2[typeof(System.IComparable)] = new CustomCache(this); caches2[typeof(System.Object)] = new AutoCache(this); caches = caches2; } }