Version History

12/12/2016 – 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/17/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 >

10/17/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 >

3/7/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 >

8/30/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/9/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
  • 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.