private void generateBindings()
        {
            List <Type> allTypes    = new List <Type>();
            List <Type> bindedTypes = new List <Type>();

            foreach (BindingAssembly assembly in mAssemblies.Values)
            {
                allTypes.AddRange(assembly.Assembly.GetTypes());
                bindedTypes.AddRange(assembly.bindedTypes.ConvertAll <Type>(n => assembly.Assembly.GetType(n)));
            }
            BinderGenerator.GenerateBinders(allTypes, bindedTypes);
            Configuration configuration = Utility.GetConfiguration();

            if (null != configuration)
            {
                foreach (string filename in configuration.extraBindingConfigs)
                {
                    BindingRecordConfig config = JsonUtility.FromJson <BindingRecordConfig>(File.ReadAllText(filename));
                    foreach (BindingRecordConfigAssembly record in config.assemblies)
                    {
                        Assembly assembly = Assembly.Load(record.name);
                        foreach (string typename in record.types)
                        {
                            bindedTypes.Add(assembly.GetType(typename));
                        }
                    }
                }
            }
            BinderGenerator.GenerateSnippets(bindedTypes);
        }
        private void saveConfig()
        {
            BindingRecordConfig config = new BindingRecordConfig {
                assemblies = new List <BindingRecordConfigAssembly>()
            };

            foreach (BindingAssembly assembly in mAssemblies.Values)
            {
                BindingRecordConfigAssembly record = new BindingRecordConfigAssembly {
                    name = assembly.Name, types = assembly.bindedTypes
                };
                config.assemblies.Add(record);
            }
            File.WriteAllText(CONFIG_PATH, JsonUtility.ToJson(config, true));
        }
        static public void BindFromJson(string filename)
        {
            string jsonContent = FileUtility.ReadStringFromFile(filename);

            if (string.IsNullOrEmpty(jsonContent))
            {
                Entry.LogError("Try to bind dynamically but no content from json [{0}]!", filename);
                return;
            }

            BindingRecordConfig config = JsonUtility.FromJson <BindingRecordConfig>(jsonContent);

            if (config.assemblies?.Count > 0)
            {
#if UNITY_IOS
                Entry.LogError("Dynamic binding is not supported on iOS, since reflection is forbidden!");
#else
                foreach (BindingRecordConfigAssembly record in config.assemblies)
                {
#if !UNITY_IOS
                    Assembly assembly = Assembly.Load(record.name);
                    if (null == assembly)
                    {
                        Entry.LogError("Try to bind dynamically but load assembly [{0}] failed!", record.name);
                        continue;
                    }
#endif
                    foreach (string typename in record.types)
                    {
#if UNITY_IOS
                        Type type = sTypeTable?.GetType(typename);
#else
                        Type type = assembly.GetType(typename);
#endif
                        if (null == type)
                        {
                            Entry.LogError("Try to bind dynamically but load type [{0}] failed!", typename);
                            continue;
                        }
                        Bind(type);
                    }
                }
#endif
            }
        }
        private void initialize()
        {
            string configContent = File.Exists(CONFIG_PATH) ? File.ReadAllText(CONFIG_PATH) : File.ReadAllText(DEFAULT_CONFIG_PATH);
            //string configContent = File.ReadAllText(DEFAULT_CONFIG_PATH);
            BindingRecordConfig config = JsonUtility.FromJson <BindingRecordConfig>(configContent);

            foreach (BindingRecordConfigAssembly record in config.assemblies)
            {
                Assembly assembly = Assembly.Load(record.name);
                if (null == assembly)
                {
                    Entry.LogWarning("Cannot load assembly [{0}]!", record.name);
                    continue;
                }
                //record.types.AddRange(assembly.GetTypes().ToList().Where(t => ClassBinder.IsSupportedType(t)).ToList().ConvertAll<string>(t => t.FullName));
                this.addAssembly(assembly, record.types.ConvertAll <Type>(t => assembly.GetType(t)));
            }
            //File.WriteAllText(DEFAULT_CONFIG_PATH, JsonUtility.ToJson(config, true));
        }