Visual Basic 6 to .NET Migration Services

Section 01

The "Burning Platform"

Visual Basic 6.0 has been unsupported since 2008. While the runtime still works on Windows 10/11, it carries growing security and compliance risk.

Section 02

Technical Deep Dive

1. COM Interop vs. Native Rewrite

• The Trap: Using COM Interop to keep old VB6 DLLs running alongside new .NET code. This creates "DLL Hell" and memory leaks.
• The Fix: Aim for a "Clean Break". Rewrite the DLLs in C# Standard 2.0 so they can be used by both .NET Framework and .NET Core.

2. Data Access: ADO to Entity Framework

VB6 used ADO (Recordset). .NET uses ADO.NET or Entity Framework (ORM).

• Challenge: Recordset was often passed around the entire application, tightly coupling UI to Database.
• Solution: Create Data Transfer Objects (DTOs) to pass data between layers. Do not try to emulate the Recordset object in C#; it kills performance.

3. UI Modernization: WinForms vs. Web

• WinForms: Closest to VB6. Easiest migration path but still a "desktop" app.
• Web (Blazor/React): Harder migration but a better long-term fit. Requires moving logic from Form_Load to API controllers.

Recommendation: If the app is internal and data-heavy, Blazor is a reasonable middle ground, offering desktop-like performance in a browser. If the app looks different or removes a beloved shortcut key, expect pushback.

---

How to Choose a VB6 to .NET Migration Partner

If you want automated code conversion: GAPVelocity.ai (which took over Mobilize.Net's VBUC in 2023). VBUC is widely used for automated translation; ask for supported-construct coverage measured on a sample of your own code.

If you need a complete web rewrite: EPAM Systems. They specialize in re-engineering desktop apps into cloud-native web platforms (React/Angular + .NET Core).

If you need cost-effective refactoring: N-iX. They provide strong manual refactoring services to clean up the "spaghetti code" post-migration.

If you need long-term legacy management: Fresche. They offer a holistic approach to managing and modernizing legacy portfolios.

If you have a small budget/app: Feathersoft. Good for straightforward porting projects with minimal architectural changes.

Red flags:

• Vendors who promise "100% automated migration" (the unconverted remainder takes disproportionate time)
• No plan for replacing ActiveX/OCX controls (grids, charts)
• Suggesting to keep using COM Interop indefinitely
• Ignoring the "Event Loop" architectural difference (VB6 vs .NET)

---

Section 03

When to Hire VB6 to .NET Migration Services

1. Windows OS Compatibility Risks

VB6 runtime is technically supported on Windows 10/11, but the IDE is not. You cannot install the development environment on modern machines without hacks.

Trigger: Developers cannot compile the code on Windows 11 laptops; reliance on a single "build machine" running Windows XP/7.

2. Security & Compliance Failures

Your VB6 app uses old encryption libraries (MD5, SHA1) or cannot support TLS 1.2+. It fails modern security audits (SOC2, PCI-DSS).

Trigger: Security audit finding "Critical" due to weak crypto; inability to integrate with modern SSO (Okta/Azure AD).

3. Dependency Rot (ActiveX/OCX)

Your app relies on a 3rd party grid control (e.g., TrueDBGrid 6.0) from a vendor that went out of business in 2005. You lost the installer keys.

Trigger: Cannot reinstall the app on new PCs because OCX registration fails; "Class not registered" errors.

4. Integration Roadblocks

The business wants to expose app data to a mobile app or web portal. VB6 has no native REST API support. You're building fragile "file drop" integrations.

Trigger: Business demands a mobile dashboard; integration projects take 3x longer than expected due to legacy hacks.

5. Talent Scarcity

You have one developer named "Bob" who knows the codebase. Bob is retiring in 6 months. No new hire wants to touch VB6.

Trigger: "Bus factor" of 1; inability to hire replacement developers.

---

Section 04

Total Cost of Ownership: VB6 vs .NET

The split below is an illustrative allocation for a hypothetical $450K project, not a measured benchmark.

Hidden Costs NOT Included:

• Report Rewrites: Crystal Reports 8.5 files often need complete recreation in SSRS or PowerBI.
• Installer Logic: Rewriting complex InstallShield scripts into MSIX or ClickOnce.
• Help Files: Converting .hlp (WinHelp) files which are no longer supported to .chm or web-based help.

Break-Even Analysis: Divide one-time investment by documented annual maintenance savings (for example .NET developer cost versus VB6 contractors), net of new run costs, and include the parallel-run period. Risk avoidance, such as avoiding a business stoppage if a key developer leaves, is real but is not quantified here; treat it separately from the payback calculation.

---

Section 05

VB6 to .NET Migration Roadmap

Phase 1: Assessment & Inventory (Weeks 1-4)

Activities:

• Scan codebase for LOC, form count, and 3rd party dependencies (OCX/DLLs)
• Identify "dead code" (often a meaningful share of a VB6 app is unused; measure yours)
• Select target architecture (Desktop WinForms vs Web Blazor/React)
• Proof of Concept (POC): Migrate 1 complex form end-to-end

Deliverables:

• Inventory spreadsheet with complexity scoring
• POC application
• Migration strategy document

---

Phase 2: Automated Conversion & Fix (Months 2-6)

Activities:

• Run automated tool (VBUC) to generate C# code
• Fix compilation errors (thousands of them)
• Replace unsupported keywords (On Error Resume Next, GoSub)
• Replace 3rd party controls with .NET equivalents (Telerik/DevExpress)

Risks:

• "The Last Mile": Automated tools get you most of the way there, but the remainder (graphics, printing, hardware calls) is hard.

Deliverables:

• Compilable C# solution
• UI that renders (even if logic is broken)

---

Phase 3: Logic Refactoring & Data Access (Months 7-10)

Activities:

• Rewrite ADO Recordset logic to Entity Framework or Dapper
• Extract business logic from UI code-behind (Button_Click) into Services
• Implement Unit Tests for critical calculations (impossible in VB6)

Risks:

• Subtle logic bugs (e.g., VB6 1-based arrays vs C# 0-based arrays)
• Date/Currency formatting differences

Deliverables:

• Functional application connected to DB
• Unit test suite covering core logic

---

Phase 4: QA & UAT (Months 11-14)

Activities:

• Parallel testing: Run VB6 and .NET apps side-by-side
• Compare outputs (reports, calculations) bit-by-bit
• Performance tuning (garbage collection tuning, query optimization)

Deliverables:

• Signed-off UAT
• Production deployment plan

---

Section 06

Post-Migration: Best Practices

Months 1-3: Stabilization

• Memory Management: Watch for memory leaks. VB6 used deterministic destruction (COM); .NET uses Garbage Collection. You may need to manually Dispose() resources.
• User Training: If you moved to Web, train users on browser behaviors (back button, refresh).

Months 4-6: Modernization

• CI/CD: Set up Azure DevOps/GitHub Actions pipelines (impossible with VB6).
• Containerization: If you migrated to .NET Core/Web, containerize with Docker for easy deployment.

---

Section 07

Expanded FAQs

Should we migrate to WinForms, WPF, or Web?

Answer: WinForms: Fastest/Cheapest (closest to VB6 model), but "dead end" tech. WPF: Better styling, but steep learning curve (XAML). Web (Blazor/React): Best for future-proofing and remote access, but most expensive (stateless architecture change). Recommendation: If it's a back-office data entry app, Blazor is the sweet spot.

Can we keep the database as is?

Answer: Yes, usually. You can keep the SQL Server/Oracle DB structure. However, you should replace the data access layer (ADO) in the code. Don't use ADODB.Recordset in .NET via COM Interop - it's slow and buggy. Rewrite using ADO.NET or Dapper.

What about "On Error Resume Next"?

Answer: This VB6 command suppresses all errors and continues execution. It is the root of many hidden bugs. Automated tools often translate this to try { ... } catch { } (swallowing errors). You MUST manually review these blocks to implement proper error handling, or your .NET app will fail silently.

How do we handle 3rd party controls (ActiveX)?

Answer: You cannot use 32-bit ActiveX controls in a 64-bit .NET app reliably. You must replace them. Vendors like Telerik, DevExpress, and Infragistics have .NET equivalents for most grids and charts. Budget significant time for re-wiring the events and properties of these new controls.

Is a "Big Bang" rewrite better?

Answer: Almost never. Rewriting from scratch without looking at the old code leads to "Second System Effect" (over-engineering) and missing critical business rules hidden in the spaghetti code. We recommend a Port-then-Refactor approach: Port the code to C# first (even if ugly), verify it works, THEN refactor it.

---

Evidence note: Earlier versions of this page cited project counts, median costs and timelines, and success rates that could not be reproduced from available records; they have been withdrawn. Cost and timeline ranges are editorial scoping ranges, not supplier quotes. See our methodology.

---

Section 08

Risk Factors

COM Dependency Hell

VB6 applications are tightly coupled with COM components. .NET uses a completely different interop model. Vendors who promise 'automated migration' often ignore this, resulting in fragile COM Interop wrappers that crash in production.

ActiveX/OCX Dependencies

VB6 apps often rely on 3rd party controls (grids, charts, calendars) that have no direct .NET equivalent. You must find modern replacements (e.g., Telerik, DevExpress) and rewrite the interaction logic manually.

The 'Spaghetti Code' Event Loop

VB6 encourages putting business logic directly into UI event handlers (Button_Click). Migrating this to a clean MVVM or MVC architecture requires extracting logic, not just translating syntax.

Graphics & Printing (GDI)

VB6 used GDI for drawing and the Printer object for reporting. .NET uses GDI+ or completely different reporting engines (SSRS, Crystal). Direct translation of printing logic almost always fails.

---

Section 09

Feasibility Analysis

Ideal candidates

• Application runs on unsupported Windows versions
• Security compliance requires modern TLS/Auth
• Need to expose functionality via API

Break-even cost: $150k Talent risk: Medium. VB6 devs are rare, but logic is readable by .NET devs.