public static JsonStyles FromString(string inlineStyles) { JsonStyles retVal = new JsonStyles(); retVal.styles = DictionaryExtensions.FromDelimited(inlineStyles, ";", ":"); return(retVal); }
public void Deserilize(Stream stream) { this._selfProperties = stream.ReadObject <Dictionary <object, object> >(); this.LobbyCustomProperties = stream.ReadObject <Dictionary <object, object> >(); //服务器传来的是包含置空的值,需要排除掉 this.OtherCustomProperties = DictionaryExtensions.BytesDictToProp(stream.ReadObject <Dictionary <object, object> >(), false); }
/// <summary> /// Gets lexically related words for the current synset. Many of the relations in WordNet are lexical instead of semantic. Whereas /// the latter indicate relations between entire synsets (e.g., hypernym), the former indicate relations between specific /// words in synsets. This method retrieves all lexical relations and the words related thereby. /// </summary> /// <returns>Mapping from relations to mappings from words in the current synset to related words in the related synsets</returns> public Dictionary <WordNetEngine.SynSetRelation, Dictionary <string, Set <string> > > GetLexicallyRelatedWords() { Dictionary <WordNetEngine.SynSetRelation, Dictionary <string, Set <string> > > relatedWords = new Dictionary <WordNetEngine.SynSetRelation, Dictionary <string, Set <string> > >(); foreach (WordNetEngine.SynSetRelation relation in _lexicalRelations.Keys) { DictionaryExtensions.EnsureContainsKey(relatedWords, relation, typeof(Dictionary <string, Set <string> >)); //ZK changed to static method foreach (SynSet relatedSynSet in _lexicalRelations[relation].Keys) { // make sure related synset is initialized if (!relatedSynSet.Instantiated) { relatedSynSet.Instantiate(); } foreach (int sourceWordIndex in _lexicalRelations[relation][relatedSynSet].Keys) { string sourceWord = _words[sourceWordIndex - 1]; DictionaryExtensions.EnsureContainsKey(relatedWords[relation], sourceWord, typeof(Set <string>), false); //ZK changed to static method foreach (int targetWordIndex in _lexicalRelations[relation][relatedSynSet][sourceWordIndex]) { string targetWord = relatedSynSet.Words[targetWordIndex - 1]; relatedWords[relation][sourceWord].Add(targetWord); } } } } return(relatedWords); }
public override void OnReceiveRpc(object session, Stream stream) { this.Name = stream.ReadString(); this.Password = stream.ReadString(); this.PlayerName = stream.ReadString(); this.PlayerProperties = DictionaryExtensions.BytesDictToProp(stream.ReadObject <Dictionary <object, object> >()); }
public void Serilize(Stream stream) { lock (this._selfProperties) { stream.WriteObject(this._selfProperties); } if (this.LobbyCustomProperties == null) { stream.WriteObject(null); } else { lock (this.LobbyCustomProperties) { stream.WriteObject(this.LobbyCustomProperties); } } if (this.OtherCustomProperties == null) { stream.WriteObject(null); } else { lock (this.OtherCustomProperties) { //自定义属性允许服务器无法序列化的类型,所以转为bytes后再传到服务器 var bytesDict = DictionaryExtensions.PropToBytesDict(this.OtherCustomProperties); stream.WriteObject(bytesDict); } } }
public void PopFailsWithNullThis() { var e = Assert.Throws <ArgumentNullException>(() => DictionaryExtensions.Pop <object, object>(null, new object())); Assert.Equal(e.ParamName, "dictionary"); }
public override void OnSendRpc(Stream stream) { stream.Write(this.Name); stream.Write(this.Password); stream.Write(this.PlayerName); stream.WriteObject(DictionaryExtensions.PropToBytesDict(this.PlayerProperties)); }
public static StreamSubscriptionMatch[] Match(IActorSystem system, StreamIdentity stream) { var specifications = DictionaryExtensions.Find(configuration, stream.Provider) ?? Enumerable.Empty <StreamSubscriptionSpecification>(); return(Match(system, stream.Id, specifications)); }
internal void Deserilize(Stream stream) { this.Id = stream.ReadInt(); this.Name = stream.ReadString(); this.IsMaster = stream.ReadBool(); this.CustomProperties = DictionaryExtensions.BytesDictToProp(stream.ReadObject <Dictionary <object, object> >(), false); }
public void Then_the_dictionary_that_is_created_should_be_case_sensitive() { var dict = DictionaryExtensions.AnonymousObjectToCaseSensitiveDictionary(new { Foo = "Bar" }); Assert.That(dict.ContainsKey("Foo")); Assert.That(!dict.ContainsKey("foo")); }
public void And_the_object_is_null_then_an_empty_dictionary_should_be_returned() { var dict = DictionaryExtensions.AnonymousObjectToCaseSensitiveDictionary(null); Assert.That(dict, Is.Not.Null); Assert.That(dict.Count, Is.EqualTo(0)); }
/// <summary> /// Compare an old and new version of a database /// </summary> /// <param name="oldDataBase">Old version</param> /// <param name="newDataBase">New version</param> /// <returns>A object stating changes to the database</returns> public static DatabaseMetaChange CompareVersions(DataBase oldDataBase, DataBase newDataBase) { // Get changes happened to the database var databaseMetaChange = DetectChanges(oldDataBase, newDataBase); // If the database is added or deleted, we don't care about the remaining tables and columns. if (databaseMetaChange.IsSet(DatabaseChanges.Addition | DatabaseChanges.Deletion)) { return(databaseMetaChange); } // Proceed down towards the tables and record these. foreach (var pair in DictionaryExtensions.MergeKeys(oldDataBase.Tables, newDataBase.Tables).Values) { // Check if the new version is not null, then use that ID for the dictionary, if it is then use the old ID if (pair.New != null) { databaseMetaChange.Tables[pair.New.ID] = Table.CompareVersions(pair.Old, pair.New); } else { databaseMetaChange.Tables[pair.Old.ID] = Table.CompareVersions(pair.Old, pair.New); } } return(databaseMetaChange); }
public IndexDefinitionCompareDifferences Compare(AutoIndexDefinition other) { if (other == null) { return(IndexDefinitionCompareDifferences.All); } if (ReferenceEquals(this, other)) { return(IndexDefinitionCompareDifferences.None); } var result = IndexDefinitionCompareDifferences.None; if (string.Equals(Collection, other.Collection) == false || DictionaryExtensions.ContentEquals(MapFields, other.MapFields) == false) { result |= IndexDefinitionCompareDifferences.Maps; } if (DictionaryExtensions.ContentEquals(GroupByFields, other.GroupByFields) == false) { result |= IndexDefinitionCompareDifferences.Reduce; } if (Priority != other.Priority) { result |= IndexDefinitionCompareDifferences.Priority; } return(result); }
public void AddRange_OtherIsNotEmpty_ShouldAggregate() { // Arrange var target = new Dictionary <string, int> { { "one", 5 }, { "two", 34 } }; var other = new Dictionary <string, int> { { "two", 67 }, { "three", 2 } }; // Act DictionaryExtensions.AddRange(target, other, (lhs, rhs) => lhs + rhs); // Assert target.ShouldBeEquivalentTo(new Dictionary <string, int> { { "one", 5 }, { "two", 34 + 67 }, { "three", 2 } }); }
public void When_comparing_dictionaries_with_comparer() { IDictionary <int, string> left = new Dictionary <int, string>(); IDictionary <int, string> right = new Dictionary <int, string>(); var comparer = StringComparer.OrdinalIgnoreCase; DictionaryExtensions.Equals(left, right, comparer).ShouldBeTrue(); left.Add(1, "A"); DictionaryExtensions.Equals(left, right, comparer).ShouldBeFalse(); right.Add(1, "A"); DictionaryExtensions.Equals(left, right, comparer).ShouldBeTrue(); left[2] = "A"; DictionaryExtensions.Equals(left, right, comparer).ShouldBeFalse(); right[2] = "A"; right[3] = "B"; DictionaryExtensions.Equals(left, right, comparer).ShouldBeFalse(); left[3] = "B"; DictionaryExtensions.Equals(left, right, comparer).ShouldBeTrue(); left[3] = "b"; DictionaryExtensions.Equals(left, right, comparer).ShouldBeTrue(); DictionaryExtensions.Equals(((IDictionary <int, string>)null), right, comparer).ShouldBeFalse(); left = right; DictionaryExtensions.Equals(left, null, comparer).ShouldBeFalse(); DictionaryExtensions.Equals(((IDictionary <int, string>)null), null, comparer).ShouldBeTrue(); }
public static EndpointDetails SendingEndpoint(IDictionary <string, string> headers) { var endpointDetails = new EndpointDetails(); DictionaryExtensions.CheckIfKeyExists(Headers.OriginatingEndpoint, headers, s => endpointDetails.Name = s); DictionaryExtensions.CheckIfKeyExists("NServiceBus.OriginatingMachine", headers, s => endpointDetails.Host = s); DictionaryExtensions.CheckIfKeyExists(Headers.OriginatingHostId, headers, s => endpointDetails.HostId = Guid.Parse(s)); if (!string.IsNullOrEmpty(endpointDetails.Name) && !string.IsNullOrEmpty(endpointDetails.Host)) { return(endpointDetails); } var address = Address.Undefined; DictionaryExtensions.CheckIfKeyExists(Headers.OriginatingAddress, headers, s => address = Address.Parse(s)); if (address != Address.Undefined) { endpointDetails.Name = address.Queue; endpointDetails.Host = address.Machine; return(endpointDetails); } return(null); }
private ZoneDetailsProviderResult.CountersData GetCountersData(ZoneState zone, ControllerState state, Building building) { var heaterIds = zone.Zone.Heaters.Select(x => x.HeaterId).ToHashSet(); var heatersCounters = _counterRepository.Read(x => heaterIds.Contains(x.HeaterId) && !x.ResetDate.HasValue) .ToDictionary(x => x.HeaterId, x => x); var now = DateTime.UtcNow; var heaterIdToCountedSeconds = heaterIds.ToDictionary(x => x, x => { var savedCounterValue = DictionaryExtensions.GetValueOrDefault(heatersCounters, x)?.CountedSeconds ?? 0; var heaterState = state.HeaterIdToState[x]; var currentCounterValue = heaterState.OutputState ? (int)(now - heaterState.LastCounterStart).TotalSeconds : 0; return(savedCounterValue + currentCounterValue); }); var usageUnitToHeaterToValue = building.Heaters .Where(x => heaterIds.Contains(x.HeaterId)) .GroupBy(x => x.UsageUnit) .ToDictionary(x => x.Key, x => x.ToDictionary(h => h.Name, h => h.UsagePerHour * (decimal)(heaterIdToCountedSeconds[h.HeaterId] / 3600f))); return(new ZoneDetailsProviderResult.CountersData { LastResetDate = heatersCounters.Any() ? heatersCounters.Values.Min(x => x.StartDate) : (DateTime?)null, UsageUnitToValue = usageUnitToHeaterToValue.ToDictionary(x => x.Key, x => x.Value.Sum(h => h.Value)), UsageUnitToHeaterNameToValue = usageUnitToHeaterToValue }); }
public void When_comparing_dictionaries() { IDictionary <string, int> left = new Dictionary <string, int>(); IDictionary <string, int> right = new Dictionary <string, int>(); DictionaryExtensions.Equals(left, right).ShouldBeTrue(); left.Add("A", 1); DictionaryExtensions.Equals(left, right).ShouldBeFalse(); right.Add("A", 1); DictionaryExtensions.Equals(left, right).ShouldBeTrue(); left["A"] = 2; DictionaryExtensions.Equals(left, right).ShouldBeFalse(); right["A"] = 2; right["B"] = 3; DictionaryExtensions.Equals(left, right).ShouldBeFalse(); left["B"] = 3; DictionaryExtensions.Equals(left, right).ShouldBeTrue(); DictionaryExtensions.Equals(((IDictionary <string, int>)null), right).ShouldBeFalse(); left = right; DictionaryExtensions.Equals(left, null).ShouldBeFalse(); DictionaryExtensions.Equals(((IDictionary <string, int>)null), null).ShouldBeTrue(); }
public static EndpointDetails SendingEndpoint(IReadOnlyDictionary <string, string> headers) { var endpointDetails = new EndpointDetails(); DictionaryExtensions.CheckIfKeyExists(Headers.OriginatingEndpoint, headers, s => endpointDetails.Name = s); DictionaryExtensions.CheckIfKeyExists("NServiceBus.OriginatingMachine", headers, s => endpointDetails.Host = s); DictionaryExtensions.CheckIfKeyExists(Headers.OriginatingHostId, headers, s => endpointDetails.HostId = Guid.Parse(s)); if (!string.IsNullOrEmpty(endpointDetails.Name) && !string.IsNullOrEmpty(endpointDetails.Host)) { return(endpointDetails); } string address = null; DictionaryExtensions.CheckIfKeyExists(Headers.OriginatingAddress, headers, s => address = s); if (address != null) { var queueAndMachinename = ExtractQueueAndMachineName(address); endpointDetails.Name = queueAndMachinename.Queue; endpointDetails.Host = queueAndMachinename.Machine; return(endpointDetails); } return(null); }
/// <summary> /// Records event with parameters /// </summary> /// <param name="area">Telemetry area name such as 'Toolbox'.</param> /// <param name="eventName">Event name.</param> /// <param name="parameters"> /// Either string/object dictionary or anonymous /// collection of string/object pairs. /// </param> /// <summary> public void ReportEvent(TelemetryArea area, string eventName, object parameters = null) { Check.ArgumentStringNullOrEmpty("eventName", eventName); string completeEventName = MakeEventName(area, eventName); if (parameters == null) { this.TelemetryRecorder.RecordEvent(completeEventName); } else if (parameters is string) { this.TelemetryRecorder.RecordEvent(completeEventName, parameters as string); } else { IDictionary <string, object> dict = DictionaryExtensions.FromAnonymousObject(parameters); IDictionary <string, object> dictWithPrefix = new Dictionary <string, object>(); foreach (KeyValuePair <string, object> kvp in dict) { Check.ArgumentStringNullOrEmpty("parameterName", kvp.Key); dictWithPrefix[this.PropertyNamePrefix + area.ToString() + "." + kvp.Key] = kvp.Value ?? string.Empty; } this.TelemetryRecorder.RecordEvent(completeEventName, dictWithPrefix); } }
public void Returns_Dynamic_Object_From_ToDynamic_When_Source_Is_Provided() { // arrange var id = Guid.NewGuid(); var description = "description"; var count = 1; #pragma warning disable SA1413 // No trailing commas on initializers, that is STUPID. var source = new Dictionary <string, object>() { { "Id", id }, { "Description", description }, { "Count", count } }; #pragma warning restore SA1413 // No trailing commas on initializers, that is STUPID. // act var result = DictionaryExtensions.ToDynamicObject(source); // assert Assert.IsInstanceOfType(result, typeof(ExpandoObject)); Assert.AreEqual(source["Id"], result.id); Assert.AreEqual(source["Description"], result.description); Assert.AreEqual(source["Count"], result.count); }
public void SetPoolProfileProperty(Guid workId, Guid poolId, string propertyName, object value) { if (!PoolProfileProperties.ContainsKey(propertyName)) { return; } using (var database = CreateDatabase(workId)) { var col = database.GetCollection <PoolProfileData>(); var data = col.FindById(poolId); bool exist = true; if (data == null) { exist = false; data = PoolProfileData.CreateDefaultData(poolId); } PropertyInfo propertyInfo = PoolProfileProperties[propertyName]; if (propertyInfo.PropertyType == typeof(Guid)) { value = DictionaryExtensions.ConvertToGuid(value); } propertyInfo.SetValue(data, value, null); if (exist) { col.Update(data); } else { col.Insert(data); } } }
public void SetMinerProfileProperty(Guid workId, string propertyName, object value) { if (!MinerProfileProperties.ContainsKey(propertyName)) { return; } using (var database = CreateDatabase(workId)) { var col = database.GetCollection <MinerProfileData>(); var data = col.FindAll().FirstOrDefault(); bool exist = true; if (data == null) { exist = false; data = MinerProfileData.CreateDefaultData(); } PropertyInfo propertyInfo = MinerProfileProperties[propertyName]; if (propertyInfo.PropertyType == typeof(Guid)) { value = DictionaryExtensions.ConvertToGuid(value); } propertyInfo.SetValue(data, value, null); if (exist) { data.ModifiedOn = DateTime.Now; col.Update(data); } else { col.Insert(data); } } }
public override IndexDefinitionCompareDifferences Compare(IndexDefinitionBase other) { var otherDefinition = other as AutoMapIndexDefinition; if (otherDefinition == null) { return(IndexDefinitionCompareDifferences.All); } if (ReferenceEquals(this, other)) { return(IndexDefinitionCompareDifferences.None); } var result = IndexDefinitionCompareDifferences.None; if (Collections.SetEquals(otherDefinition.Collections) == false || DictionaryExtensions.ContentEquals(MapFields, otherDefinition.MapFields) == false) { result |= IndexDefinitionCompareDifferences.Maps; } if (LockMode != other.LockMode) { result |= IndexDefinitionCompareDifferences.LockMode; } if (Priority != other.Priority) { result |= IndexDefinitionCompareDifferences.Priority; } return(result); }
public void UpdateClients(string propertyName, Dictionary <string, object> values) { InitOnece(); PropertyInfo propertyInfo = typeof(ClientData).GetProperty(propertyName); if (propertyInfo != null) { if (propertyInfo.PropertyType == typeof(Guid)) { foreach (var kv in values) { values[kv.Key] = DictionaryExtensions.ConvertToGuid(kv.Value); } } foreach (var kv in values) { string objectId = kv.Key; object value = kv.Value; if (_dicByObjectId.TryGetValue(objectId, out ClientData clientData)) { propertyInfo.SetValue(clientData, value, null); clientData.ModifiedOn = DateTime.Now; } } } }
public void EditPatterns() { var patterns = DictionaryExtensions.DeserializeFromFile(@"patterns.xml"); if (patterns == null) { Console.WriteLine("\nSorry, no patterns"); } ShowPatterns(patterns); Console.WriteLine("\nPlease, input number pattern for edit"); int[] patternNumbers = Enumerable.Range(1, patterns.Count).ToArray(); int number = InputHelper.ValidateTwoDigitNumberInput(Console.ReadLine(), patternNumbers); var pattern = patterns.ToList()[number - 1]; Console.WriteLine("\nPlease, input new value for pattern"); Console.WriteLine("\n" + pattern.Key); char value = InputHelper.ValidateLetterOrDigitInput(Console.ReadKey()); patterns[pattern.Key] = value; patterns.SerializeToFile(@"patterns.xml"); Console.WriteLine("\n\nСhanges saved successfully"); }
public static bool ExtensionMethodsCalledForAllDiagnostics(IEnumerable <DiagnosticAnalyzer> analyzers) => // In general this check is not very precise, because when the tests are run in parallel // we cannot determine which diagnostic was reported from which analyzer instance. In other // words, we cannot distinguish between diagnostics reported from different tests. That's // why we require each diagnostic to be reported through the extension methods at least once. analyzers.SelectMany(analyzer => analyzer.SupportedDiagnostics) .Select(d => DictionaryExtensions.GetValueOrDefault(counters, d.Id)) .Any(count => count > 0);
public void MergeReturnsNullIfSourceIsNull() { var candidate = DictionaryExtensions.Merge(null, new Dictionary <string, string> { { "key", "value" } }); Assert.IsNull(candidate); }
public static void Clear() { lock (metadataLock) { _instances.Clear(); DictionaryExtensions.ClearCache(); } }
public void TestTryAdd() { var dictionary = new Dictionary <string, string>(); Assert.True(DictionaryExtensions.TryAdd(dictionary, "a", "b")); Assert.Equal("b", dictionary["a"]); Assert.False(DictionaryExtensions.TryAdd(dictionary, "a", "c")); }