MVVM Toolkit

https://learn.microsoft.com/en-us/dotnet/communitytoolkit/mvvm/
Admin
The MVVM Toolkit is a modern, fast, and modular .NET library providing standard, lightweight types...
Tokens:55,472
Snippets:529
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install MVVM Toolkit via .NET CLI

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

Use the dotnet CLI to add the CommunityToolkit.Mvvm NuGet package version 8.1.0 to your project.

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

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

### Install MVVM Toolkit via PackageReference

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

Add the CommunityToolkit.Mvvm NuGet package version 8.1.0 to your project file using a PackageReference.

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

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

### C# example: Applying both [INotifyPropertyChanged] and [ObservableObject]

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

This example shows a class A decorated with both [INotifyPropertyChanged] and [ObservableObject], which triggers MVVMTK0017 because the attributes cannot be used together.

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

namespace MyApp;

// Cannot use both [INotifyPropertyChanged] and [ObservableObject]
[INotifyPropertyChanged]
[ObservableObject]
public partial class A
{
}

```

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

### C# sample generating MVVMTK0043

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

This example shows a property annotated with [ObservableProperty] that has only a getter, which triggers MVVMTK0043. The property must be partial and include both a getter and a setter that is not init-only.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

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

```

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

### Define Contact model records

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

Defines the Contact, Name, and Picture records used in the example. The Name record overrides ToString to return the full name.

```csharp
public sealed record Contact(Name Name, string Email, Picture Picture);

public sealed record Name(string First, string Last)
{
    public override string ToString() => $"{First} {Last}";
}

public sealed record Picture(string Url);

```

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

### Alternative using C# preview field keyword

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

This example shows an alternative fix for Visual Studio 17.12 or above with C# preview: use the field keyword to declare the command property without a backing field. This also avoids MVVMTK0046.

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

namespace MyApp;

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

    private void DoWork()
    {      
    }
}

```

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

### MVVMTK0039: async void [RelayCommand] method

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

This example triggers MVVMTK0039 because the [RelayCommand] method is async void. The generator expects a Task return type to create an AsyncRelayCommand.

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

namespace MyApp;

public partial class SampleViewModel : ObservableObject
{
    [RelayCommand]
    private async void DoWorkAsync()
    {
        await Task.Delay(1000); // Do some work
    }
}

```

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

### MVVMTK0011: CanExecute property without getter

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

This example triggers MVVMTK0011 because the CanExecute property 'Foo' has only a setter and no getter. The [RelayCommand] attribute references 'Foo' as the CanExecute member, but a compatible member must be readable.

```csharp
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

public partial class SampleViewModel
{
    private bool Foo { set { } }

    // The target property "Foo" does not have a getter
    [RelayCommand(CanExecute = nameof(Foo))]
    private void GreetUser()
    {
    }
}

```

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

### Define IRedditService interface with Refit

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

Defines the IRedditService interface using Refit to fetch posts from a subreddit. The [Get] attribute maps the method to the Reddit REST API endpoint. Returns a PostsQueryResponse model.

```C#
public interface IRedditService
{
    /// <summary>
    /// Get a list of posts from a given subreddit
    /// </summary>
    /// <param name="subreddit">The subreddit name.</param>
    [Get("/r/{subreddit}/.json")]
    Task<PostsQueryResponse> GetSubredditPostsAsync(string subreddit);
}

```

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

### Manual command property to avoid MVVMTK0046

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

This example shows the recommended fix: manually declare a command property (e.g., DoWorkCommand) that wraps the method. This ensures the [GeneratedBindableCustomProperty] generator can see the command property.

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

namespace MyApp;

[GeneratedBindableCustomProperty]
public partial class SampleViewModel
{
    private IRelayCommand? doWorkCommand;

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

    private void DoWork()
    {      
    }
}

```

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

### Send<TMessage> with token

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

MvvmLight's Send<TMessage>(TMessage, object) is replaced by the MVVM Toolkit's Send<TMessage, TToken>(TMessage, TToken) method. The example shows sending a message with a string token.

```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));

```

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

### Forward custom attributes to generated command properties

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

Use the [property: ] target in attribute lists over annotated methods to forward attributes like [JsonIgnore] to the generated command property. For example, this generates a GreetUserCommand property with [JsonIgnore] applied.

```csharp
[RelayCommand]
[property: JsonIgnore]
private void GreetUser(User user)
{
    Console.WriteLine($"Hello {user.Name}!");
}
```

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

### Configure IServiceProvider and register services in App class (C#)

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

Declares an IServiceProvider and initializes all necessary services at startup. The Services property is initialized in the App constructor, and the ConfigureServices method registers singleton services and returns the built service provider. Includes a new Current property to access the current App instance.

```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();
    }```json
{
  
```

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

### C# example: Applying [INotifyPropertyChanged] to a derived type

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

This example shows a base class A with [INotifyPropertyChanged] and a derived class B that also has [INotifyPropertyChanged], which triggers MVVMTK0017 because the base type already has the attribute.

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

namespace MyApp;

[INotifyPropertyChanged]
public partial class A
{
}

// The base type already has [INotifyPropertyChanged]
[INotifyPropertyChanged]
public partial class B : A
{
}

```

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

### Configure services with constructor injection

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

Configures the application services and retrieves a logger service using constructor injection. The DI service provider automatically checks whether all necessary services are registered, then retrieves them. Use this when setting up dependency injection for the application.

```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>();

```

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

### MVVMTK0027: [NotifyPropertyChangedRecipients] on ObservableObject

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

This example triggers MVVMTK0027 because the class uses [NotifyPropertyChangedRecipients] but inherits from ObservableObject instead of ObservableRecipient or lacks [ObservableRecipient].

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

namespace MyApp;

// This type is requesting broadcast support but doesn't have ObservableRecipient features
[NotifyPropertyChangedRecipients]
public partial class MyViewModel : ObservableObject
{
    [ObservableProperty]
    public int number;
}

```

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

### ConfigureServices with DI registration

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

Configures the service provider, registering SettingsService as a singleton for ISettingsService and PostWidgetViewModel as transient. This enables resolving the platform-specific service at startup.

```C#
/// <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();
}
```

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

### Register dependencies with SimpleIoc

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

Registers dependencies with MvvmLight's SimpleIoc using both type mapping and a factory delegate.

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

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

```

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

### MVVMTK0015: [NotifyPropertyChangedFor(null)] with null target

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

This example generates MVVMTK0015 because the target property name is invalid (cannot be null). The [NotifyPropertyChangedFor] attribute is given a null argument.

```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;
}

```

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

### XML: Enable preview LangVersion to trigger MVVMTK0042

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

This XML snippet sets the LangVersion to 'preview' in a PropertyGroup, which is required for the MVVMTK0042 diagnostic to be generated.

```XML
<PropertyGroup>
    <LangVersion>preview</LangVersion>
</PropertyGroup>
```

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

### UWP SettingsService implementation

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

Implements ISettingsService for UWP using ApplicationData.Current.LocalSettings.Values. SetValue adds or updates a key; GetValue returns the value or default if missing.

```C#
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;
    }
}
```

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

### C#: Invalid [RelayCommand] method returning a string

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

This example triggers MVVMTK0007 because the method returns a string value, while synchronous relay commands do not support return values.

```csharp
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

public partial class SampleViewModel
{
    // This method returns a string value (synchronous commands have no return values)
    [RelayCommand]
    private string GreetUser() => ""Hello world!"";
}

```

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

### ConfigureServices method registering services and viewmodel

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

Configures the service provider by registering IContactsService, IPhoneService, and ContactsViewModel. Uses Microsoft.Extensions.DependencyInjection. The viewmodel is registered as transient.

```C#
/// <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();
}
```

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

### Loading ProgressBar bound to IsRunning

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

Binds the ProgressBar Visibility to the IsRunning property of LoadPostsCommand, which is part of IAsyncRelayCommand. AsyncRelayCommand raises notifications for IsRunning when the async operation starts or completes.

```xml
<ProgressBar Visibility="{x:Bind ViewModel.LoadPostsCommand.IsRunning, Mode=OneWay}"/>

```

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

### Swap using directives from MvvmLight to MVVM Toolkit

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

Replace the MvvmLight using directive with the MVVM Toolkit's CommunityToolkit.Mvvm.ComponentModel namespace.

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

// MVVM Toolkit
using CommunityToolkit.Mvvm.ComponentModel;
```

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

### MVVMTK0047 fix: Using partial property with [GeneratedBindableCustomProperty]

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

This corrected example replaces the [ObservableProperty] field with a partial property named Name, which is the recommended approach to avoid MVVMTK0047 when using [GeneratedBindableCustomProperty].

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

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

```

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

### MVVMTK0047: Using [GeneratedBindableCustomProperty] with [ObservableProperty] field

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

This example triggers MVVMTK0047 because it uses [GeneratedBindableCustomProperty] on a type that also has an [ObservableProperty] field. The generator cannot see the generated property, so partial properties should be used instead.

```csharp
using CommunityToolkit.Mvvm.ComponentModel;

namespace MyApp;

[GeneratedBindableCustomProperty]
public partial class SampleViewModel : ObservableObject
{
    [ObservableProperty]
    private string? name;
}

```

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

### SampleViewModel with [ObservableProperty] on ref-returning property (C#)

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

Declares a partial ref-returning property annotated with [ObservableProperty]. Using [ObservableProperty] on a property that returns a value by reference generates MVVMTK0053.

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

namespace MyApp;

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

```

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

### Problematic code generating MVVMTK0046

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

This example shows the code that triggers MVVMTK0046: a class with [GeneratedBindableCustomProperty] and a method decorated with [RelayCommand]. The generated command property is not visible to the [GeneratedBindableCustomProperty] generator, causing the warning.

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

namespace MyApp;

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

```

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

### Project file with LangVersion 13.0 that triggers MVVMTK0041

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

This XML project file sets <LangVersion>13.0</LangVersion>, which is not 'preview' and therefore triggers MVVMTK0041 when using [ObservableProperty] on partial properties. The fix is to change it to <LangVersion>preview</LangVersion>.

```XML
<PropertyGroup>
    <LangVersion>13.0</LangVersion>
</PropertyGroup>
```

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

### MVVMTK0015: [NotifyPropertyChangedFor("FooBar")] with no matching property

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

This example generates MVVMTK0015 because the containing type has no property named "FooBar". The [NotifyPropertyChangedFor] attribute targets a non-existent property.

```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;
}

```

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

### C# sample generating MVVMTK0010

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

Shows a class with two members named Foo (a property and a method), making the CanExecute name ambiguous and triggering MVVMTK0010.

```csharp
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

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

    private bool Foo() => true;

    // There are two members named "Foo", so the match is ambiguous
    [RelayCommand(CanExecute = nameof(Foo))]
    private void GreetUser()
    {
    }
}
```

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

### Unregister<TMessage> with token

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

MvvmLight's Unregister<TMessage>(object, object) is replaced by the MVVM Toolkit's Unregister<TMessage, TToken>(object, TToken) method. The example uses a string token.

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

// MVVM Toolkit
Messenger.Unregister<MyMessage, string>(this, nameof(MyViewModel));

```

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

### Migrate Set(ref T, T, string) to SetProperty

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

Rename the Set method to SetProperty with the same parameter order.

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

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

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

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

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

Renames the MvvmLight Set method to SetProperty with the same parameter order.

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

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

```

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

### MVVMTK0022: [NotifyPropertyChangedRecipients] on a type without ObservableRecipient

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

This example triggers MVVMTK0022 because the containing type inherits from ObservableObject instead of ObservableRecipient or a type annotated with [ObservableRecipient]. The [NotifyPropertyChangedRecipients] attribute requires the ObservableRecipient functionality, which is missing here.

```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;
}

```

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

### Resolve dependency with SimpleIoc

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

Resolves a service instance with MvvmLight's SimpleIoc.

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

```

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

### Redundant [NotifyDataErrorInfo] on field with class-level attribute

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

This example triggers MVVMTK0030 because the field 'number' has [NotifyDataErrorInfo] while the containing class 'MyViewModel' already has the attribute at class level. The comment explains that the field-level attribute is redundant.

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

namespace MyApp;

[NotifyDataErrorInfo]
public partial class MyViewModel : ObservableValidator
{
    // Using [NotifyDataErrorInfo] is redundant here, as the
    // containing type is already annotated with the same attribute.
    [ObservableProperty]
    [Required]
    [NotifyDataErrorInfo]
    public int number;
}

```

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

### Using ISettingsService in SubredditWidgetViewModel

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

Injects ISettingsService via constructor and uses it to persist the SelectedSubreddit property. The initial value is loaded from settings or defaults to the first subreddit, and every setter call saves the new value.

```csharp
/// <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);
    }
}

```

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

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

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

Add this using directive to access the MVVM Toolkit APIs from C# code.

```csharp
using CommunityToolkit.Mvvm;

```

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

### MVVMTK0014: Field name collision with [ObservableProperty]

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

This example triggers MVVMTK0014 because the field 'Name' uses PascalCase, which would collide with the generated property name. Use 'lowerCamel', '_lowerCamel', or 'm_lowerCamel' for fields annotated with [ObservableProperty].

```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;
}

```

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

### MVVMTK0015: [NotifyPropertyChangedFor(nameof(Foo))] targeting a method

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

This example generates MVVMTK0015 because the target member "Foo" should be a property, but it is a method. The [NotifyPropertyChangedFor] attribute is used with nameof(Foo), but 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()
    {
    }
}

```

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

### FileLogger service with constructor injection

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

Defines a FileLogger class that implements IFileLogger and requires IFilesService and IConsoleService instances through its constructor. Constructor injection lets the DI service provider resolve these indirect dependencies automatically when the type is requested.

```C#
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...
}

```

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

### Replace using directives for RelayCommand

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

Swap MvvmLight using directives for the MVVM Toolkit's CommunityToolkit.Mvvm.Input namespace.

```C#
// MvvmLight
using GalaSoft.MvvmLight.Command;
using Galasoft.MvvmLight.CommandWpf;

// MVVM Toolkit
using CommunityToolkit.Mvvm.Input;

```

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

### RelayCommand basic usage in MyViewModel

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

Shows how to set up a simple command with RelayCommand. The viewmodel exposes an IncrementCounterCommand property and increments the Counter property through the command. Uses ObservableObject and SetProperty from the MVVM Toolkit.

```C#
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++;
}

```

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

### Redundant [NotifyDataErrorInfo] on field with inherited class-level attribute

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

This example triggers MVVMTK0030 because the field 'number' has [NotifyDataErrorInfo] while the containing class 'MyViewModel' inherits the attribute from its base class 'MyBaseViewModel'. The comment explains that the field-level attribute is redundant.

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

namespace MyApp;

[NotifyDataErrorInfo]
public class MyBaseViewModel : ObservableValidator
{
}

public partial class MyViewModel : MyBaseViewModel
{
    // Using [NotifyPropertyChangedRecipients] is redundant here, as the
    // containing type is inheriting the same attribute from a base type.
    [ObservableProperty]
    [Required]
    [NotifyDataErrorInfo]
    public int number;
}

```

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

### Send<TMessage> with and without parameterless constructor

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

Shows how to send a message using the MVVM Toolkit's Send<TMessage> extension method. For messages with a parameterless constructor, a simplified Send<MyMessage>() overload is available.

```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>();

```

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

### Swap using directives for Messenger

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

Replace the MvvmLight using directive with the MVVM Toolkit's using directive.

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

// MVVM Toolkit
using CommunityToolkit.Mvvm.Messaging;

```

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

### MVVMTK0011: CanExecute property with invalid type

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

This example triggers MVVMTK0011 because the CanExecute property 'Foo' returns a string instead of a bool. The [RelayCommand] attribute references 'Foo' as the CanExecute member, but a compatible member must return a bool.

```csharp
using CommunityToolkit.Mvvm.Input;

namespace MyApp;

public partial class SampleViewModel
{
    // The property returns a string, not a bool
    private string Foo => ""Hi!"";

    [RelayCommand(CanExecute = nameof(Foo))]
    private void GreetUser()
    {
    }
}

```

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

### C# sample generating MVVMTK0036

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

Use this C# example to reproduce the MVVMTK0036 error. The error occurs when a field: or property: attribute over a method annotated with [RelayCommand] is not resolved to a valid type, commonly because a using directive for the attribute is missing.

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

partial class MyViewModel
{
    [ObservableProperty]
    private string? name;

    [RelayCommand]
    private void GreetUser()
    {
        Console.WriteLine($
```

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

### Post widget UI with header and content

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

Displays the selected post's title, thumbnail, and self text using OneWay bindings to the Post properties. The content is placed inside a ScrollViewer for scrolling.

```xml
<Grid>

    <!--Header-->
    <Grid>
        <TextBlock Text="{x:Bind ViewModel.Post.Title, Mode=OneWay}"/>
        <controls:ImageEx  Source="{x:Bind ViewModel.Post.Thumbnail, Mode=OneWay}"/>
    </Grid>

    <!--Content-->
    <ScrollViewer>
        <TextBlock Text="{x:Bind ViewModel.Post.SelfText, Mode=OneWay}"/>
    </ScrollViewer>
</Grid>

```
Tokens:
Raw