After reading James Nies's great piece,
Fast Dynamic Property Access with C#, which gives a great performance alternative for repetative reflection tasks, I started reading the comments and found two forks from it,
one for more than just properties by Seth Heeren and the other being an
implementation that supports generics (and sports better performance, of course) by Tobias Hertkorn, all of the above being excellent work.
These, in turn, got me to start thinking there had to be a better way to create the dynamic assembly than having to hack pieces of IL, so I just decided to generate a CodeDom graph on the fly.
This is my first time creating on-the-fly assemblies and it really wasn't so difficult - just a matter of setting the
CompilerParameters.GenerateInMemory property to
true.
Although it's more maintainable and is less likely to break in future CLR versions, it's slower than the previous version, given the fact that there's a compiler involved, but once you get over that hurdle (say, by caching the original object), it's about the same if not better.
Here is the source of the modified
GenericPropertyAccessor.cs, but the rest you need to download from the
previous article.
Last bit: During work on my code, I've come across yet another bug in CodeDom, "
The C# CodeDom provider does not work correctly with PrivateImplementationType with TypeArguments", which has been flagged as fixed in the next version. Another bug in CodeDom - who'd've thunk?
I believe I am not the only person in the world who likes to work only
with maximized windows and Alt+Tab - there are quite a lot of
advantages to that approach, mainly the fact that you can pull your
mouse to the upper-right corner of the screen and blindly left-click to
close it - without the need to fuss over aiming your cursor just right.
How many times have you seen this before: A window for application A is
above another and only appears maximized, but since Windows XP has
introduced curved corners for windows, it neglects to cover the
corners. Behind application A's window is another window - application B, which really is maximized - therefore covering the
corners of the screen.
However, when you try closing application A's almost-maximized window with an upper-right corner click, the mouse-click is actually sent to application B's window, causing it to close and you, the user, to get utterly frustrated.
Unfortunately, it looks like Vista isn't going to make any great improvements there, so if you're developing a UI, please try and avoid this - when a window needs to be big - open it maximized; otherwise, please make the window, at most, with 10 pixel margins from each corner of the screen.
All you have to do is use Form.MaximumSize and set it to values received from System.Windows.Forms.Screen.PrimaryScreen.WorkingArea (for a single display system) minus the margin and save headaches from thousands.
Thank you in advance.