jorge.burgos/rc-migration-tests
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Enhance documentation for migration process

Browse Source
This commit is contained in:
Jorge Burgos 2025-01-31 16:22:23 -05:00
parent b10f40dd28
commit adc8cbfcff
1 changed files with 270 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

301
vb-migration/VB-CS-migration-guide.md
View File

@ -33,57 +33,296 @@ This guide outlines the process for migrating from VB.NET Framework to C# .NET 8
## Phase 1: Framework Migration (VB.NET to .NET 8) ## Phase 1: Framework Migration (VB.NET to .NET 8)
### Step 1: Environment Setup ### Step 1: Environment Setup
1. Install required tools:
```bash 1. **Development Environment Preparation**
dotnet tool install -g upgrade-assistant - Install Visual Studio 2022 (recommended) or later
dotnet tool install -g ICSharpCode.CodeConverter.Cli - Install the latest .NET 8 SDK
``` - Install required tools:
2. Set up version control and backup ```bash
3. Create separate environments for testing dotnet tool install -g upgrade-assistant
dotnet tool install -g ICSharpCode.CodeConverter.Cli
```
2. **Source Control Setup**
- Create a new branch for migration
- Tag the last stable version
- Set up branch protection rules
- Configure CI/CD pipeline for multiple frameworks
3. **Testing Environment**
- Create separate test environments for:
- Original .NET Framework version
- Intermediate builds
- Final .NET 8 version
- Set up automated testing pipeline
- Configure monitoring tools
*AI Enhancement*: Use Claude to:
- Generate environment comparison checklists
- Create testing strategy documentation
- Suggest monitoring metrics
### Step 2: Initial Analysis ### Step 2: Initial Analysis
1. Run .NET Upgrade Assistant analysis:
1. **Project Assessment**
```bash ```bash
# Analyze solution with upgrade-assistant
upgrade-assistant analyze your-solution.sln upgrade-assistant analyze your-solution.sln
# Generate detailed report
upgrade-assistant analyze your-solution.sln --verbose > migration-analysis.txt
```
2. **Dependency Analysis**
- Run Visual Studio dependency analysis
- Document all NuGet packages
- Identify deprecated packages
- Map external service dependencies
*AI Enhancement*: Use Claude to:
- Analyze dependency compatibility
- Suggest modern package alternatives
- Review service integration patterns
- Generate dependency migration plan
3. **Framework-Specific Code Analysis**
- Identify WebForms dependencies
- List WCF service usage
- Document System.Web dependencies
- Review app.config settings
*AI Enhancement*: Use Windsurf to:
- Identify security-critical code
- Review configuration patterns
- Suggest modern security practices
4. **Database Access Review**
- Document ADO.NET usage
- Review Entity Framework version
- Check stored procedure calls
- Analyze transaction patterns
### Step 3: Framework Migration Execution
1. **Project File Updates**
- Back up original project files
- Update target framework:
```xml
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
</PropertyGroup>
```
- Update SDK reference:
```xml
<Project Sdk="Microsoft.NET.Sdk">
```
2. **Package Migration**
```bash
# Run upgrade-assistant for package updates
upgrade-assistant upgrade your-solution.sln
``` ```
*AI Enhancement*: Use Claude to: *AI Enhancement*: Use Claude to:
- Analyze framework-specific dependencies - Review package updates
- Identify outdated patterns - Identify potential conflicts
- Suggest modern alternatives - Suggest optimal package versions
- Review upgrade-assistant recommendations
2. Document dependencies and framework-specific code 3. **Configuration Migration**
- Move from app.config/web.config to appsettings.json
- Update connection strings
- Migrate custom configuration sections
- Update startup configuration
*AI Enhancement*: Use Windsurf to: *AI Enhancement*: Use Windsurf to:
- Identify security implications - Review security settings
- Suggest secure alternatives - Validate configuration patterns
- Review configuration settings - Check for sensitive data exposure
### Step 3: Framework Migration Execution 4. **Framework-Specific Updates**
1. Start with smallest, least dependent modules
2. Run upgrade assistant: a. **Web Applications**
```bash - Replace WebForms with Blazor or MVC
upgrade-assistant upgrade your-solution.sln - Update HTTP handlers
``` - Migrate module registrations
3. Update package references - Update routing configuration
4. Fix compatibility issues
b. **WCF Services**
- Migrate to gRPC or Web API
- Update service contracts
- Migrate fault contracts
- Update client proxies
c. **Data Access**
- Update Entity Framework
- Migrate to EF Core if applicable
- Update connection handling
- Review transaction scopes
5. **Incremental Testing**
- Unit test execution
- Integration test validation
- Performance comparison
- Security validation
*AI Enhancement*: Use Claude to:
- Analyze test results
- Identify potential regressions
- Suggest test coverage improvements
### Step 4: Post-Framework Migration
1. **Performance Optimization**
- Run performance profiling
- Compare metrics with baseline
- Identify bottlenecks
- Implement improvements
*AI Enhancement*: Use Windsurf to:
- Identify performance issues
- Suggest optimization strategies
- Review resource usage
2. **Security Review**
- Run security scanning tools
- Review authentication changes
- Validate authorization
- Check data protection
*AI Enhancement*: Use Claude to:
- Review security patterns
- Suggest security improvements
- Generate security documentation
3. **Documentation Update**
- Update API documentation
- Document breaking changes
- Update deployment guides
- Create migration notes
*AI Enhancement*: Use Claude to:
- Generate change documentation
- Create API difference reports
- Update integration guides
## Phase 2: Language Migration (VB.NET to C#) ## Phase 2: Language Migration (VB.NET to C#)
### Step 1: Code Conversion ### Step 1: Code Conversion Options
1. Use ICSharpCode.CodeConverter:
#### Option A: Visual Studio Extension Method (Recommended for single files/classes)
1. **Install the Code Converter Extension**
- Open Visual Studio
- Go to Extensions → Manage Extensions
- Search for "Code Converter"
- Install "VB to C# Code Converter"
- Restart Visual Studio
2. **Converting Individual Files**
- Open the VB.NET file you want to convert
- Right-click in the code editor
- Select "Paste as C#" if you have code in clipboard, or
- Select "Convert to C#" for the current file
3. **Converting Multiple Files or Entire Project**
- In Solution Explorer, select multiple files or a project
- Right-click the selection
- Choose "Convert to C#"
- Select target location for converted files
*AI Enhancement*: Use Claude to:
- Review the converted code structure
- Identify patterns that could be modernized
- Suggest C# 8+ specific features to implement
4. **Post-Conversion File Review**
- Check file encoding (should be UTF-8)
- Verify namespace organization
- Review class accessibility modifiers
- Check Event handler conversions
- Verify LINQ syntax conversions
#### Option B: Command Line Conversion (Recommended for full projects)
1. **Install the CLI Tool**
```bash
dotnet tool install -g ICSharpCode.CodeConverter.Cli
```
2. **Convert Entire Project**
```bash ```bash
code-converter convert-project <source-project-file> -l VB2CS -t ConvertedProject code-converter convert-project <source-project-file> -l VB2CS -t ConvertedProject
``` ```
3. **Available Command Line Options**
```bash
# Preserve case when converting
code-converter convert-project MyProject.vbproj -l VB2CS -t ConvertedProject --preserve-case
# Skip resources conversion
code-converter convert-project MyProject.vbproj -l VB2CS -t ConvertedProject --skip-resources
# Specify custom mapping file
code-converter convert-project MyProject.vbproj -l VB2CS -t ConvertedProject --mapping-file custom-mappings.json
```
### Step 2: Common Conversion Points to Review
1. **Language-Specific Features**
- MyBase vs base
- MyClass vs this
- WithEvents conversions
- Default property conversions
*AI Enhancement*: Use Claude to: *AI Enhancement*: Use Claude to:
- Review converted code - Identify VB.NET specific patterns
- Identify potential bugs - Suggest C# idiomatic alternatives
- Suggest modern C# features - Review automated conversions
- Optimize code patterns
### Step 2: Post-Conversion Tasks 2. **Event Handler Patterns**
- Check delegate signatures
- Verify event wire-up locations
- Review AddHandler/RemoveHandler conversions
*AI Enhancement*: Use Windsurf to:
- Validate event pattern security
- Check for potential memory leaks
- Suggest modern event patterns
3. **Type Conversions**
- Check CType conversions
- Review DirectCast usage
- Verify TryCast implementations
*AI Enhancement*: Use Claude to:
- Suggest pattern matching alternatives
- Identify type conversion optimizations
- Review null-handling patterns
### Step 3: Specific Code Pattern Reviews
1. **LINQ and Collection Operations**
- Review converted LINQ expressions
- Check collection initializers
- Verify lambda expressions
- Review query expressions
*AI Enhancement*: Use Claude to:
- Suggest modern LINQ patterns
- Identify performance optimizations
- Review collection access patterns
2. **Async/Await Patterns**
- Check async method signatures
- Review exception handling in async code
- Verify Task usage patterns
*AI Enhancement*: Use Windsurf to:
- Validate async pattern security
- Check for deadlock possibilities
- Review resource cleanup
### Step 4: Post-Conversion Tasks
1. **Code Review** 1. **Code Review**
- Review generated C# code - Review generated C# code
- Apply C# best practices - Apply C# best practices