• Saves Valuable Time
  • Trusted Accuracy since 2004
  • 15-Day Money-Back Guarantee

VB.NET and C# Equivalents


Equivalents were produced with Instant C# and Instant VB.      


VB.NET C#
Public MustInherit Class AbstractClass
    Protected MustOverride Sub AbstractMethod()
End Class
public abstract class AbstractClass
{
    protected abstract void AbstractMethod();
}
VB.NET C#
Public
Private
Friend
Protected
Protected Friend
public
private
internal
protected
protected internal

Unsized Array

VB.NET C#
Dim myArray() As Integer int[] myArray = null;

Sized Array

VB.NET C#
Dim myArray(1) As Integer int[] myArray = new int[2];

Access Array Element

VB.NET C#
x = myArray(0) x = myArray[0];

Jagged Array

VB.NET C#
Dim myArray(1)() As Integer int[][] myArray = new int[2][];

Rectangular Array

VB.NET C#
Dim myArray(1, 2) As Integer int[,] myArray = new int[2, 3];

Resizing Array

VB.NET C#
ReDim Preserve myArray(newSize)
ReDim myArray(newSize)
System.Array.Resize(ref myArray, newSize + 1);
myArray = new foo[newSize + 1];

Initializing Array

VB.NET C#
myArray = New Integer(1) {1,2} myArray = new int[2] {1, 2};

Empty Array

VB.NET C#
Dim myArray As String() = New String() {} string[] myArray = new string[0];

Class Attribute

VB.NET C#
<Serializable()>
Public Class Foo
[Serializable()]
public class Foo

Method Attribute

VB.NET C#
<DebuggerHidden()>
Public Sub Method()
[System.Diagnostics.DebuggerHidden()]
public void Method()

Method Return Type Attribute

VB.NET C#
Public Function Method() As <ReturnAttribute> Integer [return: ReturnAttribute]
public int TestReturnValueAttribute()

Method Parameter Attribute

VB.NET C#
Public Sub Method(<ParamAttribute> ByVal x As Integer) public void Method([ParamAttribute] int x)

Named Properties in Attributes

Attributes have a special syntax which allows setting properties of the attribute type after the attribute constructor arguments - called named properties. These have the same syntax as named arguments in VB, but not in C#. Note that in the following example, 'property1' and 'property2' are named properties, not named arguments - the attribute type constructor for this example would only have one parameter, not three. Named arguments are not available for attributes.

VB.NET C#
'note: property1 and property2 are named properties:
<FooAttribute(arg, property1:=1, property2:=2)>
Public Class Foo
End Class
//note: property1 and property2 are named properties:
[FooAttribute(arg, property1=1, property2=2)]
public class Foo
{
}

AutoEventWireup is an ASP.NET page attribute that will allow automatic wireup of page events when this attribute is set to true on the page.  The AutoEventWireup page attribute leads to the following options for the associated VB and C# code-behind class:

AutoEventWireup = true

This allows specifying Page_Load, Page_Init, etc. event handler methods by name alone.  In VB, no Handles clause is appended and in C# no event wireup code is required.  Provided the method name matches, the methods will automatically handle the associated events.  If you do erroneously code any event wireup code, this will cause the event handler to execute twice.

AutoEventWireup = false

This requires that you code the event handler wireup.  In VB, you would specify a Handles clause and in C# you would include code to subscribe to the events.  However, in C# the problem is that the first page event occurs before the event wireup code has a chance to execute.  A common C# approach in this case is to override the base class OnLoad, OnInit, etc. methods, dispensing with the need to have event handler wireup code for the page events.  For these cases (Handles used instead of setting AutoEventWireup to true), Instant C# automatically adds event wireups corresponding to all 'Page' methods where a Handles clause is used to the Page_Init or OnInit method if it exists.  If no Page_Init or OnInit method exists, a new OnInit method is added.  The event wireup for the Page_Init method is added to the class constructor - if no constructor exists, then a constructor is added by Instant C#.

VB.NET C#
Sub Method1(ByRef myParam As Integer)
End Sub

Sub Method2
    Method1(foo)
End Sub
void Method1(ref int myParam)
{
}

void Method2()
{
    Method2(ref foo);   //'ref' is required in the method call also
}

The closest equivalent to the standard VB casting operators (CType and the corresponding CInt, CStr, etc.) are calls to the System.Convert methods if the appropriate method exists, otherwise they are converted to the standard C# casting operator.

The behavior of both the System.Convert methods and the standard C# casting operator are subtly different from the VB casting operators though, so you should always test the behavior of your converted code.

The C# equivalent to VB's 'DirectCast' is the standard C# casting operator.

The VB 'TryCast' operator always converts to the C# 'as' operator. The C# 'as' operator converts to the VB 'TryCast' operator, except for the case of nullable types, in which case you must use the 'CType' operator.

VB.NET C#


x = CBool(y)
x = CInt(y)
x = CDec(y)
x = CChar(y)
x = CStr(y)
x = CDate(y)
x = CObj(y)

x = CType(y, Foo)
x = DirectCast(y, Foo)
x = TryCast(y, Foo)
using System;

x = Convert.ToBoolean(y);
x = Convert.ToInt32(y);
x = Convert.ToDecimal(y);
x = Convert.ToChar(y);
x = Convert.ToString(y);
x = Convert.ToDateTime(y);
x = (object)y;

x = (Foo)y;
x = (Foo)y;
x = y as Foo;

A further complication is that C# integer casts always truncate, while the VB integer conversion operators always round. For this reason, in order to achieve the same results as the C# casts, a call to the .NET Math.Truncate function is required prior to the call to the CInt, CLng, and CShort operators when converting C# integer casts.

C# VB.NET
i = (int)someDouble; i = CInt(Math.Truncate(someDouble))

In VB, the keyword 'From' is used to initialize collections during construction.

VB.NET C#
'lists:
Dim myList As New List(Of Integer)() From {1, 2, 3}

'dictionaries:
Dim myD As New Dictionary(Of String, Integer) From {
    {string1, 80},
    {string2, 85}
}
//lists:
List<int> myList = new List<int>() {1, 2, 3};

//dictionaries:
Dictionary<string, int> myD = new Dictionary<string, int>() {
    {string1, 80},
    {string2, 85}
};

Unlike VB's #Const, C# #define's cannot set values - they always specify 'true'.

VB.NET C#
#Const ONE = True
#Const TWO = 2

#If ONE Then
    'code for condition ONE
#ElseIf TWO Then
    'code for condition TWO
#Else
    'code for other cases
#End If
#define ONE
//#Const TWO = 2 - no C# equivalent

#if ONE
    //code for condition ONE
#elif TWO
    //code for condition TWO
#else
    //code for other cases
#endif

Local Constant

VB.NET C#
Const myConst As Integer = 2 const int myConst = 2;

Local Variable

VB.NET C#
Dim myVar As Integer = 2 int myVar = 2;

Inferred Types

VB.NET C#
Option Infer On
...
Dim myVar = 2
var myVar = 2;

Shared/Static Field

VB.NET C#
Public Shared S As Integer public static int S;

Read-Only Field

VB.NET C#
Public ReadOnly R As Integer = 2 public readonly int R = 2;

VB Static Local Variable

VB.NET C# (no direct equivalent)
Sub Method()
    Static s As Integer
    s += 1
End Sub
private int Method_s;
void Method()
{
    Method_s += 1;
}
VB.NET C#
Class Foo
    Public Sub New()
        Me.New(0)   'call to other constructor
    End Sub

    Public Sub New(ByVal i As Integer)
    End Sub

    Protected Overrides Sub Finalize()
    End Sub
End Class
class Foo
{
    public Foo() : this(0)   //call to other constructor
    {
    }

    public Foo(int i)
    {
    }

    ~Foo()
    {
    }
}
VB.NET C#
Integer
Boolean
String
Char
Single
Double
Date
Object
Decimal
Short
Long
Byte
SByte
UShort
UInteger
ULong
int
bool
string
char
float
double
System.DateTime (no C# language type)
object
decimal
short
long
byte
sbyte
ushort
uint
ulong
VB.NET C#
Public Delegate Sub FooDelegate() public delegate void FooDelegate();

Implicitly-Typed Enum

VB.NET C#
Public Enum FormMode
    EditMode
    NewMode
End Enum
public enum FormMode
{
    EditMode,
    NewMode
}

Explicitly-Typed Enum

VB.NET C#
Public Enum FormMode As Byte
    EditMode
    NewMode
End Enum
public enum FormMode : byte
{
    EditMode,
    NewMode
}

Event Declarations

VB.NET C#
Public Event EventOne(ByVal p As Foo) 'implicit delegate

Public Event EventTwo As FooDelegate 'explicit delegate
public delegate void EventOneEventHandler(Foo p);
public event EventOneEventHandler EventOne;

public event FooDelegate EventTwo;

Event Wireups

VB.NET C#
AddHandler ControlA.Click, New ControlA.SomeEventHandler(AddressOf ControlA_Click)

AddHandler ControlA.Click, AddressOf ControlA_Click
ControlA.Click += new ControlA.SomeEventHandler(ControlA_Click);

ControlA.Click += ControlA_Click;

Strict Conversion of WithEvents/Handles

VB.NET C#
Class TestClass
    Private WithEvents MyField As FooDelegate

    Sub Method() Handles MyField.FooEvent
    End Sub
End Class
using System.Runtime.CompilerServices;
using System.Diagnostics;

class TestClass
{
    [AccessedThroughProperty(nameof(MyField))]
    private FooDelegate _MyField;
    private FooDelegate MyField
    {
        [DebuggerNonUserCode]
        get
        {
            return _MyField;
        }
        [MethodImpl(MethodImplOptions.Synchronized), DebuggerNonUserCode]
        set
        {
            if (_MyField != null)
                _MyField.FooEvent -= Method;

            _MyField = value;

            if (value != null)
                _MyField.FooEvent += Method;
        }
    }

    void Method()
    {
    }
}

Casual Conversion of WithEvents/Handles

VB.NET C#
Class TestClass
    Private WithEvents MyField As FooDelegate

    Sub Method() Handles MyField.FooEvent
    End Sub
End Class
class TestClass
{
    private FooDelegate MyField;

    void Method()
    {
    }

    public TestClass()
    {
        SubscribeToEvents();
    }

    private bool EventsSubscribed = false;
    private void SubscribeToEvents()
    {
        if (EventsSubscribed)
            return;
        else
            EventsSubscribed = true;

        MyField.FooEvent += Method;
    }
}
VB.NET C#
Try
    ...
Catch x As FooException
    ...
Catch y As BarException When z = 1
    ...
Finally
    ...
End Try
try
{
    ...
}
catch (FooException x)
{
    ...
}
catch (BarException y) when (z == 1)
{
    ...
}
finally
{
    ...
}

VB extension methods are declared in modules and use the 'Extension' attribute, while C# extension methods are declared in static classes and use the 'this' keyword on the first parameter.

VB.NET C#
Public Module Foo
    <System.Runtime.CompilerServices.Extension> _
    Sub Extension(ByVal myParam As String)
        '...
    End Sub
End Module
public static class Foo
    void Extension(this string myParam)
    {
        //...
    }
}

Creating a List

VB.NET C#
Dim myVar As New List(Of Integer) List<int> myVar = new List<int>();

Creating a Dictionary

VB.NET C#
Dim myVar As New Dictionary(Of String, Integer) Dictionary<string, int> myVar = new Dictionary<string, int>();

Defining a Generic Class

VB.NET C#
Public Class GenericClass (Of T)
End Class
public class GenericClass<T>
{
}

Defining a Generic Class with a Constraint

VB.NET C#
Public Class GenericClass (Of T As SomeBase)
End Class
public class GenericClass<T> where T: SomeBase
{
}

Defining a Generic Class with a 'new' Constraint

VB.NET C#
Public Class GenericClass (Of T As New)
End Class
public class GenericClass<T> where T: new()
{
}

Defining a Generic Method

VB.NET C#
Public Function Compare(Of T)(param1 As T, param2 As T) As Integer
End Function
public int Compare<T>(T param1, T param2)
{
}

Defining a Generic Method with a Constraint

VB.NET C#
Sub Swap(Of T As Class)(ByRef l As T, ByRef r As T)
End Sub
void Swap<T>(ref T l, ref T r) where T: class
{
}
VB.NET C#
Imports Foo
Imports Foo.Bar   ''Bar' is a type

'namespace alias:
Imports foo = SomeNamespace
'type alias:
Imports bar = SomeNamespace.SomeType
using Foo;
using static Foo.Bar;   //'Bar' is a type

//namespace alias:
using foo = SomeNamespace;
//type alias:
using bar = SomeNamespace.SomeType;

Basic Inheritance

VB.NET C#
Class Foo
    Inherits SomeBase

End Class
class Foo : SomeBase
{
}

Inheritance Keywords

VB.NET C#
MustInherit    (class)
MustOverride    (method)
Overrides    (method)
NotInheritable    (class)
NotOverridable    (method)
Shadows    (member)
abstract    (class)
abstract    (method)
override    (method)
sealed    (class)
sealed    (method)
new    (member)

Defining Interfaces

VB.NET C#
Public Interface IFoo
    Sub Method()
End Interface
public interface IFoo
{
    void Method();
}

Implementing Interfaces

VB.NET C#
Public Class Foo
    Implements IFoo

    Public Sub Method() Implements IFoo.Method
    End Sub
End Class

*note that you can use a method name which does not match the interface method name, provided that the 'Implements' name matches
//implicit implementation:
public class Foo : IFoo
{
    public void Method()
    {
    }
}

or:

//explicit implementation:
public class Foo : IFoo
{
    void IFoo.Method()
    {
    }
}

Expression Lambda

VB.NET C#
myVar = Function(text As String) text.Length myVar = (string text) => text.Length;

Multi-statement Lambda

VB.NET C#
myVar = Function(text As String)
    Return text.Length
End Function
myVar = (string text) =>
{
    return text.Length;
}

Event Wireup with Lambda

VB.NET C#
AddHandler button.Click, Sub(src, e) Log(src, e) button.Click += (src, e) => Log(src, e);

VB uses the 'CreateObject' function to acquire a type instance at run-time where the type is unknown at compile time. VB then allows invoking members of this instance even though the type is unknown at compile time (this requires the VB Option Strict setting to be turned off). C# allows the same behavior via the 'dynamic' keyword and a call to System.Activator.CreateInstance:

VB.NET C#
Option Strict Off
...
Dim o As Object = CreateObject(progID)
o.Foo() 'late-bound call to 'Foo' method
dynamic o = System.Activator.CreateInstance(System.Type.GetTypeFromProgID(progID));
o.Foo(); //late-bound call to 'Foo' method
VB.NET C#
Dim payingCustomers = From c In db.Customers
        Where c.Orders.Count > 0
        Select c.Email, c.Name
var payingCustomers = from c in db.Customers
        where c.Orders.Count > 0
        select new {c.Email, c.Name};

For Loop

VB.NET C#
For i As Integer = 1 To 9
Next i
for (int i = 1; i <= 9; i++)
{
}

For Each Loop

VB.NET C#
For Each s As String In StringList
Next s
foreach (string s in StringList)
{
}

While Loop

VB.NET C#
Do While condition
Loop

or:

While condition
End While
while (condition)
{
}

Do While Loop

VB.NET C#
Do
Loop While condition
do
{
} while (condition);

Loop Until

VB.NET C# (no specific 'loop until' construct)
Do
Loop Until condition
do
{
} while ( ! condition);

Do Until

VB.NET C# (no specific 'do until' construct)
Do Until condition
Loop
while ( ! condition)
{
}
VB.NET C#
Public Module Utility
    Public Sub UtilityMethod()
        ...
    End Sub
End Module

or:

Public NotInheritable Class Utility
    Private Sub New() 'prevent instantiation
    End Sub

    Public Shared Sub UtilityMethod()
        ...
    End Sub
End Class
public static class Utility
{
    public static void UtilityMethod()
    {
        ...
    }
}
VB.NET (2015 multiline string) C# (verbatim string)
Dim myVar = "first line
    second line"
var myVar = @"first line
    second line";

Inequality tests in VB using the '<>' operator involving nullable types (System.Nullable with a struct type parameter) behave very differently from the same tests in C# using the '!=' operator. In VB, if the nullable value is 'Nothing', then the conditional always evaluates to 'Nothing', which has the same effect as the conditional being 'False'. In C#, if the nullable value is 'null', then the conditional evaluates to 'true' when comparing to a non-null value.

The root of the inconsistency between VB and C# is that the '==' and '!=' operators are interpreted in C# exactly as if you were calling the System.Nullable 'Equals' method, while the VB '=' and '<>' operators are not, instead relying on the unusual VB language rules. To get the expected conditional results, the correct VB approach would be to use the System.Nullable 'Equals' method.

VB C#
Dim nullInt As Integer? = Nothing
If nullInt <> 0 Then
   'statement doesn't execute!
   MessageBox.Show("not equal")
End If
int? nullInt = null;
if (nullInt != 0)
   //statement executes as expected
   MessageBox.Show("not equal");

The following C# reproduces the VB behavior:

C#
int? nullInt = null;
if (nullInt.HasValue && nullInt != 0)
   //statement doesn't execute
   MessageBox.Show("not equal");

The following VB is a better approach and is equivalent to our original C# code:

VB C#
Dim nullInt As Integer? = Nothing
If Not nullInt.Equals(0) Then
   'statement executes as expected
   MessageBox.Show("not equal")
End If
int? nullInt = null;
if (nullInt != 0)
   //statement executes as expected
   MessageBox.Show("not equal");

Note that you can call a method on a 'null' System.Nullable instance without throwing an exception since nullable instances are never null like reference types are null. Instead, they are generic value types with no value set.

Named Type Object Initializer

VB.NET C#
Dim myVar = New Person() With
{
    .Name = s1,
    .Surname = s2
}
var myVar = new Person()
{
    Name = s1,
    Surname = s2
};

Anonymous Type Object Initializer

VB.NET C#
Dim myVar = New With
{
   .Name = x,
   .Surname = y
}
var myVar = new
{
   Name = x,
   Surname = y
};
VB.NET C#
Public Shared Operator *(ByVal X As SomeType, ByVal Y As SomeType) As Long
    '...
End Operator

Public Shared Narrowing Operator CType(ByVal X As SomeType) As SomeOtherType
    '...
End Operator

Public Shared Widening Operator CType(ByVal X As SomeOtherType) As SomeType
    '...
End Operator
public static long operator * (SomeType X, SomeType Y)
{
    //...
}

public static explicit operator SomeOtherType(SomeType X)
{
    //...
}

public static implicit operator SomeType(SomeOtherType X)
{
    //...
}
VB.NET C#
+, -, *, >, >=, <, <=, <<, >>
&    (string concatenation)
()    (indexing)
And
Or
AndAlso
OrElse
Not
Xor
Mod
x ^ y
=
Is
IsNot
<>

If(x, y, z)
If(x, y)

x / y    (where x and y are integers)
x / y    (where x and y are doubles)
x \ y    (where x and y are integers)
x \ y    (where x and y are doubles)
unchanged
+    (string concatenation)
[]
&
|
&&
||
! or ~    (depending on context)
^
%
Math.Pow(x, y)    (no exponentiation operator)
= or ==    (depending on context)
==
!=
!=

x ? y : z
x ?? y

x / (double)y
x / y
x / y
Convert.ToInt32(x) / Convert.ToInt32(y)

Optional Parameters

VB.NET C#
Sub Method(p1 As Integer, Optional p2 As Integer = 0) public void Method(int p1, int p2 = 0)

Named Arguments

VB.NET C#
Method(p1 := 2, p2 := 3) Method(p1 : 2, p2 : 3)
VB.NET C#
Sub Method(ParamArray myParam As Object())
End Sub
void Method(params object[] myParam)
{
}

Property

VB.NET C#
Property MyProperty() As Integer
    Get
        Return field
    End Get
    Set (ByVal var As Integer)
        field = var
    End Set
End Property
public int MyProperty
{
    get
    {
        return field;
    }
    set
    {
        field = value;
    }
}

Indexer

VB.NET C#
Private field() As Integer

Public Default Property Item(ByVal index As Integer) As Integer
    Get
        Return field(index)
    End Get
    Set(ByVal value As Integer)
        field(index) = value
    End Set
End Property
private int[] field

public int this[int index]
{
    get
    {
        return field[index];
    }
    set
    {
        field[index] = value;
    }
}

Parameterized Property

VB.NET C# (no direct equivalent)
Public Property ParameterizedProperty(ByVal i As Integer) As Integer
    Get
        Return GetFoo(i)
    End Get
    Set(value As Integer)
        SetFoo(i, value)
    End Set
End Property
public int ParameterizedProperty(int i)
{
    return GetFoo(i);
}
public void set_ParameterizedProperty(int i, int value)
{
    SetFoo(i, value);
}

For simple cases, VB's Select construct can be converted to the C# switch construct.  However, if any of the Case statements include range or non-constant expressions, then the equivalent is an if/else block.

VB C#
'converts to switch:
Select Case x
    Case 0
        ...
    Case 1
        ...
End Select

'converts to if/else:
Select Case x
    Case 1 To 3
        ...
    Case Is < 10, Is > 20, Is = 15
        ...
End Select
//converts to switch:
switch (x)
{
    case 0:
        //...
        break;
    case 1:
        //...
        break;
}

//converts to if/else:
if (x >= 1 && x <= 3)
{
    ...
}
else if ((x < 10) || (x > 20) || (x == 15))
{
    ...
}
VB.NET C#
SyncLock x
    ...
End SyncLock
lock (x)
{
    ...
}
VB.NET C#
Public Function TupleReturningMethod1() As (first As String, middle As String, last As String)
    '... retrieve first, middle and last
    Return (first, middle, last)
End Function

'option to not assign names to tuple fields:
Public Function TupleReturningMethod2() As (String, String, String)
    '... retrieve first, middle and last
    Return (first, middle, last)
End Function

Public Sub CallTupleMethods()
    'assign the tuple to an implicitly-type variable:
    Dim names = TupleReturningMethod1()
    'can reference different parts of tuple via 'Item1', 'Item2', etc.
    Foo(names.Item1, names.Item3)
    'can reference different parts via names provided in tuple header:
    Foo(names.first, names.last)

    'assign the tuple to an explicitly-typed variable:
    Dim tuple As (first1 As String, middle1 As String, last1 As String) = TupleReturningMethod1()
End Sub
public (string first, string middle, string last) TupleReturningMethod1()
{
    //... retrieve first, middle and last
    return (first, middle, last);
}

//option to not assign names to tuple fields:
public (string, string, string) TupleReturningMethod2()
{
    //... retrieve first, middle and last
    return (first, middle, last);
}

public void CallTupleMethods()
{
    //assign the tuple to an implicitly-type variable:
    var names = TupleReturningMethod1();
    //can reference different parts of tuple via 'Item1', 'Item2', etc.
    Foo(names.Item1, names.Item3);
    //can reference different parts via names provided in tuple header:
    Foo(names.first, names.last);

    //assign the tuple to an explicitly-typed variable:
    (string first1, string middle1, string last1) tuple = TupleReturningMethod1();
}
VB.NET C#
x = TypeOf y Is z
v = GetType(w)
x = y is z;
v = typeof(w);

VB has two ways of declaring access to an unmanaged dll - the legacy 'Declare' syntax and the modern DllImport syntax (which is also used by C#).

VB.NET C#
'legacy syntax:
Public Declare Function APIFunction Lib "kernel32"(ByRef x As String) As Integer

'modern syntax:
Imports System.Runtime.InteropServices

<DllImport("kernel32")>
Public Shared Function APIFunction(ByRef x As String) As Integer
End Function
using System.Runtime.InteropServices;

[DllImport("kernel32")]
public static extern int APIFunction(ref string x);

VB 'Collection' is a strange beast in that it allows treating the collection alternately as a keyed list or positional list so a single .NET collection will not capture everything. Also, it's 1-based, unlike nearly all other collections.

The following helper class is used by Instant C# to replicate the behavior of the VB Collection class. Note that it's intended as a drop-in replacement so it uses 1-based parameters. The replacement collection is made generic as an improvement - replace 'Collection' with 'Collection<object>' for the exact VB equivalent, but you should specify the actual type even though you don't do this in VB.

//----------------------------------------------------------------------------------------
// Copyright © 2003 - 2021 Tangible Software Solutions, Inc.
// This class can be used by anyone provided that the copyright notice remains intact.
//
// This class replicates the behavior of the VB Collection class.
//----------------------------------------------------------------------------------------
using System.Collections.Generic;
using System;

public class Collection<T>
{
    private List<T> objects = new List<T>();
    private List<string> keys = new List<string>();

    public void Add(T newObject, string key = null, object before = null, object after = null)
    {
        if (after != null)
        {
            if (after as string != null)
                Insert(newObject, keys.IndexOf(after as string) + 1, key);
            else
                Insert(newObject, (int)after, key);
        }
        else if (before != null)
        {
            if (before as string != null)
                Insert(newObject, keys.IndexOf(before as string), key);
            else
                Insert(newObject, (int)before - 1, key);
        }
        else
            Insert(newObject, objects.Count, key);
    }

    private void Insert(T newObject, int index, string key)
    {
        objects.Insert(index, newObject);
        keys.Insert(index, key);
    }

    public void Clear()
    {
        objects.Clear();
        keys.Clear();
    }

    public bool Contains(string key)
    {
        return keys.Contains(key);
    }

    public int Count
    {
        get
        {
            return objects.Count;
        }
    }

    public void Remove(string key)
    {
        RemoveAt(keys.IndexOf(key));
    }

    public void Remove(int positionOneBased)
    {
        RemoveAt(positionOneBased - 1);
    }

    private void RemoveAt(int index)
    {
        objects.RemoveAt(index);
        keys.RemoveAt(index);
    }

    public T this[int positionOneBased]
    {
        get
        {
            return objects[positionOneBased - 1];
        }
    }

    public T this[string key]
    {
        get
        {
            return objects[keys.IndexOf(key)];
        }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return objects.GetEnumerator();
    }
}

Instant C# converts calls to the legacy VB DateDiff function and IsDate function via the following helper class inserted into the conversion output:

//----------------------------------------------------------------------------------------
// Copyright © 2003 - 2021 Tangible Software Solutions, Inc.
// This class can be used by anyone provided that the copyright notice remains intact.
//
// The methods in this class replicate the behavior of IsDate and DateDiff.
//----------------------------------------------------------------------------------------
using System;
using System.Globalization;

public static class DateHelper
{
    public static bool IsDate(object expression)
    {
        if (expression == null)
            return false;

        DateTime testDate;
        return DateTime.TryParse(expression.ToString(), out testDate);
    }

    public enum DateInterval
    {
        Day,
        DayOfYear,
        Hour,
        Minute,
        Month,
        Quarter,
        Second,
        Weekday,
        WeekOfYear,
        Year
    }

    public static long DateDiff(DateInterval intervalType, DateTime dateOne, DateTime dateTwo)
    {
        switch (intervalType)
        {
            case DateInterval.Day:
            case DateInterval.DayOfYear:
                TimeSpan spanForDays = dateTwo - dateOne;
                return (long)spanForDays.TotalDays;
            case DateInterval.Hour:
                TimeSpan spanForHours = dateTwo - dateOne;
                return (long)spanForHours.TotalHours;
            case DateInterval.Minute:
                TimeSpan spanForMinutes = dateTwo - dateOne;
                return (long)spanForMinutes.TotalMinutes;
            case DateInterval.Month:
                return ((dateTwo.Year - dateOne.Year) * 12) + (dateTwo.Month - dateOne.Month);
            case DateInterval.Quarter:
                long dateOneQuarter = (long)Math.Ceiling(dateOne.Month / 3.0);
                long dateTwoQuarter = (long)Math.Ceiling(dateTwo.Month / 3.0);
                return (4 * (dateTwo.Year - dateOne.Year)) + dateTwoQuarter - dateOneQuarter;
            case DateInterval.Second:
                TimeSpan spanForSeconds = dateTwo - dateOne;
                return (long)spanForSeconds.TotalSeconds;
            case DateInterval.Weekday:
                TimeSpan spanForWeekdays = dateTwo - dateOne;
                return (long)(spanForWeekdays.TotalDays / 7.0);
            case DateInterval.WeekOfYear:
                DateTime dateOneModified = dateOne;
                DateTime dateTwoModified = dateTwo;
                while (dateTwoModified.DayOfWeek != DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek)
                {
                    dateTwoModified = dateTwoModified.AddDays(-1);
                }
                while (dateOneModified.DayOfWeek != DateTimeFormatInfo.CurrentInfo.FirstDayOfWeek)
                {
                    dateOneModified = dateOneModified.AddDays(-1);
                }
                TimeSpan spanForWeekOfYear = dateTwoModified - dateOneModified;
                return (long)(spanForWeekOfYear.TotalDays / 7.0);
            case DateInterval.Year:
                return dateTwo.Year - dateOne.Year;
            default:
                return 0;
        }
    }
}

Only simple cases of VB legacy error handling can be converted to C#.

VB.NET C#
Public Sub LegacyErrorHandling()

    On Error GoTo ErrorHandler
    '... main logic

ErrorHandler:
    '... error handling code
End Sub
public void LegacyErrorHandling()
{
    try
    {
        //... main logic
    }
    catch
    {
        //... error handling code
    }
}

Instant C# converts calls to the legacy VB IsNumeric and Val functions via the following helper class inserted into the conversion output:

//----------------------------------------------------------------------------------------
// Copyright © 2003 - 2021 Tangible Software Solutions, Inc.
// This class can be used by anyone provided that the copyright notice remains intact.
//
// The methods in this class replicate the behavior of IsNumeric and Val.
//----------------------------------------------------------------------------------------
using System;
using System.Globalization;

public static class NumericHelper
{
    public static bool IsNumeric(object expression)
    {
        if (expression == null)
            return false;

        double testDouble;
        if (expression is string)
        {
            CultureInfo provider;
            if (((string)expression).StartsWith("$"))
                provider = new CultureInfo("en-US");
            else
                provider = CultureInfo.InvariantCulture;

            if (double.TryParse((string)expression, NumberStyles.Any, provider, out testDouble))
                return true;
        }
        else
        {
            if (double.TryParse(expression.ToString(), out testDouble))
                return true;
        }

        //VB's 'IsNumeric' returns true for any boolean value:
        bool testBool;
        if (bool.TryParse(expression.ToString(), out testBool))
            return true;

        return false;
    }

    public static double Val(string expression)
    {
        if (expression == null)
            return 0;

        //try the entire string, then progressively smaller substrings to replicate the behavior of VB's 'Val', which ignores trailing characters after a recognizable value:
        for (int size = expression.Length; size > 0; size--)
        {
            double testDouble;
            if (double.TryParse(expression.Substring(0, size), out testDouble))
                return testDouble;
        }

        //no value is recognized, so return 0:
        return 0;
    }

    public static double Val(object expression)
    {
        if (expression == null)
            return 0;

        double testDouble;
        if (double.TryParse(expression.ToString(), out testDouble))
            return testDouble;

        //VB's 'Val' function returns -1 for 'true':
        bool testBool;
        if (bool.TryParse(expression.ToString(), out testBool))
            return testBool ? -1 : 0;

        //VB's 'Val' function returns the day of the month for dates:
        DateTime testDate;
        if (DateTime.TryParse(expression.ToString(), out testDate))
            return testDate.Day;

        //no value is recognized, so return 0:
        return 0;
    }

    public static int Val(char expression)
    {
        int testInt;
        if (int.TryParse(expression.ToString(), out testInt))
            return testInt;
        else
            return 0;
    }
}

Instant C# converts calls to the legacy VB Mid statement (unrelated to the Mid function) via the following helper class inserted into the conversion output:

//----------------------------------------------------------------------------------------
// Copyright © 2003 - 2021 Tangible Software Solutions, Inc.
// This class can be used by anyone provided that the copyright notice remains intact.
//
// The methods in this class replicate the behavior of miscellaneous VB features.
//----------------------------------------------------------------------------------------
using System;

public static class ConversionHelper
{
    public static void MidStatement(ref string target, int oneBasedStart, char insert)
    {
        //These 'MidStatement' method overloads replicate the behavior of the VB 'Mid' statement (which is unrelated to the VB 'Mid' function)

        if (target == null)
            return;

        target = target.Remove(oneBasedStart - 1, 1).Insert(oneBasedStart - 1, insert.ToString());
    }

    public static void MidStatement(ref string target, int oneBasedStart, string insert)
    {
        //These 'MidStatement' method overloads replicate the behavior of the VB 'Mid' statement (which is unrelated to the VB 'Mid' function)

        if (target == null || insert == null)
            return;

        target = target.PadRight(target.Length + insert.Length).Remove(oneBasedStart - 1, insert.Length).Insert(oneBasedStart - 1, insert).Substring(0, target.Length);
    }

    public static void MidStatement(ref string target, int oneBasedStart, string insert, int length)
    {
        //These 'MidStatement' method overloads replicate the behavior of the VB 'Mid' statement (which is unrelated to the VB 'Mid' function)

        if (target == null || insert == null)
            return;

        int minLength = Math.Min(insert.Length, length);
        target = target.PadRight(target.Length + insert.Length).Remove(oneBasedStart - 1, minLength).Insert(oneBasedStart - 1, insert.Substring(0, minLength)).Substring(0, target.Length);
    }

    //... more helper methods
}

VB.NET C# (omitting null handling)
LCase(x)
UCase(x)
Left(x, 2)
Right(x, 2)
Trim(x)
LTrim(x)
RTrim(x)
Mid(x, 3)
InStr(x, y)
InStrRev(x, y)
x.ToLower()
x.ToUpper()
x.Substring(0, 2)
x.Substring(x.Length - 2)
x.Trim(' ')
x.TrimStart(' ')
x.TrimEnd(' ')
x.Substring(2)
x.IndexOf(y) + 1
x.LastIndexOf(y) + 1
VB.NET C#
Dim myIntegerVar%
Dim myStringVar$
Dim myFloatVar!
Dim myDoubleVar#
int myIntegerVar = 0;
string myStringVar = null;
float myFloatVar = 0;
double myDoubleVar = 0;

Copyright © 2004 – 2021 Tangible Software Solutions, Inc.