👁 Image
I-Synergy.Framework.UI.WPF 2026.10618.11733

I-Synergy Framework UI WPF

Windows Presentation Foundation (WPF) UI framework for building modern desktop applications on Windows. This package provides a complete WPF implementation of the I-Synergy Framework UI services, controls, and patterns with support for Windows 7, 8, and 10+.

👁 NuGet
👁 License
👁 .NET
👁 Platform

Features

• Full WPF desktop support for Windows 7+, 8+, and 10+
• Dialog service with MessageBox and custom dialog support
• Navigation service with frame-based navigation
• Theme service with dynamic accent colors and styles
• File service with Windows file dialogs
• Clipboard service for Windows clipboard operations
• Update service for application updates
• Custom controls (BladeView, Console, ImageBrowser, Menu, Tiles, ErrorPresenter)
• Behaviors using Microsoft.Xaml.Behaviors.Wpf
• 40+ dynamic theme palettes with XAML resource dictionaries
• Splash screen support with customizable UI

Installation

Install the package via NuGet:

dotnet add package I-Synergy.Framework.UI.WPF

Quick Start

1. Configure Application

Setup your WPF application with I-Synergy Framework:

using ISynergy.Framework.UI;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

public partial class App : Application
{
 private IHost _host;

 protected override async void OnStartup(StartupEventArgs e)
 {
 base.OnStartup(e);

 _host = Host.CreateDefaultBuilder()
 .ConfigureServices((context, services) =>
 {
 // Core services
 services.AddSingleton<ILanguageService, LanguageService>();
 services.AddSingleton<IMessengerService, MessengerService>();
 services.AddSingleton<IBusyService, BusyService>();

 // WPF services
 services.AddSingleton<IDialogService, DialogService>();
 services.AddSingleton<INavigationService, NavigationService>();
 services.AddSingleton<IThemeService, ThemeService>();
 services.AddSingleton<IFileService<FileResult>, FileService>();
 services.AddSingleton<IClipboardService, ClipboardService>();
 services.AddSingleton<IUpdateService, UpdateService>();

 // ViewModels
 services.AddTransient<MainViewModel>();
 services.AddTransient<ShellViewModel>();
 })
 .Build();

 await _host.StartAsync();

 // Apply theme
 var themeService = _host.Services.GetRequiredService<IThemeService>();
 themeService.ApplyTheme();

 // Show main window
 var mainWindow = _host.Services.GetRequiredService<MainWindow>();
 mainWindow.Show();
 }

 protected override async void OnExit(ExitEventArgs e)
 {
 await _host.StopAsync();
 _host.Dispose();
 base.OnExit(e);
 }
}

2. Create XAML Windows with ViewModels

<Window x:Class="MyApp.MainWindow"
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
 xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
 xmlns:vm="clr-namespace:MyApp.ViewModels"
 d:DataContext="{d:DesignInstance Type=vm:MainViewModel}"
 Title="{Binding Title}"
 Height="600" Width="800">

 <Grid>
 <Grid.RowDefinitions>
 <RowDefinition Height="Auto"/>
 <RowDefinition Height="*"/>
 <RowDefinition Height="Auto"/>
 </Grid.RowDefinitions>

 
 <Menu Grid.Row="0">
 <MenuItem Header="File">
 <MenuItem Header="New" Command="{Binding NewCommand}"/>
 <MenuItem Header="Open" Command="{Binding OpenCommand}"/>
 <MenuItem Header="Save" Command="{Binding SaveCommand}"/>
 <Separator/>
 <MenuItem Header="Exit" Command="{Binding ExitCommand}"/>
 </MenuItem>
 <MenuItem Header="Edit">
 <MenuItem Header="Settings" Command="{Binding SettingsCommand}"/>
 </MenuItem>
 </Menu>

 
 <Frame Grid.Row="1"
 x:Name="MainFrame"
 NavigationUIVisibility="Hidden"/>

 
 <StatusBar Grid.Row="2">
 <StatusBarItem>
 <TextBlock Text="{Binding StatusMessage}"/>
 </StatusBarItem>
 <StatusBarItem HorizontalAlignment="Right">
 <ProgressBar Width="100"
 Height="16"
 IsIndeterminate="{Binding BusyService.IsBusy}"/>
 </StatusBarItem>
 </StatusBar>
 </Grid>
</Window>

using ISynergy.Framework.Mvvm.ViewModels;

public partial class MainWindow : Window
{
 public MainWindow(MainViewModel viewModel)
 {
 InitializeComponent();
 DataContext = viewModel;
 }
}

3. Use Dialog Service

using ISynergy.Framework.Mvvm.ViewModels;
using ISynergy.Framework.Mvvm.Commands;

public class ProductViewModel : ViewModel
{
 private readonly IProductService _productService;

 public AsyncRelayCommand SaveCommand { get; }
 public AsyncRelayCommand DeleteCommand { get; }

 public ProductViewModel(
 ICommonServices commonServices,
 IProductService productService,
 ILogger<ProductViewModel> logger)
 : base(commonServices, logger)
 {
 _productService = productService;

 SaveCommand = new AsyncRelayCommand(SaveAsync, CanSave);
 DeleteCommand = new AsyncRelayCommand(DeleteAsync);
 }

 private bool CanSave() => !string.IsNullOrEmpty(Name) && IsValid;

 private async Task SaveAsync()
 {
 try
 {
 CommonServices.BusyService.StartBusy("Saving product...");

 await _productService.SaveAsync(Product);

 await CommonServices.DialogService.ShowInformationAsync(
 "Product saved successfully",
 "Success");
 }
 catch (Exception ex)
 {
 await CommonServices.DialogService.ShowErrorAsync(ex, "Error");
 }
 finally
 {
 CommonServices.BusyService.StopBusy();
 }
 }

 private async Task DeleteAsync()
 {
 var result = await CommonServices.DialogService.ShowMessageAsync(
 "Are you sure you want to delete this product?",
 "Confirm Delete",
 MessageBoxButtons.YesNo);

 if (result == MessageBoxResult.Yes)
 {
 try
 {
 await _productService.DeleteAsync(Product.Id);
 await CommonServices.NavigationService.GoBackAsync();
 }
 catch (Exception ex)
 {
 await CommonServices.DialogService.ShowErrorAsync(ex, "Error");
 }
 }
 }

 // Show custom dialog
 private async Task EditSettingsAsync()
 {
 await CommonServices.DialogService
 .ShowDialogAsync<SettingsWindow, SettingsViewModel, Settings>();
 }
}

4. Navigation Service

public class ShellViewModel : ViewModel
{
 private readonly INavigationService _navigationService;

 public AsyncRelayCommand<Type> NavigateCommand { get; }

 public ShellViewModel(
 ICommonServices commonServices,
 INavigationService navigationService,
 ILogger<ShellViewModel> logger)
 : base(commonServices, logger)
 {
 _navigationService = navigationService;
 NavigateCommand = new AsyncRelayCommand<Type>(NavigateAsync);
 }

 private async Task NavigateAsync(Type viewModelType)
 {
 await _navigationService.NavigateAsync(viewModelType);
 }

 // Navigate with parameters
 private async Task NavigateToProductDetailAsync(Product product)
 {
 await _navigationService.NavigateAsync<ProductDetailViewModel>(product);
 }

 // Navigate back
 private async Task GoBackAsync()
 {
 if (_navigationService.CanGoBack)
 {
 await _navigationService.GoBackAsync();
 }
 }
}

5. File Operations

using ISynergy.Framework.Mvvm.Abstractions.Services;
using ISynergy.Framework.Core.Models.Results;

public class DocumentViewModel : ViewModel
{
 private readonly IFileService<FileResult> _fileService;

 public AsyncRelayCommand OpenFileCommand { get; }
 public AsyncRelayCommand SaveFileCommand { get; }

 public DocumentViewModel(
 ICommonServices commonServices,
 IFileService<FileResult> fileService,
 ILogger<DocumentViewModel> logger)
 : base(commonServices, logger)
 {
 _fileService = fileService;

 OpenFileCommand = new AsyncRelayCommand(OpenFileAsync);
 SaveFileCommand = new AsyncRelayCommand(SaveFileAsync);
 }

 private async Task OpenFileAsync()
 {
 var file = await _fileService.BrowseFileAsync(
 new[] { ".pdf", ".docx", ".txt" });

 if (file is not null)
 {
 // Read file content
 using var stream = await file.OpenReadAsync();
 // Process file...
 }
 }

 private async Task SaveFileAsync()
 {
 var file = await _fileService.SaveFileAsync(
 "document.pdf",
 "Documents",
 new[] { ".pdf" });

 if (file is not null)
 {
 // Write file content
 using var stream = await file.OpenWriteAsync();
 // Save content...
 }
 }
}

6. Update Service

using ISynergy.Framework.Mvvm.Abstractions.Services;

public class UpdateViewModel : ViewModel
{
 private readonly IUpdateService _updateService;

 public AsyncRelayCommand CheckForUpdatesCommand { get; }
 public AsyncRelayCommand InstallUpdateCommand { get; }

 public bool UpdateAvailable
 {
 get => GetValue<bool>();
 set => SetValue(value);
 }

 public string UpdateVersion
 {
 get => GetValue<string>();
 set => SetValue(value);
 }

 public UpdateViewModel(
 ICommonServices commonServices,
 IUpdateService updateService,
 ILogger<UpdateViewModel> logger)
 : base(commonServices, logger)
 {
 _updateService = updateService;

 CheckForUpdatesCommand = new AsyncRelayCommand(CheckForUpdatesAsync);
 InstallUpdateCommand = new AsyncRelayCommand(InstallUpdateAsync);
 }

 private async Task CheckForUpdatesAsync()
 {
 try
 {
 var update = await _updateService.CheckForUpdateAsync();

 if (update.IsAvailable)
 {
 UpdateAvailable = true;
 UpdateVersion = update.Version;

 var result = await CommonServices.DialogService.ShowMessageAsync(
 $"A new version ({update.Version}) is available. Would you like to install it?",
 "Update Available",
 MessageBoxButtons.YesNo);

 if (result == MessageBoxResult.Yes)
 {
 await InstallUpdateAsync();
 }
 }
 else
 {
 await CommonServices.DialogService.ShowInformationAsync(
 "You are running the latest version.",
 "No Updates");
 }
 }
 catch (Exception ex)
 {
 await CommonServices.DialogService.ShowErrorAsync(ex, "Error");
 }
 }

 private async Task InstallUpdateAsync()
 {
 try
 {
 CommonServices.BusyService.StartBusy("Downloading update...");

 await _updateService.DownloadAndInstallUpdateAsync(
 progress => CommonServices.BusyService.UpdateMessage($"Downloading... {progress}%"));

 await CommonServices.DialogService.ShowInformationAsync(
 "Update installed successfully. The application will now restart.",
 "Update Complete");

 _updateService.RestartApplication();
 }
 catch (Exception ex)
 {
 await CommonServices.DialogService.ShowErrorAsync(ex, "Error");
 }
 finally
 {
 CommonServices.BusyService.StopBusy();
 }
 }
}

Custom Controls

BladeView

<controls:BladeView ItemsSource="{Binding Blades}"
 SelectedItem="{Binding SelectedBlade}" />

ImageBrowser

<controls:ImageBrowser Images="{Binding ProductImages}"
 SelectedImage="{Binding SelectedImage}"
 AllowAdd="True"
 AllowRemove="True" />

Console

<controls:Console Messages="{Binding ConsoleMessages}"
 AutoScroll="True" />

ErrorPresenter

<controls:ErrorPresenter Errors="{Binding ValidationErrors}"
 Visibility="{Binding HasErrors, Converter={StaticResource BoolToVisibilityConverter}}" />

Tiles

<controls:Tile Title="Dashboard"
 Command="{Binding NavigateToDashboardCommand}"
 Icon="{StaticResource DashboardIcon}" />

Theme Support

The WPF framework includes 40+ built-in theme palettes:

using ISynergy.Framework.Mvvm.Abstractions.Services;

// Theme is automatically applied on startup
// To change theme programmatically:
public void ChangeTheme(string colorHex, Themes theme)
{
 // Update settings
 _settingsService.LocalSettings.Color = colorHex;
 _settingsService.LocalSettings.Theme = theme;

 // Apply theme
 _themeService.ApplyTheme();

 // Restart application to fully apply theme
 System.Windows.Forms.Application.Restart();
 System.Windows.Application.Current.Shutdown();
}

// Show theme selection to users
private async Task ShowThemeSelectionAsync()
{
 await CommonServices.DialogService
 .ShowDialogAsync<ThemeWindow, ThemeViewModel, ThemeStyle>();
}

Behaviors

Using Microsoft.Xaml.Behaviors.Wpf:

<Window xmlns:i="http://schemas.microsoft.com/xaml/behaviors">
 <i:Interaction.Behaviors>
 <behaviors:WindowDragBehavior />
 </i:Interaction.Behaviors>

 <TextBox>
 <i:Interaction.Behaviors>
 <behaviors:SelectAllOnFocusBehavior />
 </i:Interaction.Behaviors>
 </TextBox>
</Window>

Best Practices

Application Structure

• Use MVVM pattern with dependency injection
• Configure services in Host builder
• Apply theme on startup
• Use NavigationService for page navigation
• Handle application updates gracefully

Performance

• Use virtualization for large lists
• Implement lazy loading for complex views
• Dispose resources properly
• Use compiled bindings where possible
• Leverage hardware acceleration

Dependencies

• I-Synergy.Framework.UI - Base UI abstractions
• Microsoft.Xaml.Behaviors.Wpf - WPF behaviors
• Microsoft.Extensions.Configuration.Json - Configuration
• Microsoft.Extensions.Hosting - Application hosting
• OpenTelemetry.Instrumentation.Http - HTTP telemetry
• OpenTelemetry.Instrumentation.Runtime - Runtime telemetry

Platform Requirements

• Windows 7.0: .NET 10.0-windows7.0
• Windows 8.0: .NET 10.0-windows8.0
• Windows 10+: .NET 10.0-windows10.0.26100.0

Documentation

• Framework Documentation
• WPF Documentation
• Sample Applications

Related Packages

• I-Synergy.Framework.UI - Base UI abstractions
• I-Synergy.Framework.Core - Core framework
• I-Synergy.Framework.Mvvm - MVVM framework
• I-Synergy.Framework.UI.WinUI - WinUI implementation
• I-Synergy.Framework.UI.Maui - MAUI implementation

Support

For issues, questions, or contributions, please visit the GitHub repository.