📱 View (뷰)
사용자가 보는 화면이야. XAML로 작성되고, 버튼, 텍스트박스, 리스트 같은 UI 요소들이 여기 있어. View는 "어떻게 보일까?"에만 집중해.

⚙️ ViewModel (뷰모델)
View와 Model 사이의 중간 다리 역할을 해. View에 표시할 데이터를 준비하고, 사용자의 입력을 처리해서 Model에 전달하지. "어떻게 동작할까?"를 담당해.

💾 Model (모델)
실제 데이터와 비즈니스 로직이 있는 곳이야. 데이터베이스 접근, 계산, 유효성 검사 같은 핵심 기능들이 여기 있어. "무엇을 할까?"를 정의해.

1️⃣ 데이터 바인딩 (Data Binding)

WPF의 가장 강력한 기능 중 하나야. XAML에서 UI 요소를 ViewModel의 속성에 직접 연결할 수 있어.

예를 들어, 텍스트박스의 내용을 ViewModel의 속성과 바인딩하면, 사용자가 입력한 내용이 자동으로 ViewModel에 반영되고, 반대로 ViewModel의 값이 바뀌면 화면도 자동으로 업데이트돼. 마치 마법처럼! ✨

<TextBox Text="{Binding UserName, UpdateSourceTrigger=PropertyChanged}" />

이 한 줄로 TextBox와 ViewModel의 UserName 속성이 양방향으로 연결돼!

2️⃣ 커맨드 (Command)

버튼 클릭 같은 사용자 액션을 처리하는 방법이야. 전통적인 이벤트 핸들러 대신 커맨드를 사용하면, UI 로직을 ViewModel로 깔끔하게 옮길 수 있어. 🎮

코드-비하인드에 이벤트 핸들러를 잔뜩 작성하는 대신, ViewModel에서 커맨드로 처리하면 테스트도 쉽고 재사용도 가능해!

<Button Content="저장" Command="{Binding SaveCommand}" />

3️⃣ 템플릿과 스타일

WPF는 UI를 데이터로부터 완전히 분리할 수 있게 해줘. DataTemplate을 사용하면 같은 데이터를 다양한 방식으로 표현할 수 있어. 🎭

예를 들어, 사용자 목록을 카드 형태로 보여줄지, 테이블 형태로 보여줄지 ViewModel을 전혀 수정하지 않고 XAML만 바꿔서 결정할 수 있어!

4️⃣ INotifyPropertyChanged 인터페이스

이건 MVVM의 핵심 메커니즘이야. ViewModel의 속성이 변경되었을 때 View에게 알려주는 역할을 해. 📢

이 인터페이스를 구현하면, 속성 값이 바뀔 때마다 자동으로 UI가 업데이트돼. 개발자가 일일이 UI를 갱신하는 코드를 작성할 필요가 없어!

원칙 1: View는 ViewModel만 알아야 해

View는 ViewModel에 대한 참조만 가지고 있어야 해. Model을 직접 참조하면 안 돼! 🚫

View의 DataContext에 ViewModel을 설정하고, 모든 데이터와 커맨드는 바인딩을 통해 접근해야 해. 이렇게 하면 View와 비즈니스 로직이 완전히 분리돼.

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        this.DataContext = new MainViewModel();
    }
}

이게 전부야! View의 코드-비하인드는 이렇게 간단해야 해. 😊

원칙 2: ViewModel은 View를 몰라야 해

이게 진짜 중요해! ViewModel은 View에 대한 어떤 참조도 가지면 안 돼. using System.Windows 같은 UI 네임스페이스도 ViewModel에서 사용하면 안 돼! 🙅‍♂️

왜냐하면 ViewModel은 순수한 C# 클래스여야 하거든. 그래야 단위 테스트를 작성할 수 있고, 다른 플랫폼(예: Xamarin, UWP)에서도 재사용할 수 있어.

대화상자를 띄우거나 파일을 선택하는 등 UI와 상호작용이 필요한 경우에는 서비스 인터페이스를 사용해야 해.

원칙 3: Model은 독립적이어야 해

Model은 View나 ViewModel에 대해 전혀 몰라야 해. 완전히 독립적인 비즈니스 로직과 데이터 구조여야 하지. 💼

Model은 다른 애플리케이션에서도 그대로 사용할 수 있을 정도로 범용적이어야 해. 예를 들어, 같은 Model을 웹 API, 콘솔 앱, WPF 앱에서 모두 사용할 수 있어야 해!

원칙 4: 단방향 의존성

의존성은 항상 한 방향으로만 흘러야 해: View → ViewModel → Model 📊

역방향 의존성이 생기면 안 돼! 이걸 지키면 각 레이어를 독립적으로 테스트하고 수정할 수 있어. 순환 참조가 생기면 코드가 복잡해지고 유지보수가 어려워져.

INotifyPropertyChanged 구현

먼저 기본이 되는 BaseViewModel을 만들어보자. 모든 ViewModel이 상속받을 기본 클래스야:

using System.ComponentModel;
using System.Runtime.CompilerServices;

public class BaseViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
    {
        if (Equals(storage, value))
            return false;

        storage = value;
        OnPropertyChanged(propertyName);
        return true;
    }
}

이 BaseViewModel은 속성 변경 알림을 쉽게 처리할 수 있게 해줘. SetProperty 메서드를 사용하면 속성 setter를 간단하게 작성할 수 있어! 😎

속성(Property) 구현

이제 실제 ViewModel에서 속성을 어떻게 구현하는지 보자:

public class UserViewModel : BaseViewModel
{
    private string _userName;
    public string UserName
    {
        get => _userName;
        set => SetProperty(ref _userName, value);
    }

    private int _age;
    public int Age
    {
        get => _age;
        set
        {
            if (SetProperty(ref _age, value))
            {
                // Age가 변경되면 IsAdult도 업데이트
                OnPropertyChanged(nameof(IsAdult));
            }
        }
    }

    public bool IsAdult => Age >= 18;
}

보다시피 SetProperty를 사용하면 코드가 정말 간결해져! 그리고 한 속성이 변경될 때 다른 속성도 함께 업데이트해야 한다면, OnPropertyChanged를 추가로 호출하면 돼. 🎯

RelayCommand 구현

가장 많이 사용되는 커맨드 구현 방식이야. 직접 만들어보자:

using System;
using System.Windows.Input;

public class RelayCommand : ICommand
{
    private readonly Action<object> _execute;
    private readonly Func<object, bool> _canExecute;

    public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null)
    {
        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
        _canExecute = canExecute;
    }

    public event EventHandler CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }

    public bool CanExecute(object parameter)
    {
        return _canExecute == null || _canExecute(parameter);
    }

    public void Execute(object parameter)
    {
        _execute(parameter);
    }
}

이 RelayCommand는 두 가지 중요한 기능을 제공해:
1️⃣ Execute: 실제로 수행할 작업
2️⃣ CanExecute: 커맨드를 실행할 수 있는지 여부 (버튼 활성화/비활성화)

ViewModel에서 커맨드 사용하기

이제 실제로 ViewModel에서 커맨드를 어떻게 사용하는지 보자:

public class MainViewModel : BaseViewModel
{
    private string _searchText;
    public string SearchText
    {
        get => _searchText;
        set => SetProperty(ref _searchText, value);
    }

    private ICommand _searchCommand;
    public ICommand SearchCommand
    {
        get
        {
            if (_searchCommand == null)
            {
                _searchCommand = new RelayCommand(
                    execute: param => PerformSearch(),
                    canExecute: param => !string.IsNullOrWhiteSpace(SearchText)
                );
            }
            return _searchCommand;
        }
    }

    private void PerformSearch()
    {
        // 실제 검색 로직
        // 예: 데이터베이스 쿼리, API 호출 등
    }
}

XAML에서는 이렇게 바인딩해:

<TextBox Text="{Binding SearchText, UpdateSourceTrigger=PropertyChanged}" />
<Button Content="검색" Command="{Binding SearchCommand}" />

이렇게 하면 SearchText가 비어있을 때 버튼이 자동으로 비활성화돼! 별도의 코드 없이 말이야. 멋지지? 😎

비동기 커맨드

요즘 앱은 대부분 비동기 작업을 해야 해. 네트워크 호출, 파일 I/O, 데이터베이스 쿼리 등등. 비동기 커맨드를 만들어보자:

public class AsyncRelayCommand : ICommand
{
    private readonly Func<object, Task> _execute;
    private readonly Func<object, bool> _canExecute;
    private bool _isExecuting;

    public AsyncRelayCommand(Func<object, Task> execute, Func<object, bool> canExecute = null)
    {
        _execute = execute;
        _canExecute = canExecute;
    }

    public event EventHandler CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }

    public bool CanExecute(object parameter)
    {
        return !_isExecuting && (_canExecute == null || _canExecute(parameter));
    }

    public async void Execute(object parameter)
    {
        _isExecuting = true;
        CommandManager.InvalidateRequerySuggested();

        try
        {
            await _execute(parameter);
        }
        finally
        {
            _isExecuting = false;
            CommandManager.InvalidateRequerySuggested();
        }
    }
}

이 비동기 커맨드는 실행 중에 자동으로 비활성화돼서 중복 실행을 방지해줘! 👍

바인딩 모드 (Binding Mode)

WPF는 여러 가지 바인딩 모드를 제공해:

<!-- OneWay: 읽기 전용 -->
<TextBlock Text="{Binding UserName, Mode=OneWay}" />

<!-- TwoWay: 양방향 -->
<TextBox Text="{Binding UserName, Mode=TwoWay}" />

<!-- OneTime: 초기화 시 한 번만 -->
<TextBlock Text="{Binding AppTitle, Mode=OneTime}" />

UpdateSourceTrigger

언제 ViewModel을 업데이트할지 결정하는 속성이야:

<!-- PropertyChanged: 즉시 업데이트 (타이핑할 때마다) -->
<TextBox Text="{Binding SearchText, UpdateSourceTrigger=PropertyChanged}" />

<!-- LostFocus: 포커스를 잃을 때 (기본값) -->
<TextBox Text="{Binding UserName, UpdateSourceTrigger=LostFocus}" />

<!-- Explicit: 명시적으로 호출할 때만 -->
<TextBox Text="{Binding Email, UpdateSourceTrigger=Explicit}" />

실시간 검색 기능을 만들 때는 PropertyChanged를 사용하고, 일반 입력 폼에서는 LostFocus를 사용하는 게 좋아. 성능과 사용자 경험의 균형을 맞춰야 해! ⚖️

컬렉션 바인딩

리스트나 그리드에 데이터를 표시할 때는 ObservableCollection을 사용해야 해:

using System.Collections.ObjectModel;

public class MainViewModel : BaseViewModel
{
    public ObservableCollection<UserModel> Users { get; set; }

    public MainViewModel()
    {
        Users = new ObservableCollection<UserModel>();
        LoadUsers();
    }

    private void LoadUsers()
    {
        // 데이터 로드
        Users.Add(new UserModel { Name = "홍길동", Age = 25 });
        Users.Add(new UserModel { Name = "김철수", Age = 30 });
    }
}

XAML에서는:

<ListBox ItemsSource="{Binding Users}">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <StackPanel>
                <TextBlock Text="{Binding Name}" FontWeight="Bold" />
                <TextBlock Text="{Binding Age}" />
            </StackPanel>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

ObservableCollection은 항목이 추가/삭제될 때 자동으로 UI를 업데이트해줘! 일반 List를 사용하면 안 돼! 🚫

값 변환기 (Value Converter)

때로는 ViewModel의 데이터를 View에 표시하기 전에 변환해야 할 때가 있어. 예를 들어, bool 값을 "예/아니오"로 표시하거나, 날짜 형식을 바꾸는 등이지.

using System;
using System.Globalization;
using System.Windows.Data;

public class BoolToYesNoConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is bool boolValue)
        {
            return boolValue ? "예" : "아니오";
        }
        return "알 수 없음";
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value is string strValue)
        {
            return strValue == "예";
        }
        return false;
    }
}

XAML에서 사용:

<Window.Resources>
    <local:BoolToYesNoConverter x:Key="BoolToYesNo" />
</Window.Resources>

<TextBlock Text="{Binding IsActive, Converter={StaticResource BoolToYesNo}}" />

컨버터를 잘 활용하면 ViewModel을 깔끔하게 유지하면서도 다양한 표현이 가능해! 🎨

기본 프로젝트 구조

일반적으로 이런 구조를 많이 사용해:

MyWpfApp/
├── Models/
│   ├── User.cs
│   ├── Product.cs
│   └── Order.cs
├── ViewModels/
│   ├── BaseViewModel.cs
│   ├── MainViewModel.cs
│   ├── UserViewModel.cs
│   └── ProductViewModel.cs
├── Views/
│   ├── MainWindow.xaml
│   ├── UserView.xaml
│   └── ProductView.xaml
├── Services/
│   ├── IDataService.cs
│   ├── DataService.cs
│   ├── IDialogService.cs
│   └── DialogService.cs
├── Commands/
│   ├── RelayCommand.cs
│   └── AsyncRelayCommand.cs
├── Converters/
│   ├── BoolToVisibilityConverter.cs
│   └── DateTimeConverter.cs
├── Helpers/
│   └── ValidationHelper.cs
└── App.xaml

각 폴더의 역할을 명확히 구분하면 팀 작업할 때도 혼란이 없어! 👥

레이어별 책임

각 레이어가 어떤 책임을 가지는지 정리해보자:

📱 Views (뷰)
- XAML 파일과 최소한의 코드-비하인드
- UI 레이아웃과 스타일 정의
- 애니메이션과 시각 효과
- DataContext 설정

⚙️ ViewModels (뷰모델)
- 화면에 표시할 데이터 준비
- 사용자 입력 처리 (커맨드)
- 유효성 검사
- Model과 View 사이의 데이터 변환

💾 Models (모델)
- 비즈니스 엔티티 정의
- 데이터 구조
- 비즈니스 규칙
- 데이터 유효성 검사 로직

🔧 Services (서비스)
- 데이터 액세스 (데이터베이스, API)
- 파일 I/O
- 대화상자 표시
- 네비게이션
- 로깅

왜 의존성 주입이 필요할까?

예를 들어, ViewModel에서 데이터베이스에 접근해야 한다고 생각해보자. 직접 데이터베이스 클래스를 생성하면:

// ❌ 나쁜 예
public class UserViewModel : BaseViewModel
{
    private DatabaseService _database;

    public UserViewModel()
    {
        _database = new DatabaseService(); // 강한 결합!
    }
}

이렇게 하면 몇 가지 문제가 생겨:
1️⃣ 단위 테스트가 어려워 (실제 DB가 필요)
2️⃣ 다른 데이터 소스로 바꾸기 어려워
3️⃣ ViewModel이 구체적인 구현에 의존해

대신 인터페이스를 사용하고 외부에서 주입받자:

// ✅ 좋은 예
public interface IDataService
{
    Task<List<User>> GetUsersAsync();
    Task SaveUserAsync(User user);
}

public class UserViewModel : BaseViewModel
{
    private readonly IDataService _dataService;

    public UserViewModel(IDataService dataService)
    {
        _dataService = dataService; // 의존성 주입!
    }

    public async Task LoadUsers()
    {
        var users = await _dataService.GetUsersAsync();
        // ...
    }
}

이제 테스트할 때 가짜(Mock) 서비스를 주입할 수 있어! 🎭

DI 컨테이너 사용하기

수동으로 의존성을 관리하는 건 복잡해. DI 컨테이너를 사용하면 자동으로 처리해줘! Microsoft.Extensions.DependencyInjection을 사용해보자:

using Microsoft.Extensions.DependencyInjection;

public partial class App : Application
{
    private ServiceProvider _serviceProvider;

    public App()
    {
        var services = new ServiceCollection();
        ConfigureServices(services);
        _serviceProvider = services.BuildServiceProvider();
    }

    private void ConfigureServices(IServiceCollection services)
    {
        // Services 등록
        services.AddSingleton<IDataService, DatabaseService>();
        services.AddSingleton<IDialogService, DialogService>();
        
        // ViewModels 등록
        services.AddTransient<MainViewModel>();
        services.AddTransient<UserViewModel>();
        
        // Views 등록
        services.AddTransient<MainWindow>();
    }

    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);
        
        var mainWindow = _serviceProvider.GetRequiredService<MainWindow>();
        mainWindow.Show();
    }
}

이제 MainWindow의 생성자에서 ViewModel을 주입받을 수 있어:

public partial class MainWindow : Window
{
    public MainWindow(MainViewModel viewModel)
    {
        InitializeComponent();
        this.DataContext = viewModel;
    }
}

완전 자동화! 🤖 DI 컨테이너가 알아서 필요한 의존성들을 생성하고 주입해줘.

서비스 수명 (Service Lifetime)

DI 컨테이너에 서비스를 등록할 때 세 가지 수명 중 하나를 선택할 수 있어:

// Singleton: 앱 전체에서 하나만
services.AddSingleton<IDataService, DatabaseService>();

// Transient: 매번 새로 생성
services.AddTransient<MainViewModel>();

// Scoped: 범위 내에서 하나
services.AddScoped<IUnitOfWork, UnitOfWork>();

ViewModel 단위 테스트

xUnit과 Moq를 사용해서 ViewModel을 테스트해보자:

using Xunit;
using Moq;
using System.Threading.Tasks;

public class UserViewModelTests
{
    [Fact]
    public async Task LoadUsers_ShouldPopulateUsersList()
    {
        // Arrange
        var mockDataService = new Mock<IDataService>();
        mockDataService.Setup(x => x.GetUsersAsync())
            .ReturnsAsync(new List<User>
            {
                new User { Name = "홍길동", Age = 25 },
                new User { Name = "김철수", Age = 30 }
            });

        var viewModel = new UserViewModel(mockDataService.Object);

        // Act
        await viewModel.LoadUsersCommand.Execute(null);

        // Assert
        Assert.Equal(2, viewModel.Users.Count);
        Assert.Equal("홍길동", viewModel.Users[0].Name);
    }

    [Fact]
    public void UserName_WhenChanged_ShouldRaisePropertyChanged()
    {
        // Arrange
        var mockDataService = new Mock<IDataService>();
        var viewModel = new UserViewModel(mockDataService.Object);
        bool propertyChangedRaised = false;
        
        viewModel.PropertyChanged += (sender, e) =>
        {
            if (e.PropertyName == nameof(viewModel.UserName))
                propertyChangedRaised = true;
        };

        // Act
        viewModel.UserName = "새이름";

        // Assert
        Assert.True(propertyChangedRaised);
        Assert.Equal("새이름", viewModel.UserName);
    }
}

보다시피 UI 없이도 ViewModel의 모든 기능을 테스트할 수 있어! 이게 MVVM의 진정한 힘이야. 💪

커맨드 테스트

커맨드의 실행과 CanExecute도 테스트할 수 있어:

[Fact]
public void SaveCommand_WhenUserNameIsEmpty_ShouldNotExecute()
{
    // Arrange
    var mockDataService = new Mock<IDataService>();
    var viewModel = new UserViewModel(mockDataService.Object);
    viewModel.UserName = "";

    // Act
    bool canExecute = viewModel.SaveCommand.CanExecute(null);

    // Assert
    Assert.False(canExecute);
}

[Fact]
public async Task SaveCommand_WhenExecuted_ShouldCallDataService()
{
    // Arrange
    var mockDataService = new Mock<IDataService>();
    var viewModel = new UserViewModel(mockDataService.Object);
    viewModel.UserName = "홍길동";

    // Act
    viewModel.SaveCommand.Execute(null);
    await Task.Delay(100); // 비동기 작업 대기

    // Assert
    mockDataService.Verify(x => x.SaveUserAsync(It.IsAny<User>()), Times.Once);
}

Dialog Service 패턴

인터페이스를 통해 대화상자를 추상화하자:

public interface IDialogService
{
    void ShowMessage(string message, string title = "알림");
    bool ShowConfirmation(string message, string title = "확인");
    string ShowOpenFileDialog(string filter = "모든 파일|*.*");
    string ShowSaveFileDialog(string filter = "모든 파일|*.*");
}

public class DialogService : IDialogService
{
    public void ShowMessage(string message, string title = "알림")
    {
        MessageBox.Show(message, title, MessageBoxButton.OK, MessageBoxImage.Information);
    }

    public bool ShowConfirmation(string message, string title = "확인")
    {
        var result = MessageBox.Show(message, title, MessageBoxButton.YesNo, MessageBoxImage.Question);
        return result == MessageBoxResult.Yes;
    }

    public string ShowOpenFileDialog(string filter = "모든 파일|*.*")
    {
        var dialog = new OpenFileDialog { Filter = filter };
        return dialog.ShowDialog() == true ? dialog.FileName : null;
    }

    public string ShowSaveFileDialog(string filter = "모든 파일|*.*")
    {
        var dialog = new SaveFileDialog { Filter = filter };
        return dialog.ShowDialog() == true ? dialog.FileName : null;
    }
}

ViewModel에서 사용:

public class MainViewModel : BaseViewModel
{
    private readonly IDialogService _dialogService;

    public MainViewModel(IDialogService dialogService)
    {
        _dialogService = dialogService;
    }

    private void DeleteUser()
    {
        bool confirmed = _dialogService.ShowConfirmation(
            "정말 삭제하시겠습니까?", 
            "삭제 확인"
        );

        if (confirmed)
        {
            // 삭제 로직
            _dialogService.ShowMessage("삭제되었습니다.");
        }
    }
}

이제 ViewModel을 테스트할 때 Mock DialogService를 주입하면 돼! 🎉

Navigation Service

화면 전환도 서비스로 추상화할 수 있어:

public interface INavigationService
{
    void NavigateTo<TViewModel>() where TViewModel : BaseViewModel;
    void NavigateTo<TViewModel>(object parameter) where TViewModel : BaseViewModel;
    void GoBack();
    bool CanGoBack { get; }
}

public class NavigationService : INavigationService
{
    private readonly IServiceProvider _serviceProvider;
    private readonly Frame _frame;
    private readonly Stack<Type> _navigationStack;

    public NavigationService(IServiceProvider serviceProvider, Frame frame)
    {
        _serviceProvider = serviceProvider;
        _frame = frame;
        _navigationStack = new Stack<Type>();
    }

    public void NavigateTo<TViewModel>() where TViewModel : BaseViewModel
    {
        var viewModel = _serviceProvider.GetRequiredService<TViewModel>();
        var viewType = GetViewTypeForViewModel(typeof(TViewModel));
        var view = (Page)Activator.CreateInstance(viewType);
        view.DataContext = viewModel;
        
        _navigationStack.Push(typeof(TViewModel));
        _frame.Navigate(view);
    }

    public void GoBack()
    {
        if (CanGoBack)
        {
            _navigationStack.Pop();
            _frame.GoBack();
        }
    }

    public bool CanGoBack => _navigationStack.Count > 1;

    private Type GetViewTypeForViewModel(Type viewModelType)
    {
        // ViewModel 이름에서 View 이름 유추
        var viewName = viewModelType.Name.Replace("ViewModel", "View");
        var viewType = Type.GetType($"MyApp.Views.{viewName}");
        return viewType;
    }
}

사용 예시:

public class MainViewModel : BaseViewModel
{
    private readonly INavigationService _navigationService;

    public ICommand NavigateToUserCommand { get; }

    public MainViewModel(INavigationService navigationService)
    {
        _navigationService = navigationService;
        NavigateToUserCommand = new RelayCommand(_ => NavigateToUser());
    }

    private void NavigateToUser()
    {
        _navigationService.NavigateTo<UserViewModel>();
    }
}

1️⃣ Prism

가장 인기 있는 WPF MVVM 프레임워크야. Microsoft Patterns & Practices 팀이 만들었어.

주요 기능:
✅ 강력한 DI 컨테이너 통합
✅ 모듈화 시스템
✅ 이벤트 애그리게이터
✅ 네비게이션 서비스
✅ 대화상자 서비스
✅ 커맨드 구현체 제공

// Prism 사용 예시
public class MainViewModel : BindableBase
{
    private string _title;
    public string Title
    {
        get => _title;
        set => SetProperty(ref _title, value);
    }

    public DelegateCommand SaveCommand { get; }

    public MainViewModel()
    {
        SaveCommand = new DelegateCommand(ExecuteSave, CanExecuteSave)
            .ObservesProperty(() => Title);
    }

    private void ExecuteSave()
    {
        // 저장 로직
    }

    private bool CanExecuteSave()
    {
        return !string.IsNullOrEmpty(Title);
    }
}

장점: 기능이 풍부하고 대규모 프로젝트에 적합
단점: 학습 곡선이 있고 프로젝트가 무거워질 수 있어

2️⃣ MVVM Light Toolkit

가볍고 배우기 쉬운 프레임워크야. 최근에는 개발이 중단되었지만 여전히 많이 사용돼.

주요 기능:
✅ ViewModelBase 클래스
✅ RelayCommand 구현
✅ Messenger (이벤트 버스)
✅ 간단한 DI 컨테이너
✅ 디자인 타임 데이터 지원

// MVVM Light 사용 예시
public class MainViewModel : ViewModelBase
{
    private string _userName;
    public string UserName
    {
        get => _userName;
        set => Set(ref _userName, value);
    }

    public RelayCommand SaveCommand { get; }

    public MainViewModel()
    {
        SaveCommand = new RelayCommand(Save, CanSave);
    }
}

장점: 가볍고 배우기 쉬워
단점: 더 이상 업데이트되지 않음

3️⃣ CommunityToolkit.Mvvm (MVVM Toolkit)

Microsoft가 공식적으로 지원하는 최신 MVVM 라이브러리야! MVVM Light의 정신적 후계자라고 볼 수 있어. 🌟

주요 기능:
✅ Source Generator 활용 (코드 자동 생성)
✅ ObservableObject 기본 클래스
✅ RelayCommand와 AsyncRelayCommand
✅ Messenger (메시징 시스템)
✅ IoC 컨테이너 지원
✅ .NET 6+ 최적화

using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

// Source Generator가 자동으로 코드 생성!
public partial class MainViewModel : ObservableObject
{
    [ObservableProperty]
    private string _userName;

    [ObservableProperty]
    private int _age;

    [RelayCommand]
    private void Save()
    {
        // 저장 로직
    }

    [RelayCommand(CanExecute = nameof(CanDelete))]
    private void Delete()
    {
        // 삭제 로직
    }

    private bool CanDelete() => Age >= 18;
}

위 코드에서 [ObservableProperty] 어트리뷰트를 붙이면, Source Generator가 자동으로 전체 속성 코드를 생성해줘! 보일러플레이트 코드가 확 줄어들지? 🎉

장점: 최신 기술, 적은 코드, Microsoft 공식 지원
단점: .NET 6 이상 필요

4️⃣ Caliburn.Micro

컨벤션 기반의 프레임워크야. 명명 규칙만 따르면 많은 걸 자동으로 처리해줘.

주요 기능:
✅ 컨벤션 기반 바인딩
✅ 화면 관리
✅ 이벤트 애그리게이터
✅ 코루틴 지원
✅ 부트스트래퍼

// Caliburn.Micro는 명명 규칙으로 자동 바인딩
public class ShellViewModel : Screen
{
    private string _name;
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            NotifyOfPropertyChange(() => Name);
            NotifyOfPropertyChange(() => CanSayHello);
        }
    }

    // 버튼 이름이 "SayHello"면 자동으로 연결!
    public void SayHello()
    {
        MessageBox.Show($"Hello {Name}!");
    }

    // Can + 메서드명 = 활성화 조건
    public bool CanSayHello => !string.IsNullOrEmpty(Name);
}

장점: 코드가 간결하고 직관적
단점: 컨벤션을 배워야 하고, 디버깅이 어려울 수 있어

MultiBinding (다중 바인딩)

여러 속성을 하나로 합쳐서 표시할 수 있어:

<!-- Converter 정의 -->
public class FullNameConverter : IMultiValueConverter
{
    public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
    {
        if (values.Length == 2 && values[0] is string firstName && values[1] is string lastName)
        {
            return $"{firstName} {lastName}";
        }
        return string.Empty;
    }

    public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
    {
        throw new NotImplementedException();
    }
}

<!-- XAML에서 사용 -->
<Window.Resources>
    <local:FullNameConverter x:Key="FullNameConverter" />
</Window.Resources>

<TextBlock>
    <TextBlock.Text>
        <MultiBinding Converter="{StaticResource FullNameConverter}">
            <Binding Path="FirstName" />
            <Binding Path="LastName" />
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>

이렇게 하면 FirstName과 LastName이 변경될 때마다 자동으로 전체 이름이 업데이트돼! ✨

StringFormat (문자열 포맷)

간단한 포맷팅은 Converter 없이도 가능해:

<!-- 숫자 포맷 -->
<TextBlock Text="{Binding Price, StringFormat=가격: {0:C}}" />
<!-- 출력: 가격: ₩10,000 -->

<!-- 날짜 포맷 -->
<TextBlock Text="{Binding BirthDate, StringFormat=생년월일: {0:yyyy-MM-dd}}" />
<!-- 출력: 생년월일: 1990-01-01 -->

<!-- 퍼센트 -->
<TextBlock Text="{Binding Progress, StringFormat={}{0:P0}}" />
<!-- 출력: 75% -->

<!-- 여러 값 조합 -->
<TextBlock>
    <TextBlock.Text>
        <MultiBinding StringFormat="{}{0}님의 나이는 {1}세입니다.">
            <Binding Path="Name" />
            <Binding Path="Age" />
        </MultiBinding>
    </TextBlock.Text>
</TextBlock>

StringFormat을 사용하면 간단한 포맷팅을 위해 Converter를 만들 필요가 없어! 편하지? 😊

FallbackValue와 TargetNullValue

바인딩이 실패하거나 null일 때 표시할 값을 지정할 수 있어:

<!-- 바인딩 실패 시 기본값 -->
<TextBlock Text="{Binding UserName, FallbackValue=알 수 없음}" />

<!-- null일 때 표시할 값 -->
<TextBlock Text="{Binding Description, TargetNullValue=설명 없음}" />

<!-- 둘 다 사용 -->
<TextBlock Text="{Binding Email, 
                         TargetNullValue=이메일 없음,
                         FallbackValue=오류}" />

이렇게 하면 null 체크 코드를 ViewModel에 작성할 필요가 없어! 🎯

RelativeSource (상대 소스)

현재 요소를 기준으로 상대적인 위치의 요소를 바인딩할 수 있어:

<!-- 자기 자신의 다른 속성 바인딩 -->
<TextBox x:Name="myTextBox" 
         Text="Hello"
         ToolTip="{Binding RelativeSource={RelativeSource Self}, Path=Text}" />

<!-- 부모 요소 바인딩 -->
<Grid x:Name="parentGrid" Tag="ParentData">
    <TextBlock Text="{Binding RelativeSource={RelativeSource AncestorType=Grid}, Path=Tag}" />
</Grid>

<!-- DataTemplate 안에서 부모 ViewModel 접근 -->
<ListBox ItemsSource="{Binding Users}">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <Button Content="삭제"
                    Command="{Binding DataContext.DeleteCommand, 
                                    RelativeSource={RelativeSource AncestorType=ListBox}}"
                    CommandParameter="{Binding}" />
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

RelativeSource는 특히 DataTemplate 안에서 부모 ViewModel의 커맨드를 호출할 때 유용해! 💡

ValidationRules (유효성 검사)

XAML에서 직접 유효성 검사 규칙을 정의할 수 있어:

// 커스텀 ValidationRule
public class AgeValidationRule : ValidationRule
{
    public int MinAge { get; set; } = 0;
    public int MaxAge { get; set; } = 150;

    public override ValidationResult Validate(object value, CultureInfo cultureInfo)
    {
        if (int.TryParse(value?.ToString(), out int age))
        {
            if (age < MinAge || age > MaxAge)
            {
                return new ValidationResult(false, 
                    $"나이는 {MinAge}에서 {MaxAge} 사이여야 합니다.");
            }
            return ValidationResult.ValidResult;
        }
        return new ValidationResult(false, "올바른 숫자를 입력하세요.");
    }
}

// XAML에서 사용
<TextBox>
    <TextBox.Text>
        <Binding Path="Age" UpdateSourceTrigger="PropertyChanged">
            <Binding.ValidationRules>
                <local:AgeValidationRule MinAge="18" MaxAge="100" />
            </Binding.ValidationRules>
        </Binding>
    </TextBox.Text>
    <TextBox.Style>
        <Style TargetType="TextBox">
            <Style.Triggers>
                <Trigger Property="Validation.HasError" Value="True">
                    <Setter Property="ToolTip" 
                            Value="{Binding RelativeSource={RelativeSource Self},
                                          Path=(Validation.Errors)[0].ErrorContent}" />
                    <Setter Property="BorderBrush" Value="Red" />
                </Trigger>
            </Style.Triggers>
        </Style>
    </TextBox.Style>
</TextBox>

유효성 검사 오류가 있으면 자동으로 빨간 테두리가 표시되고 툴팁에 오류 메시지가 나타나! 🔴

가상화 (Virtualization)

수천, 수만 개의 항목을 표시할 때는 가상화가 필수야:

<!-- ListBox 가상화 -->
<ListBox ItemsSource="{Binding LargeDataSet}"
         VirtualizingPanel.IsVirtualizing="True"
         VirtualizingPanel.VirtualizationMode="Recycling"
         VirtualizingPanel.CacheLength="20,20"
         VirtualizingPanel.CacheLengthUnit="Item">
    <!-- ItemTemplate -->
</ListBox>

<!-- DataGrid 가상화 -->
<DataGrid ItemsSource="{Binding Users}"
          EnableRowVirtualization="True"
          EnableColumnVirtualization="True"
          VirtualizingPanel.IsVirtualizing="True"
          VirtualizingPanel.VirtualizationMode="Recycling" />

가상화를 사용하면 화면에 보이는 항목만 렌더링해서 메모리와 성능이 크게 개선돼! 10,000개 항목도 부드럽게 스크롤할 수 있어. 🎢

비동기 데이터 로딩

무거운 작업은 반드시 비동기로 처리해야 해:

public class MainViewModel : BaseViewModel
{
    private ObservableCollection<User> _users;
    public ObservableCollection<User> Users
    {
        get => _users;
        set => SetProperty(ref _users, value);
    }

    private bool _isLoading;
    public bool IsLoading
    {
        get => _isLoading;
        set => SetProperty(ref _isLoading, value);
    }

    public ICommand LoadDataCommand { get; }

    public MainViewModel(IDataService dataService)
    {
        LoadDataCommand = new AsyncRelayCommand(async () => await LoadDataAsync());
    }

    private async Task LoadDataAsync()
    {
        IsLoading = true;
        try
        {
            var users = await _dataService.GetUsersAsync();
            
            // UI 스레드에서 실행
            await Application.Current.Dispatcher.InvokeAsync(() =>
            {
                Users = new ObservableCollection<User>(users);
            });
        }
        finally
        {
            IsLoading = false;
        }
    }
}

XAML에서 로딩 표시:

<Grid>
    <ListBox ItemsSource="{Binding Users}" 
             Visibility="{Binding IsLoading, Converter={StaticResource BoolToVisibilityInverse}}" />
    
    <ProgressBar IsIndeterminate="True"
                 Visibility="{Binding IsLoading, Converter={StaticResource BoolToVisibility}}" />
</Grid>

PropertyChanged 이벤트 최적화

불필요한 PropertyChanged 이벤트를 줄이자:

// ❌ 나쁜 예: 매번 이벤트 발생
private string _name;
public string Name
{
    get => _name;
    set
    {
        _name = value;
        OnPropertyChanged(); // 값이 같아도 발생!
    }
}

// ✅ 좋은 예: 값이 실제로 변경될 때만
private string _name;
public string Name
{
    get => _name;
    set => SetProperty(ref _name, value); // 값이 다를 때만 이벤트 발생
}

// ✅ 더 좋은 예: 여러 속성을 한 번에 업데이트
public void UpdateUser(string name, int age, string email)
{
    // 이벤트를 일시적으로 중단
    _suspendNotifications = true;
    
    Name = name;
    Age = age;
    Email = email;
    
    _suspendNotifications = false;
    
    // 한 번에 알림
    OnPropertyChanged(nameof(Name));
    OnPropertyChanged(nameof(Age));
    OnPropertyChanged(nameof(Email));
}

컬렉션 업데이트 최적화

대량의 항목을 추가/삭제할 때는 일괄 처리하자:

// ❌ 나쁜 예: 하나씩 추가 (매번 UI 업데이트)
foreach (var user in newUsers)
{
    Users.Add(user); // 1000번 UI 업데이트!
}

// ✅ 좋은 예: 일괄 추가
public class RangeObservableCollection<T> : ObservableCollection<T>
{
    public void AddRange(IEnumerable<T> items)
    {
        CheckReentrancy();
        
        foreach (var item in items)
        {
            Items.Add(item);
        }
        
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(
            NotifyCollectionChangedAction.Reset));
    }

    public void RemoveRange(IEnumerable<T> items)
    {
        CheckReentrancy();
        
        foreach (var item in items)
        {
            Items.Remove(item);
        }
        
        OnCollectionChanged(new NotifyCollectionChangedEventArgs(
            NotifyCollectionChangedAction.Reset));
    }
}

// 사용
Users.AddRange(newUsers); // 한 번만 UI 업데이트!

메모리 누수 방지

이벤트 핸들러와 약한 참조를 주의해야 해:

// ❌ 메모리 누수 위험
public class MainViewModel : BaseViewModel
{
    public MainViewModel()
    {
        // 강한 참조로 인한 메모리 누수!
        SomeStaticEvent.EventOccurred += OnEventOccurred;
    }

    private void OnEventOccurred(object sender, EventArgs e)
    {
        // ...
    }
}

// ✅ 이벤트 해제
public class MainViewModel : BaseViewModel, IDisposable
{
    public MainViewModel()
    {
        SomeStaticEvent.EventOccurred += OnEventOccurred;
    }

    public void Dispose()
    {
        SomeStaticEvent.EventOccurred -= OnEventOccurred;
    }
}

// ✅ 약한 이벤트 패턴 사용
public class MainViewModel : BaseViewModel
{
    public MainViewModel()
    {
        WeakEventManager<SomeClass, EventArgs>
            .AddHandler(someInstance, nameof(SomeClass.EventOccurred), OnEventOccurred);
    }
}

1단계: Model 정의

// Models/TodoItem.cs
public class TodoItem
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Description { get; set; }
    public bool IsCompleted { get; set; }
    public DateTime CreatedDate { get; set; }
    public DateTime? DueDate { get; set; }
    public Priority Priority { get; set; }
}

public enum Priority
{
    Low,
    Normal,
    High,
    Urgent
}

// Services/ITodoService.cs
public interface ITodoService
{
    Task<List<TodoItem>> GetAllTodosAsync();
    Task<TodoItem> GetTodoByIdAsync(int id);
    Task AddTodoAsync(TodoItem todo);
    Task UpdateTodoAsync(TodoItem todo);
    Task DeleteTodoAsync(int id);
}

// Services/TodoService.cs
public class TodoService : ITodoService
{
    private readonly List<TodoItem> _todos = new();
    private int _nextId = 1;

    public Task<List<TodoItem>> GetAllTodosAsync()
    {
        return Task.FromResult(_todos.ToList());
    }

    public Task<TodoItem> GetTodoByIdAsync(int id)
    {
        var todo = _todos.FirstOrDefault(t => t.Id == id);
        return Task.FromResult(todo);
    }

    public Task AddTodoAsync(TodoItem todo)
    {
        todo.Id = _nextId++;
        todo.CreatedDate = DateTime.Now;
        _todos.Add(todo);
        return Task.CompletedTask;
    }

    public Task UpdateTodoAsync(TodoItem todo)
    {
        var existing = _todos.FirstOrDefault(t => t.Id == todo.Id);
        if (existing != null)
        {
            var index = _todos.IndexOf(existing);
            _todos[index] = todo;
        }
        return Task.CompletedTask;
    }

    public Task DeleteTodoAsync(int id)
    {
        var todo = _todos.FirstOrDefault(t => t.Id == id);
        if (todo != null)
        {
            _todos.Remove(todo);
        }
        return Task.CompletedTask;
    }
}

2단계: ViewModel 구현

// ViewModels/TodoItemViewModel.cs
public class TodoItemViewModel : BaseViewModel
{
    private readonly TodoItem _model;

    public TodoItemViewModel(TodoItem model)
    {
        _model = model;
    }

    public int Id => _model.Id;

    public string Title
    {
        get => _model.Title;
        set
        {
            if (_model.Title != value)
            {
                _model.Title = value;
                OnPropertyChanged();
            }
        }
    }

    public bool IsCompleted
    {
        get => _model.IsCompleted;
        set
        {
            if (_model.IsCompleted != value)
            {
                _model.IsCompleted = value;
                OnPropertyChanged();
                OnPropertyChanged(nameof(StatusText));
            }
        }
    }

    public string StatusText => IsCompleted ? "완료" : "진행중";

    public TodoItem GetModel() => _model;
}

// ViewModels/MainViewModel.cs
public class MainViewModel : BaseViewModel
{
    private readonly ITodoService _todoService;
    private readonly IDialogService _dialogService;

    public ObservableCollection<TodoItemViewModel> Todos { get; }

    private TodoItemViewModel _selectedTodo;
    public TodoItemViewModel SelectedTodo
    {
        get => _selectedTodo;
        set => SetProperty(ref _selectedTodo, value);
    }

    private string _newTodoTitle;
    public string NewTodoTitle
    {
        get => _newTodoTitle;
        set => SetProperty(ref _newTodoTitle, value);
    }

    public ICommand LoadTodosCommand { get; }
    public ICommand AddTodoCommand { get; }
    public ICommand DeleteTodoCommand { get; }
    public ICommand ToggleCompleteCommand { get; }

    public MainViewModel(ITodoService todoService, IDialogService dialogService)
    {
        _todoService = todoService;
        _dialogService = dialogService;
        
        Todos = new ObservableCollection<TodoItemViewModel>();

        LoadTodosCommand = new AsyncRelayCommand(LoadTodosAsync);
        AddTodoCommand = new AsyncRelayCommand(AddTodoAsync, CanAddTodo);
        DeleteTodoCommand = new AsyncRelayCommand<TodoItemViewModel>(DeleteTodoAsync);
        ToggleCompleteCommand = new AsyncRelayCommand<TodoItemViewModel>(ToggleCompleteAsync);

        // 초기 로드
        _ = LoadTodosAsync();
    }

    private async Task LoadTodosAsync()
    {
        var todos = await _todoService.GetAllTodosAsync();
        
        Todos.Clear();
        foreach (var todo in todos)
        {
            Todos.Add(new TodoItemViewModel(todo));
        }
    }

    private bool CanAddTodo()
    {
        return !string.IsNullOrWhiteSpace(NewTodoTitle);
    }

    private async Task AddTodoAsync()
    {
        var newTodo = new TodoItem
        {
            Title = NewTodoTitle,
            IsCompleted = false,
            Priority = Priority.Normal
        };

        await _todoService.AddTodoAsync(newTodo);
        Todos.Add(new TodoItemViewModel(newTodo));

        NewTodoTitle = string.Empty;
        _dialogService.ShowMessage("할 일이 추가되었습니다!");
    }

    private async Task DeleteTodoAsync(TodoItemViewModel todoVm)
    {
        if (todoVm == null) return;

        bool confirmed = _dialogService.ShowConfirmation(
            "정말 삭제하시겠습니까?",
            "삭제 확인"
        );

        if (confirmed)
        {
            await _todoService.DeleteTodoAsync(todoVm.Id);
            Todos.Remove(todoVm);
        }
    }

    private async Task ToggleCompleteAsync(TodoItemViewModel todoVm)
    {
        if (todoVm == null) return;

        todoVm.IsCompleted = !todoVm.IsCompleted;
        await _todoService.UpdateTodoAsync(todoVm.GetModel());
    }
}

3단계: View (XAML) 구현

<Window x:Class="TodoApp.Views.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="할 일 관리" Height="600" Width="800">
    
    <Window.Resources>
        <BooleanToVisibilityConverter x:Key="BoolToVis" />
    </Window.Resources>

    <Grid Margin="20">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>

        <!-- 제목 -->
        <TextBlock Grid.Row="0" 
                   Text="📝 할 일 관리"
                   FontSize="28"
                   FontWeight="Bold"
                   Margin="0,0,0,20" />

        <!-- 새 할 일 추가 -->
        <Grid Grid.Row="1" Margin="0,0,0,20">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="Auto" />
            </Grid.ColumnDefinitions>

            <TextBox Grid.Column="0"
                     Text="{Binding NewTodoTitle, UpdateSourceTrigger=PropertyChanged}"
                     FontSize="16"
                     Padding="10"
                     VerticalContentAlignment="Center">
                <TextBox.InputBindings>
                    <KeyBinding Key="Enter" Command="{Binding AddTodoCommand}" />
                </TextBox.InputBindings>
            </TextBox>

            <Button Grid.Column="1"
                    Content="➕ 추가"
                    Command="{Binding AddTodoCommand}"
                    Margin="10,0,0,0"
                    Padding="20,10"
                    FontSize="16"
                    Background="#667eea"
                    Foreground="White"
                    BorderThickness="0"
                    Cursor="Hand" />
        </Grid>

        <!-- 할 일 목록 -->
        <ListBox Grid.Row="2"
                 ItemsSource="{Binding Todos}"
                 SelectedItem="{Binding SelectedTodo}"
                 ScrollViewer.HorizontalScrollBarVisibility="Disabled">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Border BorderBrush="#e9ecef"
                            BorderThickness="1"
                            CornerRadius="8"
                            Padding="15"
                            Margin="0,5"
                            Background="White">
                        <Grid>
                            <Grid.ColumnDefinitions>
                                <ColumnDefinition Width="Auto" />
                                <ColumnDefinition Width="*" />
                                <ColumnDefinition Width="Auto" />
                            </Grid.ColumnDefinitions>

                            <!-- 완료 체크박스 -->
                            <CheckBox Grid.Column="0"
                                      IsChecked="{Binding IsCompleted}"
                                      Command="{Binding DataContext.ToggleCompleteCommand,
                                                      RelativeSource={RelativeSource AncestorType=ListBox}}"
                                      CommandParameter="{Binding}"
                                      VerticalAlignment="Center"
                                      Margin="0,0,15,0" />

                            <!-- 제목과 상태 -->
                            <StackPanel Grid.Column="1" VerticalAlignment="Center">
                                <TextBlock Text="{Binding Title}"
                                           FontSize="16"
                                           FontWeight="SemiBold">
                                    <TextBlock.Style>
                                        <Style TargetType="TextBlock">
                                            <Style.Triggers>
                                                <DataTrigger Binding="{Binding IsCompleted}" Value="True">
                                                    <Setter Property="TextDecorations" Value="Strikethrough" />
                                                    <Setter Property="Foreground" Value="#adb5bd" />
                                                </DataTrigger>
                                            </Style.Triggers>
                                        </Style>
                                    </TextBlock.Style>
                                </TextBlock>
                                
                                <TextBlock Text="{Binding StatusText}"
                                           FontSize="12"
                                           Foreground="#6c757d"
                                           Margin="0,5,0,0" />
                            </StackPanel>

                            <!-- 삭제 버튼 -->
                            <Button Grid.Column="2"
                                    Content="🗑️"
                                    Command="{Binding DataContext.DeleteTodoCommand,
                                                    RelativeSource={RelativeSource AncestorType=ListBox}}"
                                    CommandParameter="{Binding}"
                                    Background="Transparent"
                                    BorderThickness="0"
                                    FontSize="18"
                                    Cursor="Hand"
                                    Padding="10" />
                        </Grid>
                    </Border>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
</Window>

4단계: 의존성 주입 설정

// App.xaml.cs
public partial class App : Application
{
    private ServiceProvider _serviceProvider;

    public App()
    {
        var services = new ServiceCollection();
        ConfigureServices(services);
        _serviceProvider = services.BuildServiceProvider();
    }

    private void ConfigureServices(IServiceCollection services)
    {
        // Services
        services.AddSingleton<ITodoService, TodoService>();
        services.AddSingleton<IDialogService, DialogService>();

        // ViewModels
        services.AddTransient<MainViewModel>();

        // Views
        services.AddTransient<MainWindow>();
    }

    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        var mainWindow = _serviceProvider.GetRequiredService<MainWindow>();
        mainWindow.Show();
    }

    protected override void OnExit(ExitEventArgs e)
    {
        _serviceProvider?.Dispose();
        base.OnExit(e);
    }
}

학습 단계

🌱 초급 (1-2개월)
1️⃣ C# 기초 문법 완벽히 이해하기
2️⃣ WPF 기본 개념 (XAML, 레이아웃, 컨트롤)
3️⃣ 데이터 바인딩 기초
4️⃣ INotifyPropertyChanged 이해하고 구현
5️⃣ 간단한 커맨드 패턴 구현
6️⃣ 기본적인 MVVM 구조로 간단한 앱 만들기

🌿 중급 (2-3개월)
1️⃣ 의존성 주입 이해와 적용
2️⃣ 서비스 패턴 (Dialog, Navigation)
3️⃣ 고급 데이터 바인딩 (MultiBinding, Converter)
4️⃣ 비동기 프로그래밍 (async/await)
5️⃣ 단위 테스트 작성
6️⃣ MVVM 프레임워크 사용 (CommunityToolkit.Mvvm)
7️⃣ 중간 규모 프로젝트 완성

🌳 고급 (3-6개월)
1️⃣ 대규모 애플리케이션 아키텍처 설계
2️⃣ 모듈화와 플러그인 시스템
3️⃣ 성능 최적화 기법
4️⃣ 고급 XAML 테크닉
5️⃣ 메시징 패턴과 이벤트 애그리게이터
6️⃣ 실무 프로젝트 경험
7️⃣ 오픈소스 프로젝트 기여

추천 학습 리소스

📖 공식 문서
- Microsoft Learn WPF 튜토리얼
- .NET API 브라우저
- CommunityToolkit.Mvvm 문서

🎥 온라인 강의
- Pluralsight: WPF MVVM 시리즈
- Udemy: Complete WPF & MVVM
- YouTube: IAmTimCorey, SingletonSean

📚 추천 도서
- "Pro WPF in C#" by Matthew MacDonald
- "WPF 4.5 Unleashed" by Adam Nathan
- "MVVM Survival Guide" by Muhammad Shujaat Siddiqi

💻 실습 프로젝트 아이디어
- 할 일 관리 앱 (TodoList)
- 메모장 애플리케이션
- 연락처 관리 시스템
- 간단한 POS 시스템
- 파일 탐색기
- 음악 플레이어
- 채팅 애플리케이션

커뮤니티와 도움 받기

🌐 온라인 커뮤니티
- Stack Overflow (wpf, mvvm 태그)
- Reddit: r/csharp, r/dotnet
- GitHub Discussions
- Discord: C# 서버들

🤝 한국 커뮤니티
- OKKY
- 생활코딩
- 인프런 질문 게시판
- 재능넷 같은 플랫폼에서 멘토 찾기

혹시 WPF MVVM 개발을 배우고 싶은데 혼자 하기 어렵다면, 재능넷에서 경험 많은 개발자들에게 멘토링을 받아보는 것도 좋은 방법이야! 실무 경험을 가진 선배 개발자들이 1:1로 코드 리뷰도 해주고, 프로젝트 설계도 도와줄 수 있거든. 🎯

1. 명명 규칙 일관성 유지

팀 전체가 같은 명명 규칙을 따라야 해:

// ViewModel 명명
MainViewModel, UserListViewModel, SettingsViewModel

// View 명명
MainWindow, UserListView, SettingsView

// Command 명명
SaveCommand, DeleteCommand, LoadDataCommand (동사 + Command)

// Property 명명
UserName, IsEnabled, SelectedItem (명사 또는 형용사)

// Service 명명
IDataService, IDialogService, INavigationService (I + 명사 + Service)

2. ViewModel은 가볍게 유지

ViewModel에 너무 많은 로직을 넣지 마! 비즈니스 로직은 Service나 Model로 분리해:

// ❌ 나쁜 예: ViewModel에 비즈니스 로직
public class UserViewModel : BaseViewModel
{
    public void SaveUser()
    {
        // 데이터베이스 연결
        using var connection = new SqlConnection(connectionString);
        connection.Open();
        
        // SQL 쿼리 실행
        var command = new SqlCommand("INSERT INTO Users...", connection);
        command.ExecuteNonQuery();
        
        // 파일 저장
        File.WriteAllText("user.json", JsonSerializer.Serialize(user));
    }
}

// ✅ 좋은 예: Service로 분리
public class UserViewModel : BaseViewModel
{
    private readonly IUserService _userService;

    public async Task SaveUser()
    {
        await _userService.SaveUserAsync(User);
    }
}

3. 에러 처리 전략

사용자에게 친절한 에러 메시지를 보여줘야 해:

public class MainViewModel : BaseViewModel
{
    private readonly IDialogService _dialogService;
    private readonly ILogger _logger;

    private string _errorMessage;
    public string ErrorMessage
    {
        get => _errorMessage;
        set => SetProperty(ref _errorMessage, value);
    }

    private bool _hasError;
    public bool HasError
    {
        get => _hasError;
        set => SetProperty(ref _hasError, value);
    }

    public ICommand SaveCommand { get; }

    private async Task SaveAsync()
    {
        try
        {
            HasError = false;
            ErrorMessage = string.Empty;

            await _dataService.SaveAsync(Data);
            _dialogService.ShowMessage("저장되었습니다!");
        }
        catch (ValidationException ex)
        {
            // 유효성 검사 오류 - 사용자에게 표시
            HasError = true;
            ErrorMessage = ex.Message;
            _logger.LogWarning(ex, "Validation failed");
        }
        catch (Exception ex)
        {
            // 예상치 못한 오류 - 로그 기록 후 일반 메시지
            HasError = true;
            ErrorMessage = "저장 중 오류가 발생했습니다. 다시 시도해주세요.";
            _logger.LogError(ex, "Save failed");
            
            _dialogService.ShowMessage(ErrorMessage, "오류");
        }
    }
}

4. 메모리 관리

큰 데이터를 다룰 때는 메모리 관리에 신경 써야 해:

public class LargeDataViewModel : BaseViewModel, IDisposable
{
    private ObservableCollection<DataItem> _items;
    private CancellationTokenSource _cts;

    public async Task LoadDataAsync()
    {
        _cts = new CancellationTokenSource();

        try
        {
            // 페이징 처리
            const int pageSize = 100;
            var page = 0;

            while (!_cts.Token.IsCancellationRequested)
            {
                var items = await _dataService.GetPageAsync(page, pageSize, _cts.Token);
                
                if (items.Count == 0) break;

                foreach (var item in items)
                {
                    Items.Add(item);
                }

                page++;
            }
        }
        catch (OperationCanceledException)
        {
            // 취소됨
        }
    }

    public void Dispose()
    {
        _cts?.Cancel();
        _cts?.Dispose();
        
        // 큰 컬렉션 정리
        Items?.Clear();
    }
}

5. 디자인 타임 데이터

디자이너에서 미리보기를 위한 샘플 데이터를 제공해:

public class MainViewModel : BaseViewModel
{
    public ObservableCollection<User> Users { get; set; }

    public MainViewModel() : this(null)
    {
    }

    public MainViewModel(IUserService userService)
    {
        if (userService == null)
        {
            // 디자인 타임 데이터
            Users = new ObservableCollection<User>
            {
                new User { Name = "홍길동", Age = 25 },
                new User { Name = "김철수", Age = 30 },
                new User { Name = "이영희", Age = 28 }
            };
        }
        else
        {
            // 런타임 데이터
            Users = new ObservableCollection<User>();
            LoadUsers(userService);
        }
    }
}

// XAML에서 디자인 타임 ViewModel 설정
<Window xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:vm="clr-namespace:MyApp.ViewModels"
        mc:Ignorable="d"
        d:DataContext="{d:DesignInstance Type=vm:MainViewModel, IsDesignTimeCreatable=True}">
    <!-- UI 요소들 -->
</Window>

6. 코드 리뷰 체크리스트

MVVM 코드를 리뷰할 때 확인할 사항들:

✅ View가 ViewModel만 참조하는가?
✅ ViewModel이 View를 참조하지 않는가?
✅ 비즈니스 로직이 Service로 분리되어 있는가?
✅ 모든 속성이 PropertyChanged를 발생시키는가?
✅ 커맨드의 CanExecute가 적절히 구현되어 있는가?
✅ 비동기 작업이 올바르게 처리되는가?
✅ 에러 처리가 적절한가?
✅ 메모리 누수 가능성은 없는가?
✅ 단위 테스트가 작성되어 있는가?
✅ 명명 규칙이 일관적인가?

핵심 요약 정리

1️⃣ MVVM의 세 가지 레이어
- Model: 데이터와 비즈니스 로직
- View: 사용자 인터페이스 (XAML)
- ViewModel: 중간 연결 계층

2️⃣ 핵심 메커니즘
- 데이터 바인딩으로 View와 ViewModel 연결
- INotifyPropertyChanged로 변경 알림
- Command 패턴으로 사용자 액션 처리

3️⃣ 설계 원칙
- View는 ViewModel만 알아야 함
- ViewModel은 View를 몰라야 함
- 단방향 의존성 유지
- 의존성 주입 활용

4️⃣ 실무 팁
- 명명 규칙 일관성
- ViewModel은 가볍게
- 적절한 에러 처리
- 성능 최적화
- 테스트 작성