Exemplo n.º 1
0
        public void RegisterAllUniqueInterfaceImplementations(bool overwriteExistingRegistrations = false, params Assembly[] assemblies)
        {
            if (assemblies == null || !assemblies.Any())
            {
                assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(x => !x.IsDynamic).ToArray();
            }

            var classTypes = assemblies.SelectMany(x => x.GetTypes()).Where(x => !x.IsInterface && !x.IsAbstract).ToList();
            var interfaces = new HashSet <Type>(assemblies.SelectMany(x => x.GetTypes()).Where(x => x.IsInterface));

            var interfaceMap = new HashSetDictionary <Type, Type>();

            foreach (var classType in classTypes)
            {
                foreach (var interfaceType in classType.GetInterfaces().Where(x => interfaces.Contains(x)))
                {
                    interfaceMap.Add(interfaceType, classType);
                }
            }

            foreach (var interfaceType in interfaceMap.Keys)
            {
                var values = interfaceMap.GetValuesAsHashSet(interfaceType);
                if (values.Count != 1)
                {
                    continue;
                }

                if (overwriteExistingRegistrations || !_actions.ContainsKey(interfaceType))
                {
                    Register(interfaceType, values.First());
                }
            }
        }
        public void TestSerialization()
        {
            var lookup = new HashSetDictionary <string, string>();

            lookup.Add("zoo", "zebra");
            var tester = new SerializationTester();

            tester.TestSerialization(lookup, result =>
            {
                Assert.IsTrue(result["zoo"].Contains("zebra"));
            });
        }
Exemplo n.º 3
0
        public void If_adding_single_item_Then_expected_count_and_values_match()
        {
            _sut.Add(1, 1000);

            Assert.That(_sut.Count, Is.EqualTo(1));
            Assert.That(_sut.ContainsKey(1), Is.True);
            Assert.That(_sut.GetValues(1), Is.EquivalentTo(new[] { 1000 }));
            Assert.That(_sut.GetValuesAsHashSet(1), Is.EquivalentTo(new[] { 1000 }));
            Assert.That(_sut.Keys, Is.EquivalentTo(new[] { 1 }));
            Assert.That(_sut.Values, Is.EquivalentTo(new[] { 1000 }));
        }
Exemplo n.º 4
0
        public void Then_adding_single_int_keys_are_benchmarked()
        {
            var sut = new HashSetDictionary <int, int>();

            var sw = Stopwatch.StartNew();

            for (var i = 0; i < Count; i++)
            {
                sut.Add(1, i);
            }
            sw.Stop();

            var opsPerSec = Count / (sw.ElapsedMilliseconds + 0.001m) * 1000m;

            Assert.Inconclusive($"{Count} iterations of Add multiple keys and value, {sw.Elapsed} ({opsPerSec:N0} ops/sec)");
        }
Exemplo n.º 5
0
        public MimeList(string body)
        {
            string[] lines = body._GetLines();

            HashSetDictionary <string, string> extToMime = new HashSetDictionary <string, string>(StrComparer.IgnoreCaseComparer, StrComparer.IgnoreCaseComparer);
            HashSetDictionary <string, string> mimeToExt = new HashSetDictionary <string, string>(StrComparer.IgnoreCaseComparer, StrComparer.IgnoreCaseComparer);

            foreach (string line in lines)
            {
                string line2 = line._StripCommentFromLine(Consts.Strings.CommentStartStringForMimeList)._NonNullTrim();

                if (line2._IsFilled())
                {
                    if (line2._GetKeyAndValue(out string key, out string value))
                    {
                        key   = key.ToLowerInvariant();
                        value = value.ToLowerInvariant();

                        if (key.StartsWith("."))
                        {
                            key = key.Substring(1);
                        }

                        if (key._IsFilled() && value._IsFilled())
                        {
                            extToMime.Add(key, value);
                            mimeToExt.Add(value, key);

                            if (line._InStr("#overwrite") || line._InStr("# overwrite"))
                            {
                                this.ExtToMimeDictionary.TryAdd(key, value);
                            }
                        }
                    }
                }
            }

            foreach (var extInfo in extToMime)
            {
                string?mime = extInfo.Value.OrderBy(x => mimeToExt[x].Count).FirstOrDefault();
                if (mime._IsFilled())
                {
                    this.ExtToMimeDictionary.TryAdd(extInfo.Key, mime);
                }
            }
        }
Exemplo n.º 6
0
        static void _Main(string[] args) // De-activated
        {
            var lookup = new HashSetDictionary <string, string>();

            lookup.Add("zoo", "zebra");
            using (var stream = new MemoryStream())
            {
                var formatter = new BinaryFormatter();
                formatter.Serialize(stream, lookup);

                stream.Seek(0, SeekOrigin.Begin);
                var result = (HashSetDictionary <string, string>)formatter.Deserialize(stream);

                Console.WriteLine(lookup["zoo"].Contains("zebra"));
            }

            Console.ReadKey();
        }