07/19/2020 – VB.Net to C# Converter 5.08 Released

• Added support for UWP, .Net Core, and .Net Standard projects.
• Major performance increase converting single projects or snippets.
• Simplified/cleaner type conversions.
• Improved conversions for late binding.
• Improved accuracy converting WPF projects.
• Improved appearance for high DPI settings.
• Improved installation experience and smaller space requirements.
• Improved correction of ambiguous references (allowed in VB but not in C#).
• Corrected conversion of date literals with just the time portion specified.
• Fixed issue of enums concatenated together sometimes being converted incorrectly.
• Corrected problem of converting enum comparisons to Nothing.
• Improved automatic error correction for CS0029, CS1729, CS0103 C# compiler errors.
• Improved conversion of multi-line lambdas.
• More information about this release >

07/01/2019 – VB.Net to C# Converter 5.07 Released

• Now with Visual Studio 2019 support!
• The number of test projects increased from 12k to 15k.  They must all convert without C# compiler errors before each release.
• To help manage large project groups there is now the ability to apply filters by project status and Visual Studio version.
• Improved detection of the Visual Studio version of a VB.Net project.
• Improved conversions in name overloaded scenarios, with class, variable, arguments, etc. being named the same.
• Reduced number of duplicate definitions commented out in complex overloading/interface scenarios.
• Improved disabiguation converting () to () or [].
• Improved conversions in complex inheritance scenarios.
• Reduced number of temporary variables created during conversions.
• Improved conversions in complex for each scenarios.
• Fixed error converting static local variables within a routine with an separate line attribute.
• Corrected problem converting elseif lines causing temporary variables to be declared.
• Improved conversions of parameterized property references defined in an external dll.
• Corrected error converting RaiseEvent on an event renamed as part of an interface implementation.
• Improved conversion of events in interfaces.
• Improved conversion of events. Unnecessary add/remove clauses not output in C#.
• Fixed error converting a parameterized property named “Value”
• Fixed runtime issue of adding event handler to variable being assigned null
• Fixed problem of converter hanging in rare circumstances.
• Improved conversion of complex conditional constants.
• Fixed error parsing If() statement with no Then and no space between If and (
• Fixed issue where the application would sometimes crash opening a project.
• Fixed problem converting RaiseEvent lines for events with ByRef parameters requiring a temporary variable to be created.
• Import statements with generic definitions are now converted.
• Improved conversion logic on poorly formatted upgraded VB6 projects.
• Improved accuracy of converting exponentiation within built-in conversion functions.
• Fixed error converting left bit shift operators.
• Eliminated CS0019 errors being generated due to string comparisons or case statements with string ranges.
• Improved accuracy of conversions referencing import aliases.
• Improved type conversions to avoid CS0266, CS0029 compile errors.
• Added ability to automatically correct CS0738 errors about interface implementations having wrong return type.
• Improved accuracy of CS0019, CS0021, CS0030, CS0103, CS117, CS118, CS119, CS121, CS0176, CS0234, CS0246, CS0266, CS0571, CS1061, CS0426, CS0839, CS1061, CS1546, CS1620, CS1955 automatic compiler error correction.
• Reduced the number of C# compiler errors for CS0019, CS0029, CS0037,  CS0103, CS0106, CS0117, CS0119, CS0149, CS0161, CS0173, CS0176, CS0234, CS0246, CS0266, CS0664, CS1002, CS1501, CS1503, CS1525, CS1750.
• More information about this release >

01/14/2019 – VB.Net to C# Converter 5.06 Released

• Improved ability to convert very large projects without running into memory issues.
• Added support to automatically fix CS0621, CS0736 compiler errors.
• Improved conversion of read-only properties which are assigned to outside of a constructor.
• Improved conversion of read-only properties which implement and interface.
• Fixed rare error which would occasionally cause the program to hang during conversions.
• Reduced number of CS0106, CS2016 errors generated.
• Fixed problem converting LINQ statement inside of an If() function.
• Improved CS0023, CS0246, CS0161, CS1620, CS0118, CS0103, CS0131 automatic error correction.
• Improved disambiguation of = as assignment or comparison operators.
• Improved conversion of complicated With statements.
• Improved conversion of default properties not named “Item”.
• Eliminated need for some temporary variables in out parameters.
• Null checks on RaiseEvent only added if necessary.
• Fixed error converting Else If statements and array literals
• Fixed error converting variable declaration lines with a trailing comment ending in Set or Get
• Simplified conversion of events.
• Eliminated CS0053 inconsistant accessibility errors when converting delegates and events.
• Fixed error converting Modules defined as Partial.
• Corrected issue converted complex Case statements with > or <.
• More information about this release >

09/21/2018 – VB.Net to C# Converter 5.05 Released

• Improved accuracy of WPF project conversions.
• .xaml files are now displayed and can be edited in the project conversion results screen.
• Added “Apply” button on Options screen to apply changes without leaving screen.
• Added support for #Enable Warning and #Disable Warning compiler directives.
• Added option to use Visual Studio compiler in addition to the .Net Framework compiler in order to better support WPF conversions.
• Improved performance in converting multiple projects in parallel.
• Improved conversion of routines which assign to the function/property name as a return value. Eliminated the need to create a temporary variable in many cases.
• Removed unnecessary type conversions to int for enum comparisons.
• Removed unnecessary type conversions to string for nameof operators.
• Removes previous limitation of variable initializers being greater than 80,000 characters.
• Fixes error of built-in and project references not being added to C# project if no other references were found in VB project file.
• Corrected problem of Microsoft.CSharp reference sometimes being incorrectly included in the C# project in older .Net Framework versions where it’s unsupported.
• Improved automatic correction of CS1750, CS0029 compiler errors.
• Prevented compiler errors in form default instance behavior when System.Windows.Forms is not in the project includes list.
• Fixed error converting Property Get or Set accessors which have attributes defined.
• If a auto-implemented readonly property is assigned to outside of a constructor, thee C# property will be modified to include “private set” in its declaration.
• Fixed error where a readonly modifier would sometimes be removed from a variable declaration.
• More information about this release >

09/26/2018 – VB.Net to C# Converter 5.04 Released

• Removed 15 day limitation on trial version.  It never expires.
• Improved performance.
• Fixed problem converting generic functions referencing a structure
• Improved conversions of complex expressions containing ushort variables.
• Fixed conversion of AnchorStyles which though valid C#, would break the Windows Forms designer.
• Improved error correction on CS0234 errors.
• Improved conversion of routine attributes.
• Improved conversion of DLL Import routines.
• Improved determination of whether single character string literals should be converted to strings or characters.
• Improved variable resolution to external types.
• Prevented stack overflow condition in certain rare circumstances.
• Prevent infinite loop in certain rare circumstances.
• Fixed error converting variables declare as type Keys and initialized to default value.
• Improved CS0149 automatic error correction.
• More information about this release >

05/02/2018 – VB.Net to C# Converter 5.03 Released

• And/Or can optionally be converted to non-short circuited boolean operators & and | for maximum compatibility.
  The detected Visual Studio version of the project can now be overridden.
• For VB.Net 2015 and above – converts Imports to using static .
• Fixed issue of converting foreach lines with implicit line continuation.
• Corrected problem converting named argument references which are reserved words or have brackets around them.
• Improved variable resolution accuracy, with less reliance on post conversion C# compiler error fixes.
• Better type conversions, with less reliance on CS0266, CS0019, CS0037, CS0176 compiler error corrections.
• Improved conversion of logic with unsigned integers.
• Improved accuracy in converting old style VB code where the function return value is set by assigning to the function name.
• Improved conversion accuracy by adding parenthesis after well-known methods if the context can’t be determined.
• Simplified conversions of groups of enums being and/or’d together. Removed unnecessary casts to int.
• Fixed issue of converting a lambda expression within a function.
• Corrected problem of converting an anonymous class with the “Key” keyword.
• Corrected issue of converting VB.Net global namespaces.
• Fixed error converting Class Library projects with a startup object defined in the project file, which isn’t allowed in C#.
• Fixed issue of converting overridden methods with generic constraints, which prevents CS0460 errors.
• Corrected error of a using statement sometimes being output in a multi-line lambda.
• Fixed problem converting method arguments with a default enum value that is a reserved word.
• Fixed error converting a class named “Trim”, which would have parenthesis added in error when referenced.
• Corrected issue of variable named “func” being converted as “Func”.
• Fixed error of inline null checks ?. not being converted correctly after a TryCast or CType call.
• Corrected problem of converting a Case statement with implicit line continuations.
• Fixed error of type names being occasionally converted with parenthesis afterwards, if named the same as well known methods.
• Corrected problem of converting For Each loops with implicit line continuation and a temporary variable defined.
• Improved conversion of complex inline array declarations.
• Fixed problem where an invalid cast to an external type with `1 at the end would be applied.
• Corrected issue converting a TypeOf statement referencing an array, such as “a is b()”
• Fixed problem converting array literals, which sometimes would not put a “new []” in front.
• Corrected error converting Linq expressions within lambda routines, where the “from” keyword would be omitted.
• Improved conversions of complex attributes.
• Delegates, enums and classes are now initially output with visibility of their highest reference, to prevent inconsistent accessibility errors in C#.
• Fixed issue of decimal literals in attributes not being converted correctly.
• Improved type detection in complex string expressions
• More information about this release >

12/27/2017 – VB.Net to C# Converter 5.02 Released

• Improved lambda function conversion accuracy.
• Added support for .Net Framework 4.7, which broke Tuple support in Visual Studio 2017 projects.
• Fixed compatibility issue converting Visual Studio 2003 projects on Windows 10.
• Improved accuracy of My.Resources conversions.
• Fixed issue converting async inline functions.
• Improved non-static initializer detection.
• Improved conversions of enums declared as a type other than integer, such as ushort.
• Improved detection of correct overloaded method to use in complex scenarios.
• Improved conversion of expressions referencing complex implicitly typed variables.
• Fixed error converting embedded case statements within a Select Case True block.
• Fixed issue converting Array.Empty(Of TypeName), where the () was added before the instead of after.
• Fixed issue of Array.Empty not being recognized as a static initializer and the assignment being moved to a class constructor.
• Improved conversion of generic arguments requiring (), like .OfType(Of TypeName). Parens are added in the initial conversion, and not relying on compiler error correction.
• Generated variables for With statements are now implicitly typed.
• Corrected conversions of MySettings.SettingName
• Fixed an issue converting a varible declared as type My.MySettings
• ChrW(intLiteral) is converted as (char) intLiteral instead of Strings.ChrW(intLiteral), to allow initial assignment to constants.
• Chr(intLiteral) is also converted as (char) intLiteral instead of \unnnn syntax, unless an initial assignment to a string constant is necessary.
• Improved accuracy of AddressOf conversions, when initialized in a variable declared with a generic type.
• Calling TryRemove method of ConcurrentDictionary.TryRemove is now passed with “out” instead of “ref” for the second argument.
• AddHandler/RemoveHandler doesn’t unnecessarily wrap routines with event handlers.
• Corrected problem converting “a is b” within a Case expression.
• Improved conversion of generics, prevent output of terms like “System.Func`2” when converting code.
• CStr is now converted as Convert.ToString() instead of .ToString(), to avoid possible null reference exceptions at runtime.
• Improved routine resolution. Fixed issue where a custom routines would be incorrectly resolved to like named routines in referenced assemblies.
• Short literals assigned to an object variable are now casted to short rather than being converted as an integer literal.
• ASP.Net projects: Improved tag parsing, language detection, correctly parsing server side comments, added support for ashx files
• Improved accuracy of converting Iterator functions.
• The converter now does not apply unnecessary type conversions to variables with implied types
• Improved accuracy of CS1061 compiler error correction.
• More information about this release >

 6/16/2017 – VB.Net to C# Converter 5.01 Released

• Improved installation on Windows 10 and Windows Server 2012 and 2016.
• Now converts very complex one line if statements, which may contain : or nested Ifs, such as “If a Then If b Then a = False : b = False Else c = False : b = False Else a = False”
• Corrected converter to not insert “break;” at the end of a case block if the preceding statement is a Throw. This prevents dead code warnings.
• Fixed issue of a variable declaration which is an array of generic types not converting correctly.
• Fixed problem of multiple attributes on a variable or argument not being converted correctly.
• Corrected issue iterating over an array of generic types in a for each loop
• Fixed issue converting some inline functions.
• Corrected problem converting VB date constants when Windows date settings are non-English
• Fixed rare issue of converter errors when constant initialization references hex constants and other defined constants
• Fixed bug of string substitution not replacing the second occurrence of search term on a line correctly.
• Improved accuracy of complex TryCast conversions.
• Improved accuracy of type conversions via TryCast, CType, and DirectCast which are followed by a default property reference. () are converted to [] without having to rely on compiler error correction.
• Converter now adds missing parens after a .OfType(Of ClassName) call.
• Dim a(b – 1) now converted as a(b), not a(b – 1 + 1).
• Fixed conversion errors when one VB extension method calls another VB extension method.
• More information about this release >

 4/4/2017 – VB.Net to C# Converter 5.00 Released

• Visual Studio 2017 is now fully supported, including binary literals and tuples.
• There is now the ability to import, export option settings and to restore them to default values.
• On Windows 10, it no longer prompts to install .Net 3.5.
• Changed With variables to use implicitly types variables (var) instead of dynamic.
• Improved accuracy in string interpolation conversions.
• Improved conversions of auto-implemented readonly properties.
• Fixed problem converting project references which specify $(TargetDir) in the output or hint paths.
• Date constants are now converted as new DateTime(), instead of DateTime.Parse().
• Warnings are now not issued for Option Strict Off in Reference.vb, an auto-generated file.
• Improved conversion of VB routines marked as Overloads, without relying on compiler error correction to insert “new” as needed.
• Explicit types in inline lambda expressions/statements are now output during the conversion.
• Fixed issue converting lambda statements in inline functions/subs.
• Improved accuracy in complex typeof conversions.
• Fixed problem of optional parameter default values not being set correctly.
• Corrected errors in converting variables named “Left”, which don’t correspond to the built in VB.Net Left function.
• Simplified conversions of enum references to not use fully qualified names if not necessary.
• Corrected issue of conversion hanging with xaml projects containing special characters in the path name.
• Fixed issue of unnecessary parenthesis being issued after variable names, then removed during compiler error correction process.
• Improved variable resolution to external assembly static methods.
• Fixed error converting property setters which don’t specify a value variable and also have a visibility specifier.
• Fixed error converting property getters which have a visibility specifier.
• Corrected issue converting inline XML, where a class attribute would sometimes be mistaken for XML.
• Fixed error of Extension attributes sometimes being output in C#.
• Fixed issue of variables in attributes not being resolved correctly in some circumstances.
• Fixed problem of constants being referenced in AssemblyInfo not resolving correctly.
• The VB.Net Split function converts more accurately on the initial conversion, without relying on the compiler error correction feature to fix issues.
• There is more simplified conversions of Select Case True statements.
• More information about this release >

1/18/2017 – VB.Net to C# Converter 4.01 Released

• Changed conversion of parameterized readonly properties to not have a “get_” prefix.
• Now automatically corrects CS1715 compiler errors, for mismatched types in overridden properties.
• Now automatically corrects CS0217 compiler errors, dealing with issues in converting bitwise operators.
• Now automatically corrects CS1540 compiler errors, regarding accessing base class protected members.
• Improved accuracy of enum conversions, with non-int types.
• Fixed issue of 2015 string interpolation conversions not converting correctly.
• Fixed problem converting multi-line lambda within a constructor call.
• Doubles are converted to ints with Convert.Int32, instead of casts, which can lead to different runtime behavior in C# vs VB.
• Corrected problem of static local variable initialized in multiple lines not converting correctly.
• Corrected issue of converting embedded quotes within multi-line strings (2015).
• Improved accuracy in detecting non-static initializers in class variables to move to a constructor.
• Fixed problem of attributes in enums not being converted.
• Corrector error of temporary generic variables created with the wrong type.
• Improved compiler error correction for CS0152, duplicate case statement in block, which is allowed in VB but not in C#.
• Fixed rare issue of converter hanging in certain circumstances.
• Corrected indentation issue of when formatting properties in C# code.
• Fixed issue converting exponents of literal integers.
• Fixed issue of Linq extension methods not being found in some converted C# projects.
• Added the option of converting Is and IsNothing to ReferenceEquals, which may be necessary if the equals operator is overloaded.
• Guid arguments being initialized to null now convert to default(Guid), rather than null.
• Fixed problem of converting auto-implemented properties named after a C# reserved word.
• Fixed problem of converting auto-implemented properties visibility wrong.
• Fixed issue of CS7027 errors when converting projects with an assembly key file.
• Fixed issue of auto-initializing variables in multi-line lambdas.
• More information about this release >

5/18/2016 – VB.Net to C# Converter 4.00 Released

• Cleaner string to int conversions without relying on compiler error correction
• Add .ElementAt() as necessary to Linq variable references and not rely on compiler error correction
• Protected Friend Const declarations convert correctly
• Fixed errors converting “typeOf x Is Type” which failed for Array-Types
• Fixed problems converting vb files with special characters, like () $ @
• Now automatically initializes variables in InitializeComponent, to prevent problems in the forms designer
• Fixed issue of default constructor for a form not being created in certain circumstances
• Corrected issue of converting complex Linq statements with end of line comments
• Now converts Math.Log function correctly if using System.Math is used
• Improved accuracy of Linq conversions
• Corrected problem of variable resolving to a variable definition in a different case block
• Now handles CData conversions in embedded XML correctly.
• CS0159 goto outside of scope errors now automatically detected and corrected
• Corrected issue of () erroneously appended to variable references, then removed during compiler error correction
• Conversions of double? to double, DateTime? to DateTime, which don’t require compiler error correction
• Improved conversions of generic references which don’t require compiler error correction
• More information about this release >

11/3/2015 – VB.Net to C# Converter 3.12 Released

• Greatly improved conversions in complex VB.Net interface scenarios.
• Improved embedded XML conversions.
• Improved conversions of projects which use ComponentOne third party controls
• Added support for C# 2015 exception filters (converts When clauses on Catch statements).
• Converts stringVar <> “” to !string.isNullOrEmpty(stringVar) for greater accuracy.
• For null assignments, such as varName = Nothing, convert to appropriate defaults for value types rather than null.
• Fixed issue converting auto-implemented readonly properties and property backing fields (supported in VB but not C#)
• Fixed error converting RaiseEvent statement which requires temp variable to be created.
• CS1066 errors in VS2010 and above now treated as warnings (optional parameter ignored in context).
• Corrected conversion problems when a local variable is named “assembly”.
• Fixed conversion of array literals at start of Linq expression, such as: If {“a”, “e”, “i”, “o”, “u”}.Any
• Corrected problem of namespace line being inserted before assembly attributes in #regions.
• Fixed problem of converting references to a user function named “String”.
• Corrected VB 2005 issue of referencing properties with “_”, even if private members aren’t defined
• Significantly improved automatic C# compiler error correction, including compiler errors CS1503, CS1620, CS0161, CS0115, CS0021, CS1995, CS1736, CS0118, CS1750, CS0234, CS0031, CS1061, CS0122, CS1501, CS0103, and CS0051.
• More information about this release >

4/22/2015 – VB.Net to C# Converter 3.11 Released

• Added complete Visual Studio 2015 support, including new VB multi-line strings.
• Added support for Yield and Iterator keywords.
• Added automatic C# compiler error correction for CS1621 – The yield statement cannot be used inside an anonymous method.
• Improved automatic C# compiler error correction for CS0246 and CS1061 errors.
• Fixed conversion issue for Visual Studio 2013 Silverlight projects.
• Corrected error loading legacy assemblies in Visual Studio 2013 and 2015 projects.
• Fixed digital signature so warning does not occur upon installation.
• Corrected issue with With statements and object initializers.
• Corrected problem with assigning to function name which has an identical named type.
• Fixed issue with named and positional parameters in function call in complex overloaded scenarios.
• Corrected error in converting interfaces with over 100 declarations.
• Fixed error where “ref” wasn’t included when calling a routine with named arguments.
• Fixed error with attributes on arguments not being converted.
• Corrected problem with concatenated enums.
• Fixed problem with casts to enums.
• Fixed error with CLng being converted to int.
• Corrected problem with temp variables created for ref arguments unnecessarily.
• Fixed problem of variable initialization moved to constructors not working for variables declared in a #Region
• More information about this release >

7/31/2014 – VB.Net to C# Converter 3.10 Released

• Added support to convert FormatCurrency to string.Format
• Fixed C# brace formatting error when { is placed on same line as if/else
• Fixed C# formatting issue when option is checked to remove unnecessary braces
• Corrected issue converting VB functions (Left, Right, etc.) to .Net equivalents if prefixed with “Strings.”
• Fixed error of Project Add->New item not displaying templates after conversion in some C# projects.
• Fixed event handling conversions where they would not be overwritten by the designer
• Corrected error converting assigning to a default instance, such as FormName = nothing
• Fixed issues automatically correcting CS0149 and CS0030 C# compiler errors.
• Fixed conversion of some integer division scenarios, where integer1/integer2 should be converted as (double) integer1/integer2
• Corrected issue of invalid conversions when converting complex exponentiation scenarios
• More information about this release >

3/20/2014 – VB.Net to C# Converter 3.09 Released

• Improved conversion of exponents in enum constants for large values
• Fixed conversion where Implements clause is in a separate #region different than its associated class (very rare)
• Fixed issue converting methods which implement a generic type
• Improved detection of when to change select case statements to if statements
• Corrected casing problem in complex interface conversions
• Corrected CS1618 errors, where a method passed to AddressOf has a conditional attribute applied, which isn’t allowed in C#. Original function is wrapped to avoid errors.
• Improved conversion of complex expressions
• Improved conversion of projects with legacy ActiveX references
• Corrects CS1758 errors regarding duplicate types in COM references
• Improved resolution of ActiveX references
• Improved resolution in external assemblies
• More information about this release >

1/20/2014 – VB.Net to C# Converter 3.08 Released

• Added the ability to add a comment to multiple projects at once.Much improved conversions in complex interface scenarios.
• Enum constants which contain exponents, such as 2^3, now convert successfully.
• Cleaner CInt conversions: expressions like CInt(42) now convert to 42, rather than (int) 42.
• Fixed error resolving references to external assemblies with “.” in name, which will lead to more accurate conversions in those cases.
• Improved select case conversions in complex scenarios, when determining to change Select Case to if statements
• Improved accuracy in converting MyApplication.vb, eliminating “No suitable method to override” errors.
• Corrected an error creating main routine in some Windows Forms projects
• CS0675 doesn’t show as a compiler error on the errors tab anymore since it’s a warning.
• Fixed CS0019 error which produced a maximum size line due to repeated correction attempts.
• Fixed CS0723 error not being fixed in VB2005 conversions.
• Fixed Microsoft.VisualBasic references missing module names
• Fixed CS0051 error correction on external methods.
• Improved CS1503, CS0118 when dealing with COM objects.
• Improved variable resolution of .term in abc(xxx).term expressions.
• More information about this release >

12/13/2013 – VB.Net to C# Converter 3.07 Released

Release 3.07 contains the following improvements:

• Snippet converter supports drag and drop and displays tips.
• You can now add project comments in the multi-project converter.
• Speed improvements.
• Memory efficiency improvements to support very large project conversions.
• Improved late binding support.
• Simplified and improved event handler conversion.
• Improved support for converting Windows Mobile projects.
• Improved Linq conversions.
• Improved conversion of projects which reference Excel.
• Much cleaner type conversions.
• Improved automatic C# compiler error correction (CS0117, CS0122, CS0021, CS0426, CS1763).
• More information about this release >

9/15/2013 – VB.Net to C# Converter 3.06 Released

Release 3.06 contains the following improvements:

• Dynamic variables are used to help convert late binding in VB.
• VB line continuations are honored in C#.
• Speed improvements.
• Correctly convert structures which implement interfaces
• Fixed error converting Multi-Line Lambdas within BeginInvoke
• Correctly converts auto-implemented property backing fields, removing preceding from “_” from field name
• Fixed error converting auto-implemented properties with default values which implement an interface member
• Fixed issue where references to named constants were converted with the constant value, rather than the name.
• Improved ability to detect type of “With” expressions, to reduce late binding
• Improved CS0037, CS0426, CS0117, and CS0234 compiler error correction
• A great number of other conversion accuracy improvements, too many to list, thanks to the detailed feedback from many customers.
• More information about this release >

6/29/2013 – VB.Net to C# Converter 3.05 Released

Release 3.05 contains the following improvements:

• Support for converting Visual Studio 2013 Preview projects!
• For C# 3.0 and above, “AddressOf ” as an argument to a routine isn’t wrapped in an event handler anymore, but just passed as and uses type inference.
• Static local variables are now converted to static only when in a shared routine or module, and private when in a class.
• Fixed issue of null being passed to a param array argument when no argument should be specified.
• More information about this release >

5/27/2013 – VB.Net to C# Converter 3.04 Released

Release 3.04 contains the following improvements:

• The installation program is now code signed, for greater security and improved installation.
• Smoother install on Windows 8 and Windows XP 64 bit.
• Corrected problem of converting a generic definition defined “As Structure”.
• Fixed issue of not opening projects with compiler errors when the locale has a decimal separator which isn’t a period.
• Fixed issue of program crashing when variable is named “from” in Visual Studio 2008 or above.
• Now correctly converts operator definitions named “IsTrue” and “IsFalse”.
• Fixed error converting Widening Operators.
• Corrected issue of converting operators which return generic types.
• Fixed problem of converting parenthesis around a variable which is indexed, like (varName)(0).
• CS1729 compiler errors are now automatically corrected.
• Temporary variables are now created correctly for ref arguments for a type declared from a generic type.
• Fixed problem of displaying a XML error message when viewing some project conversions.
• Improved visual experience on Windows XP.
• More information about this release >

2/6/2013 – VB.Net to C# Converter 3.03 Released

Release 3.03 contains the following improvements:

• Better conversions of large / complex projects.
• 30% improvement in conversion speed.
• Fixed error when converting an overloaded ^ operator.
• Corrected issue converting <<= and >>= operators.
• Added options to always initialize local variables, or only when needed.
• Added options to control file encoding when converting non-English projects.
• Added options to control post conversion C# compiler error correction.
• More information about this release >

10/27/2012 – VB.Net to C# Converter 3.02 Released

Release 3.02 contains the following improvements:

• Improved accuracy when converting multi-line lambdas.
• Fixes application crashes when converting Visual Studio 2012 projects.
• Improved conversion accuracy on heavily overloaded methods, such as Console.Writeline.
• More accurate conversions of projects which access databases via ADODB.
• Improved accuracy on automatic C# compiler fixes for CS1593, CS1503, CS0050, CS0815.
• More information about this release >

9/23/2012 – VB.Net to C# Converter 3.01 Released

Release 3.01 contains the following improvements:

• The ability to specify the Visual Studio version in the snippet converter
• Multiple accuracy improvements, especially related to LINQ expression conversions
• More information about this release >

7/28/2012 – VB.Net to C# Converter 3.00 Released

Release 3.00 is an exciting major new release, which contains the following improvements:

• Full Visual Studio 2012 support
• Multiple accuracy improvements
• Snippet conversions
• Direct code editing from within converter
• Easily find and open recent conversions
• Mark conversion issues as “worked”
• More information about this release >

2/25/2012 – VB.Net to C# Converter 2.32 Released

Release 2.32 contains the following improvements:

• The ability to specify the default target directory for the C# projects generated.  This default can be overwritten on a project by project basis.
• This is now the ability to choose where linked files are converted or if they should be copied and converted as a non-linked file.
• Enums and classes contained in interfaces are now converted.
• Automatically correcting more late bound code
• Type conversions and casting are much cleaner.
• Events in site.master files are now converted correctly.
• Plus many more accuracy improvements, which have allowed 580 new projects to be added to the test suite.
• More information about this release >

10/7/2011 – VB.Net to C# Converter 2.31 Released

Release 2.31 contains the following improvements:

• Major focus of this release was accuracy improvements, especially in converting upgraded VB6 projects.
• All reports have been rewritten and are now exportable in over a dozen different formats, including PDF, Word, Excel, CSV, Html, PowerPoint, etc.
• Late binding is now being detected and warnings issued.  Late binding is allowed in VB.Net but not in C#.
• 30% increase in conversion performance over the prior release.
• Over 100 new projects added to the 4 million line, pre-release regression tests.
• More information about this release >

6/4/2011 – VB.Net to C# Converter 2.30 Released

Release 2.30 has many major improvements:

• VB.Net and C# code, and any associated conversion issues can be viewed / navigated in a side by side Visual Studio like environment.  The conversion experience feels much more intuitive and productive.
• There is now complete control over how the C# code is formatted, similar to the code formatting options in Visual Studio.
• On Error Goto -> try/catch conversion logic has been rewritten from scratch, and converts most On Error Goto scenarios very cleanly and without awkward goto logic, similar to being rewritten by hand.
• Improved conversion accuracy across the board – really too many improvements to list.
• More information about this release >

11/8/2010 – VB.Net to C# Converter 2.29 Released

Release 2.29 was intensely focused on improving conversion accuracy rather than adding features or improving performance.  Many thanks to the customers who submitted hundreds of thousands of lines of sample code to help with the new release.  Release 2.29 contains the following improvements:

• Corrected issue where converter would hang when converting very long VB.Net lines of code (>30,000 characters).
• Improved accuracy when converting .aspx and .ascx files in web projects.
• Fixed issue converting project references in VB.Net 2005 projects and higher, where the references would show up as missing when the C# project was opened in Visual Studio.
• Fixed bug where converted database projects would not open in Visual Studio after the conversion.
• Fixed error converting typed datasets, where Visual Studio would regenerate the C# code in a different namespace than the VB.Net code when the C# project was opened after the conversion.
• Corrected issue with converting the IsNot keyword in complex VB.Net expressions.
• Fixed error converting module names which are VB.Net reserved words, like [Global].
• Corrected issue with For loops not converting correctly if the loop control variable is a With variable or a method argument.
• Improved code formatting when fixing CS0030 compiler errors.
• Fixed rare problem of converter picking the wrong overloaded method when there is a param array argument.
• Corrected error in converting complex case statements.  Improved the logic which decides to switch to an if statement when the case statement is too complex for C#.
• Improved the accuracy in determining the type of the With expression in With / End With blocks.
• In the multiple project screen, added the ability to compile multiple VB.Net projects in parallel.  This is useful when converting many VB.Net projects and you need to ensure they will compile correctly in VB.Net before converting to C#.
• Fixed problem where VB.Net string variables initialized to Nothing would be initialized in C# to an empty string, rather than null.
• Improved accuracy when automatically correcting CS0103 and CS0246 C# compiler errors.

10/5/2010 – VB.Net to C# Converter 2.28 Released

Release 2.28 contains the following improvements:

• Continued performance gains started in the previous version.  Version 2.28 is almost three times faster than version 2.27, completing a 3.3 million line conversion in less than 15 minutes, compared to 39 minutes for a 3 million line test in version 2.27.  Tests are done with 8 parallel processes on an I7-860.
• Improved accuracy when converting in line subroutines (lambda expressions).
• Fixed error when using TryCast to cast to an array.
• Improved logic converting code that assigns return values to function or property names.
• Fixed problems with passing properties by reference, which is allowed in VB.Net, but not C#.
• Improved logic when converting reference arguments to value arguments in inherited methods.
• Improved automatic C# compiler error correction for CS1660, CS1936, CS0266, CS0021, and CS1503 errors.

Special thanks to Craig Richards for providing sample code which helped drive much of the accuracy improvements in this release.

7/18/2010 – VB.Net to C# Converter 2.27 Released

Release 2.27 contains the following improvements:

• Improvements in conversion accuracy, especially in VS2008, VS2010, and Silverlight 3.0 and 4.0 projects.
• Multi-processor support when converting multiple VB projects in a list.  The number of parallel processes can be changed dynamically at run time.  Conversion time on over 5500 test projects is now over four times faster using multi-processor support.
• 30-40% speed improvement when converting single projects without multi-processor support.
• Drag and drop is now supported between Windows Explorer and a project list.  Folders, VB project files, and solutions can be dropped onto a project list, and the included VB projects will be added.

12/5/2009 – VB.Net to C# Converter 2.26 Released

Release 2.26 contains the following improvements:

• Fully supports new Visual Basic 2010 language features (Multiline Lambdas, Implicit Line Continuation, Auto-Implemented Properties, Collection Initializers, Array Literals, Nullable Optional Parameters, Generic Variance).
• Improved overall performance by approximately 10%.
• Fixed error converting LINQ within XML “code holes”.
• Corrected problem of converting an array initializer within a CType statement.
• Fixed error converting complex With statements.
• Corrected error with generated labels before Else statements causing C# compiler errors.
• Improved auto-correction of C# compiler errors, including CS0120, CS1503, CS0176, CS0104, CS0122, CS0103, CS0428, CS0236, CS1579, CS0266, CS0108, CS1750, CS0571.
• Fixed error converting Properties named after some reserved words.
• Corrected problem converting a self-referencing class variable initializer.
• Fixed problem converting complex attributes.
• Corrected issue converting generic arrays.
• Many more minor fixes and improvements.

10/13/2009 – VB.Net to C# Converter 2.25 Released

Release 2.25 contains the following improvements:

• Support for VB 2010 projects.
• Converts all VB versions (2003, 2005, 2008, and 2010) from one user interface.
• The user interface and help system has been completely revamped.
• When opening a VB or C# project, the correct version of Visual Studio is explicitly opened, rather than relying on the operating system default.
• Corrected problem converting files in subdirectories off the main project folder.
• Fixed issue of lambda variables sometimes not being initialized correctly (thanks Phil for notifying).
• Corrected error converting for each loop within case block, where the loop variable is also defined in a different case block.
• Fixed error sometimes occurring in expressions with exponents.
• Corrected problem when converting a generic definition with multiple parameters, when some are array types.
• Improved automatic fixing of CS0019, CS0023, CS0266, CS0428 and other C# compiler errors.
• Fixed problem converting constant Microsoft.VisualBasic.FirstDayOfWeek.
• Corrected many other minor issues.

1/29/2009 – VB.Net to C# Converter 2.24 Released

Release 2.24 contains the following improvements:

• Improved handling of un-typed constants, especially in VB 2005 and 2008.
• Lowered severity of un-typed constants warning to low, as un-typed constants should be converted much more accurately.
• General performance improvements
• Improved automatic fixing of CS0134 and CS0283 compiler errors.

12/15/2008 – VB.Net to C# Converter 2.23 Released

Release 2.23 contains the following improvements:

• Improved automatic C# compiler error correcting in CS0019, CS0051, CS0117, CS0149, CS1510, and CS1703 errors.
• XML literals which are function arguments now converted correctly.
• Fixed problem of VB Split functions not being converted correctly in rare situations.
• Improved dead code detection, specifically C# code after a return statement wasn’t being marked as dead if there was a subsequent label which can be the target of a goto statement.
• A rare problem with MySettings conversions has been fixed.
• Fixed a problem with Resume conversions.  Resume and Resume Next now have high severity warnings issued.
• Improved ReDim conversions.  Redim statements with embedded parenthesis were sometimes converted to brackets incorrectly.
• Fixed problem of multiple compiler constants not being converted correctly.
• Fixed problem of On Error Goto not converting to try-catch blocks correctly in some rare cases.

10/20/2008 – VB.Net to C# Converter 2.22 Released

Release 2.22 contains the following improvements, many of which were suggested by Bill Staib (thanks Bill!):

• Added option (on by default) of converting InStr function calls with .IndexOf methods.
• Converting numbered labels and Gotos (valid in VB but not C#), was giving an error.  Numbered labels are now prefixed with an underscore on conversion.
• Converting a variable named “custom” in VB 2005 and 2008 was converting incorrectly.
• Numeric literals weren’t being converted to true/false in If statements when appropriate.
• An Untyped Argument warning was being incorrectly issued for generic arguments to event handlers.
• Multiple generic variables defined on one line were not being converted correctly.
• Imports statements with improper casing of the namespace were sometimes being converted incorrectly.
• Generic array arguments weren’t being converted correctly.
• Generic delegates and interfaces weren’t being converted correctly.
• Automatic error correction was implemented or improved in the following C# compiler errors: CS0117, CS0118, CS0188, CS0403, CS0446, CS0815, and CS1587.
• Improved AddressOf conversions.
• Changed visibility of Handles clause method if necessary to be referenced by event handler registration.
• In VB 2008, a string literal of “?” was being converted to “”.
• If a VB Replace function had a first argument of a character and a second as an empty string, a run time error would result.
• String comparisons with less than or greater than were being converted to integers rather than use String.Compare.
• On very rare occassions, “new classname” was being converted to “newclassname”, without the space.

9/14/2008 – VB.Net to C# Converter 2.21 Released

Release 2.21 contains the following improvements:

• Quotes are now removed when converting #Region directives.  #Region “name” becomes #region name, not #region “name”.
• A broken purchase link was fixed.

8/23/2008 – VB.Net to C# Converter 2.20 Released

Release 2.20 focuses on improving conversion accuracy, especially in VB2008 projects. The following problems were identified and fixed:

• Equal sign sometimes not converting correctly in a LINQ Where clause
• a..Value was converting to a.Elements(“name”).Value instead of a.Element(“name”).Value
• Nullable parameterized properties not converting correctly
• CS1955 compiler error not fixed correctly
• References to module members without specifying module name sometimes converted incorrectly
• Visibility sometimes converted wrong on parameterized properties
• Exit Do / Exit While not converted correctly in complex control structures
• Generic Collection object sometimes misinterpreted as VB Collection object

7/6/2008 – VB.Net to C# Converter 2.19 Released

Release 2.19 contains the following improvements:

• Support for converting Compact Framework projects!
• Support for converting inline VB Code in .aspx and .ascx pages.
• Added import/export capability to project groups.
• Added find / replace functionality on project group names (useful if moving project groups to a different drive or computer).
• The syntax of Synclock conversions has been simplified.
• Conversion notes are now not reported on designer generated files.
• Fixed problems converting My.Settings references
• Fixed problem of occasionally not correcting CS0012 compiler errors.
• Fixed problem of web page events not being converted properly if aspx file was in a project sub folder.

5/22/2008 – VB.Net to C# Converter 2.18 Released

Release 2.18 contains the following improvements:

• Performance improved 27%
• Drag and drop now supported between project groups on different versions of the converter
• Fixed problems with embedded image resources not being recognized in the C# forms designer
• Missing XML Comment warnings are suppressed by default (can be changed in Options screen)
• Fixed problems converting import aliases
• Fixed problem of converter freezing on non-English long comments
• Removed unnecessary MyClass warnings (for non inheritable classes and MyClass.New)
• Fixed problems viewing side by side code on some files
• Fixed problems converting some My.Computer.FileSystem functions
• Fixed problem with variables named “checked” and “override” not converting correctly
• Fixed problem of #region directive between a class and inherits line not causing the inheritance to be recognized
• CS0657 compiler error now corrected for VB 2008
• C# reserved words in > 2nd term in an identifier (b or c in a.b.c) are now converted correctly

4/16/2008 – VB.Net to C# Converter 2.17 Released

Release 2.17 contains the following improvements:

• Issues with Vista and 64 bit OS compatibility and the VB.Net 2008 converter are resolved.
• ReDim Preserve statements on VB.Net 2005/2008 are now converted to Array.Resize.
• ReDim statements on multi-dimensional arrays are much more accurate.
• Problem converting some project references has been fixed.
• Fixed problem of Exit For on a For Each loop generating a goto statement unnecessarily.
• Fixed problem converting 2008 projects with containing a variable name of “from” or “aggregate”.
• Improved automatic C# compiler error correcting for CS1620, CS0149, CS1527, CS0206, CS0023, and CS0104.
• Fixed problem of some Select Case statements being converted to If statements unnecessarily.
• Many more minor issues fixed.

3/16/2008 – VB.Net to C# Converter 2.16 Released

Release 2.16 contains Visual Studio 2008 support!  All VB 2008 features are supported, including many some would think were unconvertible:

• LINQ queries (including Aggregate queries)
• XML Literals
• “Code Holes” in XML Literals
• Extension methods
• Lambda expressions
• Object initializers
• The new If operator
• WPF applications
• Nullable data types
• Implicit data typing
• Anonymous types

In addition to the 2008 features, 44 other improvements were made, including:

• The creation of temporary variables during for each loop conversions has been drastically reduced.  Variable scoping differences between VB.Net and C# sometimes require temporary variables.
• Select Case conversions have been completely rewritten to provide cleaner conversions.
• Several issues with constrained generics were fixed.
• Performance was improved, especially when converting multiple projects.
• Problems converting interfaces with multiple inherits clauses fixed.
• Problems converting CULng, CUShort, CUInt, and ULONG fixed.
• Added or fixed ability to automatically correct C# compiler errors CS0136, CS3005, CS0542, CS0161, CS0111, and CS1025.
• Fixed multiple errors in converting My namespace methods and added ThreadSafeObjectProvider support.
• Fixed occasional problems converting Shadows variables.
• Fixed problem with embedded resource files not converting correctly.
• Corrected problem with External Source conditional compilation directives not converting correctly.
• Fixed problem of for each loops with a variable type containing generic definitions not converting correctly.
• Fixed occasional problem of Exit Do statements not converting correctly.
• Fixed problem of variables named “now” sometimes not converting correctly.
• Plus, many more fixes, mostly for obscure errors.

11/9/2007 – VB.Net to C# Converter 2.15 Released

Release 2.15 contains 54 improvements made after converting and reviewing hundreds of programs.  Some of more notable fixes/updates are:

• The type conversion engine has been completely reworked to minimize calls to the System.Convert.ToXXX functions, which always works but is ugly.  Implicit conversions or casting are used where possible, with System.Convert.ToXXX called as a last resort.
• ASP.Net event handling weren’t being converted in some projects.
• Return statements in case blocks caused subsequent case statements within the select being erroneously commented out as dead code.
• All Implements clauses on a class weren’t being converted if they were on separate lines
• Not determining the correct project type (2003 or 2005) in some cases
• Problems finding the main method in some 2003 projects
• Non-standard ascii characters in .vb files weren’t being converted correctly
• VB comparison shortcuts like 3 < X < 10 weren’t being converted correctly
• Preprocessor directives in enums weren’t being converted correctly
• Complex expressions involving exponents weren’t being converted correctly
• ReDims with complex array definitions weren’t being converted correctly
• Many other other bugs were also fixed, mostly obscure.

8/26/2007 – VB.Net to C# Converter 2.14 Released

• This release includes compatibility with 64 bit Windows Vista.

7/9/2007 – VB.Net to C# Converter 2.13 Released

This release fixes:

• Type conversions involving array references
• A C# Main method not being generated for WinForms applications which don’t use the Application Framework.
• The C# project file being corrupted under rare circumstances.

6/20/2007 – VB.Net to C# Converter 2.12 Released

This release fixes occasional erroneous warnings stating that there are no vb files in the project to be converted.

5/31/2007 – VB.Net to C# Converter 2.11 Released

This release fixes:

• Problems converting Using statements in VB.Net 2005
• Problems with Interface inheritance
• Methods implementing interface methods with generic parameters (VB.Net 2005)
• Problems with functions returning multidimensional arrays

4/29/2007 – VB.Net to C# Converter 2.10 Released

More minor bug fixes and performance enhancements.

4/7/2007 – VB.Net to C# Converter 2.09 Released (3x Faster!)

This a major performance release! Projects convert more than three times faster than version 2.08. The Microsoft 101 VB.Net Samples convert in 10:39 minutes in version 2.08 and 2:54 minutes in version 2.09.

There were also many bug fixes and enhancements focused on making conversions more accurate:

• Events in interfaces and modules converted correctly.
• Minimizes use of temp variables when converting ref arguments.
• Fixed bug in dead code marking in Case statements.
• Automatically fix CS0107 errors – more than one protection modifier.
• If method is implementing interface, force visibility to public.
• Fix bug when converting ReDim statements with nested parenthesis.
• Drag and drop now supported between project groups.
• Compiler Error screen resizes correctly.
• Minor problems in online help fixed.

1/22/2007 – VB.Net to C# Converter 2.08 Released

Web project event handling: “Handles” clauses on subroutines are converted to the OnEventName attribute in the control declaration in the corresponding aspx/ascx file (just as if you created the event originally in C#).  This is a huge improvement in web event handling.

You are now given the choice of converting vbCrLf to “\r\n” or System.Environment.NewLine.  You can find the new option on the “VB Namespace tab” of the conversion options screen.

Fixed a bug in which extraneous nulls would sometimes be inserted as extra parameters in function calls.  This has been fixed.