C#

Anonymous Delegates (Methods) and Visual Basic (VB)

H. Steele Price, IV — Thu, 28 Sep 2006 16:08:00 GMT

What is an Anonymous Delegate?

I have recently been converting these and talking about them quite alot.

This is a technique not currently implemented in VB, but is used in C# (and other languages) to write some inline code in which I do not want to create classes and handlers to perform some simple operation. Typically this is used in Generics when iterating over a collection, or to execute some specific functionality when an event occurs.

These are similar to "Closures" in other languages see:

http://en.wikipedia.org/wiki/Closure_(computer_science)
http://www.martinfowler.com/bliki/Closure.html

OK, so if these are NOT supported in VB, then why as a VB Developer should I care? Specifically, as more and more C# examples using these are posted, there will be an occassion where you really want to use the posted technique and don't quite get how to transalate it into VB.

There are several way's to work with itteration, so in this sample, I will focus on using delegates for Asynchronous Callbacks such as adding an event listener that performs a set of operations when an event fires. This is a little more difficult to grasp than simple iteration and it also happens to be extremely useful in the event based programming model.

What does one look like?

It can be as simple as adding a handler to an event, in C#:

button1.Click += delegate {MessageBox.Show("Hello");};

So that is the simplified code, lets break it down first in VB terms:

button1.click is an event (obviously...)
+= will add what is inside the delegate{}; block as a new handler, if one (or more) already exists, it will perform this one in the order in which added. In C# the handler is created automatically by the compiler (thus the anonymous part, since we didn't have to give the function a name...) so it is not done manually as we will need to in VB.

A Click event is oviously radically simplified for realizing the power and usefullness of this coding model. What is cool about an Anonymous Delegate is that you can pass local variables to a set of code that you could not otherwise do in VB. Consider a more real-world example, since I have also been working with System.Transactions:

transaction.TransactionCompleted += delegate
                                    {
                                       lock(this)
                                       {
                                          m_PendingTransactions.Remove(pair);
                                       }
                                       lock(manualEvent)
                                       {
                                          if(manualEvent.SafeWaitHandle.IsClosed == false)
                                          {
                                             manualEvent.Set();
                                          }
                                       }
                                    };

This code is admitedlly daunting because it uses 3 uncommon things in VB. First, we are assigning code to a multicast event, secondly we have the use of an Anonymus Delegate, then thirdly we have some Thread Safty being applied.

So what do I do in VB when I see some sample code in C# that contains things like this? One option you could apply is to fire up .Net Reflector and have a look at what is going on. so, lets do that:

If (handler1 Is Nothing) Then
    handler1 = New TransactionCompletedEventHandler(AddressOf class1.<Lock>b__0)
End If
AddHandler transaction.TransactionCompleted, handler1

This tends to still be quite cryptic since it uses the compiler created names to describe the functions. It also doesn't help when you are looking at a block of code and don't want to copy/create project/compile it.

In reviewing this code... what is handler1?, what is class1? and what the heck is this class1.<Lock>b__0)

Now it starts to get a bit hairy, especially if you don't know C# very well or what the compiler is doing behind the scenes.

Let me explain what happened here when we look at the Code. Since we do not have Anonymous Delegates in VB, we have to make class1 to hold the State information and the Method (Sub) we want to run, the compiler in C# decided that should be class1 and class1.<Lock>b__0) Next we need to pass in all the state information that the Anonymous Delegate was allowed to just use, now are you starting to see why these things are cool?

We have to look a little bit higher in the Code to see where that all happens:

Dim handler1 As TransactionCompletedEventHandler = Nothing
Dim class1 As New <>c__DisplayClass2
class1.<>4__this = Me
class1.manualEvent = New ManualResetEvent(False)
class1.pair = New KeyValuePair(Of Transaction, ManualResetEvent)(transaction, class1.manualEvent)

There is still a bunch of cryptic stuff in here...

handler1
<>c__DisplayClass2
class1.<>4__this

These also got created by the compiler and just generated the names, so they aren't especially helpful.

So, when you see this: There are 5 things you need to do to implement this code in VB:

Make a Private NotInheritable Class with an empty constructor
Create Fields to hold each variable
Create a Sub that matches the Signature you need to Delegate
Perfom the desired functionality inside this Sub, operating on the Class&squot;s Fields
Use AddHandler to point to the Class's Sub and run it at the appropriate time

Let have a look at what the Final cleaned up Code in VB looks like and then go through it.

Private NotInheritable Class TransactionState
    Public tLock As TransactionalLock
    Public manualEvent As ManualResetEvent
    Public pair As KeyValuePair(Of Transaction, ManualResetEvent)

    Public Sub New()
    End Sub

    Public Sub RemoveSelf(ByVal sender As Object, ByVal e As TransactionEventArgs)
        With Me
            SyncLock .tLock
                .tLock.m_PendingTransactions.Remove(DirectCast(.pair, KeyValuePair(Of Transaction, ManualResetEvent)))
            End SyncLock
            SyncLock .manualEvent
                If Not .manualEvent.SafeWaitHandle.IsClosed Then
                    .manualEvent.Set()
                End If
            End SyncLock
        End With
    End Sub
End Class

Private Overloads Sub Lock(ByVal transaction As Transaction)
    If (OwningTransaction = Nothing) Then
        ''' Other stuff
    Else 
        If (OwningTransaction = transaction) Then
            Return
        Else 'Need to lock when different
            Dim manualEvent As New ManualResetEvent(False)
            Dim pair As New KeyValuePair(Of Transaction, ManualResetEvent)
            Dim tHandler As TransactionCompletedEventHandler
            Dim TranState As New TransactionState

            With TranState
                .tLock = Me
                .manualEvent = New ManualResetEvent(False)
                .pair = New KeyValuePair(Of Transaction, ManualResetEvent)(transaction, .manualEvent)
            End With

            ''' Other stuff
            If (transaction IsNot Nothing) Then
                If (tHandler Is Nothing) Then
                    tHandler = New TransactionCompletedEventHandler(AddressOf TranState.RemoveSelf)
                End If
                AddHandler transaction.TransactionCompleted, tHandler
            End If
            ''' other stuff
        End If
    End If
End Sub

First for the renaming of what we saw in Reflector:

class1 = TranState
handler1 = tHandler
<>c__DisplayClass2 = TransactionState
.<>4__this = tLock
and
.<Lock>b__0= .RemoveSelf

Now let see what we had to do:

First we have to create a Named Class that does what the delegate does, this is Class TransactionState. Next inside that class, we need to create fields to hold all the state information for the state of the variables when we instantiate the Class.

Armed with the Class we can now instantiate the Class, Populate the Fields with our Variables then Add an new Handler that listens for the TransactionCompleted Event and runs the Sub in the Class when it fires.

As you can see just from the amount of code, having Anonymous Delegates in VB would make this drastically simpler to implement, however it IS indeed possible to convert this code to VB with a little work and the understanding of what is going on. I do these types of Classes already so it was not a huge surprise to see the functionality, but what really surprised me was how much easier it could be when we get Anonymous Delegates to shortcut the whole idea.

There are many of us fighting hard to have Anonymous Delegates in VB9, but it unfortunately may be too late and we might have to wait until VB10, that would be extremely dissapointing since we are going to get something called a Lambda Expression in VB9 that is fairly close (part of LINQ, a one line quick expression) but certainly not as powerful as a full inline function.

If C# has them, the compiler knows how to create them, so it should not be a huge task to actually include it, but I am not on the VB Design team so I really don't know what it would take inside the compiler and parsers to provide it to VB. Hopefully we will see them soon as a natural part of the evolving VB.NET Language and when we need to convert some C# code into something more useful for our VB Projects, we will not have to be so verbose.

C# Narrowly makes Top 10 while VB hails at #4

H. Steele Price, IV — Mon, 29 Nov 2004 10:52:00 GMT

The TIOBE Programming Community Index for November shows that VB is still more popular than C# by a Very Wide margin, though you wouldn't know that if you listen to Microsoft and most of the DotNet community.

It's not that I am against using C# at all, it's just that when it comes to real world popularity C# still has a long way to go to gain on the installed base of developers that actually use the language.

Despite Microsoft pushing the language on everyone as a “more efficient and capable“ language it, like any language has its shortcomings. What I think would really be nice is a way to make regular C just as easy to use in Rapid Application development as any of the other DotNet Languages. If that were the case, the popularity of C# would dwindle even further down the list.

It's quite impressive that any new language can even make the top ten in the first 5 years of its release, but without widespread support from the Open Source community, it's interesting to see just how far ahead VB really is to C#.

Remove the Open Source Languages and you have VB, Delphi then C# as the contenders for the top crown in Microsoft OS driven languages. I also find it interesting that they separated C from C++ when the bulk of the real applications are a combination of the two and together represent over 20% of the entire pool.

C/C++ is still the clear winner of all languages with Java and VB running a fairly close race for second.

If VB had the Open Source push that Java gets would there be any doubt who the real winner would be for ease of use and popularity in development?

C# Misinformation about VB, yet again.

H. Steele Price, IV — Mon, 12 Jul 2004 16:41:00 GMT

Update: somehow I missed these threads when I posted...

A well-deserved smack back to some C# zealotry
Why VB.Net Is Better Than C#
Language wars (sigh)

I really share Eric's sentiments here, but I however, will comment...

Sorry if whoever's doing this reads my blog, but personally I think a lot of the stuff on your list is really silly.

C-Sharpener For VB - Why Switch?

[Via HumanCompiler - Erik Porter (MS MVP) Blog]

On a point by point basis, why this list annoys the heck out of me, and makes the list itself outrageous to seasoned VB developers.

The "For the Developer list"

maybe, the average is perhaps biased, It's not like you will make more money just for developing in C#. Quality code is Quality code no matter what the language.
C# is no more elegant looking than VB, PERIOD.
C# is closer to java, so what? I don't program in java unless I am forced to and that is extremely rare. In fact I use DotNet to specifically avoid Java altogether.
VB is perceived as a "toy" language. ONLY BECAUSE OF MISREPRESENTATIONS LIKE THIS STUPID LIST!
Bah, show me ONE Microsoft person besides Anders that will publicly admit to this.
First point is addressed in Whidbey, 2nd addressed with nDoc, 3rd who cares, if you want unsafe code you probably wouldn't write it in C# anyway, you can't (at least shouldn't) write a hardware driver in C#.
um, all those are the next release of VB too, not just C#.

The "For the Manager Section"

your code won't magically improve by switching to C#. If this statement actually had any merit, we would all be programming in ADA.
VB is 3x more productive for me than C# and the main reason I don't switch primary development to it, besides that, I just don't like C style syntax, in C#, C++ OR Java, I don't care how many people love it, I don't.
this is PURE crap, if it's mixed, its mixed, you can switch all the C# to VB just as easily, if not MORE easily without codegen.
so what, we aren't using DotNet for portability, and Mono can compile VB anyway.
ECMA doesn't make syntax any more standards stable than anything else from Microsoft.
LIE, flat out LIE... anything they sell is written in C++.
both points are totally moot to MOST development efforts and point #1 is solved completely with nDoc.

Lists like this remind me of idiots promoting rumor and inuendo as facts that must be refuted by sites like this.

Proof C# code can be written just as poorly as VB code

H. Steele Price, IV — Tue, 06 Jul 2004 00:04:00 GMT

As John Sands points out so eloquently, some people just shouldn't write code, no matter what language they use. I wonder what the Whiz means in Whizlabs...

Comments show alot of C# Snobbery

H. Steele Price, IV — Mon, 05 Jul 2004 23:57:00 GMT

In this JOKE posting, Hannes lets C# developers demonstrate their complete snobbery through their inane comments.

This reminds me of the bitterness shown by the Delphi crowd towards VB Developers 10 years ago and the monotonous whining of the Java camps.

Bill Gates himself changed the Whidbey roadmap and brings back the focus on VB. The development language which is part of the Microsoft success. They stopped all their activity and rewrite everything in VB.NET. I give you the opportunity to share this very secret information. Read the whole story!

The actual point here is: Why the heck should anyone care WHAT language its written in as long as it is well written and provides the desired functionality. Language snobbery belongs to the French, it plays a very unimportant role in technology. Microsoft says you shouldn't write core OS processes in C# either so there... all important code should be written only in C/C++.

Curly Braces Begone!

H. Steele Price, IV — Tue, 15 Jun 2004 10:05:00 GMT

Hehehe,

This is an interesting way to dump curly braces if you absolutely can't stand them.

a lot of VB Coders just despise the whole idea. Code formatting isn't preventing me from making a transition to C#, what prevents me from making the transition is the peculiarities of Visual Studio with regard to C#, no background compiling, etc.

I just find myself more productive working in the sometimes nagging intellisense of VB, I tend to make fewer mistakes and get more accomplished in a shorter amount of time. Yes VB allows you to write really poor code, but so does any other language, I don't buy that as an excuse not to use VB. With Whidbey on the way (and my ability to start coding under Whidbey almost exclusively in a few months) I see even less of a reason to transition. Since 'Generics' and 'Using' were the only things I really wanted from C# that reason has evaporated because they are going to be in VB.

With Codesmith and other tools like it supporting VB why bother going to C#. If someone can give me a real reason, I'm all for listening, but its going to take alot more than an opinion to get me to change over.

AnkhSVN

H. Steele Price, IV — Tue, 03 Feb 2004 13:03:00 GMT

Have I mention AnkhSVN lately? If not there is a new version 0.4.1 available.

Also, added Arild's Blog to links.

New Blog System

H. Steele Price, IV — Tue, 28 Oct 2003 11:01:00 GMT

I have officially converted this blog from Drupal on Linux to DotText on Windows.

I had a small amount of trouble getting it to work right in a subdomain, but it's all functioning correctly now (I think).

I had to make some small edits to the code to accomodate my hosting service (it just needed a try/catch block for the configure page) because it didn't want to load correctly with an Empty Application name since null is not allowed I wasn't sure what to do here so the try/catch just ignores the error when it tries to load the appname for editing now.

Creating the skin was not too bad, it's just a bunch of css and some tricks I use with images, the mcp logo is actually in the tagline :-) I could have edited a control to float it around, but why bother when css works just fine. I also didn't bother renaming leftmenu even though it's on the right, because I didn't want to recode the controls. This is based on the Hover skin with colors and some other things changed. If anyone wants to see what I did, email me.

I tested the CSS in Firebird as well as IE but I don't know how graceful it will downgrade to others, I don't really care either, anything less than a version 6 browser and you can just go upgrade... or suffer.

I need to figure out how DotText can use a summary for display on the front page, I thought it would just use the Description/Excerpt field, but it doesn't. Now that I officially have it up and running I can mess with it whenever I have some free time.

Converting over the nodes from drupal took some tweaking, thank goodness I only had a couple dozen entries, anything with code had to be html cleaned because it was running the code, that not quite safe and probably needs a filter added in the code..