### Registering dependencies with SimpleIoc

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Example of registering dependencies using MvvmLight's SimpleIoc. This is the pattern you'll be migrating from.

```csharp
public void RegisterServices()
{
  SimpleIoc.Default.Register<INavigationService, NavigationService>();

  SimpleIoc.Default.Register<IDialogService>(() => new DialogService());
}
```

--------------------------------

### Standard Command Setup

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/overview

This demonstrates the conventional method for creating a command, involving a private method for execution and manual instantiation of `RelayCommand` with a backing field.

```csharp
private void SayHello()
{
    Console.WriteLine("Hello");
}

private ICommand? sayHelloCommand;

public ICommand SayHelloCommand => sayHelloCommand ??= new RelayCommand(SayHello);

```

--------------------------------

### Standard Observable Property Setup

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/overview

This is the traditional way to set up an observable property, requiring manual implementation of the getter, setter, and property change notification.

```csharp
private string? name;

public string? Name
{
    get => name;
    set => SetProperty(ref name, value);
}

```

--------------------------------

### Install MVVM Toolkit via .NET CLI

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmbasic

Use the .NET CLI to add the CommunityToolkit.Mvvm NuGet package to your project. Ensure you specify the desired version.

```bash
dotnet add package CommunityToolkit.Mvvm --version 8.1.0
```

--------------------------------

### Unregistering dependencies with SimpleIoc

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Example of how to unregister a dependency with MvvmLight's SimpleIoc. The MVVM Toolkit's Ioc does not have a direct replacement for this.

```csharp
SimpleIoc.Default.Unregister<INavigationService>();
```

--------------------------------

### Implementing OnChanging and OnChanged (New Value Only)

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/observableproperty

Example demonstrating how to implement the partial methods OnNameChanging and OnNameChanged to execute logic based solely on the new value when the 'Name' property changes.

```csharp
[ObservableProperty]
private string? name;

partial void OnNameChanging(string? value)
{
    Console.WriteLine($"Name is about to change to {value}");
}

partial void OnNameChanged(string? value)
{
    Console.WriteLine($"Name has changed to {value}");
}

```

--------------------------------

### Install MVVM Toolkit via PackageReference

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Add this XML element to your project file to include the CommunityToolkit.Mvvm NuGet package using the PackageReference format.

```xml
<PackageReference Include="CommunityToolkit.Mvvm" Version="8.1.0" />

```

--------------------------------

### MVVMTK0036 Error Example

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0036

This code snippet demonstrates the MVVMTK0036 error caused by a missing `using` directive for the `JsonIgnore` attribute.

```C#
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    [ObservableProperty]
    private int counter;

    [RelayCommand]
    [property: JsonIgnore]
    private void IncrementCounter()
    {
        Counter++;
    }
}
```

--------------------------------

### Install MVVM Toolkit via PackageReference

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmbasic

Add the CommunityToolkit.Mvvm NuGet package to your project using the PackageReference XML format. Specify the version required for your project.

```xml
<PackageReference Include="CommunityToolkit.Mvvm" Version="8.1.0" />
```

--------------------------------

### Asynchronous Request Message Example

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/messenger

Define and use an asynchronous request message to get a User object. Register a receiver that replies with a `Task<User>`. The request can be directly awaited, simplifying asynchronous data retrieval.

```csharp
public class LoggedInUserRequestMessage : AsyncRequestMessage<User>
{
}

WeakReferenceMessenger.Default.Register<MyViewModel, LoggedInUserRequestMessage>(this, (r, m) =>
{
    m.Reply(r.GetCurrentUserAsync());
});

User user = await WeakReferenceMessenger.Default.Send<LoggedInUserRequestMessage>();

```

--------------------------------

### Synchronous Request Message Example

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/messenger

Define and use a synchronous request message to get a User object. Register a receiver to handle the request and reply with the current user. The `RequestMessage<T>` class ensures a response is received or throws an exception.

```csharp
public class LoggedInUserRequestMessage : RequestMessage<User>
{
}

WeakReferenceMessenger.Default.Register<MyViewModel, LoggedInUserRequestMessage>(this, (r, m) =>
{
    m.Reply(r.CurrentUser);
});

User user = WeakReferenceMessenger.Default.Send<LoggedInUserRequestMessage>();

```

--------------------------------

### Implementing OnChanging and OnChanged (Old and New Values)

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/observableproperty

This example shows how to implement the overloads of OnSelectedItemChanging and OnSelectedItemChanged to access both the old and new values, useful for updating related state.

```csharp
[ObservableProperty]
private ChildViewModel? selectedItem;

partial void OnSelectedItemChanging(ChildViewModel? oldValue, ChildViewModel? newValue)
{
    if (oldValue is not null)
    {
        oldValue.IsSelected = true;
    }

    if (newValue is not null)
    {
        newValue.IsSelected = true;
    }
}

```

--------------------------------

### Command Setup with Source Generator

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/overview

The `RelayCommand` attribute streamlines command creation. By annotating a method with `[RelayCommand]`, the source generator automatically creates the associated command property.

```csharp
[RelayCommand]
private void SayHello()
{
    Console.WriteLine("Hello");
}

```

--------------------------------

### SubredditWidgetViewModel Setup with AsyncRelayCommand and Observable Properties

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/puttingthingstogether

This viewmodel manages subreddit posts, exposing an async command to load posts and observable properties for the post collection, subreddits, and selected items. Use `SetProperty` for observable properties and `AsyncRelayCommand` for asynchronous operations.

```csharp
public sealed class SubredditWidgetViewModel : ObservableRecipient
{
    /// <summary>
    /// Creates a new <see cref="SubredditWidgetViewModel"/> instance.
    /// </summary>
    public SubredditWidgetViewModel()
    {
        LoadPostsCommand = new AsyncRelayCommand(LoadPostsAsync);
    }

    /// <summary>
    /// Gets the <see cref="IAsyncRelayCommand"/> instance responsible for loading posts.
    /// </summary>
    public IAsyncRelayCommand LoadPostsCommand { get; }

    /// <summary>
    /// Gets the collection of loaded posts.
    /// </summary>
    public ObservableCollection<object> Posts { get; } = new ObservableCollection<object>();

    /// <summary>
    /// Gets the collection of available subreddits to pick from.
    /// </summary>
    public IReadOnlyList<string> Subreddits { get; } = new[]
    {
        "microsoft",
        "windows",
        "surface",
        "windowsphone",
        "dotnet",
        "csharp"
    };

    private string selectedSubreddit;

    /// <summary>
    /// Gets or sets the currently selected subreddit.
    /// </summary>
    public string SelectedSubreddit
    {
        get => selectedSubreddit;
        set => SetProperty(ref selectedSubreddit, value);
    }

    private object selectedPost;

    /// <summary>
    /// Gets or sets the currently selected subreddit.
    /// </summary>
    public object SelectedPost
    {
        get => selectedPost;
        set => SetProperty(ref selectedPost, value, true);
    }

    /// <summary>
    /// Loads the posts from a specified subreddit.
    /// </summary>
    private async Task LoadPostsAsync()
    {
        // TODO...
    }
}
```

--------------------------------

### Configure Service Provider for Settings Service

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/puttingthingstogether

This C# code demonstrates how to configure the service provider to register a singleton instance of `SettingsService` as `ISettingsService` and a transient instance of `PostWidgetViewModel`. This setup ensures that the UWP-specific `SettingsService` is used when resolving `ISettingsService` on UWP platforms.

```csharp
/// <summary>
/// Gets the <see cref="IServiceProvider"/> instance to resolve application services.
/// </summary>
public IServiceProvider Services { get; }

/// <summary>
/// Configures the services for the application.
/// </summary>
private static IServiceProvider ConfigureServices()
{
    var services = new ServiceCollection();

    services.AddSingleton<ISettingsService, SettingsService>();
    services.AddTransient<PostWidgetViewModel>();

    return services.BuildServiceProvider();
}
```

--------------------------------

### XAML Binding for Command and Parameter

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/relaycommand

This XAML example demonstrates how to bind a Button's Command and CommandParameter to properties in the ViewModel. The Command is linked to the generated RelayCommand, and the CommandParameter is bound to the selected user.

```xml
<!-- Note: this example uses traditional XAML binding syntax -->
<Button
    Content="Greet user"
    Command="{Binding GreetUserCommand}"
    CommandParameter="{Binding SelectedUser}"/>
```

--------------------------------

### ObservableProperty on Partial Properties

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0041

Example of using [ObservableProperty] on a partial property within a class inheriting from ObservableObject. This requires the C# language version to be set to 'preview'.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    [ObservableProperty]
    public partial string? Name { get; set; }
}
```

--------------------------------

### ViewModel Receiving Messages via IRecipient

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/observablerecipient

This example shows a ViewModel inheriting from ObservableRecipient and implementing IRecipient to automatically receive messages when active. The OnActivated method implicitly registers the message handler.

```csharp
public class MyViewModel : ObservableRecipient, IRecipient<LoggedInUserRequestMessage>
{
    public void Receive(LoggedInUserRequestMessage message)
    {
        // Handle the message here
    }
}

```

--------------------------------

### ViewModel Manually Registering Message Handlers

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/observablerecipient

This example demonstrates manually registering message handlers within the OnActivated method of a ViewModel that inherits from ObservableRecipient. It shows both method group and lambda expression approaches for handling messages.

```csharp
public class MyViewModel : ObservableRecipient
{
    protected override void OnActivated()
    {
        // Using a method group...
        Messenger.Register<MyViewModel, LoggedInUserRequestMessage>(this, (r, m) => r.Receive(m));

        // ...or a lambda expression
        Messenger.Register<MyViewModel, LoggedInUserRequestMessage>(this, (r, m) =>
        {
            // Handle the message here
        });
    }

    private void Receive(LoggedInUserRequestMessage message)
    {
        // Handle the message here
    }
}

```

--------------------------------

### MVVM Toolkit Error MVVMTK0009 Example

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0009

This C# code demonstrates the MVVMTK0009 error. The `CanExecute` property is set to "Bar", but no member named "Bar" exists in the `SampleViewModel` class, causing the error.

```csharp
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

public partial class SampleViewModel
{
    private bool Foo => true;

    // There is no member named "Bar"
    [RelayCommand(CanExecute = "Bar")]
    private void GreetUser()
    {
    }
}

```

--------------------------------

### Configure Services and Retrieve with Constructor Injection

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/ioc

Configure the DI service collection by registering services and their dependencies. Then, retrieve a service, and the DI provider will automatically resolve its constructor arguments.

```csharp
/// <summary>
/// Configures the services for the application.
/// </summary>
private static IServiceProvider ConfigureServices()
{
    var services = new ServiceCollection();

    services.AddSingleton<IFilesService, FilesService>();
    services.AddSingleton<IConsoleService, ConsoleService>();
    services.AddSingleton<IFileLogger, FileLogger>();

    return services.BuildServiceProvider();
}

// Retrieve a logger service with constructor injection
IFileLogger fileLogger = App.Current.Services.GetService<IFileLogger>();

```

--------------------------------

### Configure Services in UWP App

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/ioc

This code sets up the IServiceProvider by configuring and building a ServiceCollection. It registers singleton instances for various services like IFilesService, ISettingsService, and others. This is typically done at application startup.

```csharp
public sealed partial class App : Application
{
    public App()
    {
        Services = ConfigureServices();

        this.InitializeComponent();
    }

    /// <summary>
    /// Gets the current <see cref="App"/> instance in use
    /// </summary>
    public new static App Current => (App)Application.Current;

    /// <summary>
    /// Gets the <see cref="IServiceProvider"/> instance to resolve application services.
    /// </summary>
    public IServiceProvider Services { get; }

    /// <summary>
    /// Configures the services for the application.
    /// </summary>
    private static IServiceProvider ConfigureServices()
    {
        var services = new ServiceCollection();

        services.AddSingleton<IFilesService, FilesService>();
        services.AddSingleton<ISettingsService, SettingsService>();
        services.AddSingleton<IClipboardService, ClipboardService>();
        services.AddSingleton<IShareService, ShareService>();
        services.AddSingleton<IEmailService, EmailService>();

        return services.BuildServiceProvider();
    }
}

```

--------------------------------

### NotifyPropertyChangedFor Target Cannot Be Null

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0015

The target property name provided to `[NotifyPropertyChangedFor]` cannot be null. This example demonstrates the error when 'null' is passed as the target property name.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    // The target property name is invalid (cannot be null)
    [ObservableProperty]
    [NotifyPropertyChangedFor(null)]
    private string name;
}

```

--------------------------------

### Resolving dependencies with SimpleIoc

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

How to retrieve registered dependencies using MvvmLight's SimpleIoc.Default.GetInstance.

```csharp
IDialogService dialogService = SimpleIoc.Default.GetInstance<IDialogService>();
```

--------------------------------

### Initial Project Configuration (MVVMTK0051)

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0051

This XML configuration sets the LangVersion to 10.0, which can lead to MVVMTK0051 warnings when using [ObservableProperty] on fields in WinRT scenarios.

```XML
<PropertyGroup>
    <LangVersion>10.0</LangVersion>
</PropertyGroup>
```

--------------------------------

### NotifyPropertyChangedFor Target Must Be a Property, Not a Method

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0015

The member specified in `[NotifyPropertyChangedFor]` must be a property. This example shows an error where the target member 'Foo' is a method, not a property.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    // The target member "Foo" should be a property, but it's a method
    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(Foo))]
    private string name;

    public void Foo()
    {
    }
}

```

--------------------------------

### Configure Service Provider with Refit

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/puttingthingstogether

This method configures the application's service provider, registering a singleton for ISettingsService and using Refit's RestService.For to create a type-safe implementation of IRedditService. It also registers PostWidgetViewModel.

```csharp
/// <summary>
/// Configures the services for the application.
/// </summary>
private static IServiceProvider ConfigureServices()
{
    var services = new ServiceCollection();

    services.AddSingleton<ISettingsService, SettingsService>();
    services.AddSingleton(RestService.For<IRedditService>("https://www.reddit.com/"));
    services.AddTransient<PostWidgetViewModel>();

    return services.BuildServiceProvider();
}
```

--------------------------------

### Configure C# Language Version to Preview

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0041

Set the C# language version to 'preview' in your .csproj file to enable source generators for [ObservableProperty] on partial properties.

```xml
<PropertyGroup>
    <LangVersion>13.0</LangVersion>
</PropertyGroup>
```

--------------------------------

### Configure Services for Viewmodels

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/ioc

Configures the application's service collection to register services and viewmodels. Use AddSingleton for services with a single instance and AddTransient for viewmodels that should be created each time they are requested.

```csharp
/// <summary>
/// Configures the services for the application.
/// </summary>
private static IServiceProvider ConfigureServices()
{
    var services = new ServiceCollection();

    // Services
    services.AddSingleton<IContactsService, ContactsService>();
    services.AddSingleton<IPhoneService, PhoneService>();

    // Viewmodels
    services.AddTransient<ContactsViewModel>();

    return services.BuildServiceProvider();
}
```

--------------------------------

### MVVM Toolkit Error MVVMTK0020 Example

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0020

This C# code snippet demonstrates the MVVMTK0020 error. It shows a field `number` that is not annotated with `[ObservableProperty]` but is used with `[NotifyPropertyChangedFor]`, which is not allowed.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class MyViewModel
{
    // The field is not using [ObservableProperty]
    [NotifyPropertyChangedFor("")]
    public int number;
}

```

--------------------------------

### Incorrect property declaration causing MVVMTK0043

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0043

This code demonstrates the incorrect way to declare a property with `[ObservableProperty]`, leading to the MVVMTK0043 error. Ensure properties have both a `get` and a `set` accessor.

```C#
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    [ObservableProperty]
    public partial string? Name { get; }
}

```

--------------------------------

### Configure LangVersion for MVVM Toolkit

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0042

Ensure your project is configured to use a preview version of C# to enable certain features required by the MVVM Toolkit.

```xml
<PropertyGroup>
    <LangVersion>preview</LangVersion>
</PropertyGroup>
```

--------------------------------

### Implement RelayCommand for ViewModel

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/relaycommand

This C# code demonstrates how to set up a simple command using RelayCommand within a ViewModel. It initializes an ICommand property that wraps a private method, which is then invoked when the command is executed.

```csharp
public class MyViewModel : ObservableObject
{
    public MyViewModel()
    {
        IncrementCounterCommand = new RelayCommand(IncrementCounter);
    }

    private int counter;

    public int Counter
    {
        get => counter;
        private set => SetProperty(ref counter, value);
    }

    public ICommand IncrementCounterCommand { get; }

    private void IncrementCounter() => Counter++;
}
```

--------------------------------

### Generated RelayCommand Property

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/relaycommand

This is an example of the IRelayCommand property that the RelayCommand attribute generates. The command name is derived from the annotated method name, appending 'Command' and stripping prefixes like 'On' or 'Async'.

```csharp
private RelayCommand? greetUserCommand;

public IRelayCommand GreetUserCommand => greetUserCommand ??= new RelayCommand(GreetUser);

```

--------------------------------

### Registering dependencies with MVVM Toolkit Ioc

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Achieve similar dependency registration as MvvmLight but using the MVVM Toolkit's Ioc with Microsoft.Extensions.DependencyInjection. ConfigureServices expects an IServiceProvider.

```csharp
public void RegisterServices()
{
  Ioc.Default.ConfigureServices(
    new ServiceCollection()
    .AddSingleton<INavigationService, NavigationService>()
    .AddSingleton<IDialogService>(new DialogService())
    .BuildServiceProvider());
}
```

--------------------------------

### NotifyPropertyChangedFor Target Must Be Accessible Property

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0015

Ensure the property specified in `[NotifyPropertyChangedFor]` exists and is accessible within the parent type. This example shows an invalid usage where the target property 'FooBar' does not exist.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    // The containing type has no property named "FooBar"
    [ObservableProperty]
    [NotifyPropertyChangedFor("FooBar")]
    private string name;
}

```

--------------------------------

### MVVMTK0022 Error Example

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0022

This C# code snippet demonstrates the incorrect usage that triggers the MVVMTK0022 error. The containing type 'MyViewModel' inherits from 'ObservableObject' but lacks the necessary ObservableRecipient functionality for the [NotifyPropertyChangedRecipients] attribute.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class MyViewModel : ObservableObject
{
    // The containing type does not have the ObservableRecipient functionality
    [ObservableProperty]
    [NotifyPropertyChangedRecipients]
    public int number;
}
```

--------------------------------

### Service Configuration

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/puttingthingstogether

Configures the service provider to include the Reddit service, using Refit to create a type-safe implementation.

```APIDOC
## ConfigureServices

### Description
Configures the services for the application, including registering the Reddit service.

### Method
`services.AddSingleton(RestService.For<IRedditService>("https://www.reddit.com/"));`

### Details
This line registers an instance of `IRedditService` with the service collection. Refit automatically generates the implementation for `IRedditService` based on the interface definition and the provided base URL.
```

--------------------------------

### MVVMTK0006 Error Example

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0006

This C# code demonstrates the scenario that generates MVVMTK0006. The `[Required]` attribute is applied to a field (`name`) within a class (`SampleViewModel`) that does not inherit from `ObservableValidator`, while also using the `[ObservableProperty]` attribute.

```csharp
using System.ComponentModel.DataAnnotations;
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

[INotifyPropertyChanged]
public partial class SampleViewModel
{
    // The field has a validation attribute (the [Required] attribute), but the
    // containing type (SampleViewModel) doesn't inherit from ObservableValidator
    [ObservableProperty]
    [Required]
    private string name;
}

```

--------------------------------

### MVVM Toolkit Error MVVMTK0024 Example

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0024

This C# code demonstrates a scenario that generates the MVVM Toolkit error MVVMTK0024. The field 'property' of type 'object' causes a naming collision with the generated OnPropertyChanged method.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class MyViewModel : ObservableObject
{
    // This field would generate a property named "Property", which would cause the
    // generated partial OnPropertyChanged() method to collide with the base helper
    // method to raise the PropertyChanged event. Additionally, since the field is
    // of type object, this would make the generated OnPropertyChanged() call bind
    // to the generated partial method, and not to the helper raising the event.
    [ObservableProperty]
    public object property;
}
```

--------------------------------

### Avoid Field Name Collisions with [ObservableProperty]

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0014

The target field for `[ObservableProperty]` should use 'lowerCamel', '_lowerCamel', or 'm_lowerCamel' patterns to prevent collisions with the generated property. This example shows an incorrect field name that triggers MVVMTK0014.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    // The target field would generate a property with the same name
    [ObservableProperty]
    private string Name;
}
```

--------------------------------

### Synchronous Method with IncludeCancelCommand

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0013

This code generates MVVMTK0013 because the target method `GreetUser` is synchronous. The `IncludeCancelCommand` property requires an asynchronous command type that accepts a cancellation token.

```csharp
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

public partial class SampleViewModel
{
    // The target method is synchronous, so no cancel command can be generated
    [RelayCommand(IncludeCancelCommand = true)]
    private void GreetUser(User user)
    {
    }
}
```

--------------------------------

### Define a Service with Constructor Dependencies

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/ioc

Define a service that requires other services through its constructor. The DI service provider will automatically resolve and inject these dependencies.

```csharp
public class FileLogger : IFileLogger
{
    private readonly IFilesService FileService;
    private readonly IConsoleService ConsoleService;

    public FileLogger(
        IFilesService fileService,
        IConsoleService consoleService)
    {
        FileService = fileService;
        ConsoleService = consoleService;
    }

    // Methods for the IFileLogger interface here...
}
```

--------------------------------

### Implement UWP Settings Service

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/puttingthingstogether

This C# code defines a `SettingsService` for UWP that implements `ISettingsService`. It uses `IPropertySet` to store and retrieve settings from `ApplicationData.Current.LocalSettings.Values`. Use this when you need a platform-specific implementation for UWP.

```csharp
public sealed class SettingsService : ISettingsService
{
    /// <summary>
    /// The <see cref="IPropertySet"/> with the settings targeted by the current instance.
    /// </summary>
    private readonly IPropertySet SettingsStorage = ApplicationData.Current.LocalSettings.Values;

    /// <inheritdoc/>
    public void SetValue<T>(string key, T value)
    {
        if (!SettingsStorage.ContainsKey(key)) SettingsStorage.Add(key, value);
        else SettingsStorage[key] = value;
    }

    /// <inheritdoc/>
    public T GetValue<T>(string key)
    {
        if (SettingsStorage.TryGetValue(key, out object value))
        {
            return (T)value;
        }

        return default;
    }
}
```

--------------------------------

### MVVMTK0044 Error Example with Older SDK

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0044

This C# code snippet demonstrates the scenario that generates the MVVMTK0044 error when using an older .NET SDK, such as the .NET 8 SDK. It shows the usage of `[ObservableProperty]` with a partial property.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    [ObservableProperty]
    public partial string? Name { get; set; }
}

```

--------------------------------

### MVVMTK0047: Correct usage with partial properties

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0047

This sample shows the correct way to use `[GeneratedBindableCustomProperty]` and `[ObservableProperty]` by converting the field to a partial property. This resolves the MVVMTK0047 warning.

```C#
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

[GeneratedBindableCustomProperty]
public partial class SampleViewModel : ObservableObject
{
    [ObservableProperty]
    public partial string? Name { get; set; }
}

```

--------------------------------

### Resolving dependencies with MVVM Toolkit Ioc

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Retrieve dependencies using the MVVM Toolkit's Ioc.GetService method, which is the equivalent of SimpleIoc.Default.GetInstance.

```csharp
IDialogService dialogService = Ioc.Default.GetService<IDialogService>();
```

--------------------------------

### Corrected async Task method with RelayCommand

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0039

This sample shows the corrected way to implement an asynchronous method with `[RelayCommand]` by returning a `Task`. This allows the MVVM Toolkit to generate an `AsyncRelayCommand`, providing features like concurrency control and execution tracking.

```C#
using System.Threading.Tasks;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    [RelayCommand]
    private async Task DoWorkAsync()
    {
        await Task.Delay(1000);
    }
}
```

--------------------------------

### MVVM Toolkit C# Code Example Triggering MVVMTK0008

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0008

This C# code demonstrates a scenario where the MVVMTK0008 error might occur if the project's C# language version is set below 8.0. Ensure your project's configuration aligns with the required language version.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

// The project doesn't have a high enough version of C#
[INotifyPropertyChanged]
public partial class SampleViewModel
{
}
```

--------------------------------

### Add CommunityToolkit.Mvvm.Input Namespace

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmbasic

Include the `CommunityToolkit.Mvvm.Input` namespace in files that use `RelayCommand`. This ensures that `RelayCommand` and its related methods are accessible.

```csharp
using CommunityToolkit.Mvvm.Input;
```

```vb
Imports CommunityToolkit.Mvvm.Input
```

--------------------------------

### SubredditViewModel with Persistent Settings

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/puttingthingstogether

Implements a ViewModel that uses an ISettingsService to persist the selected subreddit. The value is retrieved on initialization and saved on change.

```C#
/// <summary>
/// Gets the <see cref="ISettingsService"/> instance to use.
/// </summary>
private readonly ISettingsService SettingsService;

/// <summary>
/// Creates a new <see cref="SubredditWidgetViewModel"/> instance.
/// </summary>
public SubredditWidgetViewModel(ISettingsService settingsService)
{
    SettingsService = settingsService;

    selectedSubreddit = settingsService.GetValue<string>(nameof(SelectedSubreddit)) ?? Subreddits[0];
}

private string selectedSubreddit;

/// <summary>
/// Gets or sets the currently selected subreddit.
/// </summary>
public string SelectedSubreddit
{
    get => selectedSubreddit;
    set
    {
        SetProperty(ref selectedSubreddit, value);

        SettingsService.SetValue(nameof(SelectedSubreddit), value);
    }
}
```

--------------------------------

### Migrate Set<T>(ref T, T, bool, string) to SetProperty

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

The Set<T>(ref T, T, bool, string) method has a direct replacement named SetProperty<T>(ref T, T, bool, string).

```csharp
// MvvmLight
Set(ref this.myProperty, value, true, nameof(MyProperty));

// MVVM Toolkit
SetProperty(ref this.myProperty, value, true);

```

--------------------------------

### Alternative manual command property with C# preview features

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0048

This code snippet provides an alternative solution for MVVMTK0048 using C# preview features available in Visual Studio 17.12 and above. It simplifies the manual command property declaration.

```csharp
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

[GeneratedBindableCustomProperty]
public partial class SampleViewModel : BaseViewModel
{
}

public partial class BaseViewModel
{
    public IRelayCommand DoWorkCommand => field ??= new RelayCommand(DoWork);

    private void DoWork()
    {
    }
}
```

--------------------------------

### Handle custom IMessenger implementations without OverrideDefault

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

MvvmLight's OverrideDefault method has no direct replacement. Use custom IMessenger implementations by registering them with dependency injection or manually constructing and passing a static instance.

```csharp
// MvvmLight
Messenger.OverrideDefault(new Messenger());

// MVVM Toolkit
// No direct replacement
```

--------------------------------

### Migrate Set<T>(Expression, ref T, T, bool) to SetProperty

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Replace Set<T>(Expression, ref T, T, bool) with SetProperty<T>(ref T, T, bool, string) using the nameof keyword for improved performance.

```csharp
// MvvmLight
Set<MyObject>(() => MyProperty, ref this.myProperty, value, true);

// MVVM Toolkit
SetProperty(ref this.myProperty, value, true);

```

--------------------------------

### Update using directives for RelayCommand

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Replace MvvmLight directives with CommunityToolkit.Mvvm directives for command implementations.

```csharp
// MvvmLight
using GalaSoft.MvvmLight.Command;
using Galasoft.MvvmLight.CommandWpf;

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

```

--------------------------------

### Implement IRecipient Interface for Message Handling

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/messenger

Implement the IRecipient interface to handle specific message types. This provides a structured way to receive and process messages within a dedicated method.

```csharp
// Create a message
public class MyRecipient : IRecipient<LoggedInUserChangedMessage>
{
    public void Receive(LoggedInUserChangedMessage message)
    {
        // Handle the message here...   
    }
}

// Register that specific message...
WeakReferenceMessenger.Default.Register<LoggedInUserChangedMessage>(this);

// ...or alternatively, register all declared handlers
WeakReferenceMessenger.Default.RegisterAll(this);

// Send a message from some other module
WeakReferenceMessenger.Default.Send(new LoggedInUserChangedMessage(user));
```

--------------------------------

### Sending Messages with a Token

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

The MVVM Toolkit's Send method with a token is equivalent to MVVM Light's Send method with a recipient object.

```C#
// MvvmLight
Messenger.Default.Send<MyMessage>(new MyMessage(), nameof(MyViewModel));
Messenger.Default.Send(new MyMessage(), nameof(MyViewModel));

// MVVM Toolkit
Messenger.Send(new MyMessage(), nameof(MyViewModel));

```

--------------------------------

### Cleaning Up Messenger

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

The MVVM Toolkit provides a Cleanup method that directly replaces MVVM Light's Cleanup. Note that this is primarily relevant for messengers using weak references; StrongReferenceMessenger handles internal trimming automatically.

```C#
// MvvmLight
Messenger.Default.Cleanup();

// MVVM Toolkit
Messenger.Cleanup();

```

--------------------------------

### Using C# preview feature for command property with MVVMTK0046

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0046

This code snippet shows an alternative solution for the MVVMTK0046 warning using a C# preview feature available in Visual Studio 17.12 and above. It simplifies the manual command property declaration.

```C#
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

[GeneratedBindableCustomProperty]
public partial class SampleViewModel
{
    public IRelayCommand DoWorkCommand => field ??= new RelayCommand(DoWork);

    private void DoWork()
    {
    }
}

```

--------------------------------

### Set C# Language Version to 8.0 or Higher

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0008

Configure your project's .csproj file to use C# 8.0 or a later version to satisfy the MVVM Toolkit's source generator requirements. This setting is crucial for enabling features like `INotifyPropertyChanged` generation.

```xml
<PropertyGroup>
    <LangVersion>7.3</LangVersion>
</PropertyGroup>
```

--------------------------------

### Update using directives for ObservableObject

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Replace MvvmLight directives with CommunityToolkit.Mvvm directives when migrating.

```csharp
// MvvmLight
using GalaSoft.MvvmLight;

// MVVM Toolkit
using CommunityToolkit.Mvvm.ComponentModel;

```

--------------------------------

### Manually declared command property for [GeneratedBindableCustomProperty]

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0048

This code shows the recommended solution for MVVMTK0048. It involves making the command field a partial property and manually initializing the command, allowing [GeneratedBindableCustomProperty] to work correctly.

```csharp
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

[GeneratedBindableCustomProperty]
public partial class SampleViewModel : BaseViewModel
{
}

public partial class BaseViewModel
{
    private IRelayCommand? doWorkCommand;

    public IRelayCommand DoWorkCommand => doWorkCommand ??= new RelayCommand(DoWork);

    private void DoWork()
    {
    }
}
```

--------------------------------

### Sending Messages

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

The MVVM Toolkit provides a simplified way to send messages, especially those with parameterless constructors.

```C#
// MvvmLight
Messenger.Default.Send<MyMessage>(new MyMessage());
Messenger.Default.Send(new MyMessage());

// MVVM Toolkit
Messenger.Send(new MyMessage());

```

```C#
// MVVM Toolkit
Messenger.Send<MyMessage>();

```

--------------------------------

### Add C# using directive for CommunityToolkit.Mvvm

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm

Include this directive in your C# project to access the MVVM Toolkit APIs.

```csharp
using CommunityToolkit.Mvvm;

```

--------------------------------

### Replace MessengerInstance with Messenger

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Use `Messenger` from the MVVM Toolkit as a direct replacement for `MessengerInstance` from MVVM Light. The default instance is `WeakReferenceMessenger.Default`, which can be customized.

```csharp
// MvvmLight
IMessenger messenger = MessengerInstance;

// MVVM Toolkit
IMessenger messenger = Messenger;
```

--------------------------------

### Replace Set(string, ref T, T) with SetProperty

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

The Set<T>(string, ref T, T) method from MvvmLight is replaced by SetProperty<T>(ref T, T, string) in the MVVM Toolkit, with reordered parameters.

```csharp
// MvvmLight
Set(nameof(MyProperty), ref this.myProperty, value);

// MVVM Toolkit
SetProperty(ref this.myProperty, value);

```

--------------------------------

### Register Messenger Handler (with Token)

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Migrate the Register<TMessage>(object, object, Action<TMessage>) method using a token. The MVVM Toolkit's method includes a generic type parameter for the token.

```csharp
// MvvmLight
Messenger.Default.Register<MyMessage>(this, nameof(MyViewModel), this.OnMyMessageReceived);

// MVVM Toolkit
Messenger.Register<MyViewModel, MyMessage, string>(this, nameof(MyViewModel), static (r, m) => r.OnMyMessageReceived(m));

```

--------------------------------

### Integrate Reddit Service into ViewModel

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/puttingthingstogether

This ViewModel demonstrates how to use the IRedditService to fetch and display posts from a selected subreddit. It clears existing posts and adds new ones from the API response.

```csharp
public sealed class SubredditWidgetViewModel : ObservableRecipient
{
    /// <summary>
    /// Gets the <see cref="IRedditService"/> instance to use.
    /// </summary>
    private readonly IRedditService RedditService = Ioc.Default.GetRequiredService<IRedditService>();

    /// <summary>
    /// Loads the posts from a specified subreddit.
    /// </summary>
    private async Task LoadPostsAsync()
    {
        var response = await RedditService.GetSubredditPostsAsync(SelectedSubreddit);

        Posts.Clear();

        foreach (var item in response.Data.Items)
        {
            Posts.Add(item.Data);
        }
    }
}
```

--------------------------------

### Migrate RelayCommand with asynchronous actions

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Replace MvvmLight's RelayCommand for asynchronous actions with the CommunityToolkit.Mvvm's AsyncRelayCommand.

```csharp
// MvvmLight
var command = new RelayCommand(() => OnCommandAsync());
var command = new RelayCommand(async () => await OnCommandAsync());

// MVVM Toolkit
var asyncCommand = new AsyncRelayCommand(OnCommandAsync);

```

--------------------------------

### Settings Service Interface Definition

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/puttingthingstogether

Defines an interface for a settings service to abstract platform-specific storage. This allows viewmodels to interact with settings without direct platform dependencies.

```C#
public interface ISettingsService
{
    /// <summary>
    /// Assigns a value to a settings key.
    /// </summary>
    /// <typeparam name="T">The type of the object bound to the key.</typeparam>
    /// <param name="key">The key to check.</param>
    /// <param name="value">The value to assign to the setting key.</param>
    void SetValue<T>(string key, T value);

    /// <summary>
    /// Reads a value from the current <see cref="IServiceProvider"/> instance and returns its casting in the right type.
    /// </summary>
    /// <typeparam name="T">The type of the object to retrieve.</typeparam>
    /// <param name="key">The key associated to the requested object.</param>
    [Pure]
    T GetValue<T>(string key);
}
```

--------------------------------

### Wrap a Non-Observable Model with Notification Support

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/observableobject

Create a bindable model that relays properties from a non-observable model and raises notifications. This overload of SetProperty is efficient for wrapping existing models.

```csharp
public class ObservableUser : ObservableObject
{
    private readonly User user;

    public ObservableUser(User user) => this.user = user;

    public string Name
    {
        get => user.Name;
        set => SetProperty(user.Name, value, user, (u, n) => u.Name = n);
    }
}
```

--------------------------------

### Add CommunityToolkit.Mvvm.ComponentModel Namespace

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmbasic

Include the `CommunityToolkit.Mvvm.ComponentModel` namespace in files that use `ObservableObject`. This can be done manually or via IDE quick actions.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;
```

```vb
Imports CommunityToolkit.Mvvm.ComponentModel
```

--------------------------------

### Update Messenger Using Directives

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Replace MvvmLight Messenger using directives with the Community Toolkit's messenger directives.

```csharp
// MvvmLight
using GalaSoft.MvvmLight.Messaging;

// MVVM Toolkit
using CommunityToolkit.Mvvm.Messaging;

```

--------------------------------

### Access the default messenger instance

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

The 'Default' property for accessing the messenger instance requires no change in implementation when migrating from MvvmLight to the MVVM Toolkit, though the underlying type may differ.

```csharp
// MvvmLight
IMessenger messenger = Messenger.Default;

// MVVM Toolkit
IMessenger messenger = WeakReferenceMessenger.Default;
```

--------------------------------

### Annotating Overloaded Methods with [RelayCommand]

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0023

This sample demonstrates the incorrect usage of [RelayCommand] on overloaded methods within the same class, which triggers the MVVMTK0023 error. Command methods must be unique.

```csharp
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

public partial class SampleViewModel
{
    [RelayCommand]
    private void GreetUser()
    {
    }

    // Cannot have an overload of a command method
    [RelayCommand]
    private void GreetUser(object value)
    {
    }
}
```

--------------------------------

### Unregistering Specific Message Handler (MVVM Light vs MVVM Toolkit)

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

MVVM Light allowed unregistering a specific message handler. The MVVM Toolkit simplifies this by only allowing unregistration of all handlers for a given message type and recipient, as a recipient can only have one handler per message type.

```C#
// MvvmLight
Messenger.Default.Unregister<MyMessage>(this, OnMyMessageReceived);

// MVVM Toolkit
Messenger.Unregister<MyMessage>(this);

```

--------------------------------

### Migrate RelayCommand<T> with asynchronous actions

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

Replace MvvmLight's RelayCommand<T> with the MVVM Toolkit's AsyncRelayCommand<T> for improved asynchronous operation handling. AsyncRelayCommand<T> is specifically designed for async methods.

```csharp
// MvvmLight
var command = new RelayCommand<string>(async () => await OnCommandAsync());

// MVVM Toolkit
var asyncCommand = new AsyncRelayCommand<string>(OnCommandAsync);

```

--------------------------------

### MVVMTK0033: Fixing by inheriting from ObservableObject

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/generators/errors/mvvmtk0033

This code sample shows the corrected approach to resolve the MVVMTK0033 warning by having the `SampleViewModel` class directly inherit from `ObservableObject`. This is the preferred method for classes without other base types.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
}

```

--------------------------------

### Replace Set(ref T, T, string) with SetProperty

Source: https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/migratingfrommvvmlight

The Set<T>(ref T, T, string) method is directly replaced by SetProperty<T>(ref T, T, string) in the MVVM Toolkit.

```csharp
// MvvmLight
Set(ref this.myProperty, value, nameof(MyProperty));

// MVVM Toolkit
SetProperty(ref this.myProperty, value);

```