@ Head : .NET 4.0

VB Quark #7 : Optional Parameters and Dates

bill — Wed, 09 Nov 2011 04:14:54 GMT

Hopefully you already know VB has full support for Optional parameters, both declaring them and calling them, but did you know you can use Dates as Optional parameters ?

   Public Sub AddNewCustomer(customer As Customer,
                             Optional dateAdded As Date = Nothing)
      If dateAdded = Nothing Then dateAdded = Now

VB has had this support for Optional parameters in place for the last decade or so in .NET and for years before that back in the COM versions of VB.

In the last release of .NET (VS 2010), C# finally got support for Optional parameters, so the above in C# would look like:

     public void AddNewCustomer(Customer customer,
                           DateTime dateAdded = default(DateTime))
      {
         if (dateAdded == default(DateTime)) dateAdded = DateTime.Now;

The Nothing in the VB declaration is the same as default(DateTime) in C#, which equates to the theoretical Gregorian date of 1/1/0001.

But what if you want to specify a default date ? Well because VB supports date literals, in VB you can, but in C# you can’t. In VB you can write any date literal for the optional parameter value. For example, you might have some legacy database support, and when the date is unknown you want to use the equivalent of an OLE Date’s zero value:

Public Sub AddNewCustomer(customer As Customer,
Optional dateAdded As Date = #12/30/1899#)

When the VB compiler compiles this, it adds a System.Runtime.CompilerServices.DateTimeConstantAttribute to the parameter information with the default value stored as an Int64 (the number of ticks). C# actually sees the optional value in the above example and will use it. That is both VB and C# can call the code taking advantage of the optional value for the date parameter, but only VB let’s you define that value.

Displaying Dates in VS 2010

bill — Tue, 08 Nov 2011 05:30:00 GMT

From time to time there’s discussion about the way dates are displayed in the Visual Studio IDE for Visual Basic. Typically dates are shown using VB’s date literal syntax of #MM/dd/yyyy# which is the standard US format. For people outside of the USA this can be confusing or ambiguous at times. The good news is Visual Studio allows you to easily add your own display formatter.

Simply create a new class library project, add the following attribute to your AssemblyInfo file:

<Assembly: DebuggerDisplay("Date: {ToString(""s"")} kind={Kind}", Target:=GetType(DateTime))>

And then just copy the assembly to your Visualizers directory, eg:
My Documents\Visual Studio 2010\Visualizers

I added the Kind property to the display so as you can easily see if the Date is a local date, UTC or unspecified.

I've attached a sample project. Enjoy

VB Quark #6: Date operators

bill — Wed, 26 Oct 2011 06:28:19 GMT

The DateTime structure in .NET includes custom operators for Date comparisons such as less than, greater than, equal and not equal; but did you know it also includes addition and subtraction operators ? There’s two subtraction operators and one addition operator defined inside DateTime:

date = date – timespan
timespan = date – date
date = date + timespan

Those three cases should all seem relatively obvious, such as adding or subtracting an hour from a date, or calculating how many minutes between two dates etc...

BUT, did you know VB also defines another case where you can add two dates, eg:

Dim result = Date1 + Date2

Now if you guessed that the type of result is String, then congratulations !! Note: this operator resolution is only valid with Option Strict Off

Obviously adding two dates can’t give a valid date or timespan, so the only real options are to return a string concatenation of the date or throw an error. There are a couple of fringe cases where, depending on your system locale, the resultant string can indeed be parsed back into a date, eg:

      Dim dt1 = #1:00:00 PM#
      Dim dt2 = Now.Date
      Dim dtResult As Date = dt1 + dt2

But that really is a fringe case, and would depend on the system locale formatting.

I think it’s probably fair to say this case is a quirk of a quark, probably introduced as partial legacy. I honestly can’t see any usefulness of the addition operator between two dates that returns a string. If the intent was some legacy support, it might have made sense to return a date if one of the dates was date zero with time information, but the concatenation of the date strings doesn’t seem to reliably serve any purpose.

The good news is you can only do the string = date + date operation with Option Strict Off. Guess that’s just another reason to turn Option Strict On

VB Quark #5: C is for Char

bill — Thu, 29 Sep 2011 05:50:20 GMT

Can you pick the problem with this code ? :

      Dim currentChar As Char

      For i = 0 To largenumber
         currentChar = getChar(i)
         If currentChar = "a" Then
            count += 1
         End If
      Next

The answer of course is the literal “a” is of type string, not of type Char. Hence currentChar gets implicitly widened to a String to make the expression a string comparison expression. This means a new string is created with the contents of currentChar on each iteration, and the comparison is a string comparison which checks for null strings and empty strings and then does a compare ordinal etc. This is incredibly inefficient.

If “a” was typed as Char, then the comparison is a simple low level IL compare of the underlying values (int16’s).

You can use CChar, as in CChar(“a”), but it’s a lot easier just to add the type literal suffix c, eg “a”c

      Dim currentChar As Char

      For i = 0 To largenumber
         currentChar = getChar(i)
         If currentChar = "a"c Then
            count += 1
         End If
      Next

The change in this code is about 20 fold performance improvement (run as release build outside of Visual Studio). That’s a 20 fold increase just by typing one extra letter !!

This example was based on real sample code where a massive file was being parsed char by char. There too, attention to the fine detail showed a massive performance improvement over the original code. It’s often the little things that can make a huge difference.

This VB quark was brought to you by the type literal “c”

VB Quark #4: type literals

bill — Mon, 26 Sep 2011 05:54:00 GMT

Do you know why you can’t write this code in VB:

Dim x = 123456789.0123456789

Answer: The IDE won’t let you

If you try to write that code the IDE will truncate the number, giving :

Dim x = 123456789.01234567

To include all the decimal places you need to be using the Decimal type. To do this you indicate the constant is of type decimal by adding the suffix D on the end, eg:

Dim x = 123456789.0123456789D

The reason for this is VB treats numeric literals as of type Double by default if they have a decimal place. If there is no decimal place in the literal then the value is consider to be an Integer (Int32), or if it is too large for an Integer, it’s considered to be a Long (Int64).

If you want the literal as a type other than Double, Integer or Long you need to either convert using CType, CShort, CSng etc, or add a type literal suffix. The following is the complete list for numeric type literal suffixes in VB:

Suffix	Type
F	Single
R	Double
D	Decimal
S	Int16, Short
I	Int32, Integer
L	Int64, Long
US	UInt16, UShort
UI	UInt32, UInteger
UL	UInt64, ULong

In case you’re wondering, the “F” for Single is short for "Float”, and the “R” for Double is short for “Real Number”.

Here’s another example of where you should use type literal suffixes. Consider this code :

      Dim i1, i2 As Int16
      i1 = &HF0
      i2 = i1 And &HFF

If you have Option Strict On, the last line will cause a compile time error saying that an implicit conversion from Integer to Short is not allowed. So what is happening here, and why doesn’t the middle line cause the same problem ?

Well the line i1 = &HF0 compiles fine because the constant &HF0 can be evaluated at compile time, so there’s no problem there. The last line however cannot be evaluated because the variable i1 is not a constant. Try it for yourself if you like: change the declaration of i1 to a Const, and you’ll see the last line compiles fine with Strict On.

Because VB can’t evaluate the variable expression at compile time, it uses the default type for numeric constants : Integer (aka Int32). And because a short can be implicitly widened to Int32, the expression on the right hand side becomes an Int32: hence the error.

In Visual Studio the error correction wizard will suggest converting the entire expression to an Int16, as such :

i2 = CShort(i1 And &HFF)

But that’s a runtime conversion that isn’t needed if you declare the &HFF constant with the correct type literal suffix S:

i2 = i1 And &HFFS

As you can see, the code correction wizard in Visual Studio doesn’t always provide the best syntax to use, so it really is up to you to know the correct literals to use and apply them.

Oh, you may have also noticed there is no type literal suffix for Byte and SByte. I’ll leave that for yet another quark

VB Quark #3: operator differences in VB/C#

bill — Sun, 25 Sep 2011 10:20:00 GMT

Can you spot the problem with this code:

   <Extension()>
   Public Function ToColor(argb As UInteger) As Color
      Return Color.FromArgb( _
                      CType((argb & &HFF000000) >> &H18, Byte), _
                      CType((argb & &HFF0000) >> &H10, Byte), _
                      CType((argb & &HFF00) >> 8, Byte), _
                      CType(argb & &HFF, Byte))
   End Function

If you said it should be the bitwise And operator not the string concatenation operator give yourself a pat on the back. The problem here is three fold:

The code is a failed attempt at translating from C#, and
The project must have Option Strict Off for this code to even compile.
No testing or unit tests to check if the code works at runtime.

Sadly this is all too common. The above is in fact a very real example taken from the Silverlight Toolkit samples on Codeplex .

So the steps to correct this are first be aware of the language equivalents when translating from C# to VB. See the MSDN documentation on language equivalents for a great starting point. And take note of the operator equivalents. Some of the most common operators where people seem to make mistakes are:

operator	VB	C#
bitwise And	And	&
bitwise Or	Or	\|
bitwise exclusive Or	XOr	^
Short circuited Boolean And	AndAlso	&&
Short circuited Boolean Or	OrElse	\|\|
equality	=	==
assignment	=	=
not equal	<>	!=
exponent	^
modulus	Mod	%
string concatenation	&	+

From the short list above you can see the ^ and & operators have very different meanings in VB compared to C#. Which leads us to items 2 & 3.

If you are unsure of VB, or are translating and hence have a lot of code that *may* be invalid you can improve catching of these kind of developer mistakes by turning Option Strict On. In the original example, the argb & &HFF000000 would have given the result of a string: argb.ToString followed by –16777216. At runtime this string would then try to be converted to a number and then shifted right, most likely failing.

So if you turn Option Strict On, you’d immediately get warnings on trying to convert the string to a long. But even once you’ve got it compiling with Strict On, you should test the code. A lot of code you can quickly query in the immediate window, or write unit tests.

Oh, and the corrected code in this particular case is:

   <Extension()>
   Public Function ToColor(argb As UInteger) As Color
      Return Color.FromArgb( _
                      CType((argb And &HFF000000) >> 24, Byte), _
                      CType((argb And &HFF0000) >> 16, Byte), _
                      CType((argb And &HFF00) >> 8, Byte), _
                      CType(argb And &HFF, Byte))
   End Function

For a complete project that fixes the VB samples for the Silverlight Toolkit, see my blog post from last month

VB Quark #2: compiler directives and constants

bill — Sat, 24 Sep 2011 04:31:00 GMT

Building upon VB Quark #1 , did you know you can use compiler directives alongside expressions in constants ?

#If CONFIG = "Debug" Then
Const path As String = "Z:\mydebug.sdf"
#Else
Const path As String = "|DataDirectory|\Database1.sdf"
#End If

Const connectionString = "Data Source=" & path

The nice thing about this is as you change the config from Debug to Release, Visual Studio will grey out the parts that aren’t in the current compilation. In the above example, when I do a debug build I’m using my database in Z:\mydebug.sdf, but when I do a release build it automatically uses the database Database1.sdf in the application’s DataDirectory.

You can use compiler directives pretty much anywhere in your code to replace any code block with another at compile time based on the directives.

VB Quark #1: constant expressions

bill — Sat, 24 Sep 2011 03:56:00 GMT

This quark is more of a did ya know quark about constant expressions in VB. You probably know you can declare a constant expression such :

Const appName As String = "My Really Cool App"

But did you know you can also do operations in constants ?

Rather than calculate the area of a circle you can write:

Const radius = 4.2
Const area = Math.PI * radius ^ 2

The compiler will calculate the area constant at compile time. This makes it easy to change the area constant by simply changing the radius.

The operations you can do include all the standard mathematical operations : +, –, /, \, * , ^ and Mod as well as bitwise operations such as And and Or as well as bit shifting << and >>.

For example you can declare an enum for bits using shift operations: (note: Enums are constants)

   Public Enum bits
      bit0 = 1
      bit1 = 1 << 1
      bit2 = 1 << 2
      bit3 = bit2 << 1
   End Enum

You can also use the If operator. For example you might want to limit a constant based on another constant, eg if gravity is greater than 20g’s then you might want to limit it to 20g for calculations.

Const workingG = If(g < 20 * 9.8, g, 20 * 9.8)

And you can also do conversions between the intrinsic numeric types, eg CDbl, CSng, CDec, CLng, CInt, CShort, CByte, CULng, CUInt, CUShort, CSByte. And conversions to and from boolean to the numeric types: CBool and the aforementioned conversion operators.

Const roughArea As Int32 = CInt(area)

For dates, there aren’t any operations or conversions you can do: you have to define them using the literal representation in US format, eg today 24/9/2011 is defined as #9/24/2011# . This is still a lot better than certain other languages (not picking on C#) that don’t support constant date literals.

For strings, you can’t do any conversions but can use the concatenation operator &. You can use + instead of &, but I don’t recommend that (more on that in another quark). Strings that are compiled as constants are also typically interned.

Anywhere you use an expression that can be compiled as a constant, it is evaluated at compile time: you don’t have to declare a constant variable to reap the benefits of compile time evaluation.

VB Windows Phone Toolkit Aug 11 sample

bill — Fri, 19 Aug 2011 12:57:20 GMT

The Silverlight Windows Phone Toolkit August 2011 (7.1 SDK) doesn't contain a working VB sample. If you try to load the VB sample that does ship, you’ll get hundreds of errors. So I put together the VB sample that should have shipped.

Download the VB Windows Phone Toolkit samples

Enjoy

Oh, and Thanks to Nick Randolph for confirming the SDK doesn’t contain a working example.

Remember variant ?

bill — Thu, 28 Jul 2011 03:40:39 GMT

Cory is continuing his posts about VB10 differences from VB6. His latest posts is on variants.

Variants were/are basically a structure that contains a variant type enumeration and either the variable’s data value or a pointer to the variable data. In pseudo code it basically looks like:

Structure Variant
Public VT as VariantType
Public Value As Object
End Structure

The Value field would hold the actual data in the case of simple value types, or a pointer to the object such as in the case of arrays. In the .NET world there are actually variant structures but not as part of the .Net framework: you can find one for example in the Microsoft.VisualStudio.Package namespace.

The reason you won’t find it in the framework is because the variant structure is not only limited but also superfluous in .NET due to the type system. Take for example the case of a value as a Double versus an Integer. In VB6 you would use Variant to allow you to pass both values to a method. The Value field would hold the actual data so it was important that the VT field told you the value type. The problem with this approach is the VT field is an enumeration, so doesn’t allow for custom value types to have their actual type discoverable: try passing a UDT into a variant and then determining which type of UDT is is in VB6 to see what I mean

In .NET the object based type system means you can always determine the type of a variable. So the “everything stems from Object” approach in .NET is definitely more versatile.

There was however one thing missing: yep, IsMissing was missing. Variants allow optional parameters to indicate if a value was missing. The first release of .Net didn’t have anything in place to indicate if an optional parameter was missing. It wasn’t until nullable types were added that you could do the equivalent of IsMissing by testing for Is Nothing. The Is Nothing approach is more holistic and uniform (as opposed to IsEmpty versus IsMissing et al) and works across the board for nullable types and As Object variables and parameters.

So, in summary, there was initially some gains and some losses with the move from Variant to an Object based system, but as the .NET framework and language implementations have matured, the Object based system (.NET) offers far more functionality and flexibility.

Oh, as you can probably see, the above explanation/description actually touches on a number of items in the list Cory referred to: in particular but not limited to items 11 and 27. I think it is always important to come up for air and see the big picture: the forest from the trees. The overall benefits of moving to Object based in .NET extend far beyond these one or two items.

Windows Phone 7 : 6 months later

bill — Fri, 17 Jun 2011 07:29:55 GMT

I’ve had my HTC Mozart for about 6 months now, so I thought I’d give an update of my thoughts about it and Windows Phone 7.

The first set of WP7 updates were really slow to roll-out here in Australia to Telstra: Telstra was the 2nd last mobile operator to deliver the update in the world. Given that the Spain’s Telefonica apparently still is only scheduling updates, for now Telstra has the honour of actually being last to deliver the updates (to date). Despite those middle party delays, the 7.1 update was awesome ! Performance improvements are huge with some applications, and most importantly we got cut and paste back.

For more feature improvements we still have to wait until later this year when the “Mango” update will be released. Developers can play with the mango bits in Visual Studio and the phone emulator. So far Mango looks really cool and addresses many of my initial/early concerns about Windows Phone. Looking at my “xmas wish list” of 3 items, that list seems at least half way addressed :

Sensors: Yes, in Mango the platform exposes more of the phone’s sensors.
Content Providers: Again it seems like Microsoft has heard and is exposing ways for applications to work with the contacts list etc. At the same time they are also introducing “groups” for contacts which may in itself address many of the reasons I want/need to have the contacts list exposed. hopefully groups too will be exposed to programmatic access (with permissions). There still doesn’t appear to be any shared storage/data access on the phone.
Let me work with my PC : Sadly, I haven’t heard any news on this front; everything I have heard has been focused on a better “cloud” experience. It’s a pity as there are times when there is no internet access, and it would be handy to transfer files & contacts to the phone. Zune really needs to open up to include basic file management; and ideally outlook synchronisation. This is a MUST have given the lack of Zune music in Australia.

So that was my old list. Today some of the things I’d like to see Mango address are (in no particular order):

Capacitive button settings:
Way too often I find I accidentally hit the home, search or back buttons, especially when passing the phone to other people to show them something on the phone. It’s be nice if there was a settings page where you could modify the sensitivity of these buttons. Ideally I’d like to be able to set them to only work on double click/touch. It’s a little thing, but it would drastically change the way I feel about the phone’s physical form factor. It’d make it feel like the phone was truly mine, rather than the phone constantly dictating to me not to touch it there, and not to hold it that way
iCal and/or vCal support:
A month or two ago I got an email from some of the crew at Microsoft to attend a Live Meeting about Windows Phone. “Cool !!” I thought. The problem was I read that email on my phone, and couldn’t save the attached calendar appointment ! Oh the irony !!!!
Must be able to send and receive calendar appointments via email.
vCard support:
There needs to be a way to simply share contact details with people. VCard support in email and especially SMS is a must have.
Better document handling:
The ability to:
+ simply save a document from an email,
+ transfer files directly to/from a PC
+ programmatically generate and save documents (e.g. invoices/quotes etc.) in shared locations. Ditto for data access.
Zune music:
If Microsoft wants people in Australia to take it seriously about its commitment to Windows Phone it needs to invest in actually having Zune Music available here (ditto for other countries). ITunes has no problem with providing music in Australia. Microsoft: either make Zune Music in Australia happen or open the phone up to 3rd party music sites and file organisation (iTunes on the Windows Phone !!) or both. It’s really crappy to lock the phone down and then not provide the service. Even worse when you open Zune and it constantly reminds you there is no service here.

Despite the list of “wants” or “shortcomings”, Windows Phone really is a nice device. The UI is generally enjoyable (as long as you don’t accidentally hit those capacitive buttons <g>). Mango looks even better.

Looking forward to hearing more details. Spaces to watch:

Memory mapped files and pointers… or not ???

bill — Thu, 10 Mar 2011 01:29:04 GMT

Last week I was in Seattle for the MVP summit. Whilst there I saw a brief presentation from Joe Kunk on Memory Mapped files in .NET 4. I suggested to Joe that perhaps pointers might give a performance boost. Then someone from Microsoft (not to mention names) suggested if that were the case, it might be a good argument for the inclusion of pointers in a future version. I chatted to Joe afterwards and he suggested I download the code and give it a try, so I did. The following are my findings, and the journey along the way. The end result is a dramatic performance improvement:

First steps : code review

I downloaded Joe’s code and created a 5GB sample data file. I figured 5 GB is big enough to push it into the 64 bit realm. I ran the code and it took about 25 minutes to create the index file. I had a quick look at the code and identified some areas to immediately tweak. Inside the main code block loop there were a number of conversions going on, some implied; all of which tend to slow code down. The original code was as follows:

   For i = 1 To accessor.Capacity
      Dim CurrentByte = accessor.ReadByte(ViewPosition) : ViewPosition += 1
      Dim CurrentChar = Chr(CurrentByte)

      If (Char.IsLetterOrDigit(CurrentChar)) Then
         InWord = True
         Wordlength += 1
         If ((Char.IsUpper(CurrentChar) AndAlso CurrentChar = "R") OrElse
             (Char.IsLower(CurrentChar) AndAlso CurrentChar = "r")) Then
            HasR = True
         End If

There’s a number of issues to be aware of here. The code that compares a Char with a String causes overhead, causing the char to be converted to a string and then calling VB’s string comparison routines. Rather than write AndAlso CurrentChar = "R" , it’s better to write AndAlso CurrentChar = "R"c) . This makes it a simple comparison of Char’s.

The calls to IsUpper and IsLower are completely redundant and are more expensive than the Char comparison calls. In fact, it’s questionable if Char is even needed here. Given this code is purely designed for ASCII, not Unicode, I rewrote the code to use Byte instead of Char for this initial part of the loop. Modifying the code only took a few minutes, the only bump being the need to create a replacement for the IsLetterOrDigit call. I’d argue IsLetterOrDigit might not be what is wanted in the first place, as it means words with hyphens, @ signs or apostrophes are excluded. Given St Pat’s day is next week, I certainly wouldn’t want to be excluding any of the O’Reily’s ;)

Never the less, I kept the code pure to it’s original implementation. For IsLetterOrDigit, I made a simple True/False array. This was easy to make by writing out the values into the debug window, e.g:

      For i = 0 To 255
         Debug.Write(Char.IsLetterOrDigit(Chr(i)) & ", ")
      Next

From the output in debug window the output from that, I created a lookup array via cut and paste:

Private IsLetterOrDigit() As Boolean = {False, False, False, False, False, ……………

With those quick changes in place the test time dropped to around 18 to 19 minutes: a significant improvement, and well worth the time it took to make them, but nothing earth shattering.

Look for bottlenecks

On my desktop machine I have standard mechanical hard drives and newer Solid State Drives (SSD’s). The SSD’s are blistering fast, and make a huge gain in read times (and windows boot times). Putting the data file on a SSD gave a performance improvement of about another 5 minutes. (test was now 14.4 minutes). Although again a significant improvement, it wasn’t the order of magnitude I would expect in what is basically a file IO bound operation. This alluded to the bottleneck being the code, not the hardware. So it was time to revisit the entire Memory Mapped file hypothesis. The first step was to write a standard benchmark using a standard FileStream.

My first runs came in at about 36 seconds !!

I set the FileStream to read the data in blocks of &H10000 bytes at a time. It’s an arbitrary figure, but later testing shows it’s around the sweet spot for this particular machine. My first runs came in at about 36 seconds !! I was astounded. Some minor tweaks and the time was down to 32 seconds. I checked and verified the output. The locations were correct and I had the same number of matches as Joe did plus one. I’m guessing the extra one is a boundary case condition that my code picked up on. (It’d probably be easy enough to test by looking at the last entries)

Out of curiosity I put the data file back on the old mechanical drive. The time jumped massively from 30 seconds to about 90 seconds. This told me the bottle neck was now the hardware. Investment spent on the hardware rather than the software, such as SSD’s and even RAID SSD’s etc, are worth investigating at this point.

As to pointers?

Well I never bothered writing the code to test the pointers and memory mapped file. The code I wrote was already 40 to 50 times faster than the memory mapped file implementation. With the file stream approach I estimate pointers to save about 10%, or 3 seconds on the fastest case scenario. If you look under the covers of the file stream you’ll see the buffer used internally uses pointers with win API call to ReadFile. With a bit of work you could write your own wrapper, call ReadFile yourself and skip the copying from the internal buffer to the buffer used in the search loop. Rather than go to that length, I simply tested what that extra copying was causing by copying into yet another buffer from inside the search loop: that added about 3 seconds to the code. It hardly seems worth the effort. Rather than spend time porting the code to use pointers it would be probably more worth the time to investigate making the code run async (I’ll leave that one for another day ;) )

But that doesn’t mean there isn’t a case for pointers with memory mapped files. I used them many years ago (even from VB6). All I have shown is that for this case scenario, Memory Mapped files are not a good match. A compelling case scenario for pointers and memory mapped files remains to be shown.

Conclusion

Memory mapped files are useful in many scenarios, such as shared data manipulation, and inter process communication. For raw data reads however, they are overhead with no realizable benefit.

Create benchmarks using similar techniques. And look under the covers to try to understand the differences and their significance.
Write well typed code and use Strict On semantics where ever possible. For example the quick code clean-up I did on the original code shaved off 5 minutes. Although that was only 20% improvement for the initial code, it was quick and easy to implement. On the final code, that 5 minutes is a massive overhead on top of 30 seconds (10 fold) !! So little bits of detail in your code can go a long long way to writing high performance code.

#Region "modifications by Bill McCarthy"
 
 
   Private Function CreateIndexEntryList(ByVal TextFilePath As String) As List(Of IndexEntry)
 
      Dim index As New List(Of IndexEntry)(&HF0000)
      Dim bufferSize As Int32 = &H10000
      Dim offset As Int32 = 0
      Dim buffer(0 To bufferSize - 1) As Byte
      Dim filePosition As Long = 0
 
      Dim inWord = False
      Dim wordlength As Int32 = 0
      Dim hasR = False
 
 
      Dim sb As New System.Text.StringBuilder(6)
 
      Try
 
         Using stream = New IO.FileStream(TextFilePath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize)
 
            Dim countRead = stream.Read(buffer, offset, bufferSize - offset)
 
            While countRead > 0
 
               Dim upper = countRead + offset
               For i = offset To upper - 1
                  Dim currentByte = buffer(i)
 
                  If (IsLetterOrDigit(currentByte)) Then
                     inWord = True
                     wordlength += 1
                     If (currentByte = byteUpper_R) OrElse (currentByte = byteLower_r) Then
                        hasR = True
                     End If
                  Else
                     If (wordlength = 5 And hasR = True) Then
 
                        Dim bufferPosition = i - 5
                        sb.Clear()
                        For j = 0 To 4
                           sb.Append(Chr(buffer(bufferPosition + j)))
                        Next
                        index.Add(New IndexEntry(sb.ToString, filePosition + bufferPosition - offset))
                     End If
                     inWord = False
                     wordlength = 0
                     hasR = False
 
                  End If
 
               Next
               offset = wordlength
               If offset > 0 Then
                  For i = 0 To offset - 1
                     buffer(i) = buffer(upper + i - offset)
                  Next
               End If
 
               filePosition += countRead
               countRead = stream.Read(buffer, offset, bufferSize - offset)
 
            End While
 
         End Using
 
      Catch ex As Exception
         Dim message = "IndexingLargeFiles.Index.CrearteIndexEntryList: " + ex.Message
         Throw New Exception(message, ex)
      End Try
 
      Return index
   End Function
 
 
   Private Const byteUpper_R = CByte(Asc("R"c))
   Private Const byteLower_r = CByte(Asc("r"c))

Private IsLetterOrDigit()As Boolean = {False,False,False,False,False,False,

False, False, False, False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False, False, False, False, False,
False, False, False, False, False, False, True, True, True, True, True, True, True,
True, True, True, False, False, False, False, False, False, False, True, True, True,
True, True, True, True, True, True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True, False, False, False, False,
False, False, True, True, True, True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True, True, True, True, True, True,
False, False, False, False, False, False, False, False, True, False, False, False,
False, True, False, True, False, True, False, True, False, False, False, False, False,
False, False, False, False, False, False, True, False, True, False, True, True, False,
False, False, False, False, False, False, False, False, False, True, False, False,
False, False, False, False, False, False, False, False, True, False, False, False,
False, True, False, False, False, False, False, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True, True, True, True, True, True,
True, True, True, False, True, True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, True, True, True, True, True, True, True,
True, True, True, True, True, True, True, False, True, True, True, True, True, True,
True, True}

#End Region

WP7 copy and paste is here !

bill — Sat, 05 Feb 2011 07:49:07 GMT

In the emulator in the tools SDK that is

Still waiting on the actual phone update, but for developers the tools update is now available from:

http://www.microsoft.com/downloads/en/details.aspx?FamilyID=49b9d0c5-6597-4313-912a-f0cca9c7d277&displaylang=en

Windows Phone Virtual Keyboards

bill — Wed, 17 Nov 2010 00:44:28 GMT

Windows Phone 7 comes with about 57 different input scopes you can use (there’s actually 62 or so, but 5 of them give an exception when loaded). The two most important scopes are Text and TelephoneNumber.

TelephoneNumber gives you the numeric keypad when the user goes to enter text.
Text gives you word suggestions and smiley faces like in messaging.

Setting these in code is a little convoluted. It’s a lot easier to simply set it in the XAML, eg:
<TextBox ... .. InputScope="Text" ></TextBox>

If you want to set the input scope in code, you need to construct an InputScope class instance, and add to it a InputScopeName class with the InputScopeName’s Value set to the InputScopeNameValue enum value. It’s easiest to wrap this in an extension method:

   <Extension()>
   Sub SetInputScope(ByVal textbox As TextBox, ByVal value As InputScopeNameValue)
      Dim scope As New InputScope
      scope.Names.Add(New InputScopeName With {.NameValue = value})
      textbox.InputScope = scope
   End Sub

Then setting the input scope in code simply becomes:

 TextBox1.SetInputScope(InputScopeNameValue.Text)

Some things to note about input scopes:

although you can cache an input scope, and assign it to a different textbox on an as needed basis, you have to be careful to ensure it is only assigned to one textbox at any given time. I doubt the memory minimization would be worth the effort.
an InputScope can have multiple InputScopeName values, but it seems like only the first one in the list is used.
the following InputScopeNameValue’s give a runtime error when run from the debugger: PhraseList, RegularExpression, Srgs, Xml, EnumString

The main values you’ll want to use are:

value	description
Default	Standard QWERTY layout
Text	Standard layout with features such as autocorrect and text suggestion
Url	Standard layout with .com and customized Enter key for typing URLs.
EmailSmtpAddress	Standard layout with .com and @ key.
EmailNameOrAddress	Standard layout with .com and @ key, and easy access to phone number layout.
Maps	Standard layout with a customized Enter key. Used to type a location to search for on a map
TelephoneNumber	12-key layout
Search	Semi-transparent layout with a Search and .com key.
NameOrPhoneNumber	Standard layout with access to phone number layout. Used to type in the SMS To field
Chat	Text input that uses intelligent features such as abbreviations

abbreviated from http://msdn.microsoft.com/en-us/library/39D7932C-3E67-4142-9CCB-68843A571A66(v=vs.95,d=lightweight).aspx

My Windows Phone 7 Xmas wish list

bill — Tue, 16 Nov 2010 23:03:59 GMT

As much as I like Windows Phone 7, there’s some really key areas that are missing. The following is my xmas wish list :

1. Give me my compass back.

When I bought my HTC Mozart, I did so with the understanding it had a gps and compass. On the HTC web site it says :

This illusion was even more exaggerated by so called navigation applications that actually show virtual compass dials: thing is they don’t work, and at best can only give you your course based on differential gps. When you’re on foot (especially in the Australian bush) that simply is not good enough.

So Microsoft, please give me access to my compass.

2. Provide Content Providers

Those of you who work with certain other phones, probably know what I am talking about when I say ContentProvider’s. It’s the broad ability for applications to share data/”content”. It’s the key programmatical interface missing in Windows Phone 7.

ContentProviders can allow access to the phone contacts list (with permissions); they can provide access to documents in the office hub; they can allow applications to choose whom they share data with; they can even provide a clipboard service.

3. Let me work with my PC

It really should be straight forward to connect the phone to my PC and put files on the phone. Today, unless you have exchange, the only way to work with documents is to email them to yourself. Skydrive, despite what some people may tell you, definitely DOES NOT synchronize office documents; it only synchronizes your OneNote. But even if they do fix skydrive, I shouldn’t be forced to copy documents over the web to get them from my PC to my phone and back.

One of the key reasons I went with Windows Phone was the belief that they would have great synergy with the PC. At present they don’t. At present it doesn’t even work well with the cloud, only exchange. (again, perhaps the way to address this is via ContentProvider’s)

So please Microsoft, give me better PC to phone sync and synergy.

There’s more I could easily put on my list, but Christmas is coming soon, and I’m sure the elves in Redmond are busy working away at something. It’d be really nice if Microsoft addressed some of these, even in the form of an announcement and a time frame (and some CTP’s?); even better if they do it before Christmas.

Windows Phone 7 does COM ??

bill — Tue, 16 Nov 2010 00:12:22 GMT

Wow, seems Windows Phone 7 supports COM inside ! Chris Walsh has been doing some “investigating” into the inners of Windows Phone 7.

Interesting, but also totally not usable in any production application.

Reflector and Windows Phone 7

bill — Mon, 15 Nov 2010 10:35:00 GMT

If you’re like me and like to open reflector from the Visual Studio Tools menu, you’ll probably have noticed that you need to have a different configuration (or list) of assemblies when developing with Windows Phone 7.

To make it simple to setup, I’ve attached a configuration file.

download the attached configuration and save it to a writeable path
In Visual Studio, click on the External Tools menu item (from the Tools menu), and add a new item:
set the command path the path to the full path of reflector.exe
make the Arguments:
/configuration:"Full Path To config file\reflector_phone.txt" $(TargetPath)

Help Library Manager and error 0x80190194

bill — Fri, 12 Nov 2010 23:58:35 GMT

Yesterday I noticed that the Windows Phone content had been updated online, but my local help library didn’t have the new content. So I thought I’d just open up Help Library Manager and update my local content. Sadly it wasn’t that simple. Help Library Manager would only let me update the entire collection, a process it never managed to complete. Each time help library manager failed it would have to start all over again, again saying it had to download about 2 GB of files.

The solution : In the end, after a dozen or more attempts spanning most of the afternoon, I gave up and uninstalled all my existing help content. This allowed me to add back the books I wanted one by one and have them update when added.

The problem : When the help library manager does its updates, it doesn’t allow you to select an individual book, instead it demands to update all books. And if any download fails, it aborts the entire process. The error message you get is:

If you look in the Windows Application logs (via Event Viewer), you’ll find error messages such as :

An error occurred while updating local content: Microsoft.Help.CacheLib.CacheLibDownloadException: An error occurred while the BITS service was transferring 'http://packages.mtps.microsoft.com/visual_studio_22759845_vs_100_en-us_6(e46593e9-d0e9-0b05-536f-729a38c64fa1).cab' to 'C:\ProgramData\Microsoft\HelpLibrary\content\Microsoft\incoming\36d8cf67-0d25-406f-8a5e-3b6143bc3769\Visual_Studio_22759845_VS_100_en-us_6.cab'. The error context was 'RemoteFile', and the error code was '0x80190194'.

Searching for 0x80190194 and Help Library Manager won’t bring you much joy (hopefully this blog post might change that).

A bit of an insight might be able to be inferred from the event log. It says the error occurred at :

at Microsoft.Help.CacheLib.DocumentationCache.<>c__DisplayClass6c.<DownloadWebContent>b__69(IGrouping`2 chunk)

at Microsoft.Help.CacheLib.Extensions.Each[T](IEnumerable`1 that, Action`1 lambda)

at Microsoft.Help.CacheLib.DocumentationCache.DownloadWebContent(IEnumerable`1 webDownloads, Int32 totalDownloads, Int32 completedDownloads, String workingDirectory, StatusCallback`1 statusCallback)

Note: I’m only guessing here as I haven’t seen the code, by my guess is there is no individual error handling in the Action lambda. It’s a if one fails the lot fails approach. I always think this is something to be wary of with enumerable and lambda expressions. Simple lambdas look clean and elegant but often aren’t robust. The result is all or not at all. And when that result is “not at all” most of the time, then we’ve got a problem.

So the workaround I employed was to limit the collection to start off with. This limited the “all” to a workable set. But there’s lots more the team responsible for the Help Library Manager should do (IMO).

First thing to do is publish a KB and blog post about error 0x80190194, and let people know what is going on (and what the team plans to do about it) and suggest workarounds (like above).
Fix the code. Add robust error handling that internally retries the download multiple times; and split it up so as the downloads that have succeeded are installed. Get over and get past the lazy all or not at all approach.
Fix the UI. Apart from the antiquated fixed dialogue window (instead of modern resizable), the UI should allow updating of individual books (aka products). If I want the latest Windows Phone documentation right NOW, I don’t want to be waiting until all the other updates apply.
Provide downloads that can be installed offline. If you have multiple computers, you don’t want to be downloading 2GB for each one.

Too many hyperlinks in your XAML ?

bill — Thu, 04 Nov 2010 03:03:35 GMT

If you are editing XAML code in Visual Studio and seeing a lot of the code underlined as a hyperlink, the problem is you most likely have the “Enable single-click URL navigation” option selected. It is best if you uncheck that option:

PDC 2010 Sessions

bill — Wed, 03 Nov 2010 00:49:59 GMT

You can view PDC 2010 sessions online at microsoftpdc.com , but you can also download sessions to view later or copy over to your windows 7 phone

The sessions info is all online in one nice big XML file :
http://videoak.microsoftpdc.com/pdc_schedule/Schedule.xml

Just scroll down or search for <DownloadableContent>

Or if you want you can run some XLinq on it to make it into a nice html doc. Here’s my quick and dirty attempt:

 Dim doc = XDocument.Load("http://videoak.microsoftpdc.com/pdc_schedule/Schedule.xml")
 
 Dim sessions = doc...<Session>
 
 Dim output = <html><body>
                  <%= From sess In sessions Select
                     <div><strong><%= sess.@Code %><%= " " %><%= sess.<ShortTitle>.Value %></strong>
                        <blockquote>
                           <%= sess.<FullDescription>.Value %>
                           <ul>
                              <%= From content In sess...<Content> Select
                                 <a href=<%= content.@Url %>><li><%= content.@Title %></li></a>
                               %>
                            </ul>
                        </blockquote>
                      </div>
                   %>
              </body></html>
 
IO.File.WriteAllText(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) & 
                           "\session.html", output.ToString)