@ Head : CSharp

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.

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

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

Is C# unacceptable ?

bill — Thu, 03 Sep 2009 00:50:00 GMT

Well if you mark your methods as being void from the outset …….

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.

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 .

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

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.

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 :(

.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.

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

VS 2008 SP1 Now available to MSDN subscribers

bill — Mon, 11 Aug 2008 15:10:23 GMT

Check out the msdn subscriber homepage. S

P1 for Visual Studio 2008 English is about 830 MB… downloading at present

Then I can install SQL 2008 :)

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

Are iterators fundamentally flawed ?

bill — Sat, 02 Aug 2008 02:14:22 GMT

It seems apparent that with computers as we currently know them, processors are now set to scale out not up.. that is, clock speeds aren’t rapidly growing, and certainly not doubling every year or two, instead the number of processors on a chip is. As a case in evidence, 2 or 3 years ago, my PC’s were all single CPU, then a bit over a year ago I bought my new desktop PC and it was a dual core. And as of a few days ago I swapped that dual core out for a quad core. For me, the number of cores/CPU’s is clearly doubling every year or two, but clock speed itself isn’t that much faster.

So what that means for computing is the emphasis is on parallel or concurrent computing. As such, we need to look at the fundamentals and see if they are designed for the task. Iterators don’t look like they are.

If you consider an iterator primary task of getting the next element, then look at how it does it, you should observe a major design flaw… the operation is not atomic. An iterator’s implementation is IEnumerator or IEnumerator(Of T), and IEnumerator require you to first call MoveNext then read the Current property. If you allow multiple threads to use the same IEnumerator, then you could get a call sequence such as MoveNext, MoveNext, Current, Current, which would skip one item and repeat the next one. So IEnumerator is not well designed for threading. This is a known design limitation, but rather than address that, languages like C# have implemented their iterators to be a different iterator per thread. That is they not only recognise the limitation but they also enforce it.

Going forward, perhaps we need a new IEnumerator class. In the good bad old days that would be called IEnumerator2(Of T). IEnumerator2 would make iterating a single method call that would return a Tuple(Of T, Boolean). It could extend IEnumerator, but it would be difficult to enforce thread safety to the IEnumerator interface. The problem that language like C# would then face is do they risk breaking existing code by returning the same enumerator to different threads ? Well no they would have to provide an IEnumerable2.GetEnumerator as well, so it would be possible to have the same class used for both single instance per thread and shared class across threads. As such, then the code that calls the iteration, the For Each loop, would then have to indicate whether it wants to do so using parallel or single threaded.. this would probably surface in the languages such as the For Parallel instruction on a loop.

So maybe iterators aren’t fundamentally flawed, they just currently have a lot of limitations which can and hopefully will be addressed as we venture more into the world of multi core :)

Text preview filters for Vista|Windows 2008

bill — Wed, 23 Jul 2008 05:41:20 GMT

I really like the preview pane in explorer in Vista, but it doesn’t have previews for a lot of text based files registered. You can of course write your own or download and install some other preview filters, but personally I find a text preview is all I generally need. So I re-use the existing Text preview handler and apply it to a range of file types including batch files, .bat, xml, .reg files, .vb and .cs files etc. Just copy and run the following .reg file

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\.xml\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.reg\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.cmd\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.bat\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.VBS\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.vb\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.vbproj\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.cs\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.csproj\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.sln\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"

[HKEY_CLASSES_ROOT\.snippet\ShellEx\{8895b1c6-b41f-4c1c-a562-0d564250836f}]
@="{1531d583-8375-4d3f-b5fb-d23bbd169f22}"