push project

Author: DerekGooding

README.md

@@ -1,179 +1,242 @@
-# SimpleInjection
+# SimpleMVVM
 
-A lightweight dependency injection library for C# that combines simple DI container functionality with powerful source generation for content management.
+A lightweight WPF MVVM framework with automatic source generation that eliminates boilerplate code while maintaining full control over your view models.
 
 ## Features
 
-### 🚀 Simple Dependency Injection
-- **Attribute-based registration** - Mark classes with `[Singleton]`, `[Scoped]`, or `[Transient]`
-- **Automatic service discovery** - No manual registration required
-- **Constructor injection** - Automatic dependency resolution
-- **Scope management** - Built-in scoped service lifetime management
-
-### ⚡ Content Source Generation
-- **Automatic enum generation** - Creates enums from your content collections
-- **Type-safe access** - Generated helper methods for accessing content by enum or index
-- **Performance optimized** - Uses `NamedComparer<T>` for fast dictionary lookups
-- **Roslyn analyzers** - Enforces best practices and catches common mistakes
+- **Zero Boilerplate Commands**: Transform methods into ICommand properties with a simple `[Command]` attribute
+- **Automatic Property Binding**: Generate observable properties from fields using `[Bind]` attribute
+- **Source Generation**: All code generation happens at compile time with no runtime reflection
+- **Lightweight**: Minimal dependencies and overhead
+- **Type Safe**: Full IntelliSense support and compile-time validation
+- **WPF Optimized**: Built specifically for WPF applications with proper CommandManager integration
 
 ## Quick Start
 
-### 1. Install the Package
-```bash
-dotnet add package SimpleInjection
+### Installation
+
+```xml
+<PackageReference Include="SimpleMVVM" Version="0.9.0" />
 ```
 
-### 2. Dependency Injection Usage
+### Basic Usage
 
-Mark your classes with lifetime attributes:
+1. **Create a ViewModel**:
 
 ```csharp
-[Singleton]
-public class DatabaseService
-{
-    public void Connect() => Console.WriteLine("Connected to database");
-}
+using SimpleMVVM;
+using SimpleMVVM.BaseClasses;
 
-[Scoped]
-public class UserService
+[ViewModel]
+public partial class MainViewModel : BaseViewModel
 {
-    private readonly DatabaseService _database;
-    
-    public UserService(DatabaseService database)
+    [Command]
+    public void SaveData()
     {
-        _database = database;
+        // Your save logic here
+        MessageBox.Show("Data saved!");
+    }
+
+    [Command] 
+    public void LoadData()
+    {
+        // Your load logic here
+        MessageBox.Show("Data loaded!");
     }
-    
-    public void GetUser() => _database.Connect();
 }
 ```
 
-Initialize and use the host:
+2. **Bind to XAML**:
+
+```xml
+<Window x:Class="MyApp.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <StackPanel>
+        <Button Content="Save" Command="{Binding SaveDataCommand}" />
+        <Button Content="Load" Command="{Binding LoadDataCommand}" />
+    </StackPanel>
+</Window>
+```
+
+3. **Set DataContext**:
 
 ```csharp
-var host = Host.Initialize();
+public partial class MainWindow : Window
+{
+    public MainWindow()
+    {
+        InitializeComponent();
+        DataContext = new MainViewModel();
+    }
+}
+```
 
-// Get singleton services directly
-var dbService = host.Get<DatabaseService>();
+That's it! The source generator automatically creates `SaveDataCommand` and `LoadDataCommand` properties for you.
 
-// Create scopes for scoped services
-using var scope = host.CreateScope();
-var userService = scope.Get<UserService>();
-```
+## Advanced Features
 
-### 3. Content Generation Usage
+### Observable Properties
 
-Define your content classes:
+Use the `[Bind]` attribute to automatically generate observable properties:
 
 ```csharp
-// Your content item must implement INamed
-public record Material(string Name, string Color, int Durability) : INamed;
-
-// Your content collection must implement IContent<T>
-[Singleton]
-public partial class Materials : IContent<Material>
+[ViewModel]
+public partial class UserViewModel : BaseViewModel
 {
-    public Material[] All { get; } = 
-    [
-        new("Steel", "Gray", 100),
-        new("Wood", "Brown", 50),
-        new("Gold", "Yellow", 25)
-    ];
+    [Bind]
+    private string _firstName = "";
+    
+    [Bind]
+    private string _lastName = "";
+    
+    [Bind]
+    private int _age;
 }
 ```
 
-The source generator automatically creates:
+Generated code includes proper `INotifyPropertyChanged` implementation:
 
 ```csharp
-// Generated enum
-public enum MaterialsType
+public string FirstName
 {
-    Steel,
-    Wood,
-    Gold
+    get => _firstName;
+    set => SetProperty(ref _firstName, value);
 }
+```
 
-// Generated helper methods
-public partial class Materials
+### Command with Parameters
+
+Commands automatically support parameters:
+
+```csharp
+[ViewModel]
+public partial class DocumentViewModel : BaseViewModel
 {
-    public Material Get(MaterialsType type) => All[(int)type];
-    public Material this[MaterialsType type] => All[(int)type];
-    public Material GetById(int id) => All[id];
-    public Material Steel => All[0];
-    public Material Wood => All[1];
-    public Material Gold => All[2];
+    [Command]
+    public void DeleteItem(object parameter)
+    {
+        if (parameter is string itemId)
+        {
+            // Delete logic here
+        }
+    }
 }
 ```
 
-Use the generated code:
+### Integration with Dependency Injection
 
-```csharp
-var materials = host.Get<Materials>();
+SimpleMVVM works seamlessly with dependency injection containers:
 
-// Type-safe access using enums
-var steel = materials[MaterialsType.Steel];
-var wood = materials.Get(MaterialsType.Wood);
+```csharp
+// Using SimpleInjection (companion package)
+[Singleton][ViewModel]
+public partial class MainViewModel : BaseViewModel
+{
+    private readonly IDataService _dataService;
+    
+    public MainViewModel(IDataService dataService)
+    {
+        _dataService = dataService;
+    }
+    
+    [Command]
+    public async void LoadData()
+    {
+        var data = await _dataService.GetDataAsync();
+        // Handle data
+    }
+}
+```
 
-// Direct property access
-var gold = materials.Gold;
+## How It Works
 
-// Index-based access
-var firstMaterial = materials.GetById(0);
-```
+SimpleMVVM uses Roslyn source generators to analyze your code at compile time and automatically generate:
 
-## Advanced Features
+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
 
-### Performance Optimizations
+All generated code is available in IntelliSense and can be debugged normally.
 
-The library includes `NamedComparer<T>` for efficient dictionary operations with `INamed` keys:
+## Generated Code Example
 
+**Your Code:**
 ```csharp
-// Use ToNamedDictionary extension method
-var materialDict = materials.All.ToNamedDictionary(m => m.Durability);
-
-// Or explicitly specify the comparer
-var dict = new Dictionary<Material, int>(new NamedComparer<Material>());
+[ViewModel]
+public partial class MyViewModel : BaseViewModel
+{
+    [Command]
+    public void DoSomething() => Console.WriteLine("Done!");
+}
 ```
 
-### SubContent Collections
-
-For hierarchical content organization:
-
+**Generated Code:**
 ```csharp
-public class WeaponStats : ISubContent<Material, int>
+public partial class MyViewModel
 {
-    public Dictionary<Material, int> ByKey { get; }
-    public int this[Material material] => ByKey[material];
+    private DoSomethingCommand? _doSomethingCommand;
+    public DoSomethingCommand DoSomethingCommand => _doSomethingCommand ??= new DoSomethingCommand(this);
+}
+
+public sealed class DoSomethingCommand : BaseCommand
+{
+    private readonly MyViewModel _viewModel;
+    
+    public DoSomethingCommand(MyViewModel viewModel)
+    {
+        _viewModel = viewModel;
+    }
+    
+    public override void Execute(object? parameter)
+    {
+        _viewModel.DoSomething();
+    }
 }
 ```
 
-### Roslyn Analyzers
+## 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
+
+## Troubleshooting
+
+### Generator Not Running
 
-The package includes analyzers that help you:
-- **NC001**: Ensures `Dictionary<TKey, TValue>` uses `NamedComparer<T>` for `INamed` keys
-- **TND001**: Suggests using `ToNamedDictionary()` instead of `ToDictionary()` for `INamed` keys
+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
+5. Clean and rebuild your solution
+
+### Missing Commands in XAML
+
+If commands aren't appearing in XAML IntelliSense:
+
+1. Rebuild the project to trigger source generation
+2. Check that the generated files are created (enable `<EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>` to see them)
+3. Ensure proper namespace imports in XAML
 
 ## Requirements
 
 - .NET 8.0 or .NET 9.0
-- C# with nullable reference types enabled (recommended)
+- Windows (WPF applications only)
+- C# 10.0 or later
 
-## How It Works
+## License
 
-1. **Service Discovery**: The host scans all loaded assemblies for classes marked with lifetime attributes
-2. **Dependency Resolution**: Constructor parameters are automatically resolved from registered services
-3. **Source Generation**: The generator scans for classes implementing `IContent<T>` and generates enums and helper methods
-4. **Code Analysis**: Roslyn analyzers ensure best practices for dictionary usage with named keys
+MIT License - see LICENSE file for details.
 
-## Best Practices
+## Contributing
 
-- Use `[Singleton]` for stateless services and shared resources
-- Use `[Scoped]` for services that should be unique per operation/request
-- Use `[Transient]` for lightweight, stateless services that need fresh instances
-- Always implement `INamed` for content objects to enable source generation
-- Use the generated enums for type-safe content access
-- Leverage `ToNamedDictionary()` for performance when working with `INamed` collections
+Contributions are welcome! Please feel free to submit issues and pull requests.
 
-## License
+## Related Packages
 
-MIT License - see the license file for details.
+- **SimpleInjection**: Companion dependency injection container with automatic service discovery