16

Is there any way to use the new dynamic features in the 4.0 framework like ExpandoObject in VB.NET without setting Option Strict Off? With C#, you lose type safety only with the variables you specifically declare as dynamic. But with VB, the only way I've found to use these features is with the old Option Strict Off trick that's been in VB.NET since the beginning. Without Option Strict, everything in the file is polluted with fuzzy typing like so:

Option Explicit On
Option Strict Off
Option Infer On

Partial Public Class ClassX

   Public Sub TestDynamic()
      Dim dyn As Object = New System.Dynamic.ExpandoObject()
      Dim a As String = 1 ''# Ew!
      Dim obj As Object = "999"

      dyn.Str = a   ''# a is a string, remember?  Even though it has a number
      ''# dyn.Str = 1 : Type = System.String
      Console.WriteLine("dyn.Str = {0} : Type = {1}", dyn.Str, dyn.Str.GetType().ToString())

      dyn.Num = 123
      ''# dyn.Num = 123 : Type = System.Int32
      Console.WriteLine("dyn.Num = {0} : Type = {1}", dyn.Num, dyn.Num.GetType().ToString())

      dyn.Dbl = obj / 9
      ''# dyn.Dbl = 111 : Type = System.Double
      Console.WriteLine("dyn.Dbl = {0} : Type = {1}", dyn.Dbl, dyn.Dbl.GetType().ToString())

      dyn.Obj = obj
      ''# dyn.Obj = 999 : Type = System.String
      Console.WriteLine("dyn.Obj = {0} : Type = {1}", dyn.Obj, dyn.Obj.GetType().ToString())

      dyn.Dte = #5/5/1955#
      ''# dyn.Dte = 7/7/1977 12:00:00 AM : Type = System.DateTime
      Console.WriteLine("dyn.Dte = {0} : Type = {1}", dyn.Dte, dyn.Dte.GetType().ToString())

      AmICalled(dyn.Num)
      AmICalled(dyn.Obj)
      AmICalled(dyn.Str)
      AmICalled(dyn.Dbl)

      Try
         AmICalled(dyn.Dte)
      Catch
         Console.WriteLine("Dates don't convert to ints I guess... but we don't know that 'till runtime")
      End Try

      Console.WriteLine(dyn.Num + dyn.Str) ' 124!?
      Console.WriteLine(dyn.Num & dyn.Str) ' 1231!?

   End Sub

   Private Sub AmICalled(ByVal i As Integer)
      Console.WriteLine("AmICalled was called with: " & i)
   End Sub

End Class

Is this really correct? And, if so, what's the best way to still use things like ExpandoObject and mitigate the risk of losing all type safety? Partial classes? Or should I just not be so worried about type safety in this case?

mattmc3
  • 17,595
  • 7
  • 83
  • 103
  • Okay folks, I started a bounty. Is there a way VB.NET developers can use the new .NET 4.0 dynamic features without turning Option Strict Off, and thus losing type safety for everything instead of just the one dynamic variable? – mattmc3 Jul 31 '10 at 11:47
  • I put a request for this feature against VB.Net on [Microsoft Connect](https://connect.microsoft.com/VisualStudio/feedback/details/591963/please-give-vb-net-some-equivalent-for-c-dynamic-with-option-strict-on). Anyone with an opinion before or against can vote there. There's also this [blog post](http://blogs.msdn.com/b/lucian/archive/2010/01/28/core2-dynamic-pseudo-type-scoped-late-binding.aspx) from the VB team lead. – MarkJ Apr 23 '11 at 08:15
  • BTW there is also a [duplicate question](http://stackoverflow.com/questions/2889974/vb-net-equivalent-for-c-dynamic-with-option-strict-on) – MarkJ Apr 23 '11 at 08:17

3 Answers3

8

It appears you can't without having to turn Option Strict off. I'll research some more though.

Edit

After going through some documentation on the ExpandoObject, it appears it is used in C# for COM and Office Interop. Traditionally, in VB.NET, the Object was used for such purposes and that would require you turn off Option Strict.

To answer your question this means that you can use dynamic types in VB.NET by using the Object type instead of the ExpandoObject [if such a type exists in VB.NET], set Option Infer On and Option Strict On or Off.
You could also consider using partial classes to localise your non Option Strict code to particular files.



Suggested Reading

Alex Essilfie
  • 12,339
  • 9
  • 70
  • 108
4

I haven't tried this, and it wouldn't be pretty, but you ought to be able to use CallByName.

Adapting your example 

Partial Public Class ClassX  

   Public Sub TestDynamic()  
      Dim dyn As Object = New System.Dynamic.ExpandoObject()  
      Dim a As String = "1" ''# Option Strict is on  
      Dim obj As Object = "999"  

      ''# dyn.Str = a  
      CallByName(dyn, "Str", CallType.Set, a) 
      Console.WriteLine("dyn.Str = {0} : Type = {1}", 
        CallByName(dyn, "Str", CallType.Get, a), 
        CallByName(dyn, "Str", CallType.Get, a).GetType().ToString()
      )     

      ''# etc etc... I can't face any more of that

As I said, it's not pretty.

MarkJ
  • 30,070
  • 5
  • 68
  • 111
2

No. This is sort of the modern day late-binding.

Stan
  • 746
  • 1
  • 17
  • 35