private bool DrawConfigEditor(LoadBalancerConfig cfg)
        {
            bool changed = false;

            var interval = EditorGUILayout.FloatField("Update Interval", cfg.updateInterval);
            if (cfg.updateInterval != interval)
            {
                cfg.updateInterval = interval;
                changed = true;
            }

            var auto = EditorGUILayout.Toggle("Auto Adjust", cfg.autoAdjust);
            if (cfg.autoAdjust != auto)
            {
                cfg.autoAdjust = auto;
                changed = true;
            }

            if (!auto)
            {
                var maxUpdates = EditorGUILayout.IntField("Max Updates Per Frame", cfg.maxUpdatesPerFrame);
                if (cfg.maxUpdatesPerFrame != maxUpdates)
                {
                    cfg.maxUpdatesPerFrame = maxUpdates;
                    changed = true;
                }

                var maxUpdateTime = EditorGUILayout.IntField("Max Update Time In Milliseconds Per Update", cfg.maxUpdateTimeInMillisecondsPerUpdate);
                if (cfg.maxUpdateTimeInMillisecondsPerUpdate != maxUpdateTime)
                {
                    cfg.maxUpdateTimeInMillisecondsPerUpdate = maxUpdateTime;
                    changed = true;
                }
            }

            return changed;
        }
        private void ResolveLoadBalancers()
        {
            var resolveBalancers = new List <LoadBalancedQueue>();
            var configSet        = new Dictionary <string, LoadBalancerConfig>(StringComparer.Ordinal);

            if (_configurations != null)
            {
                foreach (var cfg in _configurations)
                {
                    configSet.Add(cfg.targetLoadBalancer, cfg);
                }
            }

            var lbType   = typeof(LoadBalancer);
            var qType    = typeof(LoadBalancedQueue);
            var qTypeAlt = typeof(ILoadBalancer);

#if NETFX_CORE
            var lbTypeInf = lbType.GetTypeInfo();
            var asm       = lbTypeInf.Assembly;

            var sources = (from t in asm.DefinedTypes
                           where t == lbTypeInf || t.IsSubclassOf(lbType)
                           select t).ToArray();

            //Process properties
            var props = from t in sources
                        from p in t.DeclaredProperties
                        where (p.PropertyType == qType || p.PropertyType == qTypeAlt) && p.CanRead && p.GetMethod.IsStatic
                        select p;
#elif UNITY_WP8
            var asm = lbType.Assembly;

            var sources = (from t in asm.GetTypes()
                           where t == lbType || t.IsSubclassOf(lbType)
                           select t).ToArray();

            //Process properties
            var props = from t in sources
                        from p in t.GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly)
                        where (p.PropertyType == qType || p.PropertyType == qTypeAlt) && p.CanRead
                        select p;
#else
            var asm = Assembly.GetAssembly(lbType);

            var sources = (from t in asm.GetTypes()
                           where t == lbType || t.IsSubclassOf(lbType)
                           select t).ToArray();

            //Process properties
            var props = from t in sources
                        from p in t.GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly)
                        where (p.PropertyType == qType || p.PropertyType == qTypeAlt) && p.CanRead
                        select p;
#endif
            LoadBalancerConfig config;
            foreach (var p in props)
            {
                var lbName = p.Name;

                var balancer = p.GetValue(null, null) as LoadBalancedQueue;
                if (balancer == null && p.CanWrite)
                {
                    balancer = new LoadBalancedQueue(4);
                    p.SetValue(null, balancer, null);
                }

                if (balancer != null)
                {
                    if (!configSet.TryGetValue(lbName, out config))
                    {
                        config = LoadBalancerConfig.From(lbName, balancer);
                        configSet.Add(lbName, config);
                    }
                    else
                    {
                        config.ApplyTo(balancer);
                    }

                    resolveBalancers.Add(balancer);
                }
            }

            //Process fields
#if NETFX_CORE
            var fields = from t in sources
                         from f in t.DeclaredFields
                         where (f.FieldType == qType || f.FieldType == qTypeAlt) && f.IsStatic
                         select f;
#else
            var fields = from t in sources
                         from f in t.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly)
                         where (f.FieldType == qType || f.FieldType == qTypeAlt)
                         select f;
#endif
            foreach (var f in fields)
            {
                var lbName = f.Name;

                var balancer = f.GetValue(null) as LoadBalancedQueue;
                if (balancer == null && !f.IsInitOnly)
                {
                    balancer = new LoadBalancedQueue(4);
                    f.SetValue(null, balancer);
                }

                if (balancer != null)
                {
                    if (!configSet.TryGetValue(lbName, out config))
                    {
                        config = LoadBalancerConfig.From(lbName, balancer);
                        configSet.Add(lbName, config);
                    }
                    else
                    {
                        config.ApplyTo(balancer);
                    }

                    resolveBalancers.Add(balancer);
                }
            }

            _configurations = configSet.Values.Where(c => c.associatedLoadBalancer != null).OrderBy(c => c.targetLoadBalancer).ToArray();
            _loadBalancers  = resolveBalancers.ToArray();
        }
        private void ResolveLoadBalancers()
        {
            LoadBalancerConfig       loadBalancerConfig;
            List <LoadBalancedQueue> loadBalancedQueues  = new List <LoadBalancedQueue>();
            Dictionary <string, LoadBalancerConfig> strs = new Dictionary <string, LoadBalancerConfig>(StringComparer.Ordinal);

            if (this._configurations != null)
            {
                LoadBalancerConfig[] loadBalancerConfigArray = this._configurations;
                for (int i = 0; i < (int)loadBalancerConfigArray.Length; i++)
                {
                    LoadBalancerConfig loadBalancerConfig1 = loadBalancerConfigArray[i];
                    strs.Add(loadBalancerConfig1.targetLoadBalancer, loadBalancerConfig1);
                }
            }
            Type type  = typeof(LoadBalancer);
            Type type1 = typeof(LoadBalancedQueue);
            Type type2 = typeof(ILoadBalancer);

            Type[] array = (
                from asm in (IEnumerable <Assembly>)AppDomain.CurrentDomain.GetAssemblies()
                from t in asm.GetTypes()
                select new { asm = asm, t = t }).Where((argument0) => {
                if (argument0.t == type)
                {
                    return(true);
                }
                return(argument0.t.IsSubclassOf(type));
            }).Select((argument3) => argument3.t).ToArray <Type>();
            foreach (PropertyInfo propertyInfo in (
                         from t in (IEnumerable <Type>) array
                         from p in t.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)
                         select new { t = t, p = p }).Where((argument1) => {
                if (!(argument1.p.PropertyType == type1) && !(argument1.p.PropertyType == type2))
                {
                    return(false);
                }
                return(argument1.p.CanRead);
            }).Select((argument4) => argument4.p))
            {
                string            name  = propertyInfo.Name;
                LoadBalancedQueue value = propertyInfo.GetValue(null, null) as LoadBalancedQueue;
                if (value == null && propertyInfo.CanWrite)
                {
                    value = new LoadBalancedQueue(4);
                    propertyInfo.SetValue(null, value, null);
                }
                if (value == null)
                {
                    continue;
                }
                if (strs.TryGetValue(name, out loadBalancerConfig))
                {
                    loadBalancerConfig.ApplyTo(value);
                }
                else
                {
                    loadBalancerConfig = LoadBalancerConfig.From(name, value);
                    strs.Add(name, loadBalancerConfig);
                }
                loadBalancedQueues.Add(value);
            }
            foreach (FieldInfo fieldInfo in (
                         from t in (IEnumerable <Type>) array
                         from f in t.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public)
                         select new { t = t, f = f }).Where((argument2) => {
                if (argument2.f.FieldType == type1)
                {
                    return(true);
                }
                return(argument2.f.FieldType == type2);
            }).Select((argument5) => argument5.f))
            {
                string            str = fieldInfo.Name;
                LoadBalancedQueue loadBalancedQueue = fieldInfo.GetValue(null) as LoadBalancedQueue;
                if (loadBalancedQueue == null && !fieldInfo.IsInitOnly)
                {
                    loadBalancedQueue = new LoadBalancedQueue(4);
                    fieldInfo.SetValue(null, loadBalancedQueue);
                }
                if (loadBalancedQueue == null)
                {
                    continue;
                }
                if (strs.TryGetValue(str, out loadBalancerConfig))
                {
                    loadBalancerConfig.ApplyTo(loadBalancedQueue);
                }
                else
                {
                    loadBalancerConfig = LoadBalancerConfig.From(str, loadBalancedQueue);
                    strs.Add(str, loadBalancerConfig);
                }
                loadBalancedQueues.Add(loadBalancedQueue);
            }
            this._configurations = (
                from c in strs.Values
                where c.associatedLoadBalancer != null
                orderby c.targetLoadBalancer
                select c).ToArray <LoadBalancerConfig>();
            this._loadBalancers = loadBalancedQueues.ToArray();
        }