@ Head : VB10

ElementAtOrDefault

bill — Tue, 15 Dec 2009 01:40:17 GMT

VB 9 or later has a particular feature that can make life easier in some circumstances: the compiler allows you to access indexed items on non indexed enumerables. Let’s say you have code such as:

Dim items as IEnumerable(Of String)
. . . .
For i = 0 to items.Count - 1
Debug.Print items(i)
Next

VB will compile that for you. The Count is an extension method that loops through the list to determine the count; luckily VB calls that only once. The real killer though is items(i) is actually compiled as items.ElementAtOrDefault(i).

The ElementAtOrDefault extension tries to cast the IEnumerable(Of T) to an IList(Of T); if the IEnumerable isn’t actually an IList, it loops through the collection, returning at the given index. As you can imagine this would get extremely slow for large lists especially inside a loop.

The Good:
If your IEnumerable is in fact an IList, such as a List(Of T), then the compiler magically adding this extension call makes life a little easier as you don’t have to cast to IList yourself.

The BAD:
You have to be really careful when doing any code maintenance, especially if you change an IEnumerable source to a different collection base that doesn’t implement IList(Of T). You can end up writing really bad, slow code really easily.

I got bitten by the bad, but I caught it immediately as I was curious about the collection base I was using. In my particular case I had swapped an List(Of T) out with a ConcurrentBag(Of T). ConcurrentBag(Of T) basically uses linked lists where each item is stored as a node. Each node has a previous and next node; the list has a head and a tail. I thought it strange that ConcurrentBag would have an indexer given that would force walking through the nodes. I went to change the items(i) to items.Item(i) and BINGO it wouldn’t compile.

Possible best practices to avoid being bitten by this:

(1) Use For Each loops, not indexers. Your code will be far more flexible/manageable

(2) If you only want the first item, make it explicit by using First or FirstOrDefault extensions.

(3) Try to do the explicit cast to IList(Of T) yourself and work with an IList(Of T) instead of an IEnumerable(Of T)

(4) Consider explicitly using the Item property , eg: items.Item(0) instead of items(0)

I’m not really comfortable with having to use the Item property: hopefully practices 1 to 3 will alleviate the need for practice 4.

IntPtr gets operators !!!

bill — Thu, 05 Nov 2009 01:48:27 GMT

This seems so incredibly long overdue, but at last as of .NET 4, IntPtr has + and – operators added to it !!

This means you can now easily write code such as :

Dim ptr As IntPtr

. . . .
ptr += 4

this is great when dealing with offsets etc.

The actual implementation is kind of interesting. Here I’m seeing the implementation as :

Public Shared Operator -(ByVal pointer As IntPtr, ByVal offset As Integer) As IntPtr
Return New IntPtr((pointer.ToInt32 - offset))
End Function

I guess this is because it is the 32 bit version of the library. Hopefully in the 64 bit version it calls on IntPtr.ToInt64 ;)

Iterators: a flag for simplification ?

bill — Tue, 21 Apr 2009 02:02:16 GMT

A couple of months ago I blogged about iterators in VB (or the lack there-of), and pointed folks to an article I wrote for Visual Studio magazine that provides snippets and templates to help with iterators in VB.

One of the things I talk about in that article is often the use of iterators in C# code that I have seen is superfulous, especially given the LINQ libraries. Yesterday I read another example of this where the developer(s) had written a custom iterator instead of using a LINQ query. Their code required the defining of a generic class:

public class EnumerableGeneric<TClass, TInterface> 
              : IEnumerable<TInterface> where TClass : TInterface
{
   private IList<TClass> list;

   public EnumerableGeneric(IList<TClass> list)
   {
      this.list = list;
   }

   public IEnumerator<TInterface> GetEnumerator()
   {
      foreach (TClass item in list)
      {
         yield return item;
      }
   }

   IEnumerator IEnumerable.GetEnumerator()
   {
      return this.GetEnumerator();
   }
}

And the example of using this required the calling code to instantiate an instance of this class:

MyMethod(new EnumerableGeneric<ClassA, IClassInterface>(caInstance));

A simpler alternative is to actually use LINQ, eg:

MyMethod(caInstance.Cast<IClassInterface>());

In VB talk I think it’s even more natural flowing:

MyMethod(caInstance.Cast(Of IClassInterface))

It is in places like that I like the (Of T) syntax of VB a lot better, but some folks prefer a Cup<T> to a Cup(Of T) . The key point here is the use of “yield return” in C# is a good indicator that the code can often be replaced with far simpler LINQ constructs that reduce your LOC’s, and hence reduce your debugging and maintenance loads. There will of course be times where there isn’t a simple LINQ replacement, but if you do ever come across custom iterators, do take pause to think about using LINQ.

Microsoft: make VB like C#

bill — Thu, 19 Mar 2009 11:48:24 GMT

I was reading yet another VB versus C# rant: I don’t want to get sucked into wading into that, but I will say that anyone who thinks folks that use VB can’t use C# has really got things back the front. Most people who use VB can read and write C# quite well; they choose VB knowing both. Whereas so many C# developers I’ve met have absolutely no idea about VB or concepts such as declarative event handling etc, etc. For them they don’t have the basis of choice.

The reason VB folk have to read and write in C# is because a lot of SDK’s etc are all in C# originally. Even things like the enterprise library provide source code only in C#; this even after Soma promised to do better in regard to that. So for VB folks there is a real need to learn C#.

The big problem though is if you want to use C# source code in your VB project: you often have to re-write it or separate into different assemblies. That’s not productive. What I want is for VB to like C# and vice versa. I don’t mean make them the same, I mean for them to like each other; to get along well inside the same project. I’d like to be able to add a C# class to my VB project and happily compile it. And I bet some C# folk would love to have some concurrent basic or XML literals in their C# projects without all the current barriers.

Maybe the talk of compilers as a service type thing will give us that true cross language project, where VB and C# like each other so much that they then are free to diverge again :)

String.IsNullOrEmpty : update on that nasty null reference exception

bill — Tue, 10 Mar 2009 12:08:26 GMT

Back in April 2006, I blogged about a nasty JIT compiler optimisation that would cause String.IsNullOrEmpty to throw a null reference exception; ironic really given that is the very thing you’d use the IsNullOrEmpty method to check against. Well since then, due to popular demand on the connect site, this bug has been fixed in .NET 2.0 SP1 (which implies .NET 3.0 and 3.5)

940900 (http://support.microsoft.com/kb/940900/ ) FIX: You receive the NullReferenceException exception when you call the String.IsNullOrEmpty function in an application that is built on the .NET Framework 2.0

Snippet Editor 2.1 screen-cast

bill — Thu, 05 Feb 2009 09:08:31 GMT

I’ve just uploaded a new screen cast:

Snippet Editor Tips and Tricks

Enjoy :)

(oh and don’t forget the “buy me a beer” button)

New release of Snippet Editor

bill — Tue, 03 Feb 2009 17:31:38 GMT

Snippet Editor 2.1 is now released on codeplex:
http://www.codeplex.com/SnippetEditor

Apart from the few minor bug fixes, it includes improved search and now support for Visual Studio 2010 as well as 2008 and 2005.

I’ve also added a “buy me a beer” button to this blog, and on the codeplex site, so if you like the Snippet Editor you can help put a smile on my face :)

The snippet editor remains free: no advertisements, no nag screens.

yep, free as in beer ;)

Enjoy :)

Iterators in VB 10 ?

bill — Mon, 02 Feb 2009 13:56:01 GMT

Although VB 10 won’t have a formal syntax for iterators, it will have all the necessary ingredients to easily write iterators. In VB10 you can use a generic template and multi line lambdas to create iterators.

This iterator in C# :

static public IEnumerable<String> Lines( this TextReader rdr)
{
     String line;
     while ((line = rdr.ReadLine()) != null) {
              yield return line;
     }
}

Can be written as this in VB10:

<Extension()> 
Public Function Lines(ByVal rdr as TextReader) As IEnumerable(Of String)

     Return New GenericIterator(Of String) 
          (Function(ByRef nextItem As String) As Boolean
              nextItem = rdr.ReadLine
              Return nextItem IsNot Nothing
           End Function)

End Function

The above code uses a generic iterator class that accepts a lambda function. The lambda function sets the Current item of the iterator and returns True if MoveNext should be True. The above example is written as an extension method, but you can also use the inner part of the function inline.

For more on using iterators in VB 9 today, as well as the generic class for the above example, see my latest article in Visual Studio Magazine .

VB.Net and splash screens

bill — Tue, 20 Jan 2009 00:27:39 GMT

One of the nice things about the My application framework in VB.NET is the ability to easily show splash screens. The splash screen is displayed using a separate thread and by default will close when your main form’s Load event is called. There is however a quirk with it sometimes.

Whilst testing, if I launched the application from Explorer, the splash screen would appear in front of the explorer window but the main form behind it. When the splash screen closed, the main form didn’t come to the foreground. This behaviour would depend on the system being tested and seems to only consistently show up when run from a VPC. The fix for this is reasonably simple: you just need to call Activate in your main form’s Load event

   Private Sub Me_Load(ByVal sender As Object, ByVal e As EventArgs) Handles MyBase.Load
      Me.Activate()
   End Sub

Kudos to the VB team for the fix :)

When the VB team suggested this fix to me, I could have sworn I had already tried that. I had also looked into the my application framework code and saw it called Activate in it’s handler of the Load. So my first thoughts on it was it was a race condition, and hence I set up a single shot timer to call Activate, the timer being set to trigger a couple of hundred milliseconds after the load event. At first I thought that fixed it, but that was the “sometimes” effect tricking me <g>

Kevin from the VB team suggested I try Activate in the Load event, and sure enough it seems to work *ALL* the time. But this was even more puzzling as to why didn’t my timer approach work. So I tried overriding the OnLoad method :

   Protected Overrides Sub OnLoad(ByVal e As EventArgs)
      MyBase.OnLoad(e)
      Me.Activate()
   End Sub

That actually fails ( yes “sometimes”). But if you change that to:

 
  Protected Overrides Sub OnLoad(ByVal e As EventArgs)
      Me.Activate()
      MyBase.OnLoad(e)
   End Sub

Then it works. So the key is that Activate has to be called before the call to OnLoad completes. Suddenly the pieces of the puzzle all fit together.

What I think is happening is this: The my application framework hooks into the Load event and uses that to dispose of the splash screen. The problem occurs when the splash screen which has the UI input is closed before the call to Activate is made. Because the calling thread doesn’t have the UI Input, SetForeGround window doesn’t work. Based on this hypothesis, I suggested a fix to the WindowsFormsApplicationBase. Currently is has this method in it:

        '''************************************************************************** 
        ''' ;HideSplashScreen
        ''' <summary> 
        ''' Hide the splash screeen.  The splash screen was created on another thread so marshal 
        ''' the call over to it.
        ''' </summary> 
        ''' <remarks></remarks>
        <EditorBrowsable(EditorBrowsableState.Advanced)> Protected Sub HideSplashScreen()
            SyncLock m_SplashLock 'We can get called from two threads at once
               If m_SplashScreen IsNot Nothing AndAlso Not m_SplashScreen.IsDisposed Then 
                    Dim TheBigGoodbye As New DisposeDelegate(AddressOf m_SplashScreen.Dispose)
                    m_SplashScreen.Invoke(TheBigGoodbye) 
                    m_SplashScreen = Nothing 
               End If
               If Me.MainForm IsNot Nothing Then 
                    Call New System.Security.Permissions.UIPermission(UIPermissionWindow.AllWindows).Assert()
                    Me.MainForm.Activate()
                    System.Security.PermissionSet.RevertAssert() 'CLR also reverts if we throw or when we return from this function
               End If 
            End SyncLock
        End Sub 

My suggestion is to activate the main form before disposing of the splash screen :

          <EditorBrowsable(EditorBrowsableState.Advanced)> ProtectedSub HideSplashScreen()    
SyncLock m_SplashLock 'We can get called from two threads at once
IfMe.MainForm IsNotNothingThen     
CallNew System.Security.Permissions.UIPermission(UIPermissionWindow.AllWindows).Assert()                        Me.MainForm.Activate()
                    System.Security.PermissionSet.RevertAssert() 'CLR also reverts if we throw or when we return from this function
               End If
               If m_SplashScreen IsNot Nothing AndAlso Not m_SplashScreen.IsDisposed Then 
                    Dim TheBigGoodbye As New DisposeDelegate(AddressOf m_SplashScreen.Dispose)
                    m_SplashScreen.Invoke(TheBigGoodbye) 
                    m_SplashScreen = Nothing 
               End If
            End SyncLock
        End Sub 

Hopefully that will fix this issue completely.

In the meanwhile, simply call Activate in your main form’s Load event :)

Extension methods and Interfaces.

bill — Thu, 15 Jan 2009 04:58:59 GMT

A comment by Joe Duffy on the Framework Guidelines for Extension says :

Extension methods can also be used to provide actual concrete method implementations for interfaces.

And this is a very important point. In .NET there is no support for multiple implementation inheritance. So although you could use an abstract class (MustInherit) with some implementation in it, you would be tied to that single chain in your class inheritance. Interfaces on the other hand are extremely flexible, supporting multiple inheritance both in interfaces and implementing classes. So by providing extension methods for interfaces, you get great flexibility and code re-use, and you also get to extend existing interfaces.. the classic example being the Enumerable set of extensions which extend IEnumerable(Of T)

So what is a “Library” ?

bill — Sun, 11 Jan 2009 14:13:41 GMT

Earlier I posted what I hope wetted your appetite for some more info about Libraries in Windows 7. So what are libraries you ask//I ask ;) Well I hope the following provides some insight.

caveat emptor: this is still just my first impressions !

A Library is really a view of different “folders”. Each library is a file, which internally is an xml file. The default library files are stored in the user’s roaming profile, eg:

C:\Users\Bill\AppData\Roaming\Microsoft\Windows\Libraries

This is an example of

<?xml version="1.0" encoding="UTF-8"?>
<libraryDescription>
   <ownerSID>S-1-5-21-168223323-3520011370-4180941423-1000</ownerSID>
   <version>3</version>
   <isLibraryPinned>-1</isLibraryPinned>
   <templateInfo>
      <folderType>{5C4F28B5-F869-4E84-8E60-F11DB97C5CC7}</folderType>
   </templateInfo>
   <propertyStore>
      <property name="HasModifiedLocations" type="boolean"><![CDATA[-1]]></property>
   </propertyStore>
   <searchConnectorDescriptionList>
      <searchConnectorDescription>
         <isDefaultSaveLocation>-1</isDefaultSaveLocation>
         <simpleLocation>
            <url>C:\Users\Bill\Documents\Visual Studio 2008\Projects</url>
         <serialized>…</serialized>
         </simpleLocation>
      </searchConnectorDescription>
   </searchConnectorDescriptionList>
</libraryDescription>

I omitted the contents of the serialized element for brevity.

You can programmatically access libraries via the IShellLibrary interface and some shell helper functions.

You can add multiple “folders” to these library files. I say “folders” in quotes, because according to the IShellLibrary::AddFolder documentation, the object in psiLocation can be a folder or a Search Connector (*.searchconnector-ms) file.

What’s this mean. Well I don’t know for sure yet, but it looks to me like Libraries can be a way to aggregate search providers. At the simplest level they provide a view of directories, but they have the potential to provide a view over data from various sources, not just file based. This of course leads us towards the topic of “Federated Search” (more on that in next episode <g>).

So is it WinFS ? Not really. It is not reliant on managed frameworks like the entity framework… it is instead heavily reliant on XML. From the Library file, saved searches, right through to Federated Search which itself is based around RSS style of XML.

Thankfully VB9 rocks when it comes to working with XML !

XSD’s in Visual Studio: Past, Present and Future.

bill — Tue, 30 Dec 2008 02:51:36 GMT

When I was going through the snippet editor code to put it on CodePlex, I wanted to grab a screen shot of the snippet schema. immediately I was confronted with there being no visual designer for schemas in VS 2008, but the worse part was I could have sworn there use to be. To clear up that confusion here’s an illustrated history lesson on schema views in Visual Studio.

In earlier versions of Visual Studio the schema designer was a bit like the early dataset designer.

This is Visual Studio 2005 :

It was detailed as far as types and constraints goes but omitted documentation. With complex schemas it was a mess, but you could hide parts.

Then in Visual Studio 2008 they decided to get rid of the schema designer completely !! I’m really not sure the logic on that. There was however a CTP for the new Schema Explorer, and come Visual Studio 2008 Service Pack 1, the schema explorer was included. (I hope I’ve got that bit of history right)

The Schema explorer gives a nice overview, and provides for navigation but totally lacks real details (not synchronized with the properties window). Sadly for Visual Studio 2008 that’s as best as it gets, the rest is wading through the actual xsd file as xml.

The first CTP of Visual Studio 10, reveals a new designer that can be used in conjunction with the Schema Explorer.

This pretty visual representation is all done in WPF so you can zoom in and out nicely. As well as the ability to easily expand and shrink elements, it’s really nice way to get an overview. You can even turn on documentation so as you can see any comments from the schema:

Although this is very pretty, and a great visual aid, it still doesn’t provide any means to create a schema or edit one… it’s simply a view. Some things I’d like to see improved are :

Provide designer editing and creation of schemas
have an export to .png feature
Ability to fully expand comments for all items. At present only the first two lines are shown and you have to double click on each element to get the comments to fully expand
did I mention editing ?
tear-offs would be nice, such that I could then use the width of the screen (eg: Drag the “Header” element from the above picture to the right, and then it expands over there rather than in situ.)
show restrictions. For example, the SnippetType is restricted to three possible legal values, “Expansion”, “SurroundsWith” and “Refactoring”. To find that out I have to delve into the xsd.
Synchronise with Properties window allowing for more detail to be shown and edited in the Properties window
Provide Copy as Path. The bottom of the screen shows the path of the selected node, but it would be great if you could select to copy that to the clipboard as an XPath. Even cooler if you could choose between XPath, VB XML Axis/Literal sytnax, or XElement syntax (for those poor ol’ C# folks ;) )

The Visual Studio 10 stuff looks promising, but still has a long way to go. (did I mention the lack of editing ?) In the interim it would be nice if there was something, anything ! I’m really not sure why the 2005 xsd designer was dropped. Sure some of it was ugly, especially the way it shows things like the string restrictions, but it was and is less ugly than the XML for that part of the xsd !!

Visually we have progressed... but what about the editing ??

Snippet Editor is now on CodePlex

bill — Sun, 28 Dec 2008 09:13:22 GMT

I’ve just finished uploading the Snippet Editor to CodePlex

http://www.codeplex.com/SnippetEditor

It includes some minor bug fixes from the previous release.

Enjoy :)

And Merry XMas :)

List transactions

bill — Thu, 18 Dec 2008 14:55:53 GMT

From a recent discussion on using lists, and whether or not you can remove items in while iterating, I decided to write an extension that allows you to get a “transaction” for an IList(Of t). This ListTransaction(Of T) caches adds and removes until you call commit (kudos to Duncan for the idea !!). It also implements IDisposable so you can use a using scope, eg:

      Using listTran = mylist.GetTransaction
         For Each item In mylist
            ' other code here
            listTran.Remove(item)
         Next
      End Using

And here’s the implementation:

Module ListExtensions
 
   <Runtime.CompilerServices.Extension()> _
   Function GetTransaction(Of T)(ByVal list As IList(Of T)) As ListTransaction(Of T)
      Return New ListTransaction(Of T)(list)
   End Function
 
 
   Public Class ListTransaction(Of T)
      Implements IDisposable
 
      Private _list As IList(Of T)
      Private _adds As List(Of T)
      Private _removes As List(Of T)
 
      Public Sub New(ByVal list As IList(Of T))
         _list = list
      End Sub
 
      Public Sub Add(ByVal item As T)
         If _adds Is Nothing Then _adds = New List(Of T)
         _adds.Add(item)
      End Sub
 
      Public Sub Remove(ByVal item As T)
         If _removes Is Nothing Then _removes = New List(Of T)
         _removes.Add(item)
      End Sub
 
      Public Sub Commit()
         If _list Is Nothing Then Exit Sub
         If _adds IsNot Nothing Then
            For Each item As T In _adds
               _list.Add(item)
            Next
            _adds = Nothing
         End If
         If _removes IsNot Nothing Then
            For Each item As T In _removes
               _list.Remove(item)
            Next
            _removes = Nothing
         End If
      End Sub
 
      Public Sub Rollback()
         _adds = Nothing
         _removes = Nothing
      End Sub
 
 
      Public Sub Dispose() Implements IDisposable.Dispose
         Commit()
         GC.SuppressFinalize(Me)
      End Sub
 
   End Class
 
End Module

VB Snippet Editor

bill — Mon, 08 Dec 2008 11:42:02 GMT

Over the last week I’ve got a sudden influx of emails about the Snippet Editor. I’m figuring this is stemming from Lisa’s recent blog entry and her tips and trips for VS 2008 presentation :)

Some of the emails have been really nice praise, folks wanting to add some features, a bug on XP 64 (which unfortunately is about the only OS I don’t have in my testing suite), and some general questions around snippets. So I gave this lots of thought and decided to put up a site on CodePlex. This will allow people to add features, work together on bugs, and share discussions around snippets including future directions for the snippet editor.

The new codeplex site will be at http://www.codeplex.com/SnippetEditor

It’s not ready yet, and will probably be a week while I get all the bits together and ensure there’s no rude words in the code comments etc ;) I was hesitant about moving to CodePlex as I was really disappointed how gotdotnet was just closed down and not migrated. And I should add here a word of caution for those in charge should CodePlex go a similar route.. I will travel the continents and track you down and when I find you stare at you for a really long time until you feel uncomfortable !! ;) (Seriously, please don’t close codeplex)

So, all going well, the Snippet Editor will be on CodePlex this time next week. I’ll make sure to post when it’s ready and redirect my current site there. Any suggestions on the open source license eula etc most welcome.

What does VB 10 have ?

bill — Wed, 12 Nov 2008 01:18:10 GMT

To answer what is in VB 10, have a look at the document on the vb futures site. Basically the list is removal for the need of the line continuation character in many places, collection and array initializers, multi statement lambdas, and generic variance.

I decided to look back at my brief wish lists for VB10

VB 10 thoughts Part 1
VB 10 thoughts Part 2
VB 10 thoughts Part 3
VB 10 thoughts Part 4
VB 10 thoughts Part 5
VB 10 thoughts Part 6
VB 10 thoughts Part 7
VB 10 thoughts Part 8
VB 10 thoughts Part 9

Seems I did very poorly. The only match I got was number 6 multi statement lambdas. I should have had generic variance in the list considering that’s something I wanted since I first saw .NET generics although that really is a framework thing not a language thing. The continuation character, collection and array initializers all seem nice, but functionally trivial to void. Ironically, C#. which has many of those things on my list also picked up a couple it didn’t such as dynamic and they implemented optional parameters as they should be. I must admit that hurts, especially as the optional parameters issues was my #1 item.

For some reason in this new era of supposed language parity, I feel short changed :(

Making tuples more friendly

bill — Mon, 08 Sep 2008 13:30:19 GMT

Via Don Box’s blog, I found the preliminary code for a tuple at CodePlex. The tuple is a simple structure containing in this case two values: a double tuple. It basically looks like this :

Structure Tuple(Of TFirst, TSecond)

Public Property First() As TFirst

Public Property Second() As TSecond

End Structure

I’ve omitted the details, such as the constructor or equality overloads and operators etc.

So Tuple’s can be handy general purpose storage to pass around a couple of values. Let’s say I write a Parse method such as :

   Function Parse(ByVal value As String) As Tuple(Of Int32, Boolean)
      Dim iVal As Int32
      Dim success = Int32.TryParse(value, iVal)
      Return New Tuple(Of Int32, Boolean)(iVal, success)
   End Function

That makes it a little easier for calling code to parse a string to an int32, but the problem they then face is the values are First and Second. For example:

      Dim tuple = Parse("1")
      Dim i? = If(tuple.Second, tuple.First, Nothing)

Wouldn’t it be nicer if that could be written as :

      Dim tuple = Parse("1")
      Dim i? = If(tuple.Success, tuple.Value, Nothing)

Sure you could write your own structure for this, but then we are back to type bloat. That level of detail, Success and Value are only needed at design time, so they could be compiler magic based on XML comments. Perhaps something like this on my Parse method would make the tuple parameters appear as Success and Value instead of First and Second :

   ''' <summary>

   ''' A Parse wrapper for string to integer

   ''' </summary>

   ''' <param name="value">a string representation of an integer value</param>

   ''' <returns>

   ''' <tuple>

   '''   <First name="Value">the integer value or 0 if the parse fails</First>

   '''   <Second name="Success">true if the parse succeeds, otherwise false</Second>

   ''' </tuple>

   ''' </returns>

   Function Parse(ByVal value As String) As Tuple(Of Int32, Boolean)

      Dim iVal As Int32

      Dim success = Int32.TryParse(value, iVal)

      Return New Tuple(Of Int32, Boolean)(iVal, success)

   End Function

The down side of this is it would only work with the immediate assignment, and one could argue only when it is used with type inference (as I did above). I doubt the cost justifies the benefit, but imagine the fun you could have if it was a cooking tuple: you could have a double Tuple with Boil and Bubble

(I can’t believe I left that last line in here ;) )

Unsubscribing events: How VB Handles it

bill — Thu, 21 Aug 2008 11:40:39 GMT

Davy Brion posted about how events can keep object references alive. In C# to rid yourself of this issue you have to manually unwire any event handler you wired. In VB, it is a lot easier, all you have to do is use WithEvents and set the variable to nothing. This code is the VB version of Davy’s sample:

 
Public Class Publisher
   Public Event MyEvent As EventHandler
 
   Public Sub FireEvent()
      RaiseEvent MyEvent(Me, EventArgs.Empty)
   End Sub
 
End Class
 
Public Class GoodSubscriber
   Implements IDisposable
 
   Private WithEvents _publisher As Publisher
 
   Public Sub New(ByVal publisher As Publisher)
      _publisher = publisher
   End Sub
 
   Private Sub _publisher_MyEvent(ByVal sender As Object, ByVal e As System.EventArgs) Handles _publisher.MyEvent
      Console.WriteLine("the publisher notified the good subscriber of an event")
   End Sub
 
   Public Sub Dispose() Implements IDisposable.Dispose
      _publisher = Nothing
   End Sub
 
End Class

As long as the variable is declared as WithEvents any event wired up via declarative event handling will be unwired when the variable is set to Nothing.

This is yet another subtle but important example of how declarative coding styles can lead to more robust code. The above example is minimal, but when you get many events and many objects raising events, the cleanness of the VB way of handling it becomes even more important. Or in other words in C# you have to make sure you unwire each and every event, in VB you use declarative events syntax and VB handles it for you ;)

WPF Toolkit on CodePlex

bill — Mon, 18 Aug 2008 15:44:15 GMT

In case you haven’t seen it, Microsoft is releasing tools for WPF out of cycle as part of the WPF toolkit. Current release includes a CTP of a Data Grid, and a Date Picker and Calendar is planned.

Generic Variance Part1 : Do you really need it ?

bill — Mon, 11 Aug 2008 03:21:25 GMT

Lucian has kicked off the conversation on generic variance in VB , so I thought I’d write a few posts outlining my perspectives on the subject… the first of which is this one, and what better place to start than to question whether or not it is really needed……

Generics came to .NET after the base framework and languages were implemented. It was very much a bolt-on approach. As such there was and still is an impedance mismatch between conventional concepts of polymorphism and generics. As I posted previously, I had raised this is issue with Anders and other language experts back at the 2003 PDC (at which time Anders suggested using a language other than VB or C# <g>). Fast forward to today, and this issue is now being looked at, but now I find myself questioning if it is really needed, or is the fault the mismatch of the original framework.

Let’s take Lucian’s example :

Dim args As New List(Of ConstantExpression)
args.Add(Expression.Constant(2))
args.Add(Expression.Constant(3))
Dim y = Expression.Call(instance, method, args)

This code fails because the Call method is defined as :

   Public Shared Function [Call](ByVal instance As Expression, _

                                 ByVal method As MethodInfo, _

                                 ByVal arguments As IEnumerable(Of Expression)) _

                                 As MethodCallExpression

But if it was defined as follows then the code would work:

   Public Shared Function [Call](Of T As Expression) _

                                (ByVal instance As Expression, _

                                 ByVal method As MethodInfo, _

                                 ByVal arguments As IEnumerable(Of T)) _

                                 As MethodCallExpression

So where exactly is the problem ? The simple rule is if you want polymorphism (read as “generic variance”) in your code, then you need to expose the types as generic parameters not as concrete types.

That is, the above is solved by better API design and some simple refactoring. This in fact solves 90% or more of all the cases I have seen. The one place where you can’t do this is when the type is late bound and defined only as Object (more on this in a future post no doubt ;))