update readme

DerekGooding · DerekGooding · commit 92a09e4fd914 · 2025-06-17T14:55:10.000-04:00
diff --git a/README.md b/README.md
@@ -1,7 +1,11 @@
-# SimpleViewModel
+﻿# SimpleViewModel
 
 A lightweight WPF ViewModel framework with automatic source generation that eliminates boilerplate code while maintaining full control over your view models.
 
+[![NuGet Version](https://img.shields.io/nuget/v/SimpleViewModel)](https://www.nuget.org/packages/SimpleViewModel/)
+[![NuGet Downloads](https://img.shields.io/nuget/dt/SimpleViewModel)](https://www.nuget.org/packages/SimpleViewModel/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 ## Features
 
 - **Zero Boilerplate Commands**: Transform methods into ICommand properties with a simple `[Command]` attribute
@@ -11,12 +15,23 @@ A lightweight WPF ViewModel framework with automatic source generation that elim
 - **Type Safe**: Full IntelliSense support and compile-time validation
 - **WPF Optimized**: Built specifically for WPF applications with proper CommandManager integration
 
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Advanced Features](#advanced-features)
+- [How It Works](#how-it-works)
+- [Generated Code Example](#generated-code-example)
+- [Best Practices](#best-practices)
+- [Troubleshooting](#troubleshooting)
+- [Requirements](#requirements)
+- [Contributing](#contributing)
+
 ## Quick Start
 
 ### Installation
 
 ```xml
-<PackageReference Include="SimpleViewModel" Version="0.9.6" />
+<PackageReference Include="SimpleViewModel" Version="0.9.6.4" />
 ```
 
 ### Basic Usage
@@ -28,7 +43,7 @@ using SimpleViewModel;
 using SimpleViewModel.BaseClasses;
 
 [ViewModel]
-public partial class MainViewModel : BaseViewModel
+public partial class MainViewModel
 {
     [Command]
     public void SaveData()
@@ -82,7 +97,7 @@ Use the `[Bind]` attribute to automatically generate observable properties:
 
 ```csharp
 [ViewModel]
-public partial class UserViewModel : BaseViewModel
+public partial class UserViewModel
 {
     [Bind]
     private string _firstName = "";
@@ -105,46 +120,63 @@ public string FirstName
 }
 ```
 
-### Command with Parameters
+### Property Change Callbacks
 
-Commands automatically support parameters:
+Add custom logic when properties change:
 
 ```csharp
 [ViewModel]
-public partial class DocumentViewModel : BaseViewModel
+public partial class UserViewModel
 {
-    [Command]
-    public void DeleteItem(object parameter)
+    [Bind(OnChangeMethodName = nameof(OnNameChanged))]
+    private string _name = "";
+    
+    private void OnNameChanged()
     {
-        if (parameter is string itemId)
-        {
-            // Delete logic here
-        }
+        // Custom logic when name changes
+        Console.WriteLine($"Name changed to: {_name}");
     }
 }
 ```
 
-### Integration with Dependency Injection
+### Command with CanExecute
 
-SimpleViewModel works seamlessly with dependency injection containers:
+Commands can include conditional execution logic:
 
 ```csharp
-// Using SimpleInjection (companion package)
-[Singleton][ViewModel]
-public partial class MainViewModel : BaseViewModel
+[ViewModel]
+public partial class DocumentViewModel
 {
-    private readonly IDataService _dataService;
-    
-    public MainViewModel(IDataService dataService)
+    [Bind]
+    private string _selectedItem = "";
+
+    [Command(CanExecuteMethodName = nameof(CanDelete))]
+    public void Delete()
     {
-        _dataService = dataService;
+        // Delete logic here
+        Console.WriteLine($"Deleting {_selectedItem}");
     }
     
+    public bool CanDelete()
+    {
+        return !string.IsNullOrEmpty(_selectedItem);
+    }
+}
+```
+
+### Command with Parameters
+
+Commands automatically support parameters through the Execute method:
+
+```csharp
+[ViewModel]
+public partial class DocumentViewModel
+{
     [Command]
-    public async void LoadData()
+    public void DeleteItem()
     {
-        var data = await _dataService.GetDataAsync();
-        // Handle data
+        // Note: Parameter handling is done in the generated command class
+        // The method itself doesn't need to accept parameters
     }
 }
 ```
@@ -153,9 +185,10 @@ public partial class MainViewModel : BaseViewModel
 
 SimpleViewModel uses Roslyn source generators to analyze your code at compile time and automatically generate:
 
-1. **Command Classes**: Each `[Command]` method gets a corresponding `ICommand` implementation
-2. **Command Properties**: Properties that expose the commands for data binding
-3. **Observable Properties**: Properties with `INotifyPropertyChanged` support for `[Bind]` fields
+1. **Partial ViewModel Class**: Extends your class to inherit from `BaseViewModel`
+2. **Command Classes**: Each `[Command]` method gets a corresponding command class that inherits from `BaseCommand`
+3. **Command Properties**: Properties that expose the commands for data binding (lazily initialized)
+4. **Observable Properties**: Properties with `INotifyPropertyChanged` support for `[Bind]` fields
 
 All generated code is available in IntelliSense and can be debugged normally.
 
@@ -164,44 +197,48 @@ All generated code is available in IntelliSense and can be debugged normally.
 **Your Code:**
 ```csharp
 [ViewModel]
-public partial class MyViewModel : BaseViewModel
+public partial class MyViewModel
 {
     [Command]
     public void DoSomething() => Console.WriteLine("Done!");
 }
 ```
 
-**Generated Code:**
+**Generated ViewModel Extension:**
 ```csharp
-public partial class MyViewModel
+public partial class MyViewModel : BaseViewModel
 {
-    private DoSomethingCommand? _doSomethingCommand;
-    public DoSomethingCommand DoSomethingCommand => _doSomethingCommand ??= new DoSomethingCommand(this);
+    private Command_DoSomething? _DoSomethingCommand { get; set; }
+    public Command_DoSomething DoSomethingCommand => _DoSomethingCommand ??= new(this);
 }
+```
 
-public sealed class DoSomethingCommand : BaseCommand
+**Generated Command Class:**
+```csharp
+public sealed class Command_DoSomething : BaseCommand
 {
-    private readonly MyViewModel _viewModel;
+    private readonly MyViewModel vm;
     
-    public DoSomethingCommand(MyViewModel viewModel)
+    public Command_DoSomething(MyViewModel vm)
     {
-        _viewModel = viewModel;
+        this.vm = vm;
     }
     
     public override void Execute(object? parameter)
     {
-        _viewModel.DoSomething();
+        vm.DoSomething();
     }
 }
 ```
 
 ## Best Practices
 
-1. **Inherit from BaseViewModel**: Always inherit from `BaseViewModel` for proper `INotifyPropertyChanged` support
-2. **Use Partial Classes**: Mark your view models as `partial` to allow source generation
-3. **Async Commands**: For async operations, use `async void` in command methods
-4. **Parameter Validation**: Always validate parameters in command methods
-5. **Dependency Injection**: Use constructor injection for services and dependencies
+1. **Use Partial Classes**: Always mark your view models as `partial` to allow source generation
+2. **Apply ViewModel Attribute**: Use `[ViewModel]` on your class - the generator automatically makes it inherit from `BaseViewModel`
+3. **Field Naming**: Use underscore prefixes for fields marked with `[Bind]` (e.g., `_title` becomes `Title` property)
+4. **Async Commands**: For async operations, use `async void` in command methods
+5. **Parameter Validation**: Commands receive parameters through the `Execute(object? parameter)` method in the generated class
+6. **Dependency Injection**: Use constructor injection for services and dependencies
 
 ## Troubleshooting
 
@@ -211,8 +248,8 @@ If the source generator isn't creating commands:
 
 1. Ensure you have the `[ViewModel]` attribute on your class
 2. Make sure the class is marked as `partial`
-3. Verify you're inheriting from `BaseViewModel`
-4. Check that methods have the `[Command]` attribute
+3. Check that methods have the `[Command]` attribute and are public
+4. Verify fields have the `[Bind]` attribute for observable properties
 5. Clean and rebuild your solution
 
 ### Missing Commands in XAML
@@ -223,9 +260,15 @@ If commands aren't appearing in XAML IntelliSense:
 2. Check that the generated files are created (enable `<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>` to see them)
 3. Ensure proper namespace imports in XAML
 
+### Common Issues
+
+- **Fields not generating properties**: Make sure fields are marked with `[Bind]` and are private
+- **Commands not working**: Ensure methods are public and marked with `[Command]`
+- **CanExecute not working**: Verify the method name in `CanExecuteMethodName` exists and is public with bool return type
+
 ## Requirements
 
-- .NET 8.0 or .NET 9.0
+- .NET 8.0 or .NET 9.0 (Windows targets only)
 - Windows (WPF applications only)
 - C# 10.0 or later
 
@@ -237,6 +280,12 @@ MIT License - see LICENSE file for details.
 
 Contributions are welcome! Please feel free to submit issues and pull requests.
 
-## Related Packages
+## Repository
+
+- **🏠 GitHub**: [https://github.com/DerekGooding/SimpleViewModel](https://github.com/DerekGooding/SimpleViewModel)
+- **📦 NuGet**: [https://www.nuget.org/packages/SimpleViewModel/](https://www.nuget.org/packages/SimpleViewModel/)
+- **🐛 Issues**: [https://github.com/DerekGooding/SimpleViewModel/issues](https://github.com/DerekGooding/SimpleViewModel/issues)
+
+---
 
-- **SimpleInjection**: Companion dependency injection container with automatic service discovery
+*Built with ❤️ for the WPF community*
diff --git a/SimpleViewModel/SimpleViewModel.csproj b/SimpleViewModel/SimpleViewModel.csproj
@@ -13,20 +13,22 @@
 	  <Authors>Derek Gooding</Authors>
 	  <Company>Derek Gooding</Company>
 	  <Description>
-		  A lightweight dependency injection container with automatic service discovery and powerful source generation for content management.
-		  Features attribute-based registration ([Singleton], [Scoped], [Transient]), automatic enum generation from collections,
-		  type-safe content access, and Roslyn analyzers for performance optimization.
+		  A lightweight WPF MVVM framework with automatic source generation that eliminates boilerplate code.
+		  Features attribute-based command generation ([Command]), automatic observable property creation from fields ([Bind]),
+		  and compile-time code generation with zero runtime reflection. Built specifically for WPF applications
+		  with proper CommandManager integration and INotifyPropertyChanged support.
 	  </Description>
 	  <PackageTags>
-		  dependency-injection;DI;IoC;container;source-generator;roslyn;analyzer;
-		  content-management;enum-generation;performance;csharp;dotnet;
-		  singleton;scoped;transient;service-locator;automatic-registration;
-		  type-safety;code-generation;lightweight;minimal;simple
+		  wpf;mvvm;viewmodel;source-generator;roslyn;command;binding;
+		  inotifypropertychanged;icommand;observable;properties;
+		  code-generation;compile-time;zero-boilerplate;csharp;dotnet;
+		  commandmanager;databinding;wpf-framework;lightweight;
+		  attribute-based;partial-class;baseviewmodel;basecommand
 	  </PackageTags>
 
 	  <Summary>
-		  Lightweight DI container with source generation - automatic service discovery,
-		  enum generation from content collections, and performance-optimized analyzers.
+		  Lightweight WPF MVVM framework with source generation - automatic command and observable property generation
+		  from attributes, eliminating boilerplate code while maintaining full type safety and IntelliSense support.
 	  </Summary>
 
 	  <PackageLicenseExpression>MIT</PackageLicenseExpression>
