C # General anti-casting method

Question

I am writing a program in C # (3.5 at the moment, but I will probably adapt to other versions as necessary), which uses a simple plug-in architecture to control input and output. Each plugin is a DLL that loads when the user selects the plugins to use.

Since the actual plugin class is not known until runtime, I use reflection in the wrapper class to call the methods and properties for accessing the plugins.

So far, I have used the following calling methods for the plugin:

public object Method(string methodName, params object[] arguments) { // Assumed variables/methods/exceptions: // Dictionary<string, MethodInfo> Methods: a cache of MethodInfo's // of previously called methods. // NoSuchMethodException: thrown if an unknown/unreachable method is // requested. The message member contains the invalid method name // void LoadMethod(string methodName, params object[] arguments): responsible // for retrieving the MethodInfo's, or throw a NoSuchMethodException // object Plugin: an instance of the dynamically loaded class. if (!Methods.ContainsKey(methodName)) { LoadMethod(methodName, arguments); } if (arguments != null && arguments.Length == 0) { arguments = null; } return Methods[methodName].Invoke(Plugin, arguments); } 

Used as:

 string[] headers = (string[]) Plugin.Method("GetHeaders", dbName, tableName); 

This works well if the caller correctly returns the return value to the expected type. Plugins must implement certain interfaces, so the caller must know this type.

However, after some additional work with reflection, I received the following alternative form:

 public T Method<T>(string methodName, params object[] arguments) { if (!Methods.ContainsKey(methodName)) { LoadMethod(methodName, arguments); } if (Methods[methodName].ReturnType != typeof(T)) { // Could also move this into LoadMethod to keep all the throwing in one place throw new NoSuchMethodException(methodName); } if (arguments != null && arguments.Length == 0) { arguments = null; } return (T) Methods[methodName].Invoke(Plugin, arguments); } 

This one is used as:

 string[] headers = Plugin.Method<string[]>("GetHeaders", dbName, tableName); 

This version essentially moves casting to a method method. The caller obviously still needs to know the expected return type, but this will always be so. It does not work for void methods, but I can include a version of the method in it:

 public void Method(string methodName, params object[] arguments) { // Good for void methods, or when you're going to throw away the return // value anyway. if (!Methods.ContainsKey(methodName)) { LoadMethod(methodName, arguments); } if (arguments != null && arguments.Length == 0) { arguments = null; } Methods[methodName].Invoke(Plugin, arguments); } 

My question is, is one of them essentially better than the other (for a given value, "better")? For example, is it especially noticeably faster? Easier to understand? More supported?

I personally like the look of the latter, although I'm a little worried that my test testing of the return type ( Methods[methodName].ReturnType != typeof(T) ) may be too simplistic. Interestingly, it was originally !(Methods[methodName].ReturnType is T) , but it always seemed unsuccessful.

The closest existing question to this that I could find is the General method for casting input , and some of the answers suggested that the last method is more expensive than the first, but there are not so many details (the question is more about the implementation of the method, and not that it is better).

Clarification: This is a manual, very limited plug-in system that does not use IPlugin. I am more interested in the question of whether general methods are inherently better / worse than expected that the caller will use in this situation.

Answer 1

As for your question, I think you should provide both. Just enter the generic version with the non-standard version. You get the best of both worlds. As far as performance is concerned, think about how small the time it takes to create an object compared to dynamically invoking a method and creating an array of objects and objects. It really is not worth considering here. I prefer a general approach from a stylistic point of view, but I also think that type restrictions can be applied if necessary.

 public T Method<T>(string methodName, params object[] arguments) { return (T)Method(methodName, arguments); } 

---

Side panel

I think your implementation should distinguish the expected interface if I understand your design. You really shouldn't use reflection if you know which methods plugins should support.

 var plugin = (IPlugin)Activator.CreateInstance(pluginType); var headers = plugin.GetHeaders(dbName, tableName); 

You can try something a little different and require the plugin to implement an interface that allows them to register user behavior at runtime.

 public interface IPlugin { void Load(IAppContext context); void Unload(); } 

Your download method might look like this.

 void LoadPlugins(Assembly a) { var plugins = a.GetTypes() .Where(t => typeof(IPlugin).IsAssignableFrom(t)) .Select(t => (IPlugin)Activator.CreateInstance(t)) .ToList(); Plugins.AddRange(plugins); foreach (var p in plugins) { p.Load(Context); } }