private static bool loadPlugin(BaseCoreConfiguration config, out IStorageSyncro plugin)
        {
            Logger.Trace("start loadPlugin with param", config.ToJson());
            plugin = null;
            var ret = false;

            if (config != null)
            {
                var path = Path.Combine(_pathplugin, config.FileName);
                Logger.Debug("Plugin path", path);
                if (File.Exists(path))
                {
                    var name            = AssemblyName.GetAssemblyName(path);
                    var currentAssembly = Assembly.Load(name);

                    var type = currentAssembly.GetType($"{config.ClassName}", false, true);
                    if (type == null)
                    {
                        Logger.Error("Can not find type", config.ClassName, currentAssembly.ToJson());
                    }
                    else
                    {
                        try
                        {
                            plugin = Activator.CreateInstance(type) as IStorageSyncro;
                            plugin.OnForceRestart += plugin_OnForceRestart;
                            plugin.OnNeedRestart  += plugin_OnNeedRestart;

                            var    fn       = Path.Combine(_pathconfig, config.FileName);
                            string confdata = null;
                            if (File.Exists(fn))
                            {
                                confdata = File.ReadAllText(fn);
                            }

                            plugin.Init(confdata);
                        }
                        catch (Exception ex)
                        {
                            Logger.Fatal(ex);
                        }
                    }
                }
                else
                {
                    Logger.Error("File not found", path);
                }
            }
            Logger.Debug(plugin.ToJson());
            ret = plugin != null;
            Logger.Info("end loadPlugin with", ret);
            return(ret);
        }
        internal static void Init(BaseCoreConfiguration storeSyncroPlugin, string pluginsPath, string pathconfig)
        {
            Logger.Info("Path of execution", _path);
            _pathconfig = Path.Combine(_path, pathconfig);
            _pathplugin = Path.Combine(_path, pluginsPath);
            _current    = storeSyncroPlugin;

            Logger.Debug(storeSyncroPlugin);
            var ret = loadPlugin(storeSyncroPlugin, out IStorageSyncro data);

            if (!ret)
            {
                Logger.Error($"{storeSyncroPlugin?.FileName} not loaded");
            }
            else
            {
                _plugin = data;
                Logger.Debug("plugin load ", data);
            }

            Logger.Debug("End Init DataDispetcherClass");
        }