在Blazor与.NET MAUI共用单模型中使用INotify接口的实践疑问与最佳实践探讨

Great question—this is a really common pain point when building cross-platform .NET apps, so let’s unpack each of your concerns clearly.

1. Is sharing a single model between Blazor and .NET MAUI a good practice? #

Absolutely, this aligns with the DRY (Don’t Repeat Yourself) principle, a core tenet of maintainable software development. By reusing a single model layer, you eliminate duplicate code, reduce the risk of inconsistencies (like conflicting validation rules or property definitions across platforms), and simplify long-term maintenance.

That said, you need to balance this with platform-specific UI needs. Your core model should focus on business logic and data structure, while any platform-specific behavior (like UI-specific validation hints or state) should live in platform-specific wrappers or extensions—not the shared model itself.

2. Will implementing INotifyPropertyChanged for Blazor models cause side effects or performance issues? #

Short answer: No, not in any meaningful way.

Blazor doesn’t require INotifyPropertyChanged (INPC) because its component update model relies on parameter changes and explicit calls to StateHasChanged(). However, implementing INPC in your shared model is completely safe and even has subtle benefits:

• If you use Blazor’s EditForm with data annotations, INPC can enable more responsive real-time validation feedback.
• The overhead of INPC is minimal—property change events are lightweight, and they only fire when a property actually changes. Blazor won’t automatically react to these events unless you explicitly subscribe to them in your components (which is optional), so there’s no unexpected performance hit.
• You won’t break any existing Blazor functionality by adding INPC; it’s fully compatible with Blazor’s rendering pipeline.

3. What are the best practices for sharing a single model between Blazor and .NET MAUI? #

Here are actionable steps to make this work smoothly:

• Use a base class for INPC: Create a reusable ObservableObject base class (or leverage the one from the .NET Community Toolkit) that implements INotifyPropertyChanged with boilerplate code. Have all your shared models inherit from this—this avoids repeating INPC logic across every model.
  Example base class snippet:

  public abstract class ObservableObject : INotifyPropertyChanged
  {
      public event PropertyChangedEventHandler? PropertyChanged;
  
      protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
      {
          PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
      }
  
      protected bool SetField<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
      {
          if (EqualityComparer<T>.Default.Equals(field, value)) return false;
          field = value;
          OnPropertyChanged(propertyName);
          return true;
      }
  }
  

• Keep the model platform-agnostic: Place your shared models in a separate .NET class library (targeting .NET 6+ or .NET Standard) with no references to MAUI or Blazor-specific assemblies. This ensures your model layer isn’t coupled to any UI framework.
• Use conditional compilation for platform-specific logic: If you need to add properties or methods that only apply to one platform, use preprocessor directives like #if MAUI or #if BLAZOR to include them without cluttering the shared codebase.
• Adapt binding behavior per platform:
  • In MAUI, use the INPC implementation as usual to trigger UI updates when properties change.
  • In Blazor, stick to standard parameter binding or component state management by default. If you want to react to model property changes automatically, you can subscribe to the PropertyChanged event in your component and call StateHasChanged(), but this is optional—only do it if your use case requires real-time updates outside of Blazor’s normal parameter flow.

内容的提问来源于stack exchange，提问作者Prem