# MVVM Anti-Patterns Reference

## 1. Logic in Code-Behind

### Bad
```csharp
// MainPage.xaml.cs
public partial class MainPage : Page
{
    private async void SaveButton_Click(object sender, RoutedEventArgs e)
    {
        var service = new ProductService(); // Direct instantiation
        await service.SaveAsync(new Product
        {
            Name = NameTextBox.Text,
            Price = decimal.Parse(PriceTextBox.Text)
        });
        MessageBox.Show("Saved!");
    }
}
```

### Good
```csharp
// MainPage.xaml.cs
public partial class MainPage : Page
{
    public MainPage(MainViewModel viewModel)
    {
        InitializeComponent();
        DataContext = viewModel;
    }
}

// MainViewModel.cs
public partial class MainViewModel(IProductService productService) : ObservableObject
{
    [RelayCommand]
    private async Task SaveAsync()
    {
        await productService.SaveAsync(new Product { Name = Name, Price = Price });
    }
}
```

## 2. ViewModel Referencing View Types

### Bad
```csharp
public class MainViewModel : ObservableObject
{
    private readonly MainPage _page; // Direct View reference

    public void UpdateUI()
    {
        _page.StatusLabel.Text = "Updated"; // Manipulating View directly
    }
}
```

### Good
```csharp
public partial class MainViewModel : ObservableObject
{
    [ObservableProperty]
    private string _statusText = string.Empty;
}
```

## 3. Manual INotifyPropertyChanged

### Bad
```csharp
public class ProductViewModel : INotifyPropertyChanged
{
    private string _name;
    public string Name
    {
        get => _name;
        set
        {
            if (_name != value)
            {
                _name = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Name)));
            }
        }
    }

    public event PropertyChangedEventHandler? PropertyChanged;
}
```

### Good
```csharp
public partial class ProductViewModel : ObservableObject
{
    [ObservableProperty]
    private string _name = string.Empty;
}
```

## 4. God ViewModel

### Bad
```csharp
public partial class MainViewModel : ObservableObject
{
    // 500+ lines handling products, orders, users, settings, navigation, etc.
    [ObservableProperty] private ObservableCollection<Product> _products;
    [ObservableProperty] private ObservableCollection<Order> _orders;
    [ObservableProperty] private User _currentUser;
    [ObservableProperty] private AppSettings _settings;
    // ... hundreds more properties and commands
}
```

### Good
```csharp
// Split into focused ViewModels
public partial class ProductListViewModel : ObservableObject { /* Products only */ }
public partial class OrderListViewModel : ObservableObject { /* Orders only */ }
public partial class UserProfileViewModel : ObservableObject { /* User only */ }
public partial class SettingsViewModel : ObservableObject { /* Settings only */ }
```

## 5. Direct Service Calls in View

### Bad
```xml
<Button Click="OnClick" />
```
```csharp
private async void OnClick(object sender, EventArgs e)
{
    var service = App.ServiceProvider.GetService<IDataService>();
    var data = await service.GetDataAsync();
    // ...
}
```

### Good
```xml
<Button Command="{Binding LoadDataCommand}" />
```
```csharp
public partial class DataViewModel(IDataService service) : ObservableObject
{
    [RelayCommand]
    private async Task LoadDataAsync()
    {
        var data = await service.GetDataAsync();
        // ...
    }
}
```

## 6. Exposing Model Directly

### Bad
```csharp
public partial class OrderViewModel : ObservableObject
{
    [ObservableProperty]
    private Order _order; // Exposes database entity directly

    // View binds to Order.Customer.Address.City
}
```

### Good
```csharp
public partial class OrderViewModel : ObservableObject
{
    private readonly Order _order;

    public string CustomerName => _order.Customer.Name;
    public string ShippingAddress => FormatAddress(_order.Customer.Address);
    public decimal Total => _order.Items.Sum(i => i.Price * i.Quantity);
}
```

## 7. Synchronous Operations on UI Thread

### Bad
```csharp
[RelayCommand]
private void LoadData()
{
    var data = _service.GetData(); // Blocking call
    Items = new ObservableCollection<Item>(data);
}
```

### Good
```csharp
[RelayCommand]
private async Task LoadDataAsync()
{
    var data = await _service.GetDataAsync();
    Items = new ObservableCollection<Item>(data);
}
```

## 8. Missing Validation

### Bad
```csharp
[RelayCommand]
private async Task SaveAsync()
{
    await _service.SaveAsync(new Product { Name = Name, Price = Price });
}
```

### Good
```csharp
public partial class ProductViewModel : ObservableValidator
{
    [ObservableProperty]
    [NotifyDataErrorInfo]
    [Required]
    private string _name = string.Empty;

    [RelayCommand(CanExecute = nameof(CanSave))]
    private async Task SaveAsync()
    {
        ValidateAllProperties();
        if (!HasErrors)
        {
            await _service.SaveAsync(new Product { Name = Name, Price = Price });
        }
    }

    private bool CanSave() => !HasErrors;
}
```

## 9. Tight Coupling Between ViewModels

### Bad
```csharp
public class OrderViewModel : ObservableObject
{
    private readonly CustomerViewModel _customerViewModel; // Direct reference

    public void SelectCustomer()
    {
        _customerViewModel.ShowSelectionDialog();
        Customer = _customerViewModel.SelectedCustomer;
    }
}
```

### Good
```csharp
public partial class OrderViewModel : ObservableRecipient
{
    public OrderViewModel()
    {
        IsActive = true;
    }

    protected override void OnActivated()
    {
        Messenger.Register<CustomerSelectedMessage>(this, (r, m) =>
        {
            Customer = m.Customer;
        });
    }
}
```

## 10. Not Using IDisposable

### Bad
```csharp
public class LiveDataViewModel : ObservableObject
{
    private readonly Timer _timer;

    public LiveDataViewModel()
    {
        _timer = new Timer(UpdateData, null, 0, 1000);
    }
    // Timer never stopped, memory leak
}
```

### Good
```csharp
public partial class LiveDataViewModel : ObservableObject, IDisposable
{
    private readonly Timer _timer;
    private bool _disposed;

    public LiveDataViewModel()
    {
        _timer = new Timer(UpdateData, null, 0, 1000);
    }

    public void Dispose()
    {
        if (!_disposed)
        {
            _timer.Dispose();
            _disposed = true;
        }
    }
}
```

# MVVM Patterns Reference

## Property Patterns

### Simple Observable Property
```csharp
[ObservableProperty]
private string _name = string.Empty;
```

### Property with Change Notification
```csharp
[ObservableProperty]
private int _quantity;

partial void OnQuantityChanged(int oldValue, int newValue)
{
    // React to change
    OnPropertyChanged(nameof(Total));
}
```

### Property Affecting Commands
```csharp
[ObservableProperty]
[NotifyCanExecuteChangedFor(nameof(SaveCommand))]
[NotifyCanExecuteChangedFor(nameof(DeleteCommand))]
private bool _isValid;
```

### Property with Validation
```csharp
[ObservableProperty]
[NotifyDataErrorInfo]
[Required(ErrorMessage = "Name is required")]
[MinLength(2, ErrorMessage = "Name must be at least 2 characters")]
private string _name = string.Empty;
```

## Command Patterns

### Simple Async Command
```csharp
[RelayCommand]
private async Task LoadDataAsync()
{
    var data = await _service.GetDataAsync();
    Items = new ObservableCollection<Item>(data);
}
```

### Command with CanExecute
```csharp
[RelayCommand(CanExecute = nameof(CanSave))]
private async Task SaveAsync()
{
    await _service.SaveAsync(CurrentItem);
}

private bool CanSave() => IsValid && !IsBusy;
```

### Command with Parameter
```csharp
[RelayCommand]
private void SelectItem(Item item)
{
    SelectedItem = item;
}

[RelayCommand]
private async Task DeleteItemAsync(int itemId)
{
    await _service.DeleteAsync(itemId);
    Items.Remove(Items.First(i => i.Id == itemId));
}
```

### Command with Cancellation
```csharp
[RelayCommand(IncludeCancelCommand = true)]
private async Task SearchAsync(string query, CancellationToken token)
{
    await Task.Delay(300, token); // Debounce
    var results = await _searchService.SearchAsync(query, token);
    SearchResults = new ObservableCollection<SearchResult>(results);
}
```

## Collection Patterns

### Master-Detail
```csharp
public partial class MasterDetailViewModel : ObservableObject
{
    [ObservableProperty]
    private ObservableCollection<Item> _items = [];

    [ObservableProperty]
    private Item? _selectedItem;

    partial void OnSelectedItemChanged(Item? value)
    {
        if (value is not null)
        {
            LoadDetails(value.Id);
        }
    }

    private async void LoadDetails(int id)
    {
        DetailItem = await _service.GetDetailsAsync(id);
    }
}
```

### Filtered Collection
```csharp
public partial class FilteredListViewModel : ObservableObject
{
    private readonly List<Item> _allItems = [];

    [ObservableProperty]
    private ObservableCollection<Item> _filteredItems = [];

    [ObservableProperty]
    private string _searchText = string.Empty;

    partial void OnSearchTextChanged(string value)
    {
        FilterItems();
    }

    private void FilterItems()
    {
        var filtered = string.IsNullOrEmpty(SearchText)
            ? _allItems
            : _allItems.Where(i => i.Name.Contains(SearchText, StringComparison.OrdinalIgnoreCase));

        FilteredItems = new ObservableCollection<Item>(filtered);
    }
}
```

## Navigation Patterns

### ViewModel-First Navigation
```csharp
public interface INavigationService
{
    Task NavigateToAsync<TViewModel>() where TViewModel : ObservableObject;
    Task NavigateToAsync<TViewModel>(object parameter) where TViewModel : ObservableObject;
    Task GoBackAsync();
}

public partial class MainViewModel(INavigationService navigation) : ObservableObject
{
    [RelayCommand]
    private async Task OpenDetailsAsync(Item item)
    {
        await navigation.NavigateToAsync<ItemDetailViewModel>(item.Id);
    }
}
```

### View-First Navigation
```csharp
// Shell navigation (MAUI)
[RelayCommand]
private async Task NavigateToSettings()
{
    await Shell.Current.GoToAsync("settings");
}

// Frame navigation (WPF/WinUI)
[RelayCommand]
private void NavigateToSettings()
{
    _frame.Navigate(typeof(SettingsPage));
}
```

## State Management Patterns

### Loading State
```csharp
public partial class DataViewModel : ObservableObject
{
    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(ShowContent))]
    [NotifyPropertyChangedFor(nameof(ShowLoading))]
    [NotifyPropertyChangedFor(nameof(ShowError))]
    private ViewState _state = ViewState.Idle;

    [ObservableProperty]
    private string? _errorMessage;

    public bool ShowLoading => State == ViewState.Loading;
    public bool ShowContent => State == ViewState.Success;
    public bool ShowError => State == ViewState.Error;

    [RelayCommand]
    private async Task LoadAsync()
    {
        State = ViewState.Loading;
        try
        {
            var data = await _service.GetDataAsync();
            Items = new ObservableCollection<Item>(data);
            State = ViewState.Success;
        }
        catch (Exception ex)
        {
            ErrorMessage = ex.Message;
            State = ViewState.Error;
        }
    }
}

public enum ViewState { Idle, Loading, Success, Error }
```

### Undo/Redo Pattern
```csharp
public partial class EditViewModel : ObservableObject
{
    private readonly Stack<Action> _undoStack = new();
    private readonly Stack<Action> _redoStack = new();

    [ObservableProperty]
    [NotifyCanExecuteChangedFor(nameof(UndoCommand))]
    private bool _canUndo;

    [ObservableProperty]
    [NotifyCanExecuteChangedFor(nameof(RedoCommand))]
    private bool _canRedo;

    public void ExecuteCommand(Action doAction, Action undoAction)
    {
        doAction();
        _undoStack.Push(undoAction);
        _redoStack.Clear();
        UpdateCanUndoRedo();
    }

    [RelayCommand(CanExecute = nameof(CanUndo))]
    private void Undo()
    {
        var action = _undoStack.Pop();
        action();
        _redoStack.Push(action);
        UpdateCanUndoRedo();
    }
}
```

## Dialog Patterns

### Confirmation Dialog
```csharp
public interface IDialogService
{
    Task<bool> ConfirmAsync(string title, string message);
    Task<string?> PromptAsync(string title, string message);
    Task AlertAsync(string title, string message);
}

[RelayCommand]
private async Task DeleteItemAsync(Item item)
{
    var confirmed = await _dialogService.ConfirmAsync(
        "Delete Item",
        $"Are you sure you want to delete '{item.Name}'?");

    if (confirmed)
    {
        await _service.DeleteAsync(item.Id);
        Items.Remove(item);
    }
}
```

## Dependency Injection Patterns

### Constructor Injection (Preferred)
```csharp
public partial class ProductViewModel(
    IProductService productService,
    INavigationService navigation,
    IDialogService dialogs) : ObservableObject
{
    // Use injected services directly
}
```

### Factory Pattern for ViewModels
```csharp
public interface IViewModelFactory
{
    TViewModel Create<TViewModel>() where TViewModel : ObservableObject;
}

public class ViewModelFactory(IServiceProvider provider) : IViewModelFactory
{
    public TViewModel Create<TViewModel>() where TViewModel : ObservableObject
    {
        return provider.GetRequiredService<TViewModel>();
    }
}
```