InternalClasses

  •        79

InternalClasses is a collection of common methods that are reusable across all components in a project. It performs things like simple logging, validation, attribute validation based on assembly injection, and dynamic method operations to reduce the reflection costs.

http://internalclasses.codeplex.com/

Tags
Implementation
License
Platform

   




Related Projects

CilDemo - CIL code manipulation demo using Mono Cecil Library (post compilation).


CIL code manipulation demo using Mono Cecil Library (post compilation).

dynvm


DynVM is a high-level VM intended as a target for dynamic languages. DynVM executes a high-level assembly language modeled after the Lua IR. This high-level assembly laguage (hlasm) can be the target dynamic language compiler, analogous to static compilation to machine code. Internal DynVM uses dynamic/JIT compilation techniques to achieve performance.

.NETAsm, a JIT Native Code Injection Library


NetAsm provides a hook to the .NET JIT compiler and enables to inject your own native code in replacement of the default CLR JIT compilation. With this library, it is possible, at runtime, to inject x86 assembler code in CLR methods with the speed of a pure CLR method call and...

CInject - Code Inject & Runtime Intelligence


CInject (or CodeInject) allows code injection into any managed assembly without disassembling and recompiling it. It eases the inevitable task of injecting any code in single or multiple methods in one or many assemblies to intercept code for almost any purpose. It is deve...



Hallenberg Framework


A framework for making it easier to use modules and dependency injection in ASP.NET MVC (and WPF in the future). You can use attributes directly on you controllers' methods to construct menu hirarchies with complete support for localization.

javaDynamicCompiler - Dynamic compilation of Java code using Java Compiler API (JSR 199)


Dynamic compilation of Java code using Java Compiler API (JSR 199)

Butterknife - Bind Android views and callbacks to fields and methods.


Field and method binding for Android views which uses annotation processing to generate boilerplate code for you. Annotate fields with @BindView and a view ID for Butter Knife to find and automatically cast the corresponding view in your layout. Instead of slow reflection, code is generated to perform the view look-ups. Calling bind delegates to this generated code that you can see and debug.

PyChecker - finds bugs in Python


PyChecker is a tool for finding bugs in python source code. It is similar to lint. PyChecker checks for each function, class and method for possible problems. It is capable to identify import errors.

HK2 - A light-weight and dynamic dependency injection framework


HK2 is a light-weight and dynamic dependency injection framework. HK2 is an implementation of JSR-330 in a JavaSE environment. JSR-330 defines services and injection points that can be dynamically discovered at runtime and which allow for Inversion of Control (IoC) and dependency injection (DI).

dpy - Python Inversion of Control


dPy is a simple dependency injection libary with serious power.Yes, Python is a dynamic language so dependency injection is not necessary, but injection provides more than just the ability to test static languages. It makes your code clearer, assists developers with straightforward modularization, and makes testing extremely simple. With dPy, the effects are even clearer.

thranduil - UI module for LÖVE


A UI module for LÖVE. Facilitates the creation of game specific UI through UI elements that have all their logic abstracted away. Each element is simple enough and exposes as much of its state as possible, meaning you can use this state to draw the element in whatever way you want or to build new UI elements with it (say you wanna make a menu, you can do it with a bunch of Buttons and a Frame). Elements can also be expanded easily via the injection of custom attributes and methods, providing !¡E

ProGuard Java Optimizer and Obfuscator


Java class file shrinker, optimizer, obfuscator, and preverifier

proguard - A fork of ProGuard.


ProGuard is a free Java class file shrinker, optimizer, obfuscator, and preverifier. It detects and removes unused classes, fields, methods, and attributes. It optimizes bytecode and removes unused instructions. It renames the remaining classes, fields, and methods using short meaningless names. Finally, it preverifies the processed code for Java 6 or for Java Micro Edition.ProGuard is useful for making code more compact and more efficient, on the desktop, on tablets, on smartphones, and on embedded devices. It also makes code more difficult to reverse engineer.

metafy


Metafy is a Gem for Rails 3 that makes it possible to easily add dynamic attributes to any ActiveRecord model. These lightweight, meta attributes work just like normal database column attributes on your ActiveRecord model and are fully searchable (i.e. you can find records by values contained in these dynamic attributes).

Caseproof-metafy


Metafy is a Gem for Rails 3 that makes it possible to easily add dynamic attributes to any ActiveRecord model. These lightweight, meta attributes work just like normal database column attributes on your ActiveRecord model and are fully searchable (i.e. you can find records by values contained in these dynamic attributes).

framework - A PHP 5.5 framework with dependency injection, events, and named arguments


* Configuration* Controller Dispatch* Route Matching* Response* View* Exceptions* Dependency Injection* Plugins* Configurable events* Calling methods using named arguments and plugin supportAll of the components require dependency injection and use [`Configuration`](https://github.com/mvc5/framework/blob/master/src/Config/Configuration.php) objects for consistency and ease of use. For example, the [`ServiceManager`](https://github.com/mvc5/framework/blob/master/src/Service/Manager/ServiceManager

application - A PHP 5.5 web application with dependency injection, events, and named arguments


* Configuration* Controller Dispatch* Route Matching* Response* View* Exceptions* Dependency Injection* Plugins* Configurable events* Calling methods using named arguments and plugin supportAll of the components require dependency injection and use [`Configuration`](https://github.com/mvc5/framework/blob/master/src/Config/Configuration.php) objects for consistency and ease of use. For example, the [`ServiceManager`](https://github.com/mvc5/framework/blob/master/src/Service/Manager/ServiceManager

MvcPrecompilation - Tools and features for pre-compiling views in ASP.NET Core MVC applications


The Razor syntax provides a fast, terse, clean, and lightweight way to combine server code with HTML to create dynamic web content. This repo contains tooling that allows compilation of MVC Razor views as part of build and publish.MvcRazorCompileOnPublish: Setting this to false turns off all functions of view compilation that are enabled as part of publishing.

unsafe - Java library to compile and run C++ code in-memory


"extern \"C\" void foo() {" +"printf(\"hello world!\\n\");" +"}");nativeModule.getFunctionByName("foo").invoke();```This library is designed for performance sensitive applications where access and generation of fast native code on the fly gives a performance edge.It is not intended for integration, mainly because the linker is not exposed in the API to keep it simple.Features======== - Compile and run C++ code using Clang+LLVM - Dynamic invocation of compiled functions with basic argument marsha