Example #1
0
        static void Initialize()
        {
            Assembly[] assemblies = Device.GetAssemblies();
            if (Registrar.ExtraAssemblies != null)
            {
                assemblies = assemblies.Union(Registrar.ExtraAssemblies).ToArray();
            }

            Type targetAttrType = typeof(DependencyAttribute);

            // Don't use LINQ for performance reasons
            // Naive implementation can easily take over a second to run
            foreach (Assembly assembly in assemblies)
            {
                Attribute[] attributes = assembly.GetCustomAttributes(targetAttrType).ToArray();
                if (attributes.Length == 0)
                {
                    continue;
                }

                foreach (DependencyAttribute attribute in attributes)
                {
                    if (!DependencyTypes.Contains(attribute.Implementor))
                    {
                        DependencyTypes.Add(attribute.Implementor);
                    }
                }
            }

            s_initialized = true;
        }
Example #2
0
        static void Initialize()
        {
            if (s_initialized)
            {
                return;
            }

            Assembly[] assemblies = Device.GetAssemblies();
            if (Internals.Registrar.ExtraAssemblies != null)
            {
                assemblies = assemblies.Union(Internals.Registrar.ExtraAssemblies).ToArray();
            }

            Initialize(assemblies);
        }
Example #3
0
 private static void RegisterSizes()
 {
     foreach (var a in Device.GetAssemblies())
     {
         var namedSizes = a.GetCustomAttributes <NamedSizeAttribute>();
         foreach (var size in namedSizes)
         {
             if (!Sizes.ContainsKey(size.Idiom))
             {
                 Sizes[size.Idiom] = new ConcurrentDictionary <Type, ConcurrentDictionary <NamedSize, double> >();
             }
             if (!Sizes[size.Idiom].ContainsKey(size.Target))
             {
                 Sizes[size.Idiom][size.Target] = new ConcurrentDictionary <NamedSize, double>();
             }
             Sizes[size.Idiom][size.Target][size.WhenSize] = size.IsSize;
         }
     }
 }
Example #4
0
        void InitMappings()
        {
            var mappings = new Dictionary <string, IVisual>(StringComparer.OrdinalIgnoreCase);

            Assembly[] assemblies = Device.GetAssemblies();

            // Check for IVisual Types
            foreach (var assembly in assemblies)
            {
                Register(assembly, mappings);
            }

            if (Internals.Registrar.ExtraAssemblies != null)
            {
                foreach (var assembly in Internals.Registrar.ExtraAssemblies)
                {
                    Register(assembly, mappings);
                }
            }


            // Check for visual assembly attributes	after scanning for IVisual Types
            // this will let users replace the default visual names if they want to
            foreach (var assembly in assemblies)
            {
                RegisterFromAttributes(assembly, mappings);
            }

            if (Internals.Registrar.ExtraAssemblies != null)
            {
                foreach (var assembly in Internals.Registrar.ExtraAssemblies)
                {
                    RegisterFromAttributes(assembly, mappings);
                }
            }

            _visualTypeMappings = mappings;
        }