ImmediateMethods?

[Zxynine]

After going though and picking apart the code, I realised that this does not provide any form of Method access (Outside of course the getter and setters). I think that is a real shame as the rest of the library is astounding. I also think there are some other features missing, but ill be honest, your documentation in the readme does not provide enough different situational cases of using this library for me to tell. I'm still trying to wrap my head around it all so I've probably missed many features, though that goes back to documentation.

Methods are what I use the most from reflection and I've been looking at a number of different libraries for more insight and ideas so that I may improve the performance of my projects that need reflection. I do know that it is not quite as easy as just doing what you did for getters and setters, but I also do know from looking at your code that you are plenty capable of finding some compromise/solution.

I feel that this is the only thing thats really missing from this repository and I was wondering if you had any plans to try and implement something like an ImmediateMethod class?

Also, I have no idea what category to put this under, I was originally going to go with Q and A, but if its not already implemented, an immediateMethods class is a suggestion, so sorry if I misplaced it.

[KeRNeLith]

Hello!

Thanks for your interest to the library. I would be pleased to hear about features you think are missing for sure!
The readme are there to showcase and still be simple and easy to read. Of course there are certainly more detailed scenarios that can be described but maybe more in a more in depth documentation page. BTW if you have any suggestion on that topic, something you wanted to do, or did not manage to understand in a first approach then writing it down to a wiki or doc page would be great.

To be honest at some point I was really optimisitic that I created a branch on the project for the method handling. As you can see there is nothing for that on master branch! The main issue I didn't solved for now is how to provide an optimal way to do parameter matching that would be more efficient than standard reflection. In this case it appears to be not straighforward to solve this problem. BTW I'm open to any suggestion that would maybe end on a possible solution.

Of course I'm aware that ImmediateMethod would be the final stone for the library.

You know that a common trick to get rid of reflection is to use interfaces so that you no more pay the cost of reflection and have possibilities of calling methods kind of dynamically. But it is not always ideal of possible for sure.

No worry about that, Openning a Q&A thread is certainly a good way to brainstorm and then act!

[Zxynine]

Hey, Sadly interfaces are not an option because I use reflection for accessing classes in Unity that are private/protected/internal. The best solution for parameter matching I think I may have come across is storing methods and their parameters in a dictionary of some sort, the parameters and name of the function are hashed together into a special key that can identify individual methods with little effort. I think I even have a struct that does that to a degree called Type signature. You may not even need the name hashed in, though I probably would to be safe. From there it should be just as fast as anything else, just instead of name look up, the hashed value is a hash of the name and parameters which uniquely identify each method.

	private struct TypeSignature : IEquatable<TypeSignature> {
		public Type[] Types;
		public int Hash;

		public TypeSignature(params Type[] types) {
			(this.Types, this.Hash) = (types, 1);
			foreach (Type type in types) {
				int hashCode = type.GetHashCode();
				this.Hash = (137 * this.Hash) + (hashCode^hashCode >> 16);
			}
		}
	}















	private struct TypeSignature4 {
		public Type T1, T2, T3, T4;
		public int Hash;
		public TypeSignature4(Type t1, Type t2, Type t3, Type t4) {
			(this.T1, this.T2, this.T3, this.T4) = (t1, t2, t3, t4);

			int num = 1;
			int hashCode = t1.GetHashCode();
			num = 137 * num + (hashCode ^ hashCode >> 16);
			hashCode = t2.GetHashCode();
			num = 137 * num + (hashCode ^ hashCode >> 16);
			hashCode = t3.GetHashCode();
			num = 137 * num + (hashCode ^ hashCode >> 16);
			hashCode = t4.GetHashCode();
			num = 137 * num + (hashCode ^ hashCode >> 16);
			this.Hash = num;
		}
	}

	private class TypeSignatureComparer : IEqualityComparer<TypeSignature4> {
		public bool Equals(TypeSignature4 x, TypeSignature4 y) {
			return x.Hash == y.Hash && x.T1 == y.T1 && x.T2 == y.T2 && x.T3 == y.T3 && x.T4 == y.T4;
		}

		public int GetHashCode(TypeSignature4 obj) => obj.Hash;
	}

[Zxynine]

The topmost function was me trying to generalise it, Im not sure if that works they way i did it, you may not want to just use a loop to automate the hashing function in TypeSignature4 when you could just get the hash of the array, but I have no idea, I never quite got around to finishing the concept.