Shulou(Shulou.com)06/01 Report--

I. Preface

Plug-ins, which means extensible, and the host program does not depend on plug-ins, plug and play. This software design method can maximize the scalability, adaptability and stability of our application, and facilitate the maintenance and upgrade of the software. In what scenarios do you use plug-ins? For example, in this article, I personally have a small requirement that I want notepad to have a line number, so I wrote a very simple editor (CodeEditor). Take this editor as an example, the main program functions, including common new, copy, search, save, etc., have been completed, but in the process of use, I find that I need to use the formatting function, but I do not want to change the main program. In this case, it can be achieved through plug-ins, so that when it is used in the future, as long as there are new requirements, it can be achieved by adding plug-ins, which is to some extent in line with the open-closed design principle. The following definition of plug-ins comes from Baidu encyclopedia.

A plug-in (Plug-in) is a program written by an application program interface that follows a certain specification. It can only run under the system platform specified by the program (multiple platforms may be supported at the same time), and cannot be run separately from the specified platform.

Second, the implementation principle of plug-in mechanism

There are two elements to implement the plug-in mechanism: one is the interface, and the other is reflection. The interface is actually a "contract" through which the main program constrains whether there is an object that meets my expectations, and if it does not match, it will not load the object. The interface we agreed on in CodeEditor is IExcutable. The implementation of this "contract" is achieved through reflection, the main program will load all the DLL files under the agreed Plugin folder through reflection, then traverse these plug-ins and see if there is a class that implements IExcutable and can be instantiated, and if so, create an instance of this class to join the set and return the collection. After getting the collection, the main program loads these plug-ins in the constructor, and the loading process includes dynamically adding menus and specifying menu click events, so the complete plug-in loading process is complete. Let's take a specific look at the implementation process of the plug-in through CodeEditor.

III. The practice of plug-in mechanism

The following figure shows the directory structure of the entire CodeEditor

The third CodeEditorControl can be ignored, this class library is a custom control, is the core component of implementing a line numbered text editor, but has little to do with the topic of this article. It mainly depends on the plug-in interface CodeEditorInterface, the plug-in implementation CodeEditorPlugins and the main program CodeEditor. The relationship between the three can be shown in the following pictures.

First of all, it starts with the bridge between the main program and the plug-in, that is, the interface of the plug-in. In the interface IExcutable in CodeEditorInterface, there are two agreed methods: one is that GetName is responsible for returning the current plug-in name, which is used for the main program to obtain and dynamically load into the menu; the other is that Excute is responsible for obtaining the text of the main program and performing the corresponding operations. The code is as follows:

1 public interface IExcutable2 {3 / / for dynamic menu creation of the main program 4 string GetName (); 5 / perform specific text operations 6 string Excute (string text); 7}

The following is the core code for the main program to load plug-in objects that conform to the contract. The main function is to filter the classes that conform to the interface and instantiate the objects of the classes, adding them to the collection:

1 public class Common 2 {3 / 4 / / load plug-in 5 / 6 / 7 public static List GetPlugins () 8 {9 List implementObject = new List (); 10 / / get the Plugins folder 11 string dir = GetPluginsDir () under the project root directory 12 / / iterate through the files in the destination folder containing the dll suffix 13 foreach (var file in Directory.GetFiles (dir + @ "\", "* .dll")) 14 {15 / / load assembly 16 var asm = Assembly.LoadFrom (file) 17 / / traverse type 18 foreach (var type in asm.GetTypes ()) 19 {20 / / if it is IExcutable interface 21 if (type.GetInterfaces () .Contains (typeof (IExcutable) 22 {23 / / create interface type instance 24 Var IExcutable = Activator.CreateInstance (type) as IExcutable 25 if (IExcutable! = null) 26 {27 implementObject.Add (IExcutable); 28} 29} 30} 31} 32 return implementObject 33} 34 35 / / 36 / get the plug-in directory 37 / / 38 / 39 static string GetPluginsDir () 40 {41 string pluginDir = ConfigurationManager.AppSettings ["pluginDir"]; 42 return pluginDir;43} 44}

The main function of the following code snippet is to assign menus to the plug-in in the main program and bind common events:

1 / 2 / / create plug-in Common event 3 / 4 / 5 / 6 private void Plugin_Click (object sender, EventArgs e) 7 {8 ToolStripItem item= sender as ToolStripItem; 9 if (null! = item) 10 {11 12 if (null! = item.Tag) 13 {14 IExcutable plugin = item.Tag as IExcutable 15 if (null! = plugin) 16 {17 CodeContent.RichText=plugin.Excute (CodeContent.RichText); 18} 19} 20} 21} 22 23 / 24 / / main program load plug-in 25 / 26 private void LoadPlugins () 27 {28 List list = Common.Common.GetPlugins () 29 foreach (var Iplugins in list) 30 {31 ToolStripMenuItem item = new ToolStripMenuItem (Iplugins.GetName ()); / / dynamically create plug-in menus 32 item.Name = Iplugins.GetName (); 33 item.Click + = new EventHandler (Plugin_Click); / / bind public events 34 item.Tag = Iplugins;35 this.Plugins.DropDownItems.Add (item); 36} 37}

The GetPlugins method is to traverse the DLL file in the specified directory and add the objects that conform to the interface convention to the collection and return them to the main program. The GetPluginsDir method is to get the storage location of the plug-in, mainly to read the plug-in directory in the configuration file.

1 2 3 4 5 6 7 8 9 10

The effect is as shown in the figure:

For pre-converted text, the function of Format is to convert all lowercase letters to uppercase.

The converted text.

IV. Summary

This mini editor is a previous Mini Program, I found it when I was sorting out the code, and I suddenly wanted to modify it to make it more in line with my requirements, so I added a plug-in mechanism by the way. Plug-in mechanism is a good software design idea, which can expand the function of the main program without modifying the main program. Sometimes the plug-in function of a software is much more powerful than that of the main program. There are several points to pay attention to when applying the plug-in mechanism:

Define the interface, that is, the "contract" between the main program and the plug-in

Apply reflection, load a class that matches the interface through reflection, and then create an object of that class to call the interface method

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.