With jdk 6, the reflected fields are in deed in their declaration order. In early jdk that wasn’t the case. Apparently enough people have nagged. Although not guaranteed by javadoc, I would still take this order as granted, and I assume the order will be kept in future jdks too. In your app, like in … Read more
You can compile expression trees to use void methods without any arguments as event handlers for events of any type. To accommodate other event handler types, you have to map the event handler’s parameters to the events somehow. using System; using System.Linq; using System.Linq.Expressions; using System.Reflection; class ExampleEventArgs : EventArgs { public int IntArg {get; … Read more
OK, I found a way, using GetInterfaceMap. var map = targetType.GetInterfaceMap(interfaceMethod.DeclaringType); var index = Array.IndexOf(map.InterfaceMethods, interfaceMethod); if (index == -1) { //this should literally be impossible } return map.TargetMethods[index];
Reflection and method handles serve different purposes, and exist at different levels of abstraction. You should use the one that is right for the problem you are solving. Reflection is a general-purpose introspection mechanism, which includes many features that the method handle mechanism lacks, such as enumerating the members of a class (Class.getMethods()), inspecting the … Read more
On 1, yes, kinda: var v1 reflect.Type = reflect.TypeOf((*t1)(nil)).Elem() fmt.Println(v1) // prints “main.t1” No instantiation needed. However, Go doesn’t have type literals, which is I think what you’re asking for. To get the runtime value of a type, you need to have a value of some sort. If you don’t want to or can’t create … Read more
Try to use the library Impromptu-Interface [The Impromptu-Interface] framework to allow you to wrap any object (static or dynamic) with a static interface even though it didn’t inherit from it. It does this by emitting cached dynamic binding code inside a proxy. This allows you to do something like this: var person = new Person(); … Read more
Extension methods and attributes will help you: public class SkipPropertyAttribute : Attribute { } public static class TypeExtensions { public static PropertyInfo[] GetFilteredProperties(this Type type) { return type.GetProperties().Where(pi => pi.GetCustomAttributes(typeof(SkipPropertyAttribute), true).Length == 0).ToArray(); } } public class Test { public string One { get; set; } [SkipProperty] public string Two { get; set; } } … Read more
If MyTools.dll is located in the same directory as Addon.dll, all you need to do is call Assembly.LoadFrom instead of Assembly.LoadFile to make your code work. Otherwise, handling the AppDomain.AssemblyResolve event is the way to go.
Late entry! As I am likely to be searching for this in the future. There is a way to create copy/paste friendly Logger instances (granted this is almost never a good reason to do something!) by using Java 7’s MethodHandles class. private static final Logger LOGGER = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
If you only need to ask “Is this variant of type X ?” for a single type X, then I recommend that you prefer std::holds_alternative over std::variant::index because the line of code is easier to read and will not have to be updated if the index of the type in the variant changes in the … Read more