This page intends to describe the full implementation set of Reflective# as well as describe all of its features, while we dont have a stable release.
As soon as Reflective# 1.0 gets released, this page will be deprecated, and the domuentation for 1.0 will be released.
  • new() => We can do Foo x = new(); instead of Foo x = new Foo();
    • The new-constructor syntax. The compiler already know which type we are dealing with, thus there's no need for re-typing it.
    • an explicit type construction (C# like) may be used when dealing with different classes ex.: FooBase x = new Foo();
    • Reflective#'s var initiates a type dynamic object, thus var x = new(); is simmilar to C#'s dynamic x = new object()
  • #include => Like in C++
    • If you want to add a code snippet or a class thats not precompiled to your code.
  • #log(...) => Prints the argument. This directive only gets compiled in case that the debug flag is true.
    • Very useful for debugging.
  • Operator Creation: Whole new level of abstraction.
  • Method inlining: add the keyword inline to your method and the preprocessor will inline its calls.
  • Big number library: Arbitrary big numbers and/or arbitrary decimal precision are now built in types.
  • Multithreading like a boss: Simply mark your method with threaded keyword, and the calls to it will create a new thread using the method as entry point.
  • Deterministic methods: Any method can be marked as deterministic. if so, a number of values will be stored in a list, which will associate parameters to results, without doing the processing again.
    • Useful for very heavy method which take long time to process and are used oftenly.

Last edited Feb 18, 2012 at 5:27 PM by matheus2740, version 6

Comments

No comments yet.