Visual Basic 15 brings with it partial implementations of two important C# features: tuples and ref returns. Neither feature is \u201ccomplete\u201d, but they do offer enough work-arounds that VB applications can consume C# libraries that make use of these features.<\/b>
Visual Basic 15 brings with it partial implementations of two important C# features: tuples and ref returns. Neither feature is \u201ccomplete\u201d, but they do offer enough work-arounds that VB applications can consume C# libraries that make use of these features.
Tuples
The ability to directly return multiple values from a single function call has long been a requested feature in VB. Although you can get the same result using ByRef parameters, the syntax is clumsy compared to what you see in functional programming languages.
If you aren\u2019t familiar with the term, a \u201ctuple\u201d is just a set of related values. Since. NET 4.0, Visual Basic has had a standard Tuple class , but the user experience has been less than satisfactory. The values have to be manually unpacked from the Tuple using the unhelpful property names Item1, Item2, etc.
Seven years later, VB 15 finally adds syntax support for tuples. Or rather, the ValueTuple structure, which offers better performance than the heap-allocated Tuple object. Here is an example of a TryParse method written using the new style:
Public Function TryParse(s As String) As (Boolean, Integer)
Try
Dim numericValue = Integer. Parse(s)
Return (True, numericValue)
Catch
Return (False, Nothing)
End Try
End Function
Dim result = TryParse(s)
If result. Item1 Then
WriteLine(result. Item2)
End If
In this example, the return type of TryParse is ValueTuple. This makes the function a bit cleaner as you never have to explicitly mention the ValueTuple type. But as you can see, the code that calls it isn\u2019t any different. So let\u2019s improve it a bit by renaming the fields on the return type:
Public Function TryParse(s As String) As (IsInteger As Boolean, Value As Integer)
\u2026
End Function
Dim result = TryParse(s)
If result. IsInteger Then
WriteLine(result. Value)
End If
You can create new tuples with named fields using this syntax:
Dim kvPair = (Key := 5, Value := \u00ab\u00a0Five\u00a0\u00bb)
Unfortunately there isn\u2019t a way to \u201cunpack\u201d a tuple in VB into multiple variables. So translating this C# code into VB requires one line per variable.
var (key, value) = kvPair;
(By)Ref Returns
Ref returns, known as ByRef returns in VB, are severely limited. You can consume C# functions that return a reference (i.e. managed pointer) to a field or array index, but you can\u2019t create your own. Nor can you create local byRef variables.
What you can do is a rather complicated work-around. While again you cannot create local ByRef variables, you can create ByRef parameters. Consider this C# function signature and its VB equivalent:
public ref string FindNext(string startWithString, ref bool found)
ByRef Function FindNext(startWithString as string, ByRef found as Boolean) As String
To use this, Klaus L\u00f6ffelmann tells us that we need a helper function:
Private Function VbByRefHelper(Of t)(ByRef byRefValue As t,
byRefSetter As Func(Of t, t)) As t
Dim orgValue = byRefValue
byRefValue = byRefSetter(byRefValue)
Return orgValue
End Function
You can then pass the result of the ref-returning function as a parameter to the helper function, along with what you want to do with it as an separate anonymous function.
Dim didFind As Boolean
‘Version #2: With a simple generic helper-class:
aSentence = New NewInCS2017. Sentence(\u00ab\u00a0Adrian is going to marry Adriana, because Adrian loves Adriana. \u00ab\u00a0)
Do
VbByRefHelper(aSentence. FindNext(\u00ab\u00a0Adr\u00a0\u00bb, didFind),
Function(stringFound) As String
If stringFound = \u00ab\u00a0Adrian\u00a0\u00bb Then
stringFound = \u00ab\u00a0Klaus\u00a0\u00bb
Return stringFound
End If
Return stringFound
End Function)
Loop While didfind
For reference, this is what it would have looked like had VB fully implemented ref returns:
‘THIS DOES NOT WORK IN VB!!!
Dim aSentence = New Sentence(\u00ab\u00a0Adrian is going to marry Adriana, because Adrian loves Adriana. \u00ab\u00a0)
Dim found = False
Do
‘ !! In C# we can declare a local variable as ref – in VB we cannot.!!
‘ This variable could take the result…
Dim ByRef foundString = aSentence. FindNext(\u00ab\u00a0Adr\u00a0\u00bb, found)
If foundString = \u00ab\u00a0Adrian\u00a0\u00bb Then
‘ but via the reference, so writing would be possible as well,
‘ and we had a neat find and replace!
foundString = \u00ab\u00a0Klaus\u00a0\u00bb
End If
Loop While found
So what happened to \u201cco-evolution\u201d?
The promise of co-evolution and parity between C# and VB was never truly honored. Even when they were still seeing the same features added to both languages, there were several platforms where C# was being offered without VB. Some of the most noteworthy examples include Windows Phone 7,. NET Core, and. NET Standard. We’ve covered this before in Visual Basic: The Road Ahead , but here’s a recap.
According to Mads Torgersen, there has been a major change in the way Microsoft approaches VB. Firstly, Microsoft sees VB more as an entry-level programming language than a professional tool- something that is learned first, but then abandoned for C#:
Visual Basic is used by hundreds of thousands of people. Most are using WinForms to build business applications in Windows, and a few are building websites, overwhelmingly using ASP. NET Web Forms. The majority are also C# users. For many this may simply be because of language requirements of different projects they work on. However, outside of VB\u2019s core scenarios many undoubtedly switch to C# even when VB is supported: the ecosystem, samples and community are often richer and more abundant in C#.
An interesting trend we see in Visual Studio is that VB has twice the share of new developers as it does of all developers. This suggests that VB continues to play a role as a good, approachable entry language for people new to the platform and even to development.
As a result, here is how the new strategy for VB is described as:
We will keep Visual Basic straightforward and approachable. We will do everything necessary to keep it a first class citizen of the. NET ecosystem: When API shapes evolve as a result of new C# features, for instance, consuming those APIs should feel natural in VB. We will keep a focus on the cross-language tooling experience, recognizing that many VB developers also use C#. We will focus innovation on the core scenarios and domains where VB is popular.
Anthony Green adds some more detail on the shift in strategy. You should read the full text, but briefly summarized they are:
Green writes:
A worthwhile observation is that, contrary to how customers often think of the causal relationship between them, the investments we make aren\u2019t the force pushing the languages in these new arenas. The arenas are the forces pulling on them and the investments are responses. It\u2019s not \u201cif you just pushed Visual Basic harder on Linux it would be a huge player there\u201d but \u201cGee, they really want C# on Linux, let\u2019s make it easier for them\u201d.<\/p>\n