Beispiel #1
0
        static void Main(string[] args)
        {
            string
                pluginDir = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);

            string[]
            pluginAssemblies = Directory.GetFiles(pluginDir, "*.dll");

            List <Type>
            pluginTypes = new List <Type>();

            foreach (string file in pluginAssemblies)
            {
                Assembly
                            pluginAssembly = Assembly.LoadFrom(file);

                foreach (Type t in pluginAssembly.GetExportedTypes())
                {
                    if (t.IsClass && typeof(IPlugin.IPlugin).IsAssignableFrom(t))
                    {
                        pluginTypes.Add(t);
                    }
                }
            }

            pluginTypes.ForEach(item =>
            {
                IPlugin.IPlugin
                ai = (IPlugin.IPlugin)Activator.CreateInstance(item);

                Console.WriteLine(ai.DoSomething(5));
            });
        }
        public string Calc(string pInput)
        {
            //Funktionsname ermitteln
            Regex           regex           = new Regex("([a-z]+)");
            MatchCollection matchCollection = regex.Matches(pInput);

            String pluginName = matchCollection[0].Value;

            IPlugin.IPlugin plugin = GetPlugin(pluginName);

            //Es wurde kein Plugin gefunden, das als Namen den gesuchten Funktionsnamen hat
            if (plugin == null)
            {
                //throw new NotImplementedException();
            }
            else
            {
                try
                {
                    //Methode vom Plugin aufrufen
                    return(plugin.Calc(pInput));
                }
                catch (Exception e)
                {
                    System.Diagnostics.Trace.WriteLine(e);
                }
            }

            return("Funktion nicht gefunden.");
        }
 private IPlugin.IPlugin GetPlugin(string pluginName)
 {
     foreach (var dir in Plugins)
     {
         IPlugin.IPlugin plugin = dir.Value as IPlugin.IPlugin;
         if (plugin.Name.ToLower().Equals(pluginName.ToLower()))
         {
             return(plugin);
         }
     }
     return(null);
 }
Beispiel #4
0
        /// <summary>
        /// Load a plugin.
        /// </summary>
        /// <param name="dllfilename">The current list with loaded plugins</param>
        public static void EnablePlugin(string dllfilename)
        {
            try
            {
                System.Reflection.Assembly pluginassembly = null;
                pluginassembly = System.Reflection.Assembly.LoadFrom(Path.Combine(Settings.ProgramPluginsFolder, dllfilename));

                if (pluginassembly != null)
                {
                    foreach (Type curplugintype in pluginassembly.GetTypes())
                    {
                        if (curplugintype.IsPublic && !curplugintype.IsAbstract && !curplugintype.IsSealed)
                        {
                            if (!curplugintype.FullName.Equals(curplugintype.Namespace + "." + curplugintype.Namespace))
                            {
                                continue;
                            }

                            Type plugintype = pluginassembly.GetType(curplugintype.ToString(), false, true);
                            if (plugintype == null)
                            {
                                continue;
                            }

                            IPlugin.IPlugin plugin = (IPlugin.IPlugin)Activator.CreateInstance(pluginassembly.GetType(curplugintype.ToString()));
                            plugin.Register(dllfilename, NoteFly.Program.Notes);
                            enabledplugins.Add(plugin);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Write(LogType.exception, "Can't load file: " + dllfilename + " " + ex.Message);
            }
        }