@ Head : VS2008

Saving and transferring customisations

bill — Wed, 25 Nov 2009 03:54:10 GMT

I got an email from a reader last week asking about saving customisations in Visual Studio:

Hi Bill

I read an excellent article by you

http://visualstudiomagazine.com/Articles/2007/12/01/Customize-the-VB-IDE.aspx?Page=1

Just wondering if you know of a way to export those customisations so I can set up my computer at work restore after HDD fails and share my favorite settings with friends.

Also would like to do same for my VBIDE customisations

I have googled to no avail...... :-/

Well the good news is this is incredibly easy. On the Tools menu in Visual Studio you should see the “Import and Export Savings . . .” command. You can choose what groups of settings to import or export.

Updates on the Snippet Editor

bill — Thu, 03 Sep 2009 01:03:56 GMT

First the good news :

The February release of the Snippet Editor has now had 10,000 downloads !

Now for bug fix news:

There were a couple of issues with the paths per language. A problem with Express Editions of Visual Studio occurred due to partial entries in the registry I didn’t for-see. Initial design and testing was done with full versions of Visual Studio, but I want to ensure that it does work with the express versions, that’s why the tool is standalone not an add-in. So the good news is I have fixed those bugs (I think).

If you want those fixes you can use the original source from Feb and just download the updated products.vb file. I’ll probably look at rolling this up into a new release in the not to distant future.

Enjoy :)

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

When ….

bill — Sat, 21 Feb 2009 01:56:52 GMT

VB has a lot of high level features other .Net languages, in particular C# don’t. Sadly these are often overlooked by some developers because other languages like C# don’t have them – the lowest common denominator syndrome. This is sad because many of these features are actually part of the .NET runtime. For example, VB has full interface mapping, C# has only a limited form of interface mapping they call explicit interface implementation which for them relies on a constrained naming pattern. Another example is custom events in VB, where VB provides the full encapsulation the CIL provides: being the Add, Remove and Raise for the event. (C# doesn’t support the Raise or Fire). The most obvious example would have to be Optional parameters. For years the C# brethren dismissed them as evil and in C# 4.0 now tout them as their amazing new feature they’ve added ;)

Another rarely spoken of feature that VB and the .NET runtime support are exception filters … the When clause.

Read why you should use When in the CLR team’s blog:

http://blogs.msdn.com/clrteam/archive/2009/02/05/catch-rethrow-and-filters-why-you-should-care.aspx

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 !

Xelement : more Value in that Value !!

bill — Mon, 05 Jan 2009 00:56:32 GMT

XML is very flexible and somewhat permissive in what it allows. Consider this piece of XML:

      el = <item>some values<first>one</first><second>two</second></item>

The element named item can contain both child elements and a text value. Thankfully this kind of XML is rare: it poses a heap of whitespace formatting issues, and the value itself can reside in any combination of places between the elements, eg:

      el = <item>some values<first>one</first> are <second>two</second>in here</item>

How this is interpreted is questionable. You could argue that position needs to be preserved, in which case you’d work with the Nodes property, including both the nodes of type XElement and also XText. Each of the inline values, “some values”, “ are ” and “in here” are actually XText nodes.

If you’re just after the Text, you need to write a helper function. If you try to use the Value property you get the Value of all nested nodes. Calling el.Value with the last example will output:

some valuesone are twoin here

The extension I slapped together is :

   <Extension()> _
   Public Function GetText(ByVal el As XElement) As String
      If Not el.HasElements Then Return el.Value
      Dim sb As New StringBuilder
      For Each nd As XNode In el.Nodes
         If TypeOf nd Is XText Then sb.Append(nd.ToString)
      Next
      Return sb.ToString
   End Function

With this the output is :

some values are in here

Enjoy :)

Registered Organization on 64 bit

bill — Sat, 03 Jan 2009 02:15:54 GMT

When I’ve started new Visual Studio projects on my Vista x64 box, the Company field would always show up as “Microsoft”… somewhat presumptuous and definitely annoying. At first I thought the problem was with the templates, but upon inspection they had the correct template parameters, $registeredorganization$. A quick look in my registry and those keys looked right; then it dawned on me. Visual Studio runs as a 32 bit process, not 64, so it effectively looks in :

HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Windows NT\CurrentVersion

And that’s the solution. In there RegisteredOrganization was set to “Microsoft”. Changing that to your organization’s name solves the template issue.

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 we have here is a failure to communicate

bill — Fri, 14 Nov 2008 02:33:49 GMT

you can tell from the title there’s a Friday rant coming can’t you ? Well yeh, sometimes what should be a simple task of writing code becomes painstakingly slow. Take for example this one line of code:

  Dim doc = XDocument.Load("abc.xml")

Now if you like to write robust code, somewhere in your mind there should be that voice saying, “ah but what if the file is not there or can’t be opened or isn’t valid xml “…etc, etc. So the first thing you probably think of doing is look at what exceptions the method can throw, or so you’d hope.

Problem 1. VB doesn’t display the exception information from any xml documentation. Our first failure to communicate that then leads us on a great chase.

Problem 2. Who ever wrote the XDocument.Load method actually failed to provide the exception documentation. The Load method calls external methods such as XMLReader.Create and the exceptions from that are unchecked, allowed to bubble through. The documentation should indicate an include statement to say the XMLReader.Create exceptions bubble up. The author(s) of XDocument.Load failed to communicate the exceptions that could be thrown.

Problem 3. If you like to keep current and have installed the SilverLight 2.0 SDK, F1 help will take you to a SilverLight topic even if you are writing a Console application. That little voice in your head that first said “what if …” is now screaming. There’s a failure to communicate between Visual Studio and MSDN help.

Problem 4. Your only resolve is to do the lookup in msdn help yourself, only to find the documentation has no exception information because it relies on the xml documentation (see Problem 2). The failure to communicate cascades.

Problem 5. As a last ditch desperate measure you use Reflector and walk through the code. Thankfully in this case the code is reasonably simple. The problem now is how do you get that information back into your code, so as you handle the correct exceptions ? This isn’t Relector’s fault as such, as the same problem exists if you do find the exception information in Visual Studio’s object browser. This is a failure to interact, but it can result in you not handling exceptions or documenting which exceptions bubble up from your methods, causing your code to fail to communicate. (see Problem 2.)

If religious wars were still in fashion, we’d be saying “hey what about checked exceptions al la Java ?”. The more I am frustrated at how hard it is to write robust code because of these often cascading failures to communicate, the more I want to sign up with the holly sect for checked exceptions.

An alternative is to provide rich tooling and analysis. Some years ago, myself and Geoff Appleby with some help from Mark Miller wrote a plug-in for refactor that did a look up based on the code you selected. It would match the method calls with their xml documentation, refine and sort the list based on inheritance rules (most specific first), and let you choose which ones to add to your code. It really was simple once you got the method info, which is where refactor (or more accurately DXCore) came in. Unfortunately we hosted that project on the now defunct GotDotNet site :(

Such a tool helps break the cycle here, but such a tool also needs to be used by Microsoft (see Problem 2 above), and there needs to be analysis to ensure exceptions are either handled or the documentation says what exceptions can be thrown. Writing robust code needs to be easier: we cannot just ignore exceptions.

.NET 3.5 SP1 source code

bill — Thu, 11 Sep 2008 15:36:26 GMT

When Visual Studio 2008 SP1 was released it didn’t have the source code for the framework like the original version of 2008 had. Well now it has !! Actually it was released almost two weeks ago.

VS 2008 SDK available

bill — Thu, 21 Aug 2008 11:42:57 GMT

I’ve been waiting for this update for VS 2008 SDK for VS 2008 SP1. The link I got fro ma msdn blog post was wrong, so here’s the link to the download page.

http://www.microsoft.com/downloads/details.aspx?FamilyID=59ec6ec3-4273-48a3-ba25-dc925a45584d&DisplayLang=en

Enjoy.

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 ;)