Methods within methods

[PIEBALDconsult]

Yeeahh... anonymous methods? They can be a bit useful at times.

[Shahriar Iqbal Chowdhury Galib]

what will be use?

[Fernando A Gomez F]

It kinda reminded me of local classes in C++, where you could create a class within a method (with certain restrictions). I always wondered how could they be used, until I read Alexandrescu's Modern C++ Design, where he pointed a particular use: create a class that implements certain interface, so you could have a factory-like method...

[Mike Winiberg]

It's amazing how techniques etc that have been around for many, many years keep cropping up as though they were new - Pascal anyone? 8)

[Adriaan Davel]

The best thing about anonymous methods IMO is that you can pass them as parameters, which gives a couple of Async pattern options...

____________________________________________________________ Be brave little warrior, be VERY brave

[User 4223959]

I agree, there are times I miss those things, though barely remember how many years ago I saw Pascal for the last time. BTW, you can do the same tricks with anonymous inner classes, in Java...

[Paul Michalik]

A shorter version which demonstrates the locality better is this:

void PrintElements(Grid grid, bool isVertical)
{
foreach (FrameworkElement element in grid.Children) {
Console.WriteLine(arg => isVertical ? Grid.GetRow(arg) : Grid.GetColumn(arg));
}
}

However, you might not know that this locality is just an illusion generated by the C# compiler, or more precisely by it's code generation features. In reality the containing class is extended by automatically generated code elements which represent the lambda (and the environment of it, if necessary). All of these elements are added to assembly's meta-data (so that they do consume memory if assembly is loaded...) For your example the compiler would add a new anonymous internal class which represents the closure of the lambda environment. The generated code would look something like this (assuming your class was named YourClass and the compiler decided to choose some unique names XX and xx):

class YourClass {

\[CompilerGenerated\]
private sealed class <>XX : public System.Object {
    public bool isVertical;
    
    public <>XX() {}

    int <PrintElements>\_xx(int arg) {
        return IsVetical ? Grid.GetRow(arg) : Grid.GetRow(arg);
    }
}

void PrintElements(Grid grid, bool isVertical)
{
    // compiler generated ->
    class <>XX xx1 = new <>XX();
    xx1.IsVertical = isVertical; 
    System.Function<bool, int> xx2 = null;
    // <- compiler generated

    foreach (FrameworkElement element in grid.Children) {
        // compiler generated ->
        if (xx2 != null) {
            xx2 = new System.Function<bool, int>(xx1.<PrintElements>\_xx);
        }
        Console.WriteLine(xx2);
        //<-compiler generated
    }
}

}

The compiler possesses a lot of intelligence on deciding what code is going to be generated, in your example a local isValid identifier is required so it would generate the local closure class. If no closures are required, it just adds methods (or static methods) to the containing class depending on whether you are using class instance members or not. Interesting, isn't it? Cheers, Paul

[Paul Michalik]

Well, this is not allowed in C#, you cannot define classes (or structs) at method scope. However, it'd interesting to know, how the compiler translates the c++0x lambdas. The appropriate definitions in the current standard draft occupy 5 1/2 pages and, as usual, are not clear after first reading... The example from the orginal post would look like this (assuming some hypotetical framework grid_t which defines static methods get_row and get_col and delivers a sequence of children):

void PrintElements(const grid_t& grid, bool isVertical) {
std::transform(grid.children().cbegin(), grid.children().cend(),
std::output_iterator<int>(std::cout), [isVertical](int arg) -> int {
isVertical ? grid_t::get_row(arg) : grid_t::get_col(arg);
});
}

Cheers, Paul Edit: As far as I understand what the standard says, the result might look like below (it'd be interesting to see how the code really translates with more complex closures taking environment variables by reference etc...):

void PrintElements(const grid_t& grid, bool isVertical) {
struct XX {
bool xx_IsVertical;
int operator(int arg) {
xx_IsVertical ? grid_t::get_row(arg) : grid_t::get_col(arg);
}

    XX(bool \_xx) : xx\_IsVertical(\_xx) {};
};
std::transform(grid.children().cbegin(), grid.children().cend(),
    std::output\_iterator<int>(std::cout), XX(isVertical));

}

modified on Sunday, November 28, 2010 7:25 AM

[RobCroll]

Anonymous methods do have there place but I question there use in most cases. To me they breach basic OOP rules and make code less readable and therefore less maintainable.

[mbue]

void SortUI(unsigned int* array,const unsigned int count) { typedef struct{ static int cmp(const void *a, const void *b){ return *(int*)a-*(int*)b; } }_; qsort(array,count,sizeof(unsigned int),_::cmp); } void SortSTR(TCHAR** array,const unsigned int count) { typedef struct{ static int cmp(const void *a, const void *b){ return _tcscmp(*(TCHAR**)a,*(TCHAR**)b); } }_; qsort(array,count,sizeof(TCHAR*),_::cmp); } void SortDF(double* array,const unsigned int count) { typedef struct{ static int cmp(const void *a, const void *b){ return *(double*)a<*(double*)b?-1:(*(double*)a>*(double*)b?+1:0); } }_; qsort(array,count,sizeof(double),_::cmp); }

[Paul Michalik]

Well, exactly this is the reason, why C# was invented... :)