In particular, would it be possible to have code similar to this c++ code executed at compile time in c#?
template <int N>
struct Factorial
{
enum { value = N * Factorial<N - 1>::value };
};
template <>
struct Factorial<0>
{
enum { value = 1 };
};
// Factorial<4>::value == 24
// Factorial<0>::value == 1
void foo()
{
int x = Factorial<4>::value; // == 24
int y = Factorial<0>::value; // == 1
}
To a very limited extent, C# something that could be interpreted as meta-programming. But really it's nothing more than overload resolution. It's a real stretch to call it meta programming.
Example:
static string SomeFunc<T>(T value) {
return "Generic";
}
static string SomeFunc(int value) {
return "Non-Generic";
}
static void Example() {
SomeFunc(42); // Non-Generic
SomeFunc((object)42); // Generic
}
sort of look for t4 templates
Sorry on iphone and can't point to resource.
Scott Hansleman posted last week about it.
No, metaprogramming of this complexity is not supported directly by the C# language. However, like @littlegeek said, the Text Template Transformation Toolkit included with Visual Studio will allow you to achieve code generation of any complexity.
The essential difference between .NET Generics and C++ Templates is that generics are specialized at runtime. Templates are expanded at compile time. The dynamic behavior of generics makes things like Linq, expression trees, Type.MakeGenericType(), language independence and code re-use possible.
But there is a price, you can't for example use operators on values of the generic type argument. You can't write a std::complex class in C#. And no compile-time metaprogramming.
You must be carefull when talking about compile-time when dealing with Java or .Net languages. In those languages you can perform more powerfull metaprogamming (in the broader sense - reflection- ) than C++ due to the fact that "compilation time" (JIT) can be postponed after "run time" ;)
It is going to be possible. Watch Anders Hejlsberg's The Future of C# talk.
Most people insist on trying to metaprogram from inside their favorite language. That doesn't work if the language doesn't support metaprogramming well; other answers have observed that C# does not.
A way around this is to do metaprogramming from outside the language, using program transformation tools. Such tools can parse source code, and carry out arbitrary transformations on it (that's what metaprogramming does anyway) and then spit out the revised program.
If you have a general purpose program transformation system, that can parse arbitrary languages, you can then do metaprogramming on/with whatever language you like. See DMS Software Reengineering Toolkit for such a tool, that have robust front ends for C, C++, Java, C#, COBOL, PHP and a number of other programming langauges, and has been used for metaprogramming on all of these.
DMS succeeds because it provides a regular method and support infrastructure for complete access to the program structure as ASTs, and in most cases additional data such a symbol tables, type information, control and data flow analysis, all necessary to do sophisticated program manipulation.
EDIT (in response to comment): One could apply DMS to implement the OP's task on C#.