C To Vb.net

VB/C# .Net Code Converter is a free and simple VB to C# and C# to VB code converter. This online tool allows you to convert entire class code or selected section of code snippets.

Bookmark:

• VB.NET forum discussion. ICSharp ZIP library C# to VB.NET Port by Garry Wang (6 replies) Printing with formatting in VB.NET by jclebon (7 replies) IP2Location Geolocation.NET Component in VB.NET by dunking (5 replies) Watching Folder Activity in VB.NET by emmaddai (17 replies) print a document file without using print dialog control in Vb.net.
• Adds context menu items to convert projects/files between VB.NET and C#. See the wiki documentation for help using it. Download from Visual Studio Marketplace (Requires VS 2017 15.7+) Flexible: Convert a small selection, or a whole solution in one go, in either direction.

C#5.0 Hi Is there any free tool available in on-line or offline (exe format install in local machine) to convert whole project form C# to vb.net,no need single page convector,need full project,may be browser project folder or project zip file and output project save in one folder.

This online code conversion tool powered by open source NRefactory library. NRefactory is a powerful C# to VB and VB to C# conversion engine maintained by the developers at SharpDevelop. By default, NRefactory may requires that all code be properly wrapped in a class and (as necessary) method before converting.

Features of Visual Basic .NET not found in C#

• Variables can be declared using the WithEvents construct. This construct is available so that a programmer may select an object from the Class Name drop down list and then select a method from the Declarations drop down list to have the Method signature automatically inserted
• Auto-wireup of events, VB.NET has the Handles syntax for events
• Marshalling an object for multiple actions using an unqualified dot reference. This is done using the With ... End With structure
• IsNumeric evaluates whether a string can be cast into a numeric value (the equivalent for C# requires using int.TryParse)
• XML Literals
• Inline date declarations by using #1/1/2000# syntax (M/dd/yyyy).
• Module (although C#'s sealed static classes with additional semantics, but each field has to individually be declared as static)
• Members of Modules imported to the current file, can be access with no preceeding container accessor (See Now for example)
• The My namespace
• Visual Studio's design-time experience is more responsive in the VB.NET language
• COM components and interoperability is more powerful in VB.NET as the Object type is bound at runtime
• Namespaces can be important in project level, so they don't have to be imported to each individual file, like C#
• Root namespace, in VB.NET projets, you can set the assembly root namespace which the whole project is wrapped with it, and you don't have to declare the namespace for each container.

Features of C# not found in Visual Basic .NET

• Allows blocks of unsafe code (like C++/CLI) via the unsafe keyword.
• Partial Interfaces
• Iterators and the yield keyword
• Multi-line comments (note that the Visual Studio IDE supports multi-line commenting for Visual Basic .NET)
• Static classes (Classes which cannot contain any non-static members, although VB's Modules are essentially sealed static classes with additional semantics)
• Can use checked and unchecked contexts for fine-grained control of overflow/underflow checking

Other characteristics of Visual Basic .NET not applicable to C#

• Conversion of Boolean value True to Integer may yield -1 or 1 depending on the conversion used
• Assigning and comparing variables uses the same token, =. Whereas C# has separate tokens, for comparison and = to assign a value
• VB.NET is not case-sensitive.
• Type checking is less strict by default. If the default is left in place, It will auto convert type without notifying programmer
• Val() function which also parses a null value while converting into double (In c# Convert.ToDouble() is used to convert any object into double type value, but which throws exception in case of a null value)
• CInt, CStr, CByte and a wide variety of converting functions built in the language

Other characteristics of C# not applicable to Visual Basic .NET

• By default, numeric operations are not checked. This results in slightly faster code, at the risk that numeric overflows will not be detected. However, the programmer can place arithmetic operations into a checked context to activate overflow checking. (It can be done in Visual Basic by checking an option)
• Addition and string concatenation use the same token, +. Visual Basic .NET, however, has separate tokens, + for addition and & for concatenation, although + can be used for concatenation as well.
• In Visual Basic .NET property methods may take parameters
• C# is case-sensitive.

External Resources:

Equivalents were produced with Instant C# and Instant VB.

Unsized Array

Sized Array

Access Array Element

C# To Vb.net Format

Jagged Array

Rectangular Array

Resizing Array

C# To Vb.net Login

Initializing Array

Empty Array

Class Attribute

Method Attribute

Method Return Type Attribute

Method Parameter Attribute

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.

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

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.

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.

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

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

Local Constant

Local Variable

Inferred Types

Shared/Static Field

Read-Only Field

VB Static Local Variable

Implicitly-Typed Enum

Explicitly-Typed Enum

Event Declarations

Event Wireups

Strict Conversion of WithEvents/Handles

Casual Conversion of WithEvents/Handles

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.

Creating a List

Creating a Dictionary

Defining a Generic Class

Defining a Generic Class with a Constraint

Defining a Generic Class with a 'new' Constraint

Defining a Generic Method

Defining a Generic Method with a Constraint

C3 To Vb.net

Basic Inheritance

Inheritance Keywords

Defining Interfaces

Implementing Interfaces

Expression Lambda

Multi-statement Lambda

Event Wireup with Lambda

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:

For Loop

For Each Loop

While Loop

Do While Loop

Loop Until

Do Until

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.

The following C# reproduces the VB behavior:

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

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

Anonymous Type Object Initializer

Optional Parameters

Named Arguments

Property

Indexer

Parameterized Property

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

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
}