BranchesTags

Repository files navigation

Dynamic Reflection Library

The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a. operator), and fields.

The libary uses Lightweight Code Generation (LCG) to synthesize the minimum wrapper code to allow fully type-safe calls to arbitrary methods in any class through type-safe delgates. If appropriate runtime rights are available, these methods can even access private fields, methods and properties.

All members may be bound by name, or MemberInfo with optional automatic type coercision of the delegate's arguments to the called-method's argmuents. It also will do type-signature mapping to allow you to match a desired delegate signature and method name to the best-fit method.

Also included in this library is a DynamicCompare class, that generates a very-high performance IComparer method against any class for one or more fields/properties (with ascending/descending support). This allows you to generate the delegate to pass to Sort at runtime against a user-defined sort criteria and get near native speed.

News

  • I fix them as you find them, current patches for classes derived from an abstract generic base class in the upcoming 2.5.1.0 release.

  • Updated to release 2.5.0.0 which includes better XML documentation for the Dynamic class, code refactoring and elimination of duplicate code. At this point, I'm actually running 6% faster than native (C# compiled code)!

  • The first (CodePlex) production release 2.4.0.0 is now available on the Releases tab.

  • Full current source is now available online on the Source Code tab.

Frequently Asked Questions (FAQ)

  • What's the license?

    • In short it's Creative Commons 2.5 Attribution. The gist of which is that you can use this source any which way you want, but please leave the attribution of ownership in the sources.

  • Why would I use this?

If you need to do binding of code to fields/proporties/methods in classes dynamically, but want full type-safety and excellent performance. This means that you can, with a 25% or less overhead, bind to methods using the method name (or MemberInfo). This compares using standard Reflection, which is typically 20x slower or worse.

If you want to muck about in private members/methods of a sealed or poorly designed class that you don't have source for (e.g. to fix problems in a .Net framework class).

If you don't have the ability to dictate an interface, but can dictate a (type-compatible) method signature.

If you are allowing users to specify classes, methods or sort criteria at runtime or in configuration files.

  • What does it support?

    • Binding to any class or struct (i.e. both reference types and value types) including proper Enum support.

    • Binding to any method

    • Binding to any property of any type, including support for indexed properties with any number of arguments (up to 10)

    • Binding to any field of any type

    • Binding to public, protected or private (with appropriate reflection rights)

    • Handles implicit type coercision for arguments and return values (i.e. converting an Int16 to an Int32)

    • Does best-case matching against a specified argument list to find methods that are compatible with your expected call signature

  • Project documentation

    • Check the DynamicSample console mode application, which show all the various ways you could do this stuff using plain old Reflection, CreateDelegate, explicit-type DynamicMethods and parameter-list based DynamicMethods.

    • Check the DynamicSampleWeb mini web application to see how trivial binding by a list of property names could be done.

    • Coming soon to the Wiki near you. In the meantime, check these blog posts

Dynamic method calls:

https://www.musingmarc.org/2006/07/power-of-generics-compels-you-power-of.html

https://www.musingmarc.org/2006/07/updated-files-for-dynamic-method.html

https://www.musingmarc.org/2006/07/things-to-remember-when-creating.html

https://www.musingmarc.org/2006/08/how-to-do-late-dynamic-method-creation.html

DynamicCompare:

https://www.musingmarc.org/2006/02/dynamic-sorting-of-objects-using.html

https://www.musingmarc.org/2006/03/extending-dynamic-sorting-of-objects.html

Where it all started:

http://www.codeproject.com/dotnet/dynamiclistsorting.asp

http://msdn.microsoft.com/msdnmag/issues/05/07/Reflection/

  • Current issues

    • None reported

About

The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a. [] operator), and fields.

Topics

code-generationdynamiclcglightweightreflection

Resources

Readme
MS-PL license
Activity

Stars

9 stars

Watchers

3 watching

Forks

2 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Dynamic Reflection Library
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a.  operator), and fields.
The libary uses Lightweight Code Generation (LCG) to synthesize the minimum wrapper code to allow fully type-safe calls to arbitrary methods in any class through type-safe delgates. If appropriate runtime rights are available, these methods can even access private fields, methods and properties.
All members may be bound by name, or MemberInfo with optional automatic type coercision of the delegate's arguments to the called-method's argmuents. It also will do type-signature mapping to allow you to match a desired delegate signature and method name to the best-fit method.
Also included in this library is a DynamicCompare class, that generates a very-high performance IComparer method against any class for one or more fields/properties (with ascending/descending support). This allows you to generate the delegate to pass to Sort at runtime against a user-defined sort criteria and get near native speed.
News
  • I fix them as you find them, current patches for classes derived from an abstract generic base class in the upcoming 2.5.1.0 release.
  • Updated to release 2.5.0.0 which includes better XML documentation for the Dynamic class, code refactoring and elimination of duplicate code. At this point, I'm actually running 6% faster than native (C# compiled code)!
  • The first (CodePlex) production release 2.4.0.0 is now available on the Releases tab.
  • Full current source is now available online on the Source Code tab.
Frequently Asked Questions (FAQ)
  • What's the license?
    • In short it's Creative Commons 2.5 Attribution. The gist of which is that you can use this source any which way you want, but please leave the attribution of ownership in the sources.
  • Why would I use this?
If you need to do binding of code to fields/proporties/methods in classes dynamically, but want full type-safety and excellent performance. This means that you can, with a 25% or less overhead, bind to methods using the method name (or MemberInfo). This compares using standard Reflection, which is typically 20x slower or worse.
If you want to muck about in private members/methods of a sealed or poorly designed class that you don't have source for (e.g. to fix problems in a .Net framework class).
If you don't have the ability to dictate an interface, but can dictate a (type-compatible) method signature.
If you are allowing users to specify classes, methods or sort criteria at runtime or in configuration files.
  • What does it support?
    • Binding to any class or struct (i.e. both reference types and value types) including proper Enum support.
    • Binding to any method
    • Binding to any property of any type, including support for indexed properties with any number of arguments (up to 10)
    • Binding to any field of any type
    • Binding to public, protected or private (with appropriate reflection rights)
    • Handles implicit type coercision for arguments and return values (i.e. converting an Int16 to an Int32)
    • Does best-case matching against a specified argument list to find methods that are compatible with your expected call signature
  • Project documentation
    • Check the DynamicSample console mode application, which show all the various ways you could do this stuff using plain old Reflection, CreateDelegate, explicit-type DynamicMethods and parameter-list based DynamicMethods.
    • Check the DynamicSampleWeb mini web application to see how trivial binding by a list of property names could be done.
    • Coming soon to the Wiki near you. In the meantime, check these blog posts
Dynamic method calls:
https://www.musingmarc.org/2006/07/power-of-generics-compels-you-power-of.html
https://www.musingmarc.org/2006/07/updated-files-for-dynamic-method.html
https://www.musingmarc.org/2006/07/things-to-remember-when-creating.html
https://www.musingmarc.org/2006/08/how-to-do-late-dynamic-method-creation.html
DynamicCompare:
https://www.musingmarc.org/2006/02/dynamic-sorting-of-objects-using.html
https://www.musingmarc.org/2006/03/extending-dynamic-sorting-of-objects.html
Where it all started:
http://www.codeproject.com/dotnet/dynamiclistsorting.asp
http://msdn.microsoft.com/msdnmag/issues/05/07/Reflection/
  • Current issues
    • None reported
About
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a. [] operator), and fields. 
Topics
code-generationdynamiclcglightweightreflection
Resources
Readme
MS-PL license
Activity
Stars
9 stars
Watchers
3 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Dynamic Reflection Library
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a.  operator), and fields.
The libary uses Lightweight Code Generation (LCG) to synthesize the minimum wrapper code to allow fully type-safe calls to arbitrary methods in any class through type-safe delgates. If appropriate runtime rights are available, these methods can even access private fields, methods and properties.
All members may be bound by name, or MemberInfo with optional automatic type coercision of the delegate's arguments to the called-method's argmuents. It also will do type-signature mapping to allow you to match a desired delegate signature and method name to the best-fit method.
Also included in this library is a DynamicCompare class, that generates a very-high performance IComparer method against any class for one or more fields/properties (with ascending/descending support). This allows you to generate the delegate to pass to Sort at runtime against a user-defined sort criteria and get near native speed.
News
  • I fix them as you find them, current patches for classes derived from an abstract generic base class in the upcoming 2.5.1.0 release.
  • Updated to release 2.5.0.0 which includes better XML documentation for the Dynamic class, code refactoring and elimination of duplicate code. At this point, I'm actually running 6% faster than native (C# compiled code)!
  • The first (CodePlex) production release 2.4.0.0 is now available on the Releases tab.
  • Full current source is now available online on the Source Code tab.
Frequently Asked Questions (FAQ)
  • What's the license?
    • In short it's Creative Commons 2.5 Attribution. The gist of which is that you can use this source any which way you want, but please leave the attribution of ownership in the sources.
  • Why would I use this?
If you need to do binding of code to fields/proporties/methods in classes dynamically, but want full type-safety and excellent performance. This means that you can, with a 25% or less overhead, bind to methods using the method name (or MemberInfo). This compares using standard Reflection, which is typically 20x slower or worse.
If you want to muck about in private members/methods of a sealed or poorly designed class that you don't have source for (e.g. to fix problems in a .Net framework class).
If you don't have the ability to dictate an interface, but can dictate a (type-compatible) method signature.
If you are allowing users to specify classes, methods or sort criteria at runtime or in configuration files.
  • What does it support?
    • Binding to any class or struct (i.e. both reference types and value types) including proper Enum support.
    • Binding to any method
    • Binding to any property of any type, including support for indexed properties with any number of arguments (up to 10)
    • Binding to any field of any type
    • Binding to public, protected or private (with appropriate reflection rights)
    • Handles implicit type coercision for arguments and return values (i.e. converting an Int16 to an Int32)
    • Does best-case matching against a specified argument list to find methods that are compatible with your expected call signature
  • Project documentation
    • Check the DynamicSample console mode application, which show all the various ways you could do this stuff using plain old Reflection, CreateDelegate, explicit-type DynamicMethods and parameter-list based DynamicMethods.
    • Check the DynamicSampleWeb mini web application to see how trivial binding by a list of property names could be done.
    • Coming soon to the Wiki near you. In the meantime, check these blog posts
Dynamic method calls:
https://www.musingmarc.org/2006/07/power-of-generics-compels-you-power-of.html
https://www.musingmarc.org/2006/07/updated-files-for-dynamic-method.html
https://www.musingmarc.org/2006/07/things-to-remember-when-creating.html
https://www.musingmarc.org/2006/08/how-to-do-late-dynamic-method-creation.html
DynamicCompare:
https://www.musingmarc.org/2006/02/dynamic-sorting-of-objects-using.html
https://www.musingmarc.org/2006/03/extending-dynamic-sorting-of-objects.html
Where it all started:
http://www.codeproject.com/dotnet/dynamiclistsorting.asp
http://msdn.microsoft.com/msdnmag/issues/05/07/Reflection/
  • Current issues
    • None reported
About
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a. [] operator), and fields. 
Topics
code-generationdynamiclcglightweightreflection
Resources
Readme
MS-PL license
Activity
Stars
9 stars
Watchers
3 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Dynamic Reflection Library
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a.  operator), and fields.
The libary uses Lightweight Code Generation (LCG) to synthesize the minimum wrapper code to allow fully type-safe calls to arbitrary methods in any class through type-safe delgates. If appropriate runtime rights are available, these methods can even access private fields, methods and properties.
All members may be bound by name, or MemberInfo with optional automatic type coercision of the delegate's arguments to the called-method's argmuents. It also will do type-signature mapping to allow you to match a desired delegate signature and method name to the best-fit method.
Also included in this library is a DynamicCompare class, that generates a very-high performance IComparer method against any class for one or more fields/properties (with ascending/descending support). This allows you to generate the delegate to pass to Sort at runtime against a user-defined sort criteria and get near native speed.
News
  • I fix them as you find them, current patches for classes derived from an abstract generic base class in the upcoming 2.5.1.0 release.
  • Updated to release 2.5.0.0 which includes better XML documentation for the Dynamic class, code refactoring and elimination of duplicate code. At this point, I'm actually running 6% faster than native (C# compiled code)!
  • The first (CodePlex) production release 2.4.0.0 is now available on the Releases tab.
  • Full current source is now available online on the Source Code tab.
Frequently Asked Questions (FAQ)
  • What's the license?
    • In short it's Creative Commons 2.5 Attribution. The gist of which is that you can use this source any which way you want, but please leave the attribution of ownership in the sources.
  • Why would I use this?
If you need to do binding of code to fields/proporties/methods in classes dynamically, but want full type-safety and excellent performance. This means that you can, with a 25% or less overhead, bind to methods using the method name (or MemberInfo). This compares using standard Reflection, which is typically 20x slower or worse.
If you want to muck about in private members/methods of a sealed or poorly designed class that you don't have source for (e.g. to fix problems in a .Net framework class).
If you don't have the ability to dictate an interface, but can dictate a (type-compatible) method signature.
If you are allowing users to specify classes, methods or sort criteria at runtime or in configuration files.
  • What does it support?
    • Binding to any class or struct (i.e. both reference types and value types) including proper Enum support.
    • Binding to any method
    • Binding to any property of any type, including support for indexed properties with any number of arguments (up to 10)
    • Binding to any field of any type
    • Binding to public, protected or private (with appropriate reflection rights)
    • Handles implicit type coercision for arguments and return values (i.e. converting an Int16 to an Int32)
    • Does best-case matching against a specified argument list to find methods that are compatible with your expected call signature
  • Project documentation
    • Check the DynamicSample console mode application, which show all the various ways you could do this stuff using plain old Reflection, CreateDelegate, explicit-type DynamicMethods and parameter-list based DynamicMethods.
    • Check the DynamicSampleWeb mini web application to see how trivial binding by a list of property names could be done.
    • Coming soon to the Wiki near you. In the meantime, check these blog posts
Dynamic method calls:
https://www.musingmarc.org/2006/07/power-of-generics-compels-you-power-of.html
https://www.musingmarc.org/2006/07/updated-files-for-dynamic-method.html
https://www.musingmarc.org/2006/07/things-to-remember-when-creating.html
https://www.musingmarc.org/2006/08/how-to-do-late-dynamic-method-creation.html
DynamicCompare:
https://www.musingmarc.org/2006/02/dynamic-sorting-of-objects-using.html
https://www.musingmarc.org/2006/03/extending-dynamic-sorting-of-objects.html
Where it all started:
http://www.codeproject.com/dotnet/dynamiclistsorting.asp
http://msdn.microsoft.com/msdnmag/issues/05/07/Reflection/
  • Current issues
    • None reported
About
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a. [] operator), and fields. 
Topics
code-generationdynamiclcglightweightreflection
Resources
Readme
MS-PL license
Activity
Stars
9 stars
Watchers
3 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Dynamic Reflection Library
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a.  operator), and fields.
The libary uses Lightweight Code Generation (LCG) to synthesize the minimum wrapper code to allow fully type-safe calls to arbitrary methods in any class through type-safe delgates. If appropriate runtime rights are available, these methods can even access private fields, methods and properties.
All members may be bound by name, or MemberInfo with optional automatic type coercision of the delegate's arguments to the called-method's argmuents. It also will do type-signature mapping to allow you to match a desired delegate signature and method name to the best-fit method.
Also included in this library is a DynamicCompare class, that generates a very-high performance IComparer method against any class for one or more fields/properties (with ascending/descending support). This allows you to generate the delegate to pass to Sort at runtime against a user-defined sort criteria and get near native speed.
News
  • I fix them as you find them, current patches for classes derived from an abstract generic base class in the upcoming 2.5.1.0 release.
  • Updated to release 2.5.0.0 which includes better XML documentation for the Dynamic class, code refactoring and elimination of duplicate code. At this point, I'm actually running 6% faster than native (C# compiled code)!
  • The first (CodePlex) production release 2.4.0.0 is now available on the Releases tab.
  • Full current source is now available online on the Source Code tab.
Frequently Asked Questions (FAQ)
  • What's the license?
    • In short it's Creative Commons 2.5 Attribution. The gist of which is that you can use this source any which way you want, but please leave the attribution of ownership in the sources.
  • Why would I use this?
If you need to do binding of code to fields/proporties/methods in classes dynamically, but want full type-safety and excellent performance. This means that you can, with a 25% or less overhead, bind to methods using the method name (or MemberInfo). This compares using standard Reflection, which is typically 20x slower or worse.
If you want to muck about in private members/methods of a sealed or poorly designed class that you don't have source for (e.g. to fix problems in a .Net framework class).
If you don't have the ability to dictate an interface, but can dictate a (type-compatible) method signature.
If you are allowing users to specify classes, methods or sort criteria at runtime or in configuration files.
  • What does it support?
    • Binding to any class or struct (i.e. both reference types and value types) including proper Enum support.
    • Binding to any method
    • Binding to any property of any type, including support for indexed properties with any number of arguments (up to 10)
    • Binding to any field of any type
    • Binding to public, protected or private (with appropriate reflection rights)
    • Handles implicit type coercision for arguments and return values (i.e. converting an Int16 to an Int32)
    • Does best-case matching against a specified argument list to find methods that are compatible with your expected call signature
  • Project documentation
    • Check the DynamicSample console mode application, which show all the various ways you could do this stuff using plain old Reflection, CreateDelegate, explicit-type DynamicMethods and parameter-list based DynamicMethods.
    • Check the DynamicSampleWeb mini web application to see how trivial binding by a list of property names could be done.
    • Coming soon to the Wiki near you. In the meantime, check these blog posts
Dynamic method calls:
https://www.musingmarc.org/2006/07/power-of-generics-compels-you-power-of.html
https://www.musingmarc.org/2006/07/updated-files-for-dynamic-method.html
https://www.musingmarc.org/2006/07/things-to-remember-when-creating.html
https://www.musingmarc.org/2006/08/how-to-do-late-dynamic-method-creation.html
DynamicCompare:
https://www.musingmarc.org/2006/02/dynamic-sorting-of-objects-using.html
https://www.musingmarc.org/2006/03/extending-dynamic-sorting-of-objects.html
Where it all started:
http://www.codeproject.com/dotnet/dynamiclistsorting.asp
http://msdn.microsoft.com/msdnmag/issues/05/07/Reflection/
  • Current issues
    • None reported
About
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a. [] operator), and fields. 
Topics
code-generationdynamiclcglightweightreflection
Resources
Readme
MS-PL license
Activity
Stars
9 stars
Watchers
3 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Dynamic Reflection Library
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a.  operator), and fields.
The libary uses Lightweight Code Generation (LCG) to synthesize the minimum wrapper code to allow fully type-safe calls to arbitrary methods in any class through type-safe delgates. If appropriate runtime rights are available, these methods can even access private fields, methods and properties.
All members may be bound by name, or MemberInfo with optional automatic type coercision of the delegate's arguments to the called-method's argmuents. It also will do type-signature mapping to allow you to match a desired delegate signature and method name to the best-fit method.
Also included in this library is a DynamicCompare class, that generates a very-high performance IComparer method against any class for one or more fields/properties (with ascending/descending support). This allows you to generate the delegate to pass to Sort at runtime against a user-defined sort criteria and get near native speed.
News
  • I fix them as you find them, current patches for classes derived from an abstract generic base class in the upcoming 2.5.1.0 release.
  • Updated to release 2.5.0.0 which includes better XML documentation for the Dynamic class, code refactoring and elimination of duplicate code. At this point, I'm actually running 6% faster than native (C# compiled code)!
  • The first (CodePlex) production release 2.4.0.0 is now available on the Releases tab.
  • Full current source is now available online on the Source Code tab.
Frequently Asked Questions (FAQ)
  • What's the license?
    • In short it's Creative Commons 2.5 Attribution. The gist of which is that you can use this source any which way you want, but please leave the attribution of ownership in the sources.
  • Why would I use this?
If you need to do binding of code to fields/proporties/methods in classes dynamically, but want full type-safety and excellent performance. This means that you can, with a 25% or less overhead, bind to methods using the method name (or MemberInfo). This compares using standard Reflection, which is typically 20x slower or worse.
If you want to muck about in private members/methods of a sealed or poorly designed class that you don't have source for (e.g. to fix problems in a .Net framework class).
If you don't have the ability to dictate an interface, but can dictate a (type-compatible) method signature.
If you are allowing users to specify classes, methods or sort criteria at runtime or in configuration files.
  • What does it support?
    • Binding to any class or struct (i.e. both reference types and value types) including proper Enum support.
    • Binding to any method
    • Binding to any property of any type, including support for indexed properties with any number of arguments (up to 10)
    • Binding to any field of any type
    • Binding to public, protected or private (with appropriate reflection rights)
    • Handles implicit type coercision for arguments and return values (i.e. converting an Int16 to an Int32)
    • Does best-case matching against a specified argument list to find methods that are compatible with your expected call signature
  • Project documentation
    • Check the DynamicSample console mode application, which show all the various ways you could do this stuff using plain old Reflection, CreateDelegate, explicit-type DynamicMethods and parameter-list based DynamicMethods.
    • Check the DynamicSampleWeb mini web application to see how trivial binding by a list of property names could be done.
    • Coming soon to the Wiki near you. In the meantime, check these blog posts
Dynamic method calls:
https://www.musingmarc.org/2006/07/power-of-generics-compels-you-power-of.html
https://www.musingmarc.org/2006/07/updated-files-for-dynamic-method.html
https://www.musingmarc.org/2006/07/things-to-remember-when-creating.html
https://www.musingmarc.org/2006/08/how-to-do-late-dynamic-method-creation.html
DynamicCompare:
https://www.musingmarc.org/2006/02/dynamic-sorting-of-objects-using.html
https://www.musingmarc.org/2006/03/extending-dynamic-sorting-of-objects.html
Where it all started:
http://www.codeproject.com/dotnet/dynamiclistsorting.asp
http://msdn.microsoft.com/msdnmag/issues/05/07/Reflection/
  • Current issues
    • None reported
About
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a. [] operator), and fields. 
Topics
code-generationdynamiclcglightweightreflection
Resources
Readme
MS-PL license
Activity
Stars
9 stars
Watchers
3 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Dynamic Reflection Library
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a.  operator), and fields.
The libary uses Lightweight Code Generation (LCG) to synthesize the minimum wrapper code to allow fully type-safe calls to arbitrary methods in any class through type-safe delgates. If appropriate runtime rights are available, these methods can even access private fields, methods and properties.
All members may be bound by name, or MemberInfo with optional automatic type coercision of the delegate's arguments to the called-method's argmuents. It also will do type-signature mapping to allow you to match a desired delegate signature and method name to the best-fit method.
Also included in this library is a DynamicCompare class, that generates a very-high performance IComparer method against any class for one or more fields/properties (with ascending/descending support). This allows you to generate the delegate to pass to Sort at runtime against a user-defined sort criteria and get near native speed.
News
  • I fix them as you find them, current patches for classes derived from an abstract generic base class in the upcoming 2.5.1.0 release.
  • Updated to release 2.5.0.0 which includes better XML documentation for the Dynamic class, code refactoring and elimination of duplicate code. At this point, I'm actually running 6% faster than native (C# compiled code)!
  • The first (CodePlex) production release 2.4.0.0 is now available on the Releases tab.
  • Full current source is now available online on the Source Code tab.
Frequently Asked Questions (FAQ)
  • What's the license?
    • In short it's Creative Commons 2.5 Attribution. The gist of which is that you can use this source any which way you want, but please leave the attribution of ownership in the sources.
  • Why would I use this?
If you need to do binding of code to fields/proporties/methods in classes dynamically, but want full type-safety and excellent performance. This means that you can, with a 25% or less overhead, bind to methods using the method name (or MemberInfo). This compares using standard Reflection, which is typically 20x slower or worse.
If you want to muck about in private members/methods of a sealed or poorly designed class that you don't have source for (e.g. to fix problems in a .Net framework class).
If you don't have the ability to dictate an interface, but can dictate a (type-compatible) method signature.
If you are allowing users to specify classes, methods or sort criteria at runtime or in configuration files.
  • What does it support?
    • Binding to any class or struct (i.e. both reference types and value types) including proper Enum support.
    • Binding to any method
    • Binding to any property of any type, including support for indexed properties with any number of arguments (up to 10)
    • Binding to any field of any type
    • Binding to public, protected or private (with appropriate reflection rights)
    • Handles implicit type coercision for arguments and return values (i.e. converting an Int16 to an Int32)
    • Does best-case matching against a specified argument list to find methods that are compatible with your expected call signature
  • Project documentation
    • Check the DynamicSample console mode application, which show all the various ways you could do this stuff using plain old Reflection, CreateDelegate, explicit-type DynamicMethods and parameter-list based DynamicMethods.
    • Check the DynamicSampleWeb mini web application to see how trivial binding by a list of property names could be done.
    • Coming soon to the Wiki near you. In the meantime, check these blog posts
Dynamic method calls:
https://www.musingmarc.org/2006/07/power-of-generics-compels-you-power-of.html
https://www.musingmarc.org/2006/07/updated-files-for-dynamic-method.html
https://www.musingmarc.org/2006/07/things-to-remember-when-creating.html
https://www.musingmarc.org/2006/08/how-to-do-late-dynamic-method-creation.html
DynamicCompare:
https://www.musingmarc.org/2006/02/dynamic-sorting-of-objects-using.html
https://www.musingmarc.org/2006/03/extending-dynamic-sorting-of-objects.html
Where it all started:
http://www.codeproject.com/dotnet/dynamiclistsorting.asp
http://msdn.microsoft.com/msdnmag/issues/05/07/Reflection/
  • Current issues
    • None reported
About
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a. [] operator), and fields. 
Topics
code-generationdynamiclcglightweightreflection
Resources
Readme
MS-PL license
Activity
Stars
9 stars
Watchers
3 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
Dynamic Reflection Library
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a.  operator), and fields.
The libary uses Lightweight Code Generation (LCG) to synthesize the minimum wrapper code to allow fully type-safe calls to arbitrary methods in any class through type-safe delgates. If appropriate runtime rights are available, these methods can even access private fields, methods and properties.
All members may be bound by name, or MemberInfo with optional automatic type coercision of the delegate's arguments to the called-method's argmuents. It also will do type-signature mapping to allow you to match a desired delegate signature and method name to the best-fit method.
Also included in this library is a DynamicCompare class, that generates a very-high performance IComparer method against any class for one or more fields/properties (with ascending/descending support). This allows you to generate the delegate to pass to Sort at runtime against a user-defined sort criteria and get near native speed.
News
  • I fix them as you find them, current patches for classes derived from an abstract generic base class in the upcoming 2.5.1.0 release.
  • Updated to release 2.5.0.0 which includes better XML documentation for the Dynamic class, code refactoring and elimination of duplicate code. At this point, I'm actually running 6% faster than native (C# compiled code)!
  • The first (CodePlex) production release 2.4.0.0 is now available on the Releases tab.
  • Full current source is now available online on the Source Code tab.
Frequently Asked Questions (FAQ)
  • What's the license?
    • In short it's Creative Commons 2.5 Attribution. The gist of which is that you can use this source any which way you want, but please leave the attribution of ownership in the sources.
  • Why would I use this?
If you need to do binding of code to fields/proporties/methods in classes dynamically, but want full type-safety and excellent performance. This means that you can, with a 25% or less overhead, bind to methods using the method name (or MemberInfo). This compares using standard Reflection, which is typically 20x slower or worse.
If you want to muck about in private members/methods of a sealed or poorly designed class that you don't have source for (e.g. to fix problems in a .Net framework class).
If you don't have the ability to dictate an interface, but can dictate a (type-compatible) method signature.
If you are allowing users to specify classes, methods or sort criteria at runtime or in configuration files.
  • What does it support?
    • Binding to any class or struct (i.e. both reference types and value types) including proper Enum support.
    • Binding to any method
    • Binding to any property of any type, including support for indexed properties with any number of arguments (up to 10)
    • Binding to any field of any type
    • Binding to public, protected or private (with appropriate reflection rights)
    • Handles implicit type coercision for arguments and return values (i.e. converting an Int16 to an Int32)
    • Does best-case matching against a specified argument list to find methods that are compatible with your expected call signature
  • Project documentation
    • Check the DynamicSample console mode application, which show all the various ways you could do this stuff using plain old Reflection, CreateDelegate, explicit-type DynamicMethods and parameter-list based DynamicMethods.
    • Check the DynamicSampleWeb mini web application to see how trivial binding by a list of property names could be done.
    • Coming soon to the Wiki near you. In the meantime, check these blog posts
Dynamic method calls:
https://www.musingmarc.org/2006/07/power-of-generics-compels-you-power-of.html
https://www.musingmarc.org/2006/07/updated-files-for-dynamic-method.html
https://www.musingmarc.org/2006/07/things-to-remember-when-creating.html
https://www.musingmarc.org/2006/08/how-to-do-late-dynamic-method-creation.html
DynamicCompare:
https://www.musingmarc.org/2006/02/dynamic-sorting-of-objects-using.html
https://www.musingmarc.org/2006/03/extending-dynamic-sorting-of-objects.html
Where it all started:
http://www.codeproject.com/dotnet/dynamiclistsorting.asp
http://msdn.microsoft.com/msdnmag/issues/05/07/Reflection/
  • Current issues
    • None reported
About
The Dynamic Reflection Library is a small set of classes designed to greatly speed the use of .Net reflection to call constructors, member methods, property setters and getters including those with indexing arguments such as the Item (a.k.a. [] operator), and fields. 
Topics
code-generationdynamiclcglightweightreflection
Resources
Readme
MS-PL license
Activity
Stars
9 stars
Watchers
3 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages