🎯 마이그레이션 대상 프레임워크 선택하기

자, 이제 마이그레이션을 하기로 결정했다면 가장 중요한 질문이 나와. "어떤 프레임워크로 옮길 것인가?" 이게 정말 중요한 결정이야. 왜냐하면 한 번 선택하면 다시 바꾸기 어렵거든. 🎲

내 경험상, 대부분의 경우 WPF가 가장 안전한 선택이야. 특히 기존 WinForms 프로젝트가 Windows 전용이고, 데스크톱 환경에서만 사용된다면 말이야. WPF는 검증된 기술이고, 문제가 생겼을 때 해결 방법을 찾기도 쉬워. 😎

하지만 만약 모바일이나 웹 확장을 고려하고 있다면? 그럼 .NET MAUI나 Blazor를 진지하게 고민해봐야 해. 특히 요즘은 "어디서든 접근 가능한" 애플리케이션이 대세잖아? 사무실 PC에서만 쓰던 프로그램을 집에서도, 카페에서도, 심지어 스마트폰으로도 쓸 수 있다면 얼마나 편할까? 📱💻

🗺️ 마이그레이션 전략 수립하기

자, 이제 어떤 프레임워크로 갈지 정했다면, 본격적으로 마이그레이션 전략을 세워야 해. 여기서 가장 중요한 건 "한 번에 다 바꾸려고 하지 마!"라는 거야. 진짜로, 이게 가장 많이 실패하는 패턴이거든. 😰

📋 Big Bang vs Strangler Fig 패턴

마이그레이션에는 크게 두 가지 접근 방식이 있어:

내 경험상 Strangler Fig 방식을 강력 추천해. 실제로 대부분의 성공적인 마이그레이션 프로젝트들이 이 방식을 사용했어. 왜냐하면:

🎯 구체적인 마이그레이션 로드맵

자, 그럼 실제로 어떻게 진행하면 될까? 단계별로 살펴보자:

이 로드맵은 중간 규모 프로젝트 (화면 50-100개 정도)를 기준으로 한 거야. 프로젝트 규모에 따라 기간은 조정해야 해. 작은 프로젝트라면 6개월, 큰 프로젝트라면 2년도 걸릴 수 있어. ⏰

🔧 실전 마이그레이션 기술과 패턴

이제 본격적으로 코드 레벨에서 어떻게 마이그레이션하는지 알아보자. WinForms에서 WPF로 가는 경우를 예시로 들게! (다른 프레임워크도 개념은 비슷해) 🛠️

🏗️ 아키텍처 패턴 전환: Code-Behind에서 MVVM으로

WinForms의 가장 큰 문제 중 하나가 뭐냐면, UI 코드와 비즈니스 로직이 뒤섞여 있다는 거야. 버튼 클릭 이벤트 핸들러 안에 데이터베이스 쿼리가 있고, 그 안에 또 UI 업데이트 코드가 있고... 이런 식이지. 😱

WPF로 넘어가면서 가장 중요한 건 MVVM (Model-View-ViewModel) 패턴을 제대로 적용하는 거야. 이게 처음엔 좀 어렵게 느껴질 수 있는데, 익숙해지면 정말 깔끔해져.

실제 코드로 비교해볼까? 먼저 WinForms 스타일:

// WinForms - Code-Behind 방식
public partial class CustomerForm : Form
{
    private CustomerService _service = new CustomerService();
    
    public CustomerForm()
    {
        InitializeComponent();
    }
    
    private void btnSave_Click(object sender, EventArgs e)
    {
        // UI에서 직접 데이터 가져오기
        var customer = new Customer
        {
            Name = txtName.Text,
            Email = txtEmail.Text,
            Phone = txtPhone.Text
        };
        
        // 유효성 검사도 여기서
        if (string.IsNullOrEmpty(customer.Name))
        {
            MessageBox.Show("이름을 입력하세요!");
            return;
        }
        
        // 비즈니스 로직 호출
        try
        {
            _service.SaveCustomer(customer);
            MessageBox.Show("저장 완료!");
            this.Close();
        }
        catch (Exception ex)
        {
            MessageBox.Show("오류: " + ex.Message);
        }
    }
    
    private void btnLoad_Click(object sender, EventArgs e)
    {
        var customers = _service.GetAllCustomers();
        dataGridView1.DataSource = customers;
    }
}

이제 WPF + MVVM 스타일을 보자:

// WPF - ViewModel
public class CustomerViewModel : INotifyPropertyChanged
{
    private readonly CustomerService _service;
    private string _name;
    private string _email;
    private string _phone;
    private ObservableCollection<Customer> _customers;
    
    public CustomerViewModel()
    {
        _service = new CustomerService();
        SaveCommand = new RelayCommand(Save, CanSave);
        LoadCommand = new RelayCommand(Load);
        Customers = new ObservableCollection<Customer>();
    }
    
    // 데이터 바인딩을 위한 프로퍼티
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            OnPropertyChanged();
            SaveCommand.RaiseCanExecuteChanged();
        }
    }
    
    public string Email
    {
        get => _email;
        set
        {
            _email = value;
            OnPropertyChanged();
        }
    }
    
    public string Phone
    {
        get => _phone;
        set
        {
            _phone = value;
            OnPropertyChanged();
        }
    }
    
    public ObservableCollection<Customer> Customers
    {
        get => _customers;
        set
        {
            _customers = value;
            OnPropertyChanged();
        }
    }
    
    // 커맨드 패턴
    public RelayCommand SaveCommand { get; }
    public RelayCommand LoadCommand { get; }
    
    private bool CanSave()
    {
        return !string.IsNullOrEmpty(Name);
    }
    
    private async void Save()
    {
        var customer = new Customer
        {
            Name = Name,
            Email = Email,
            Phone = Phone
        };
        
        try
        {
            await _service.SaveCustomerAsync(customer);
            // 메시지는 View에서 처리하도록 이벤트 발생
            MessageBox.Show("저장 완료!");
            ClearForm();
        }
        catch (Exception ex)
        {
            MessageBox.Show($"오류: {ex.Message}");
        }
    }
    
    private async void Load()
    {
        var customers = await _service.GetAllCustomersAsync();
        Customers = new ObservableCollection<Customer>(customers);
    }
    
    private void ClearForm()
    {
        Name = string.Empty;
        Email = string.Empty;
        Phone = string.Empty;
    }
    
    public event PropertyChangedEventHandler PropertyChanged;
    
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

그리고 XAML View는 이렇게:

<Window x:Class="ModernApp.Views.CustomerView"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="고객 관리" Height="450" Width="600">
    
    <Window.DataContext>
        <local:CustomerViewModel />
    </Window.DataContext>
    
    <Grid Margin="20">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        
        <!-- 데이터 바인딩으로 UI와 ViewModel 연결 -->
        <StackPanel Grid.Row="0" Margin="0,0,0,10">
            <TextBlock Text="이름" FontWeight="Bold"/>
            <TextBox Text="{Binding Name, UpdateSourceTrigger=PropertyChanged}" 
                     Padding="5" FontSize="14"/>
        </StackPanel>
        
        <StackPanel Grid.Row="1" Margin="0,0,0,10">
            <TextBlock Text="이메일" FontWeight="Bold"/>
            <TextBox Text="{Binding Email, UpdateSourceTrigger=PropertyChanged}" 
                     Padding="5" FontSize="14"/>
        </StackPanel>
        
        <StackPanel Grid.Row="2" Margin="0,0,0,10">
            <TextBlock Text="전화번호" FontWeight="Bold"/>
            <TextBox Text="{Binding Phone, UpdateSourceTrigger=PropertyChanged}" 
                     Padding="5" FontSize="14"/>
        </StackPanel>
        
        <StackPanel Grid.Row="3" Orientation="Horizontal" Margin="0,0,0,20">
            <Button Content="저장" 
                    Command="{Binding SaveCommand}" 
                    Width="100" Height="35" Margin="0,0,10,0"/>
            <Button Content="목록 불러오기" 
                    Command="{Binding LoadCommand}" 
                    Width="120" Height="35"/>
        </StackPanel>
        
        <DataGrid Grid.Row="4" 
                  ItemsSource="{Binding Customers}" 
                  AutoGenerateColumns="True"
                  IsReadOnly="True"/>
    </Grid>
</Window>

차이가 느껴져? WPF 버전이 코드가 더 많아 보이지만, 실제로는 훨씬 더 유지보수하기 쉬워. 왜냐하면:

🔄 데이터 바인딩 마이그레이션

WinForms에서 가장 많이 쓰는 패턴 중 하나가 DataGridView에 데이터 바인딩하는 거잖아? WPF에서는 이게 훨씬 강력해져.

WinForms 방식:

// WinForms - 수동 바인딩
private void LoadData()
{
    var customers = _service.GetCustomers();
    dataGridView1.DataSource = customers;
    
    // 컬럼 설정도 수동으로
    dataGridView1.Columns["Id"].Visible = false;
    dataGridView1.Columns["Name"].HeaderText = "고객명";
    dataGridView1.Columns["Email"].Width = 200;
}

// 데이터 변경 감지도 수동
private void dataGridView1_CellValueChanged(object sender, DataGridViewCellEventArgs e)
{
    // 변경된 데이터 저장 로직
    var customer = (Customer)dataGridView1.Rows[e.RowIndex].DataBoundItem;
    _service.UpdateCustomer(customer);
}

WPF 방식:

// WPF - 자동 바인딩
public class CustomerViewModel : ViewModelBase
{
    private ObservableCollection<Customer> _customers;
    
    public ObservableCollection<Customer> Customers
    {
        get => _customers;
        set
        {
            _customers = value;
            OnPropertyChanged();
        }
    }
    
    private async void LoadData()
    {
        var customers = await _service.GetCustomersAsync();
        // ObservableCollection이 자동으로 UI 업데이트
        Customers = new ObservableCollection<Customer>(customers);
    }
}

XAML에서는:

<DataGrid ItemsSource="{Binding Customers}" 
          AutoGenerateColumns="False"
          CanUserAddRows="True"
          CanUserDeleteRows="True">
    <DataGrid.Columns>
        <DataGridTextColumn Header="고객명" 
                           Binding="{Binding Name}" 
                           Width="*"/>
        <DataGridTextColumn Header="이메일" 
                           Binding="{Binding Email}" 
                           Width="2*"/>
        <DataGridTextColumn Header="전화번호" 
                           Binding="{Binding Phone}" 
                           Width="*"/>
        <DataGridTemplateColumn Header="상태" Width="100">
            <DataGridTemplateColumn.CellTemplate>
                <DataTemplate>
                    <Border Background="{Binding Status, Converter={StaticResource StatusColorConverter}}"
                            CornerRadius="3" Padding="5">
                        <TextBlock Text="{Binding Status}" 
                                  HorizontalAlignment="Center"
                                  Foreground="White"/>
                    </Border>
                </DataTemplate>
            </DataGridTemplateColumn.CellTemplate>
        </DataGridTemplateColumn>
    </DataGrid.Columns>
</DataGrid>

보다시피 WPF에서는 ObservableCollection을 사용하면 컬렉션에 아이템을 추가하거나 제거할 때 UI가 자동으로 업데이트돼. 이게 진짜 편해! 🎉

🎨 UI 컨트롤 마이그레이션 가이드

자, 이제 실제로 각 컨트롤들을 어떻게 마이그레이션하는지 알아보자. WinForms와 WPF의 컨트롤 대응표를 만들어봤어! 📊

🖼️ 레이아웃 마이그레이션의 핵심

WinForms에서 가장 큰 변화 중 하나가 레이아웃 시스템이야. WinForms는 절대 좌표 (X, Y, Width, Height)를 사용하지만, WPF는 유연한 레이아웃 패널을 사용해. 이게 처음엔 어색하지만, 익숙해지면 훨씬 강력해! 💪

WinForms 스타일:

// WinForms - 절대 좌표
Label lblName = new Label();
lblName.Location = new Point(10, 10);
lblName.Size = new Size(100, 20);
lblName.Text = "이름:";

TextBox txtName = new TextBox();
txtName.Location = new Point(120, 10);
txtName.Size = new Size(200, 20);

Button btnSave = new Button();
btnSave.Location = new Point(120, 40);
btnSave.Size = new Size(100, 30);
btnSave.Text = "저장";

this.Controls.Add(lblName);
this.Controls.Add(txtName);
this.Controls.Add(btnSave);

WPF 스타일 (여러 방법이 있어!):

<!-- 방법 1: Grid 사용 (가장 유연함) -->
<Grid Margin="10">
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto"/>
        <RowDefinition Height="Auto"/>
    </Grid.RowDefinitions>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="Auto"/>
        <ColumnDefinition Width="*"/>
    </Grid.ColumnDefinitions>
    
    <TextBlock Grid.Row="0" Grid.Column="0" 
               Text="이름:" VerticalAlignment="Center" Margin="0,0,10,0"/>
    <TextBox Grid.Row="0" Grid.Column="1" 
             Text="{Binding Name}" Margin="0,0,0,10"/>
    
    <Button Grid.Row="1" Grid.Column="1" 
            Content="저장" Command="{Binding SaveCommand}" 
            HorizontalAlignment="Left" Width="100"/>
</Grid>

<!-- 방법 2: StackPanel 사용 (간단한 경우) -->
<StackPanel Margin="10">
    <StackPanel Orientation="Horizontal" Margin="0,0,0,10">
        <TextBlock Text="이름:" Width="100" VerticalAlignment="Center"/>
        <TextBox Text="{Binding Name}" Width="200"/>
    </StackPanel>
    <Button Content="저장" Command="{Binding SaveCommand}" 
            Width="100" HorizontalAlignment="Left"/>
</StackPanel>

WPF의 레이아웃 시스템이 좋은 이유는:

🎭 스타일과 테마 적용

WPF의 진짜 강점 중 하나가 스타일링이야. WinForms에서는 각 컨트롤의 속성을 일일이 설정해야 했지만, WPF에서는 스타일을 한 번 정의하면 전체 앱에 적용할 수 있어! 🎨

<!-- App.xaml 또는 ResourceDictionary에 정의 -->
<Application.Resources>
    <!-- 기본 버튼 스타일 -->
    <Style TargetType="Button">
        <Setter Property="Background" Value="#4A90E2"/>
        <Setter Property="Foreground" Value="White"/>
        <Setter Property="Padding" Value="15,8"/>
        <Setter Property="FontSize" Value="14"/>
        <Setter Property="BorderThickness" Value="0"/>
        <Setter Property="Cursor" Value="Hand"/>
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="Button">
                    <Border Background="{TemplateBinding Background}"
                            CornerRadius="5"
                            Padding="{TemplateBinding Padding}">
                        <ContentPresenter HorizontalAlignment="Center"
                                        VerticalAlignment="Center"/>
                    </Border>
                    <ControlTemplate.Triggers>
                        <Trigger Property="IsMouseOver" Value="True">
                            <Setter Property="Background" Value="#357ABD"/>
                        </Trigger>
                        <Trigger Property="IsPressed" Value="True">
                            <Setter Property="Background" Value="#2A5F8F"/>
                        </Trigger>
                        <Trigger Property="IsEnabled" Value="False">
                            <Setter Property="Background" Value="#CCCCCC"/>
                            <Setter Property="Foreground" Value="#666666"/>
                        </Trigger>
                    </ControlTemplate.Triggers>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
    
    <!-- Primary 버튼 스타일 (기본 스타일 상속) -->
    <Style x:Key="PrimaryButton" TargetType="Button" BasedOn="{StaticResource {x:Type Button}}">
        <Setter Property="Background" Value="#E74C3C"/>
    </Style>
    
    <!-- TextBox 스타일 -->
    <Style TargetType="TextBox">
        <Setter Property="Padding" Value="8"/>
        <Setter Property="FontSize" Value="14"/>
        <Setter Property="BorderBrush" Value="#DDDDDD"/>
        <Setter Property="BorderThickness" Value="1"/>
        <Style.Triggers>
            <Trigger Property="IsFocused" Value="True">
                <Setter Property="BorderBrush" Value="#4A90E2"/>
                <Setter Property="BorderThickness" Value="2"/>
            </Trigger>
            <Trigger Property="Validation.HasError" Value="True">
                <Setter Property="BorderBrush" Value="#E74C3C"/>
            </Trigger>
        </Style.Triggers>
    </Style>
</Application.Resources>

이렇게 정의하면 앱 전체의 모든 버튼과 텍스트박스가 자동으로 이 스타일을 적용받아. 나중에 디자인을 바꾸고 싶으면? 이 스타일만 수정하면 끝! 🎉

⚡ 성능 최적화와 비동기 프로그래밍

마이그레이션하면서 꼭 개선해야 할 부분이 하나 더 있어. 바로 비동기 프로그래밍이야! WinForms 시절에는 무거운 작업을 할 때 UI가 멈추는 게 흔했잖아? 이제는 그런 시대가 아니야. 😎

🔄 동기에서 비동기로

WinForms에서 흔히 보던 패턴:

// WinForms - 동기 방식 (UI가 멈춤!)
private void btnLoad_Click(object sender, EventArgs e)
{
    // UI 스레드를 블록킹
    this.Cursor = Cursors.WaitCursor;
    btnLoad.Enabled = false;
    
    try
    {
        // 오래 걸리는 작업
        var data = _service.LoadLargeData(); // 5초 걸림
        dataGridView1.DataSource = data;
    }
    finally
    {
        this.Cursor = Cursors.Default;
        btnLoad.Enabled = true;
    }
}

// 또는 BackgroundWorker 사용 (복잡함)
private void btnLoad_Click(object sender, EventArgs e)
{
    BackgroundWorker worker = new BackgroundWorker();
    worker.DoWork += (s, args) =>
    {
        args.Result = _service.LoadLargeData();
    };
    worker.RunWorkerCompleted += (s, args) =>
    {
        dataGridView1.DataSource = args.Result;
        this.Cursor = Cursors.Default;
    };
    
    this.Cursor = Cursors.WaitCursor;
    worker.RunWorkerAsync();
}

WPF에서 async/await 사용:

// WPF - 비동기 방식 (UI가 부드러움!)
public class DataViewModel : ViewModelBase
{
    private bool _isLoading;
    private ObservableCollection<DataItem> _items;
    
    public bool IsLoading
    {
        get => _isLoading;
        set
        {
            _isLoading = value;
            OnPropertyChanged();
            LoadCommand.RaiseCanExecuteChanged();
        }
    }
    
    public ObservableCollection<DataItem> Items
    {
        get => _items;
        set
        {
            _items = value;
            OnPropertyChanged();
        }
    }
    
    public RelayCommand LoadCommand { get; }
    
    public DataViewModel()
    {
        LoadCommand = new RelayCommand(async () => await LoadDataAsync(), () => !IsLoading);
        Items = new ObservableCollection<DataItem>();
    }
    
    private async Task LoadDataAsync()
    {
        IsLoading = true;
        
        try
        {
            // 비동기로 데이터 로드 (UI는 계속 반응함!)
            var data = await _service.LoadLargeDataAsync();
            
            // UI 스레드에서 안전하게 업데이트
            Items = new ObservableCollection<DataItem>(data);
        }
        catch (Exception ex)
        {
            // 에러 처리
            await ShowErrorAsync(ex.Message);
        }
        finally
        {
            IsLoading = false;
        }
    }
}

XAML에서는 로딩 상태 표시:

<Grid>
    <!-- 데이터 그리드 -->
    <DataGrid ItemsSource="{Binding Items}" 
              Visibility="{Binding IsLoading, Converter={StaticResource InverseBoolToVisibilityConverter}}"/>
    
    <!-- 로딩 인디케이터 -->
    <StackPanel HorizontalAlignment="Center" 
                VerticalAlignment="Center"
                Visibility="{Binding IsLoading, Converter={StaticResource BoolToVisibilityConverter}}">
        <ProgressBar IsIndeterminate="True" Width="200" Height="20"/>
        <TextBlock Text="데이터를 불러오는 중..." 
                  Margin="0,10,0,0" 
                  HorizontalAlignment="Center"/>
    </StackPanel>
</Grid>

이렇게 하면 사용자는 데이터가 로딩되는 동안에도 창을 움직이거나 다른 작업을 할 수 있어. 훨씬 부드러운 경험이지! ✨

💾 데이터 액세스 레이어 현대화

마이그레이션하면서 데이터 액세스 방식도 개선해보자. WinForms 시절에는 ADO.NET을 직접 쓰거나 DataSet을 많이 썼는데, 이제는 더 좋은 방법들이 있어!

// 옛날 방식 - ADO.NET 직접 사용
public List<Customer> GetCustomers()
{
    var customers = new List<Customer>();
    
    using (var connection = new SqlConnection(_connectionString))
    {
        connection.Open();
        var command = new SqlCommand("SELECT * FROM Customers", connection);
        
        using (var reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                customers.Add(new Customer
                {
                    Id = (int)reader["Id"],
                    Name = reader["Name"].ToString(),
                    Email = reader["Email"].ToString()
                });
            }
        }
    }
    
    return customers;
}

// 현대적 방식 - Entity Framework Core
public class AppDbContext : DbContext
{
    public DbSet<Customer> Customers { get; set; }
    
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(_connectionString);
    }
}

// 사용하기
public async Task<List<Customer>> GetCustomersAsync()
{
    using (var context = new AppDbContext())
    {
        return await context.Customers
            .Where(c => c.IsActive)
            .OrderBy(c => c.Name)
            .ToListAsync();
    }
}

// 또는 Dapper 사용 (가볍고 빠름)
public async Task<List<Customer>> GetCustomersAsync()
{
    using (var connection = new SqlConnection(_connectionString))
    {
        return (await connection.QueryAsync<Customer>(
            "SELECT * FROM Customers WHERE IsActive = 1 ORDER BY Name"
        )).ToList();
    }
}

Entity Framework Core나 Dapper를 사용하면:

🧪 테스트 전략과 품질 보증

마이그레이션 프로젝트에서 가장 무서운 게 뭔지 알아? "새 버전이 기존 버전과 똑같이 동작하는가?"를 확인하는 거야. 기능이 100개면 100개를 다 테스트해야 하거든. 😰

그래서 자동화된 테스트가 정말 중요해! WinForms 시절에는 테스트 작성이 어려웠지만, MVVM 패턴을 사용하면 훨씬 쉬워져.

✅ 단위 테스트 작성

// xUnit을 사용한 ViewModel 테스트
public class CustomerViewModelTests
{
    private readonly Mock<ICustomerService> _mockService;
    private readonly CustomerViewModel _viewModel;
    
    public CustomerViewModelTests()
    {
        _mockService = new Mock<ICustomerService>();
        _viewModel = new CustomerViewModel(_mockService.Object);
    }
    
    [Fact]
    public async Task LoadCustomers_ShouldPopulateCustomersList()
    {
        // Arrange
        var expectedCustomers = new List<Customer>
        {
            new Customer { Id = 1, Name = "홍길동" },
            new Customer { Id = 2, Name = "김철수" }
        };
        
        _mockService
            .Setup(s => s.GetCustomersAsync())
            .ReturnsAsync(expectedCustomers);
        
        // Act
        await _viewModel.LoadCommand.ExecuteAsync(null);
        
        // Assert
        Assert.Equal(2, _viewModel.Customers.Count);
        Assert.Equal("홍길동", _viewModel.Customers[0].Name);
        Assert.False(_viewModel.IsLoading);
    }
    
    [Fact]
    public void SaveCommand_ShouldBeDisabled_WhenNameIsEmpty()
    {
        // Arrange
        _viewModel.Name = "";
        
        // Act & Assert
        Assert.False(_viewModel.SaveCommand.CanExecute(null));
    }
    
    [Fact]
    public void SaveCommand_ShouldBeEnabled_WhenNameIsProvided()
    {
        // Arrange
        _viewModel.Name = "홍길동";
        
        // Act & Assert
        Assert.True(_viewModel.SaveCommand.CanExecute(null));
    }
    
    [Fact]
    public async Task SaveCustomer_ShouldCallService_WithCorrectData()
    {
        // Arrange
        _viewModel.Name = "홍길동";
        _viewModel.Email = "hong@example.com";
        
        Customer savedCustomer = null;
        _mockService
            .Setup(s => s.SaveCustomerAsync(It.IsAny<Customer>()))
            .Callback<Customer>(c => savedCustomer = c)
            .ReturnsAsync(true);
        
        // Act
        await _viewModel.SaveCommand.ExecuteAsync(null);
        
        // Assert
        Assert.NotNull(savedCustomer);
        Assert.Equal("홍길동", savedCustomer.Name);
        Assert.Equal("hong@example.com", savedCustomer.Email);
        _mockService.Verify(s => s.SaveCustomerAsync(It.IsAny<Customer>()), Times.Once);
    }
}

이렇게 ViewModel을 테스트하면 UI 없이도 대부분의 로직을 검증할 수 있어. 테스트 실행도 빠르고, 자동화하기도 쉽지! 🎯

🔍 통합 테스트와 UI 테스트

단위 테스트만으로는 부족해. 실제 UI가 제대로 동작하는지도 확인해야 하거든. WPF에서는 FlaUI나 White 같은 UI 자동화 프레임워크를 사용할 수 있어.

// FlaUI를 사용한 UI 테스트
[Test]
public void CustomerForm_SaveButton_ShouldSaveCustomer()
{
    using (var app = Application.Launch("YourApp.exe"))
    using (var automation = new UIA3Automation())
    {
        var window = app.GetMainWindow(automation);
        
        // 컨트롤 찾기
        var nameTextBox = window.FindFirstDescendant(cf => cf.ByAutomationId("txtName"))
            .AsTextBox();
        var emailTextBox = window.FindFirstDescendant(cf => cf.ByAutomationId("txtEmail"))
            .AsTextBox();
        var saveButton = window.FindFirstDescendant(cf => cf.ByAutomationId("btnSave"))
            .AsButton();
        
        // 데이터 입력
        nameTextBox.Text = "테스트 고객";
        emailTextBox.Text = "test@example.com";
        
        // 저장 버튼 클릭
        saveButton.Click();
        
        // 결과 확인
        var messageBox = window.FindFirstChild(cf => cf.ByClassName("MessageBox"));
        Assert.That(messageBox.Name, Does.Contain("저장 완료"));
    }
}

📊 마이그레이션 체크리스트

각 기능을 마이그레이션할 때마다 이 체크리스트를 확인해봐:

🚧 흔한 문제들과 해결 방법

마이그레이션하다 보면 예상치 못한 문제들이 정말 많이 생겨. 내가 겪었던 (그리고 다른 개발자들도 자주 겪는) 문제들과 해결 방법을 공유할게! 💪

❌ 문제 1: 데이터 바인딩이 안 돼요!

// 잘못된 예
public class MyViewModel
{
    public string Name { get; set; } // 변경 알림 없음!
}

// 올바른 예
public class MyViewModel : INotifyPropertyChanged
{
    private string _name;
    
    public string Name
    {
        get => _name;
        set
        {
            if (_name != value)
            {
                _name = value;
                OnPropertyChanged(); // 이게 핵심!
            }
        }
    }
    
    public event PropertyChangedEventHandler PropertyChanged;
    
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

// XAML에서 DataContext 설정 확인
<Window.DataContext>
    <local:MyViewModel />
</Window.DataContext>

❌ 문제 2: UI가 업데이트되지 않아요!

// 잘못된 예
private void LoadData()
{
    Task.Run(() =>
    {
        var data = _service.GetData();
        // 에러 발생! UI 스레드가 아님
        Items = new ObservableCollection<Item>(data);
    });
}

// 올바른 예 1: async/await 사용 (권장)
private async Task LoadDataAsync()
{
    var data = await Task.Run(() => _service.GetData());
    // 자동으로 UI 스레드로 돌아옴
    Items = new ObservableCollection<Item>(data);
}

// 올바른 예 2: Dispatcher 사용
private void LoadData()
{
    Task.Run(() =>
    {
        var data = _service.GetData();
        
        // UI 스레드에서 실행
        Application.Current.Dispatcher.Invoke(() =>
        {
            Items = new ObservableCollection<Item>(data);
        });
    });
}

❌ 문제 3: 메모리 누수가 발생해요!

// 잘못된 예
public class MyViewModel
{
    public MyViewModel()
    {
        SomeService.DataChanged += OnDataChanged; // 누수!
    }
    
    private void OnDataChanged(object sender, EventArgs e)
    {
        // ...
    }
}

// 올바른 예
public class MyViewModel : IDisposable
{
    private readonly IDisposable _subscription;
    
    public MyViewModel()
    {
        // WeakEventManager 사용
        WeakEventManager<SomeService, EventArgs>
            .AddHandler(SomeService, nameof(SomeService.DataChanged), OnDataChanged);
        
        // 또는 IObservable 패턴 사용
        _subscription = SomeService.DataChangedObservable
            .Subscribe(OnDataChanged);
    }
    
    public void Dispose()
    {
        WeakEventManager<SomeService, EventArgs>
            .RemoveHandler(SomeService, nameof(SomeService.DataChanged), OnDataChanged);
        
        _subscription?.Dispose();
    }
}

❌ 문제 4: 레거시 코드와의 통합이 어려워요!

마이그레이션 중에는 새 코드와 옛날 코드가 공존해야 할 때가 많아. 이럴 때는 어댑터 패턴을 사용해봐:

// 레거시 WinForms 폼을 WPF에서 호스팅
public class LegacyFormAdapter
{
    public static void ShowLegacyForm(Window owner, Form legacyForm)
    {
        // WinForms 폼을 WPF 창의 자식으로 표시
        var helper = new WindowInteropHelper(owner);
        legacyForm.Owner = Control.FromHandle(helper.Handle) as Form;
        legacyForm.ShowDialog();
    }
}

// 사용
private void ShowOldReport()
{
    var oldReportForm = new OldReportForm(); // 레거시 WinForms
    LegacyFormAdapter.ShowLegacyForm(this, oldReportForm);
}

// 또는 WinForms 컨트롤을 WPF에 임베드
<WindowsFormsHost>
    <wf:DataGridView x:Name="legacyGrid" />
</WindowsFormsHost>

이렇게 하면 모든 걸 한 번에 바꾸지 않아도 돼. 점진적으로 마이그레이션하면서 레거시 코드를 계속 사용할 수 있어! 😊

📚 학습 리소스와 커뮤니티

마이그레이션은 혼자 하기 어려워. 막힐 때마다 도움을 받을 수 있는 곳들을 알아두면 정말 유용해! 🤝

그리고 재능넷에서도 WPF나 MAUI 마이그레이션 경험이 있는 전문가들을 찾을 수 있어. 막힐 때 멘토링을 받거나, 프로젝트 일부를 아웃소싱하는 것도 좋은 방법이야! 💼

🎓 팀 교육 전략

마이그레이션 성공의 핵심은 팀 전체가 새로운 기술을 습득하는 거야. 내가 추천하는 교육 방법:

💰 비용과 일정 산정

경영진을 설득하려면 현실적인 비용과 일정을 제시해야 해. 내 경험을 바탕으로 대략적인 가이드를 줄게:

물론 이건 아주 대략적인 수치야. 실제로는 다음 요소들에 따라 크게 달라져:

📈 ROI (투자 수익률) 계산

마이그레이션 비용이 크게 느껴질 수 있지만, 장기적으로는 이득이야. 이렇게 계산해봐:

// 연간 절감 비용 계산 예시

현재 상황 (레거시 시스템):
- 유지보수 시간: 월 200시간
- 개발자 시급: 50,000원
- 월 유지보수 비용: 10,000,000원
- 연간 비용: 120,000,000원

마이그레이션 후:
- 유지보수 시간: 월 100시간 (50% 감소)
- 월 유지보수 비용: 5,000,000원
- 연간 비용: 60,000,000원
- 연간 절감액: 60,000,000원

마이그레이션 비용: 150,000,000원
투자 회수 기간: 2.5년

추가 이점 (정량화 어려움):
- 신규 기능 개발 속도 향상
- 버그 감소
- 개발자 만족도 증가
- 인재 채용 용이
- 고객 만족도 향상

이런 식으로 구체적인 숫자를 제시하면 경영진 설득이 훨씬 쉬워져! 💼

🔮 미래를 위한 준비

마이그레이션은 단순히 기술을 바꾸는 게 아니야. 앞으로 5-10년을 내다보고 준비하는 거지. 마지막으로 미래를 위한 조언을 해줄게! 🚀

🌐 크로스 플랫폼 고려

요즘 트렌드는 "한 번 개발해서 여러 플랫폼에 배포"야. WPF로 마이그레이션하더라도, 나중에 모바일이나 웹으로 확장할 가능성을 염두에 둬:

🤖 AI와 자동화

앞으로는 AI가 개발에 더 많이 활용될 거야. 마이그레이션 과정에서도 AI를 활용해봐:

📱 사용자 경험 혁신

단순히 기술만 바꾸지 말고, 이 기회에 UX도 개선해봐:

🎬 마무리하며

와, 여기까지 정말 긴 여정이었어! 😅 Windows Forms에서 모던 UI 프레임워크로의 마이그레이션은 쉽지 않은 도전이야. 하지만 제대로만 준비하고 진행한다면 충분히 성공할 수 있어.

핵심을 다시 정리하면:

마이그레이션은 단순히 기술 부채를 갚는 게 아니야. 팀의 역량을 한 단계 업그레이드하고, 더 나은 제품을 만들 수 있는 기회야. 처음엔 어렵고 막막하겠지만, 한 걸음씩 나아가다 보면 어느새 목표에 도달해 있을 거야! 💪

혹시 마이그레이션 과정에서 도움이 필요하다면, 재능넷에서 경험 많은 전문가들을 찾아봐. 멘토링을 받거나 컨설팅을 받는 것도 좋은 방법이야. 혼자 고민하지 말고, 커뮤니티의 도움을 받아가며 진행해봐!

자, 이제 당신의 레거시 시스템을 모던하게 탈바꿈시킬 시간이야! 화이팅! 🚀✨