WinForms Team Blog

WinForms — Generate Custom SVG Skin Palettes with AI (v25.2)

Dmitry Tokmachev (DevExpress) — Tue, 17 Mar 2026 02:14:00 Z

In our v25.2 release, we introduced a preview of our AI-powered custom SVG skin palette feature. This feature transforms how you design application color schemes. It leverages generative AI to interpret natural language instructions and create cohesive palettes that apply seamlessly across your entire WinForms application.

Note: We've shared our Generate Custom SVG Skin Palettes with AI implementation with the community to gather feedback and evaluate demand for similar features in DevExpress WPF, Blazor, and JS/DevExtreme product lines.

How AI-Powered Palette Generation Works

You describe the desired palette aesthetic/style in the conversational UI with plain language. Sample prompts include: "warm autumn palette", "high-contrast accessibility theme", or your favorite sports team name. You then refine results in the chat. The system preserves conversation context for the LLM (the conversation history). AI produces a custom palette and applies it programmatically.

The generated palette includes primary background/foreground colors and accent colors for interactive elements. The palette automatically applies to all DevExpress WinForms UI controls with SVG skin support, which maintains visual consistency throughout the application.

For technical details and extension options, see the Implementation Highlights section.

Real-World Use Cases

This feature addresses common application design scenarios where custom color schemes improve user experience (UX) and business value:

Enterprise Branding - You generate palettes that align with corporate brand guidelines. You describe brand colors and style in plain language. AI creates a palette with consistent color relationships across all UI controls.

High-Contrast and Accessibility Palettes - You design palettes for users with visual impairments. DevExpress WinForms UI Library already includes built-in high-contrast skins and system high-contrast mode support. You specify accessibility requirements (such as tritanopia support). AI generates palettes that meet contrast ratio standards and preserve visual clarity.

Multi-Tenant Applications - You generate a unique visual identity for each customer. You can generate and save palettes per tenant programmatically or allow users to customize their workspace (UI) appearance. This feature also accelerates prototyping. You can generate multiple palette options in minutes and present them to stakeholders.

Seasonal or Event-based Palettes - You refresh application visuals for holidays or campaigns. For example, you can generate palettes for promotions or special events.

Try the Feature with a GitHub Demo

We implemented a complete solution that demonstrates AI-powered SVG palette generation in a Windows Forms application.

Key Features

Live palette preview across DevExpress UI controls
Instant visual updates during palette generation
Compare and switch between AI-generated palettes
Persistent palette storage in JSON format within application settings
Restore palettes between sessions
Palette management with delete support
Configurable AI model selection (gpt-5-mini, gpt-4o-mini, gpt-4.1)
Support for custom AI services and a rate-limited demo endpoint
Customizable AI instructions for tailored generation behavior

Open GitHub Repo

Prerequisites

.NET 8+ SDK
DevExpress WinForms v25.2+
Microsoft.Extensions.AI (v9.7.1)
Azure.AI.OpenAI (v2.2.0-beta.5)
An active AI service subscription (Azure OpenAI, OpenAI, or Ollama)

Note: The demo targets specific Microsoft.Extensions.AI library versions. Use exact versions to avoid compatibility issues.

Getting Started

Clone the GitHub repo.
Open the solution in Visual Studio or JetBrains Rider.
Configure AI service credentials in ChatClientFactory.cs (or use the rate-limited demo endpoint).
Build and run the DevExpress.AI.WinForms.AIGeneratePalette.Demo project.
Click AI Generate Palette in the Ribbon UI to open the Color Palette Editor.

Use the following prompts to explore the feature:

- Generate a warm autumn palette with rust and gold tones
- Create a high-contrast accessibility-friendly palette for vision impaired users
- Design a modern flat pastel palette inspired by Material Design
- Build a dark mode theme with purple accents
- Make a vibrant tropical palette with coral and turquoise

The workflow completes in seconds. You describe your vision, review the result across controls, refine output with follow-up prompts (if needed), and save the palette. The generated palette is automatically applied to your WinForms application.

Ready-to-Use Project

The DevExpress.AI.WinForms.AIGeneratePalette project is production-ready. You can add it to your solution as-is.

The project includes:

A palette generation dialog UI
AI-powered palette generation logic
Palette management and persistence support.

You can customize AI instructions, modify dialog layout, or extend the feature set based on your application requirements.

Under the Hood: Implementation Highlights

The example demonstrates key implementation patterns for AI integration in WinForms applications.

AI Integration and Model Flexibility

The demo application interacts with Azure OpenAI services. It integrates with Microsoft.Extensions.AI library, registers an IChatClient with the AIExtensionsContainerDesktop container, and exposes AI capabilities across the application:

IChatClient chatClient = new Azure.AI.OpenAI.AzureOpenAIClient(
    new Uri(AzureOpenAIEndpoint),
    new System.ClientModel.ApiKeyCredential(AzureOpenAIKey))
    .GetChatClient(ModelId).AsIChatClient();
    
AIExtensionsContainerDesktop.Default.RegisterChatClient(chatClient);

This implementation supports any AI provider that implements IChatClient. You can switch models without code changes. The example supports gpt-5-mini, gpt-4o-mini, and gpt-4.1.

Different LLMs may produce different palette results. We tested AI-powered Color Palette Generation primarily with OpenAI GPT models. You can also connect AI services such as Google Gemini, Anthropic Claude, or xAI Grok. We encourage you to try different models and share your feedback on the ones that work best for your specific needs.

Structured Prompt Engineering

The GeneratePaletteInstruction.md file defines precise AI instructions for palette output. These instructions enforce palette structure and color value rules. Carefully crafted instructions ensure consistent and predictable results across different prompts.

SVG Palette Manipulation

The example creates and modifies SVG palettes. You define palette colors and register the palette in the active skin. The palette becomes available to all SVG-enabled controls at runtime.

var svgPalette = new SvgPalette();
svgPalette.Colors.Add(new SvgColor("Paint", Color.FromArgb(242, 242, 242)));
svgPalette.Colors.Add(new SvgColor("Accent Paint", Color.FromArgb(23, 107, 209)));
// ... additional colors

var commonSkin = CommonSkins.GetSkin(UserLookAndFeel.Default);
commonSkin.CustomSvgPalettes.Add(
    new SvgPaletteKey(commonSkin.CustomSvgPalettes.Count, paletteName), 
    svgPalette);

Conversation State Management

Our implementation maintains the conversation history. Users can refine palettes through follow-up requests. This creates a flexible, interactive workflow in which each adjustment builds on previous decisions and maintains the integrity of the design process.

Palette Persistence and Storage

The example saves and restores custom palettes across application sessions. The AIPaletteRepository class serializes palettes to JSON and stores them in application settings. You can extend this option to any storage solution. For example, store palettes in a database for multi-user scenarios, in configuration files for deployment flexibility, or in cloud storage for cross-device access. The example provides a strong foundation for customization based on your preferences.

This AI-powered palette generation feature is experimental, and we need your feedback to determine our next steps. Based on the response from our community, we will consider similar implementations for WPF (AI-generated resource dictionaries and theme palettes), Blazor (dynamic CSS variable values assignment), and DevExtreme.

We want to understand how this feature fits into development and end-user workflows. Please share your experience with us:

Your feedback will directly shape our future AI-powered roadmap. If you have technical questions or need assistance with the example, submit a support ticket via the DevExpress Support Center.

Additional Resources

WinForms — June 2026 Roadmap (v26.1)

Alexander Russkov (DevExpress) — Tue, 24 Feb 2026 04:00:00 Z

First and foremost – thank you for placing your trust in our component suite. We appreciate the opportunity to serve your development needs now and into the future. This blog post outlines some of our WinForms-related development plans for the second half of 2026 (v26.2). As always, you can expect other additions across our entire range of WinForms controls and components once we officially ship v26.1.

We welcome your feedback - Please feel free to share your thoughts in the survey at the end of this post or submit a support ticket via the DevExpress Support Center.

The information contained within this blog post details our current/projected development plans. Please note that this information is being shared for INFORMATIONAL PURPOSES ONLY and does not represent a binding commitment on the part of Developer Express Inc. This roadmap and the features/products listed within it are subject to change. You should not rely on or use this information to help make a purchase decision about Developer Express Inc products.

Security

Secure code starts with a safe development environment. In addition to static code analysis and on-going security reviews, we are expanding our internal security diagnostics (including custom analyzers) across our engineering workflows to further strengthen our security posture.

While these enhancements are not exposed as standalone features within the DevExpress component suite, they directly contribute to the reliability of our product libraries - a critical priority in today’s threat landscape.

Fluent Icons

Postponed to v26.2

We expect to introduce a comprehensive set of Fluent icons to our suite. To simplify migration to these new icons, you will be able to switch the icon set across all DevExpress controls via a single global setting. Our new collection will include thousands of Fluent icons which can be used in any UI element with SVG support.

Localization Tool Enhancements

In v25.2, we released a new Localization Tool as a Community Technology Preview (CTP). With v26.1, we plan to ship it officially. Our Localization Tool will offer enhanced collaboration capabilities, easier resource navigation and management, AI-powered translation services, support for multiple DevExpress products and platforms, and more.

We also expect to add the following enhancements:

Filter localization strings based on referenced DevExpress assemblies.
Automatically load base localization resources - you will no longer need to download them from a GitHub repository manually.

DateTimeOffset Core Support

We are initiating support for DateTimeOffset across our product line. We will start with core DevExpress classes, including criteria operators and data processing modules.

Our goal is to eliminate manual conversion of DateTimeOffset to DateTime when working with local time zones. You will be able to specify the required time zone, and conversion to a local date will occur automatically. In this mode, users will see a simple date/time value without the offset portion (as if it were a DateTime object).

As a first step, DateTimeOffset support will allow you to use date/time-related functions (such as AddHours, GetDays, DateDiffDays, and others) in filter expressions and unbound columns.

We are not planning DateTimeOffset-related updates for UI components as a part of v26.1. Specifically, we do not expect to add date-specific filtering options to column filter popups or enable DateTimeOffset editing in Date Edit.

DateTimeOffset offers the following advantages compared to DateTime:

Local and global time support: Suitable for usage scenarios that require both local machine time and UTC (such as logging systems).
Clear semantics: The DateTime.Kind property is not serialized (which can lead to incorrect usage). DateTimeOffset always includes the offset (for example, 6/10/2025 5:30:00 PM -07:00).
Web service compatibility: Many services return dates as DateTimeOffset. Once supported, conversion to DateTime will no longer be required.

Microsoft documentation recommends DateTimeOffset instead of DateTime when representing a single point in time, performing date/time arithmetic, and preserving related times:

These uses for DateTimeOffset values are much more common than those for DateTime values. As a result, consider DateTimeOffset as the default date and time type for application development.

AI Agents API

We are building an abstraction layer over multiple AI engine implementations. You'll be able to use both IChatClient and Microsoft Agent Framework with DevExpress AI Chat Control.

Microsoft Agent Framework allows you to define agents with custom rules, instructions, and tools. Agents can then execute multi-step tasks based on user requests.

AI Chat Enhancements

We plan to introduce a set of small but useful APIs to help customize the DevExpress AI Chat Control. For example, new properties will allow you to specify the text displayed in an empty chat view and in an empty text input field.

MemoEdit — Automatic Scrollbar

The DevExpress MemoEdit control will automatically hide the scrollbar when text height does not exceed control bounds. You will be able to control this behavior via an option.

Monaco-Based Code Editor (Example)

As you may know, Monaco Code Editor is an open-source editor used in Visual Studio Code. It includes IntelliSense, supports multiple built-in languages, allows you to define custom syntax, and more.

We will create a comprehensive example of Monaco Editor integrated into a WinForms application with DevExpress Skins. The example will mirror the most important web APIs at the C# level, so you won't need to use JavaScript for common usage scenarios.

Spreadsheet — New Excel Functions

We will enhance our Spreadsheet calculation engine by adding support for modern, dynamic array-based Excel functions, including functions like:

XLOOKUP
XMATCH
SORT
FILTER
UNIQUE

Reporting

Accessibility & Export Compliance

DOCX/HTML Export — AccessibleDescription Support

Organizations subject to WCAG 2.2 and Section 508 requirements will be able to include meaningful alternative text for all embedded images and graphical elements in exported Word documents and HTML pages. With v26.1, DevExpress Reports will apply a report control's AccessibleDescription property value to DOCX and HTML export output. This capability is especially relevant for controls exported as images, such as XRPictureBox, XRBarCode, XRShape, and XRChart, where assistive technologies rely on alternative text to describe visual content.

PDF/UA Export Enhancements

Government agencies and enterprises that must comply with PDF/UA standards will benefit from extended PDF export capabilities in v26.1:

XRRichText content will use proper semantic tagging and group continuous text into logical paragraphs instead of word-by-word <P> tags.
The AccessibleDescription property will apply to PDF signatures and AcroForm controls so that digitally signed or form-enabled PDF documents meet accessibility requirements.
XRPageInfo controls will support paragraph-level semantic markup.

Data Source Enhancements

DateTimeOffset Support

Applications that store time zone-aware timestamps (such as financial transaction logs, audit trails, and event scheduling systems) require DateTimeOffset support to preserve the original offset for accurate data representation. With v26.1, our Report Designer's Field List will display DateTimeOffset fields and allow data binding, filter, group, and sort operations across SqlDataSource, EFDataSource, and ObjectDataSource.

End-User Experience

WinForms End-User Report Designer — Startup Optimization

We will optimize the DevExpress WinForms End-User Report Designer's startup sequence to deliver a smoother and more responsive launch experience. Dock panels and UI elements will appear quickly on initial load, and transitions between the Design and Preview tabs will be rendered seamlessly.

XRLabel & XRPanel — Custom Border Styles Example

Invoice layouts, financial statements, and reports with visually distinct section separators often require independent border configuration per side. We will extend the How to Create a Custom DevExpress Report Control GitHub repository with a new example that demonstrates custom XRLabel and XRPanel controls. These custom controls will allow you to define distinct border styles and width for top, bottom, left, and right sides independently.

IDE Integration

DevExpress Report Designer for JetBrains Rider — .NET Projects Support

In v25.2, we introduced the DevExpress Report Designer for JetBrains Rider with .NET Framework support. In v26.1, we will extend this integration to .NET-based projects. We also expect to deliver property search and reset in the Properties panel and light/dark theme support to match the JetBrains Rider IDE.

AI-powered Enhancements

AI Prompt-to-Report Wizard — Optimization

We will optimize the AI Prompt-to-Report Wizard to allow users to input shorter prompts and achieve more consistent, production-ready report output. The updated implementation will use a multi-agent workflow and will also reduce token consumption per report generation request.

Report Designer — AI-powered Chat Assistant

Our DevExpress WinForms End-User Report Designer includes an AI Assistant panel that allows users to add, remove, and modify report elements, properties, and data bindings using natural language commands. In v26.1, we will extend this capability to our Web and WPF Report Designer components and add the following features:

Built-in tools that enable AI to search relevant end-user documentation
Wizards that can be launched via AI commands
Enhanced interaction with the designer environment

Stay tuned for updates as development continues.

AGENTS.md for AI Coding Assistants

Developers who use AI-powered code completion tools will obtain more accurate and context-aware suggestions when they work with DevExpress Reports. We will create an AGENTS.md file that equips AI coding assistants, such as GitHub Copilot and Cursor, with DevExpress Reports expertise. The file will contain API patterns, expression syntax rules, common report creation scenarios, troubleshooting guides, and best practices.

Your Feedback Matters

WinForms — Year-End Roadmap (v25.2)

Alexander Russkov (DevExpress) — Tue, 12 Aug 2025 06:50:00 Z

This post details WinForms-related features/capabilities we expect to introduce in our year-end update (v25.2). If you have questions or suggestions, feel free to submit your thoughts in the survey at the end of this post or submit a ticket via the DevExpress Support Center - your feedback is always welcome.

.NET 10 Support

All our WinForms controls will support .NET 10 as soon as it becomes available this November. We're already testing preview versions to ensure seamless migration. If you're wondering what enhancements .NET 10 brings to the platform itself, be sure to check the following Microsoft help topic: What's new in Windows Forms for .NET 10 Preview.

DevExpress MCP Server for AI-Powered Documentation Access

Available in Preview

We will introduce an MCP server that connects GitHub Copilot Chat, Cursor, and other MCP-compatible AI tools directly to our comprehensive documentation database. The server will provide instant access to over 300,000 help topics through natural language queries within your IDE. This will allow you and AI coding agents such as Claude Code to access current DevExpress documentation directly within the AI assistant's context.

AI Chat Control

Tool Calling API

Our new API will allow you to create tools that execute any custom commands (apply filters to Grids, modify Chart UIs, query databases, or perform business actions). With these tools, end users will be able to interact with your DevExpress-powered application directly from AI Chat using natural language.

Visual Tool Execution Indicators

Our Chat Control will provide clear visual indicators when executing AI tools, whether declared locally within your application or connected via MCP (Model Context Protocol) servers. These indicators will enhance transparency and help users understand which actions are being performed in real-time.

Resources

v25.2 will introduce a resources feature designed to attach additional context to chat messages within our Blazor AI Chat control. Unlike simple file attachments, resources can include various context types supplied by your application (binary files including audio, images and PDFs, database schemas, records, logs, and more). Users can view available resources directly in the chat input field and attach them to enhance AI interactions.

RAG Project Template

We will create a new project template based on our AI Chat Control and powered by Retrieval-Augmented Generation (RAG). This template will help you to extract information from documents and allow an AI assistant to answer questions based on your data. It will leverage our AI Chat Control to deliver a conversational UI, and Office File API to pull data from PDF and Word documents.

AI-Powered Expression Generation

We’re adding AI-powered expression generation to our WinForms controls to help users create complex expressions using natural language prompts. Generated expressions will be automatically validated before being applied to the target control. This capability will be available for:

Filter expressions
Unbound expressions
Conditional Formatting rules

Rider Support

Designer

We’re in close collaboration with the JetBrains team to enhance design-time support for DevExpress WinForms components in the Rider IDE. You’ll soon be able to use the design-time capabilities of all major DevExpress WinForms controls. Many of these improvements will roll out in Rider EAP releases (available every couple of weeks). We’ll share updates once core functionality is in place - stay tuned.

DevExpress Template Kit

DevExpress Template Kit includes dozens of project templates and building blocks available in Visual Studio and VS Code. With v25.2, you'll be able to use these templates within JetBrains Rider.

Charts — DateOnly & TimeOnly Support

In v25.2, our DevExpress Charts will introduce full DateOnly and TimeOnly support. With this enhancements, you'll be able to:

Bind chart data directly to DateOnly/TimeOnly values
Format axes with date/time options
Aggregate data by date or time intervals

Data Grid — Column Header Navigation

With our next release, users will be able to focus column headers in the DevExpress WinForms Data Grid and execute the following actions:

Apply sort operations (Space/Enter)
Sort against multiple columns (Shift + Space)
Clear sorting (Ctrl + Space)
Display the Column Filter Popup (Alt + Down)
Reorder columns (Ctrl + Left/Right)
Display the Column Context Menu (Shift+F10)
Resize a column (Shift + Left/Right)

Data Grid — Multi-Cell Editing

As you know, Microsoft Excel allows you to select multiple cells and apply text changes by pressing Ctrl + Enter (instead of Enter). We will add a similar feature to our WinForms Data Grid, allowing users to apply identical values to multiple cells simultaneously.

Editors — Screen Reader Enhancements

Though our WinForms Editors already announce values when users focus editors or enter text, we expect to extend support for screen readers for the following usage scenarios:

Partial text selection
Character deletion
Previous/next character navigation

Ribbon Control — Right Pane

You’ll be able to position vertical panels on the right side of the DevExpress WinForms Ribbon Control. This space can host application-wide features, such as an AI Chat interface or Outlook-style notifications.

Rich Text Editor

Word to PDF/UA Conversion

With our year-end-release, DevExpress Word-processing tools will automatically add accessible tags for PDF form fields when users export Word documents with Content Controls to the PDF/UA format.

Enhanced Master-Detail Mail Merge

We will extend our Word Processing API with support for mail merge operations based on hierarchical (master-detail) data sources. This feature will allow developers to bind nested collections directly to Word templates using standard merge field syntax. With this enhancement, you will be able to:

Define repeatable detail sections using region-based merge fields.
Use a single template to generate multi-level reports, invoices, or personalized documents.
Perform complex document generation from hierarchical business objects (for example, Customer → Orders, Order → Items).
Integrate with custom data sources.

Spreadsheet Editor

Excel to PDF/UA Conversion

We’ll enhance our Excel to PDF/UA conversion engine to address accessibility issues related to graphical object tagging and artifact generation (for decorative content).

OLE Object Support Enhancements

Our next release will allow you to manage OLE Objects (load, modify, and save) in binary file formats:

XLS
XLSB

New Excel Functions

We will enhance our Spreadsheet calculation engine by adding support for modern, dynamic array-based Excel functions, including functions such as:

XLOOKUP
XMATCH
FILTER
UNIQUE
And more

Reports

Enhanced PDF Export — Accessibility Enhancements

We will extend DevExpress Reports APIs and give you granular control over PDF accessibility features. This enhancement allows developers to specify PDF layout artifacts — elements skipped by assistive technologies — and define alternative text for report watermarks.

Enhanced DOCX Export — Accessibility Enhancements

A Report control's AccessibleDescription property will be available when exporting reports to DOCX files.

Report Design Analyzer — Accessibility Checker

We will extend the Report Design Analyzer pane with a new "Accessibility" error source category to help report designers create accessible documents across multiple Microsoft Office/PDF export formats. This feature mirrors accessibility assistant functionality found in Microsoft Office products and provides proactive guidance during the design phase. As you would expect, this capability will dramatically improve accessibility compliance while reducing the learning curve for developers new to accessibility standards. This feature will also:

Enable report designers to identify and fix accessibility issues before export
Reduce accessibility violations in exported documents
Provide clear, actionable guidance for accessibility improvements
Support multiple export formats with format-specific checks

DevExpress Report Designer for JetBrains Rider

Responding to community demand and the growing popularity of JetBrains Rider, we will integrate the DevExpress Visual Studio Report Designer with JetBrains Rider. This IDE integration will allow developers to create, modify, and manage DevExpress Reports directly within their preferred IDE environment, eliminating the need to switch between development tools.

AI-Powered Enhancements

With v25.2, we plan to deliver AI-powered feature parity across DevExpress Report Designer components across supported platforms, including our Visual Studio Report Designer. No matter which platform or IDE you use, you’ll benefit from the same AI-powered tools that accelerate report design and reduce manual effort.

For a detailed overview of AI-powered capabilities in DevExpress Reports, refer to the following topic: AI-powered Functionality

End-User Report Designer — Settings Window

We plan to add a new dialog window to our WinForms End-User Report Designer that allows users to configure report design/document generation settings globally at the application level:

Default settings for new reports. Users can modify report settings to match preferences.
Centralized dock panel management. Users can control the state of multiple panels simultaneously (instead of one-by-one via the toolbar).
Unified access to designer settings. Users can customize layout, data, and appearance from a single location.

DevExpress Report Designer Data Source Wizard — Pinned Data Sources

We will enhance the "Choose a data source" page in our Data Source Wizard to allow users to pin frequently used database providers as favorites. These favorite providers will be displayed at the top of the list for quick access.

Time Zone Conversion

With v25.2, DevExpress Reports will convert UTC date/time values to the viewer's local time zone. This feature is essential for applications with a global user base, as it ensures that all users analyze report data in their respective local time zones.

Your Feedback Counts

If you have a specific question about our WinForms roadmap, feel free to submit a support ticket via the DevExpress Support Center. We will be happy to follow-up.

WinForms — Early Access Preview (v25.1)

Bogdan Kharchenko (DevExpress) — Wed, 02 Apr 2025 21:20:00 Z

Our next major update (v25.1) is a couple of months away. As such, we wanted to preview a few features/capabilities we expect to ship this spring and invite all active DevExpress Universal or DXperience subscriber to download and install our Early Access Preview (EAP) today (visit the DevExpress Download Manager to obtain the EAP build). As you will see below, new desktop development standards (.NET Core, AI, Accessibility) remain key focus areas.

Early Access and CTP builds are provided solely for early testing purposes and are not ready for production use. This build can be installed side by side with other major versions of DevExpress products. Please backup your project and other important data before installing Early Access and CTP builds.

This EAP may not include all features/products we expect to ship in our v25.1 release cycle. As its name implies, the EAP offers an early preview of what we expect to ship in two months. For additional information on what you can expect, refer to our June 2025 Roadmap.

AI–driven Semantic Search within the WinForms Data Grid

Our WinForms Data Grid will ship with an enhanced search experience and allow users to locate relevant data within large datasets faster/more accurately. The Data Grid utilizes Natural Language Processing (NLP) to analyze search queries beyond exact keyword matching. By interpreting synonyms and contextual meaning, the DevExpress Data Grid will deliver more precise search results.

Once AI-driven semantic search is enabled, a dropdown button appears within the search box. The popup menu allows users to specify search mode: standard, semantic, or hybrid (a combination of standard and semantic search).

You can use semantic search in either 'Filter' or 'Search' mode. In 'Search' mode, the grid highlights relevant data rows for more flexible/intuitive data discovery:

Semantic search requires use of additional DevExpress NuGet packages:

DevExpress.AIIntegration.SemanticSearch
DevExpress.AIIntegration.WinForms.SemanticSearch

To enable AI–powered semantic search within the WinForms Data Grid, you must register an embedding generator, supply a vector storage/database, connect our new SemanticSearchBehavior to the grid, and configure behavior settings (such as, an embedding generator, vector store, record type in a vector store, data source key field, search mode, search accuracy, the maximum number of results, etc.):

The following code snippet initializes vectors. It creates an in-memory vector store to store vectorized records (for demo purposes). Production AI applications use vector databases and services to improve relevancy. You can use any vector store that implements the IVectorStore interface to store embeddings. Refer to the following topic for additional information: Available vector database solutions.


async void Form1_Shown(object sender, EventArgs e) {
    try {
        await Initialize();
    }
    catch(Exception ex) {
        MessageBox.Show(ex.ToString());
    }
}

// Define a record stored in the vector store for semantic search
class VectorStoreRecord {
    // A unique identifier for the record in a vector store
    [VectorStoreRecordKey]
    public string Key { get; set; }

    // Text content associated with the record
    [VectorStoreRecordData]
    public string ItemDescription { get; set; }

    // Numerical vector representation of the record
    // Specifies how vector data is stored and compared in a vector store
    // Ollama produces 768-dimensional vectors 
    [VectorStoreRecordVector(768, DistanceFunction.CosineSimilarity)]
    public ReadOnlyMemory<float> Vector { get; set; }
}

async Task Initialize() {
    // Initialize an embedding generator to convert text into numerical vectors
    // This example uses the Ollama embedding generator.
    var embeddingGenerator = new OllamaEmbeddingGenerator(new Uri("http://localhost:11434/"), "nomic-embed-text");
    
    /* The following code uses an Azure OpenAI embedding model.
    *  You can use the 'text-embedding-3-small' model that produces 1536-dimensional vectors.
    *  Modify the 'VectorStoreRecordVector' attribute for the 'VectorStoreRecord.Vector'.
    * var embeddingGenerator = new AzureOpenAIClient(
    *     new Uri(AzureOpenAIEndPoint),
    *     new AzureKeyCredential(AzureOpenAIKey))
    *     .AsEmbeddingGenerator(ModelId);
    */

    // Create an in-memory vector store to store vectorized records
    var vectorStore = new InMemoryVectorStore();

    // Retrieve the default AI container
    var container = AIExtensionsContainerDesktop.Default;
    
    // Register the embedding generator in the AI container
    container.AddEmbeddingGenerator(embeddingGenerator);

    // Register the vector store in the AI container
    container.AddVectorStore(vectorStore);

    // Create and populate the vector store with vectorized data items
    await container.CreateVectorStoreCollectionAsync<DataItem, VectorStoreRecord>(
        // Retrieve all items to be indexed
        dataSource: DataItem.GetAllItems(),
        // Specify the collection name in the vector store
        vectorStoreCollectionName: "DataItems",
        // Extract the text content from each item to be transformed into a vector
        vectorizableContentGetter: item => item.Name + " - " + item.Description);
}

JSON Serialization

DevExpress WinForms UI controls now support JSON-based layout serialization - an alternative to XML for simplified integration with modern web and AI services. With v25.1, a new SaveLayoutToJson(Stream) method allows you to save and restore control layout in JSON format.

JSON serialization is available for projects targeting .NET 8+ and .NET Framework 4.6.2+.

string filePath = "gridlayout.json";
void Form1_Load(object sender, EventArgs e) {
    if (File.Exists(filePath)) {
        using (var jsonStream = File.OpenRead(filePath))
            gridView.RestoreLayoutFromJson(jsonStream);
    }
}

void Form1_FormClosing(object sender, FormClosingEventArgs e) {
    using (var jsonStream = File.OpenWrite(filePath))
        gridView.SaveLayoutToJson(jsonStream);
}

Enhancements in WinForms Grid–based Controls

ItemsView – Data Validation

This EAP includes new ValidateRow and BeforeLeaveRow events in the ItemsView.

Adjust Horizontal Scrolling on Touchpad

DevExpress grid–based controls (such as GridControl, TreeList, Gantt Control, and VGridControl) support smooth scrolling with a touchpad. However, some users may experience inverted horizontal scrolling behavior when using a touchpad on Windows devices.

v25.1 introduces a new InvertHorizontalScrolling option that reverses current horizontal scrolling direction in our WinForms grid-based controls when using the touchpad.

static void Main() {
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    WindowsFormsSettings.InvertHorizontalScrolling = DefaultBoolean.True;
    Application.Run(new Form1());
}

WinForms Data Editors

WinForms Step Progress Bar - UX Enhancements

We improved the user experience for step–based navigation workflows. With v25.1, users can interact with StepProgressBar items as follows:

Click an item to select it.
Use arrow keys to move focus between items.
Press Enter or Space to select an item.

New StepProgressBar APIs include:

StepProgressBar.AllowUserInteraction: Specifies whether users can interact with items.
StepProgressBarItem.AllowUserInteraction: Prevents user interaction with a specific item.
StepProgressBar.ItemClick: Occurs when a user clicks an item in the StepProgressBar and allows you to cancel selection.

stepProgressBar1.AllowUserInteraction = true;
// ...
void StepProgressBar1_ItemClick(object sender, StepProgressBarItemClickEventArgs e) {
    if (IsDataSaved(e.Item)) return;
    if (XtraMessageBox.Show("You have unsaved changes. Would you like to save them?", "Warning", MessageBoxButtons.YesNo) == DialogResult.Yes)
        e.Handled = true;
}

WinForms SearchLookUpEdit - Synchronized Find Panel Text

Our WinForms SearchLookUpEdit allows users to specify find panel text for the popup View, ensuring synchronization with the FindFilterText property. Previously, modifying the PopupView.FindFilterText property did not update the find panel's textbox, leading to inconsistencies in search behavior. This enhancement ensures that the find panel displays the actual filter applied.


searchLookUpEdit1.Properties.View.FindFilterText = "Mike";

WinForms MemoEdit - Auto Height within the Layout Control

Our WinForms MemoEdit control includes a new LayoutControlAutoHeightMode property. This property specifies how MemoEdit height adjusts to fit content when placed within a LayoutControl. Available auto height modes include:

Default / None: MemoEdit height remains fixed and does not adjust to content. A scrollbar appears if content exceeds available height.
GrowOnly: MemoEdit height increases to fit content but does not decrease when content is reduced.
GrowAndShrink: MemoEdit height increases or decreases automatically to fit content.

WinForms CheckedListBoxControl - Custom SVG Check Icon

Our WinForms CheckedListBoxControl now supports user defined (custom) SVG check icons. With v25.1, you can specify unique icons for checked, unchecked, and grayed item states. This enhancement supports customizations designed to match application themes/UI standards.

checkedListBoxControl1.CheckStyle = CheckStyles.UserDefined;
checkedListBoxControl1.ImageOptions.SvgImageChecked = svgImageCollection1["checkedState"];
checkedListBoxControl1.ImageOptions.SvgImageUnchecked = svgImageCollection1["uncheckedState"];
checkedListBoxControl1.ImageOptions.SvgImageSize = new System.Drawing.Size(16, 16);

WinForms TokenEdit - Advanced Mode

This EAP includes new APIs for our WinForms TokenEdit. With these APIS, you can customize the following advanced mode settings:

Caret Animation
Selection Animation
Selection Color Customization

Use the TokenEdit.Properties.AdvancedModeOptions property to access Advanced Mode settings:

// Enable Advanced Mode
tokenEdit.Properties.UseAdvancedMode = DefaultBoolean.True;
// Enable caret animation
tokenEdit.Properties.AdvancedModeOptions.AllowCaretAnimation = DefaultBoolean.True;
// Animate selection
tokenEdit.Properties.AdvancedModeOptions.AllowSelectionAnimation = DefaultBoolean.True;
// Set selection color
tokenEdit.Properties.AdvancedModeOptions.SelectionColor = Color.Yellow;

We also implemented a new QueryAdvancedMode static event. This event fires for every TokenEdit control in the project and allows you to configure Advanced Mode settings based on your preferences.

WinForms Ribbon and Bars

Maximize/Minimize Ribbon

New APIs include:

MaximizeRibbon(RibbonPage): Expands a minimized Ribbon.
RibbonControl.AllowMinimizeRibbonOnDoubleClick: Specifies whether users can minimize the Ribbon by double-clicking a page header.

Identify Bar Items and Bar Links

New APIs include:

BarManager.GetItemAt(Point): Identifies the bar item at specified screen coordinates.
Barmanager.GetLinkAt(Point): Identifies the BarItemLink at specified screen coordinates.

barManager1.ItemClick += (sender, e) => {
    BarItem item = barManager1.GetItemAt(Cursor.Position);
    // BarItemLink itemLink = barManager1.GetLinkAt(Cursor.Position);
    Debug.WriteLine(item.Caption);
};

Handle Bar Item Right-Clicks

The WinForms Bar Manager and Ribbon Control will support right-click handling for bar items. New events include:

We also introduced a new e.MouseButtton event parameter that allows you to identify the pressed mouse button.

Mnemonic-Based Submenu Navigation

With v25.1, we enhanced keyboard accessibility for traditional Toolbar-based user interfaces. Users can cycle through submenu items with the same mnemonic (denoted by & in captions). When multiple items within a submenu have identical mnemonics, repeated key presses navigate through them sequentially. The feature is automatically enabled and does not require additional configuration.

barItemSaveAs.Caption = "Save &As";
barItemSaveAll.Caption = "Save &All";

BarItem - Support for AutomationId

The AutomationId property - a unique identifier that distinguishes UI elements in automated tests and accessibility (a11y) tools - is now available for BarItem objects. This property is automatically set to the bar item's Name.

BarToggleSwitchItem - Toggle Switch Width

With v25.1, you can specify a toggle switch bar item width. Use the EditorToThumbWidthRatio property to set the item's total width relative to the width of the thumb.

WinForms Accordion Control

Badges and Hints

We integrated our WinForms Accordion Control with the Adorner UI Manager to help display badges/hints and highlight specific Accordion UI elements.

using System.Drawing;
using DevExpress.Utils.VisualEffects;
// ...
Badge badgeInbox;
public Form1() {
    InitializeComponent();
    badgeInbox = new Badge();
    // Assign the badge to the 'Inbox' accordion item
    badgeInbox.TargetElement = accordionItemInbox;
    // Specify badge text
    badgeInbox.Properties.Text = "17";
    // Specify badge location and offset
    badgeInbox.Properties.Location = ContentAlignment.TopLeft;
    badgeInbox.Properties.Offset = new Point(85, 6);
    // Customize badge appearance
    badgeInbox.Appearance.BackColor = Color.Gray;
    badgeInbox.Appearance.BorderColor = Color.Gray;
    badgeInbox.Appearance.ForeColor = Color.White;
    badgeInbox.Appearance.Font = new Font("Tahoma", 8.25F, FontStyle.Bold);

    // Add the badge to the AdornerUIManager
    adornerUIManager1.Elements.Add(badgeInbox);
}

Shortcuts

Accordion items now support keyboard shortcuts. Use the ShortcutKey property to specify a predefined or custom keyboard shortcut. This enhancement improves accessibility, especially for applications with complex navigation structures.

XtraMessageBox Enhancements

v25.1 introduces new functionality designed to:

Display the DevExpress Message Box in the Windows Taskbar, ensuring it is easily accessible to users.
Define the start position of the Message Box on screen.

void messageButton_Click(object sender, EventArgs e) {
    XtraMessageBoxArgs args = new XtraMessageBoxArgs() {
        Caption = "Tip",
        Text = "Hello DevExpress!",
        Buttons = new DialogResult[] { DialogResult.OK },
    };
    args.ImageOptions.SvgImage = svgImageCollection1["info"];
    args.ImageOptions.SvgImageSize = new Size(32, 32);
    args.Showing += Args_Showing;
    XtraMessageBox.Show(args);
}
void Args_Showing(object sender, XtraMessageShowingArgs e) {
    // Get the screen working area
    Rectangle workingArea = Screen.PrimaryScreen.WorkingArea;

    // Calculate bottom-right position
    int x = workingArea.Right - e.MessageBoxForm.Width;
    int y = workingArea.Bottom - e.MessageBoxForm.Height;
            
    // Define message box start position 
    e.MessageBoxForm.StartPosition = FormStartPosition.Manual;
    e.MessageBoxForm.Location = new Point(x, y);

    // Display the message box in the Windows taskbar
    e.MessageBoxForm.ShowInTaskbar = true;
}

Your Feedback Counts

If you have a specific question about our WinForms EAP (v25.1), feel free to submit a support ticket via the DevExpress Support Center. We will be happy to follow-up.

For additional information on what you can expect, refer to our June 2025 Roadmap (you can also leave your feedback at the end of the article).

WinForms — June 2025 Roadmap (v25.1)

Bogdan Kharchenko (DevExpress) — Tue, 18 Feb 2025 07:00:00 Z

This blog post outlines new WinForms–related features we expect to ship in our mid–year release (v25.1). You can leave your feedback at the end of the article - Go to the survey now.

Modern .NET Development & Productivity

Replicate Modern Microsoft Outlook and Microsoft Teams User Interfaces (.NET 8+)

Just over a year ago, Microsoft released a new Outlook for Windows with a modern and simplified design. This updated version of Outlook offers a streamlined, web–integrated experience that aligns with Microsoft's Fluent 2 design standards.

Many of our customers have expressed interest in replicating this contemporary UI within their own DevExpress-powered WinForms applications. If you've used the new version of Outlook, you know that Microsoft's new user experience extends far beyond simple UI enhancements:

The app's sidebar extends up to the form title, optimizing vertical space to display more menu items on–screen.
The sidebar can be 'collapsed' using the Ribbon's hamburger button, allowing for a more compact layout.
The Ribbon control and form title can host additional UI elements, including buttons, a search panel, and other interactive UI components.
Fluent UI enhancements include semi–transparent effects, colorful flat icons, rounded corners, specious paddings, and more.

With our v25.1 release, you will be able to replicate Outlook's UI within your DevExpress–powered WinForms applications.

We will add our RoundedSkinPanel control to the toolbox so you can use it at design time as a container for DevExpress UI controls. We also plan to introduce this option to our WinForms Layout Control.
We will add a new project template to our Template Kit for .NET 8+. This template will allow you to create Outlook–inspired apps with a single click.
We will update our Outlook–inspired DevAV Demo app to better align with Microsoft’s new design patterns.

Middle–Tier Application Server Project Template for EF Core (.NET 8+)

Our Template Kit for .NET 8+ will include a new project template. You will be able to quickly create a WinForms application with a secured data layer powered by ASP.NET Core WebAPI, EF Core, and Middle–Tier Application Server*. With this additional layer of protection (authentication, authorization, and encryption), desktop UI clients will not be able to access database connection information or modify database tables directly. Developers will be able to maintain an existing data context (DbContext) and business logic while establishing remote/secure connections to an RDBMS–based data store.

* Ships as part of the DevExpress XAF (Cross–Platform .NET App UI). An active DevExpress Universal subscription is required to use this capability.

Template–based applications will feature a built–in login form. Additionally, the app will support UI/UX customizations based on associated access permissions. This means that UI elements, available features, and displayed content can dynamically adjust based on user roles.

This new project template will be based on the following GitHub example.

Item Template Support in the New Template Kit (.NET 8+)

Our Template Kit for .NET 8+ will include Item Templates for DevExpress User Controls, Ribbon Forms, Classic Forms, and more. We will also give you the ability to add multiple views or forms to a single project simultaneously (for example, Office–inspired forms featuring our Rich Text Editor, Spreadsheet, and Scheduler controls). This eliminates the need to create each from separately via individual templates.

This approach follows the same implementation as our .NET MAUI project wizard.

In 2025, we expect to officially release our WinForms UI Templates – a set of predesigned and ready–to–use UI components and forms (currently available as EAP). We plan to include these UI Templates in our Template Kit.

New Desktop Demo on Sharing Code, Data, Security with Mobile and Web Apps (.NET 8+)

In 2024, we published a series of blog posts focused on maintaining WinForms/WPF apps and developing companion/hybrid apps (.NET MAUI, Blazor) for non–Windows platforms (Web, Mobile, macOS, Linux), with a focus on code reuse and secure data access.

This year, we plan to develop a new demo application to help developers…

Use proven solution structures and architectures.
Leverage best practices to securely interact with DevExpress data–aware controls (grids, lookups, etc.), API services, and remote data sources (such as, VirtualServerModeSource, EntityInstantFeedbackSource, etc.).
Share and reuse data models, business logic, and code base across applications.

Accessibility / UI Automation Enhancements

We expect to improve Accessibility–related support throughout this year. We also plan to introduce Accessibility across all DevExpress WinForms demos and project templates (by default).

Enhanced Accessibility within Report Viewers

We are committed to improving accessibility compliance across all supported platforms. These enhancements will help us achieve even better support for assistive technologies and compliance with industry standards.

WinForms Dashboard — UI Automation

You need a license for the DevExpress Universal Subscription to use features listed below in production code.

We will add keyboard navigation and screen reader support to the DevExpress WinForms Dashboard control.

Artificial Intelligence (AI)

AI–Driven Semantic Search in the WinForms Data Grid

With v25.1, we will deliver more intuitive and user–friendly search experiences and allow users to locate relevant information across large data sets faster and more accurately. Our WinForms Data Grid will utilize natural language processing (NLP) to interpret user queries and match data based on synonyms, related concepts, and contextual meaning, even if they do not contain exact keywords used in the query.

To enable AI–driven semantic search in the Data Grid, you will have to register an embedding generator, supply a vector storage/database, and connect our new semantic search behavior to the WinForms Data Grid. You will be able to configure behavior settings (such as, search accuracy, the maximum number of results, etc.).

WinForms Reports — AI Enhancements

In our v25.1 release cycle (June 2025), we will introduce multiple AI-powered capabilities to streamline report creation, improve data visualization, and expedite localization. These features will help users design, analyze, and preview reports more efficiently.

AI-Powered Localization — Automatically translate report content into multiple languages, reducing the energy required to create reports for a multi-lingual user base.
Intelligent Error Resolution — The DevExpress Report Design Analyzer will suggest and apply fixes for common errors to help users resolve issues quickly and achieve expected document output.
Automated Layout & Styling Enhancements — AI-driven recommendations will optimize report layouts and ensure a professional design that follows best practices.
AI-Generated Data for Print Preview — Users can preview reports with AI-generated sample data before connecting to a live data source. This will introduce faster design iterations and report layout experiments before integrating DevExpress Reports into an app.
Natural Language to SQL & Expression Bindings — Report creators will be able to describe their data needs in plain language, and AI will recommend SQL queries or expression bindings automatically.
And More..

WinForms PDF Viewer — AI-powered Behaviors

We will integrate AI-powered features into our WinForms and WPF PDF Viewer components. These enhancements will allow users to quickly understand the underlying essence of individual documents via Generative AI summaries and translate documents to a preferred language using AI-powered translations.

Additionally, users will be able to interact with an AI-powered assistant directly within their applications and ask questions about PDF documents.

Note: Our implementation is based on the functionality provided by the Microsoft.Extensions.AI library. To access these features, you will need to register the IChatClient implementation in your app (based on the desired AI services provider: OpenAI, Azure Open AI, Google Gemini or local open-source models powered by Ollama).

WinForms Charts (.NET 8+): DateOnly/TimeOnly Support

DateOnly and TimeOnly support will be added to DevExpress Charts by the end of this year.

Improved User Experience: Visual Studio Design Time for WinForms (.NET 8+)

We expect to improve the user experience within the Visual Studio WinForms designer with the following:

Smart Tags Menus for DevExpress UI Controls: These menus will provide quick access to common actions and settings.
Streamlined Navigation: Users will be able to seamlessly navigate from control wizards directly to the Properties window.

Rider has announced partial support for DevExpress WinForms UI controls in Rider IDE v2024.3. We look forward to collaborating with JetBrains to further enhance the DevExpress user experience for those targeting the Rider IDE.

Microsoft .NET Upgrade Assistant Integration for Project Upgrades

We expect to ship a new plugin (VSIX) for Microsoft .NET Upgrade Assistant. We expect this plugin to ultimately replace the DevExpress Project Converter for .NET 8+ projects. Advantages include:

The .NET Upgrade Assistant allows us to support more IDEs and operating systems, as it is available in Visual Studio Code for Windows, Mac, and Linux. The upgrade process is simpler and streamlined because we will need to maintain less code across versions (in the future, we expect to offer the Project Converter for .NET Framework projects only).
Unlike our Project Converter, the new plugin will have access to NuGet, Roslyn, MEF, and other IDE services. With the .NET Upgrade Assistant's auto–fix capabilities, we can automatically detect and safely resolve breaking changes in DevExpress code. This includes but is not limited to obsolete code replacements (such as, Font > DXFont, DxPivotGrid > DxPivotTable, etc.).
We will deliver the new plugin for minor and major DevExpress versions. The plugin will include the latest "Directory.Packages.props" file updates (with DevExpress–compatible 3rd party dependencies for CPM). You will be able to update all project dependencies and resolve security vulnerabilities with a single click.

Our Unified Component Installer will automatically install the new plug–in. The plugin will also be able for download from the Visual Studio Marketplace, nuget.org, and nuget.devexpress.com.

WinForms Data Grid

Filter Data Rows Based on Conditional Formatting Rules

In our next major release (v25.1 June 2025), we will extend our WinForms Data Grid so you can filter data rows based on conditional formatting rules and display only records that meet specific conditions (for example, you will be able to only display overdue invoices in a financial report, display critical issues in a task management system, etc.).

We also expect to introduce the following UI/UX options:

A "Filters" tab page within our Excel–inspired filter popup.
A "Conditional Filters" submenu in Grid and Filter Editor menus.
New APIs to filter data rows by conditional formatting rules in code as needed.

ItemsView – Data Validation

We will introduce the ValidateRow event in the ItemsView.

Enhancements in WinForms Grid–based Controls

Advanced Expression Editor for Conditional Formatting Rules

We plan to replace our Filter Control with Expression Editor within the Edit Formatting Rule dialog. While the Filter Control is ideal for basic and quick filters, the Expression Editor offers much more options, including:

Advanced Expression Support
Users can write complex, custom expressions using a rich set of operators, functions, and logic.
Dynamic Expression Building
With intuitive syntax highlighting and intelligent code completion (suggesting functions as you type), users can build complex expressions on the fly.
Real-Time Validation
The Expression Editor performs real-time validation, flagging errors and providing feedback instantly. This ensures that users can catch syntax or logical mistakes before applying the expression.
Intuitive and User-Friendly UI

Adjust Horizontal Scrolling on Touchpad

DevExpress grid–based controls (such as GridControl, TreeList, and VGrid) support smooth scrolling with a touchpad. However, some users may experience inverted horizontal scrolling behavior when using a touchpad on Windows devices.

With v25.1, we will introduce a new AllowInvertedScrolling that reverses the current horizontal scrolling direction in our WinForms grid-based controls when using the touchpad.

WinForms Spreadsheet

OLE Objects

Our WinForms Spreadsheet control will support embedded and linked objects (OLE objects) within Excel documents. You will be able to import and save documents with OLE Objects to supported Excel formats without content loss. OLE Object icons will be properly displayed when you preview the document, print, or export it to PDF.

Additionally, we'll introduce APIs to create, remove, and manage OLE objects in code.

New Excel Functions Support

We will enhance our Spreadsheet calculation engine by adding support for modern, dynamic array-based Excel functions. In v25.1, we will introduce functions like:

XLOOKUP
XMATCH
UNIQUE
And more

These functions will improve data lookup, filtering, and transformation capabilities in our WinForms Spreadsheet control.

WinForms Rich Text Editor

CJK (Chinese, Japanese and Korean) Text Wrapping

To enhance document rendering and readability, our WinForms Rich Text Editor will support CJK text wrapping and line breaking rules. This feature applies correct line breaks between characters for Chinese, Japanese, and Korean (CJK) text. Documents using these wrapping rules will be displayed, printed, and exported to PDF with appropriate formatting.

RTL (Right-to-Left) Engine Enhancements

In our mid-year release v25.1, we will extend our RTL rendering engine for our Rich Text Editor. This functionality will ensure correct rendering and PDF export for document paragraphs, tables and shapes containing bi-directional text (mixed Right-to-Left and Left-to-Right text blocks).

Export Word Content Controls to PDF AcroForm Fields

We will enhance our Word-to-PDF export engine and support the conversion of Word content controls into PDF AcroForm fields. With this capability, you'll be able to import or generate Word documents with content controls in our Rich Text Editor, export these documents to PDF, and automatically generate corresponding AcroForm fields in PDF output. This feature will apply to the following content control types:

Plain Text Boxes
Check Boxes
Popups

Persistent Skin and Palette Settings

This feature ensures that skin and palette settings are saved between application runs. When a user customizes app appearance, selected skin and palette settings are stored and automatically reapplied the next time the application starts.

We expect to add a new option to the DevExpress Project Settings page in Visual Studio. With v25.1, you will no longer need to manually implement logic for saving and loading user preferences.

WinForms Step Progress Bar – UX Enhancements

With our next major update (v25.1), we will improve user experience for workflows that require step–based navigation. At present, step navigation in our WinForms Step Progress Bar control is controlled programmatically, limiting user interaction.

With v25.1, users will be able to change progress by clicking on individual steps. Direct interaction with the progress bar aligns with common UI standards, making navigation more user–friendly and adaptable to different workflow scenarios.

WinForms Accordion Control

Badges and Hints

With v25.1, we expect to integrate our WinForms Accordion Control with the Adorner UI Manager so that you can display badges and hints to highlight specific Accordion UI elements.

Shortcuts

Accordion items will support keyboard shortcuts. This enhancement will improve accessibility, especially in applications with complex navigation structures.

SVG Image Support for Check Boxes in Checked ListBox

Our WinForms Checked ListBox can display custom images within checkboxes for different check states. At present, you can only display raster images (for example, PNG), limiting flexibility and resolution quality. With v25.1, you will be able to display high–quality SVG images within checkboxes for resolution–independent interfaces.

XtraMessageBox – Display in the Task Bar

With v25.1, we will introduce new functionality designed to:

Display the DevExpress Message Box in the Windows Taskbar, ensuring it is easily accessible to users.
Define the start position of the Message Box on the screen.

WinForms Reports

Document Generation Enhancements

Improved Label and Table Cell Text Formatting

Our next release will allow users to define line spacing for displayed text/values within the DevExpress Report Designer. This capability will enhance readability and provide greater control over individual report layouts. Users can directly modify line spacing for basic report controls to improve multi-line text clarity and reduce the memory footprint associated with the XRRichText control.

Time Zone Conversion

With v25.1, DevExpress Reports will be able to convert UTC date and time values to the viewer's local time zone. This feature is essential for applications with a global user base, as it ensures that all users analyze report data in their respective local time zones.

IDE Integration

Visual Studio Enhancements

We will continue improving startup time, stability, and resilience of the DevExpress Visual Studio Report Designer for .NET.

JetBrains Rider Support (Research Phase)

We recognize the growing popularity of JetBrains Rider and will research ways to extend our tools to support this environment. During the v25.1 release cycle, we will actively explore DevExpress Report Designer support for JetBrains Rider.

BI Dashboard for WinForms

You need a license for the DevExpress Universal Subscription to use features listed below in production code.

Data Handling Improvements

DateOnly & TimeOnly Support

The DevExpress BI Dashboard will support DateOnly and TimeOnly values for the following:

Binding dashboard widgets to data
Creating dashboard and query parameters
Using calculated fields
Applying time-based filters (e.g., range filter)

New PowerPoint API Presentation Library

Usage requires one of the following subscriptions: Office File API, Universal.

We expect to extend the capabilities of the DevExpress Office File API library with a new Presentation library for .NET.

This non-visual library will allow developers to generate, modify, print, and export PowerPoint presentations to different formats in code. We expect to support the following PowerPoint-related usage scenarios programmatically:

Create new presentations from scratch.
Save presentations using the PPTX (OpenXml) document format.
Merge multiple presentations into a single file.
Add, remove, and extract presentation slides; modify slide settings.
Add, remove, and customize slide elements (shapes, texts, tables and more).
Apply formatting to slide elements.
Print and export presentations to PDF.

Note: The CTP (Community Technology Preview) version of our PowerPoint Presentation Library is expected mid-year. As in any CTP, functional limitations will apply.

PDF Document API

Usage requires one of the following subscriptions: Office File API, Universal.

PDF Document Compression

To reduce file size when saving PDF documents using DevExpress PDF Document APIs, we will introduce a compression engine for the PDF object streams. This engine will optimize PDFs for more efficient storage/sharing options. New compression mechanisms will apply to various document structures, including PDF forms, fonts, and graphics.

Redaction API

We'll introduce a new Redaction API that allows users to secure PDF documents and permanently remove sensitive information. This feature will allow you to:

Erase personal or confidential data from a PDF document and prevent end-users from accessing, viewing or copying it.
Apply overlays with custom text or graphics over redacted areas.

Word Processing Document API

Usage requires one of the following subscriptions: Office File API, Universal.

Compare Word Documents

We will introduce new APIs to compare Word documents. This capability will allow you to:

Identify changes between two document versions.
Generate revision-based output highlighting.

Note: These new APIs will focus on detecting changes and making revisions for the visible document content only.

Your Feedback Counts

If you have a specific question about our June 2025 WinForms roadmap, feel free to submit a support ticket via the DevExpress Support Center. We will be happy to follow-up.

WinForms — Connect a .NET Desktop Client to a Middle Tier Security Server (EF Core with WebSockets)

Bogdan Kharchenko (DevExpress) — Wed, 18 Sep 2024 01:10:00 Z

Series Overview

This article is the second in a series of posts for teams who wish to build .NET desktop applications that communicate securely with backend services.

We also have related blog series, which may be of interest for you as well: JavaScript — Consume the DevExpress Backend Web API with Svelte (7 parts from data editing to validation, localization, reporting).

Target Audience

The target audience for this post is as follows:

EF Core/XPO Developers planning to modernize an existing application or create a new project. Using the techniques herein, you will be able to maintain an existing data context (DbContext or Session) while establishing remote/secure connections from any .NET client to an RDBMS-based data store. You can reuse your current DbContext and EF Core data model with little or no modification.
ADO.NET Developers using direct SQL, stored procedures, or similar data access methods. This post will help you get started with EF Core, Microsoft's ORM. With EF Core, you can leverage the benefits of a distributed app architecture and introduce role-based access control alongside user authentication.

Why Use a Middle Tier Security Server?

As you know, direct client-database connections can expose sensitive data. A middle-tier server introduces an important security layer - and when designed properly - can effectively manage authentication, authorization, and encryption for your next great app. With this additional layer of protection, desktop UI clients cannot access database connection information or modify database tables directly.

When using a Middle Tier Server architecture, DbContext and other EF Core CRUD APIs are still used in UI client app code - which interacts with the server remotely. Only the server has direct access to the database. Before passing data to the client's DbContext, the server enforces security measures such as authentication, authorization, and data validation.

The DevExpress Middle Tier Security Server

By introducing a middle tier:

You separate the client interface from backend logic and database access. This separation simplifies client application development and reduces code duplication, as the same logic can be reused by multiple UI clients - making the 'system' easier to maintain/scale.
You can focus on creating intuitive interfaces without worrying about database access/and many security-related issues.

Our XAF (Cross-Platform .NET App UI) and Universal Subscription include a Middle Tier Server that allows EF Core developers to maintain their standard DbContext while establishing remote and secure database connections from .NET clients, such as WinForms or WPF. The server's security system engine supports Type, Record, and Field Level Authorization. This security system also powers our free Backend Web API Service - used by many XAF and non-XAF DevExpress users across multiple platforms, including JS, .NET MAUI, Blazor.

The DevExpress Middle Tier solution "replaces" direct database connections with middleware, ensuring that only authorized users can access specific/sensitive data or perform granted actions:


var httpRemoteRepository = new HttpRemoteRepository(httpClient, typeof(EFCoreDbContext).FullName);
var optionsBuilder = new DbContextOptionsBuilder<EFCoreDbContext>();
optionsBuilder.UseMiddleTier(opt =>
    opt.UseRemoteRepository(httpRemoteRepository));
optionsBuilder.UseChangeTrackingProxies();
optionsBuilder.UseLazyLoadingProxies();
var dbContextOptions = optionsBuilder.Options;
var dbContext = new EFCoreDbContext(dbContextOptions);
var users = dbContext.Employees.ToList();

This functionality can be used on a standalone basis (if you do not require XAF, you are not forced to use it). It relies on Visual Studio 2022 and a few non-visual cross-platform .NET 6+ packages. These include DevExpress.Data, DevExpress.Xpo, DevExpress.Document.Processor, and other core libraries. Though these packages have "XAF" or "ExpressApp" in their names, you do not need to pull XAF WinForms, WebForms, and Blazor dependencies into your projects. Read FAQ

WinForms Demo Application

We've developed a GitHub example that implements middleware in a real-world scenario. The example connects a Windows Forms (.NET 8) client application to a secure backend using the DevExpress ASP.NET Core Middle Tier server.

The example demonstrates the following capabilities:

How to build a data model for application business entities and security policies with EF Core.
How to use the DevExpress ASP.ENT Core Middle Tier Security Server to connect a Windows Forms .NET 8 client application to a backend.
How to define access permissions and activate authentication/authorization for a .NET 8 WinForms app.
How to create a login form.
How to customize UI/UX for a given user based on associated access permissions.
How to create an edit form to modify and save data (CRUD).

The example creates Admin and User roles and defines the following permissions:

Admin: Read/Write (full access)
User: Read Only (data editing is not allowed)


public class Updater : ModuleUpdater {
    private const string AdministratorUserName = "Admin";
    private const string AdministratorRoleName = "Administrators";
    private const string DefaultUserName = "User";
    private const string DefaultUserRoleName = "Users";
	//...
    private PermissionPolicyRole GetUserRole() {
        PermissionPolicyRole userRole = ObjectSpace.FirstOrDefault<PermissionPolicyRole>(u => u.Name == DefaultUserRoleName);
        if(userRole == null) {
            userRole = ObjectSpace.CreateObject<PermissionPolicyRole>();
            userRole.Name = DefaultUserRoleName;
            userRole.AddTypePermission<Employee>(SecurityOperations.Read, SecurityPermissionState.Allow);
            userRole.AddTypePermission<Employee>(SecurityOperations.Write, SecurityPermissionState.Deny);
        }
        return userRole;
    }
	//...
}

The LogIn form attempts to log the user into the security system:


using(AuthForm authForm = new AuthForm()) {
    if(authForm.ShowDialog() == DialogResult.OK) {
        MiddleTierStartupHelper.WaitMiddleTierServerReady(MiddleTierStartupHelper.EFCoreWebApiMiddleTierInstanceKey, TimeSpan.MaxValue);
        // User authorization.
        var securedClient = RemoteContextUtils.CreateSecuredClient(System.Configuration.ConfigurationManager.AppSettings["endpointUrl"], authForm.Login, authForm.Password);
        RemoteContextUtils.SecuredDataServerClient = securedClient;
        DbContextOptions<DXApplication1EFCoreDbContext> options = RemoteContextUtils.CreateDbContextOptions(securedClient);
        RemoteContextUtils.Options = options;
        Application.Run(new MainForm());
    }
    else
        break;
}

If user authentication was successful, the SetUpBinding method creates a DbContext and binds the grid to data:


public partial class MainForm : RibbonForm {
    EntityServerModeSource serverModeSource = new EntityServerModeSource();
    DXApplication1EFCoreDbContext dbContext = null;
    public MainForm() {
        InitializeComponent();
        SetUpBinding();
    }
    void SetUpBinding() {
        dbContext?.Dispose();
        dbContext = RemoteContextUtils.GetDBContext();
        serverModeSource = new EntityServerModeSource() { ElementType = typeof(Employee), KeyExpression = "ID" };
        serverModeSource.QueryableSource = dbContext.Employees;
        gridControl.DataSource = serverModeSource;
    }
}

Highlighted code snippets enable/disable Ribbon commands (New, Edit, Delete) based on access permissions for the current (logged in) user:


public MainForm() {
    InitializeComponent();
    SetUpBinding();

    bbiNew.Enabled = RemoteContextUtils.IsGranted(typeof(Employee), SecurityOperations.Create);
    bbiDelete.Enabled = RemoteContextUtils.IsGranted(typeof(Employee), SecurityOperations.Delete);
    bbiEdit.Enabled = RemoteContextUtils.IsGranted(typeof(Employee), SecurityOperations.Write);
}

Download Example from GitHub

Summary

Whether you're an EF Core/XPO developer looking to modernize legacy software, or an ADO.NET developer tasked to deliver a secure/scalable solution, implementing a middle tier server is an important step forward. The DevExpress XAF-based Middle Tier solution allows you to quickly integrate a middle tier server (with minimal modifications) into your system architecture, improving maintainability and your solution's overall security posture.

Your Feedback Matters

WinForms — Early Access Preview (v24.2)

Bogdan Kharchenko (DevExpress) — Tue, 17 Sep 2024 18:48:00 Z

Our next major update (v24.2) is a couple of months away. As such, we wanted to preview the features we expect to ship this winter and invite all active DevExpress Universal or DXperience subscriber to download and install our Early Access Preview (EAP) today (visit the DevExpress Download Manager to obtain the EAP build). As you will see below, new desktop development standards (.NET Core, Security, Accessibility, AI) continue to remain key focus areas.

This EAP may not include all features/products we expect to ship in our v24.2 release cycle. As its name implies, the EAP offers an early preview of what we expect to ship in two months. For additional information on what you can expect, refer to our Year-End 2024.2 Roadmap.

.NET Core / .NET

.NET 9 Support

The DevExpress WinForms product line now supports NET 9 RC1 .

.NET 8, .NET Framework 4.6.2, Visual Studio 2019 Will Be Minimally Supported Versions for DevExpress Libraries (v24.2+)

Learn more about this global change in this announcement.

Easier Upgrade to .NET from .NET Framework

Our Project Converter can now convert DevExpress assembly references in your solution or specific projects to corresponding DevExpress NuGet packages. By selecting the "Convert DevExpress assembly references to NuGet packages" option under Advanced settings, you can easily transition to NuGet-based project management.

To streamline the upgrade process, our Project Converter automatically creates backup (.bak) files for your CSPROJ and VBPROJ files. Once DevExpress assemblies are converted, complete the upgrade process by using the Microsoft .NET Upgrade Assistant (to migrate your application to the most recent version of .NET).

Documentation: Migrate a .NET Framework App to .NET | Choose Suitable NuGet Feed | Install NuGet Packages in IDE

Enhanced UX with the WinForms .NET Core Designer

We've optimized the way we load DevExpress NuGet packages and skins to improve form load performance within Visual Studio’s .NET/.NET Core WinForms Designer. This improves startup load time by 20-35% (when compared to v24.1). Performance enhancements are most noticeable for complex projects.

The following internal test results illustrate performance improvements we've made in this release cycle:

	v24.2 (ms)	v24.1 (ms)
Test #1 Win.Grid NuGet package A form with Ribbon and Data Grid controls.	2,424	3,929
Test #2 Win.Design NuGet package A form with Ribbon and Scheduler controls.	3,121	4,743

Documentation: Install a Unified NuGet Package vs Atomic (Control-Specific) NuGet Packages with Design-Time Support

TimeOnly Support in the WinForms TimeEdit

The WinForms TimeEdit control now supports the TimeOnly data type and incorporates a TimeOnly mask within the Mask Settings editor.

New TimeOnly Functions

This EAP adds new TimeOnly-specific criteria functions to our criteria language and Grid-based UI controls (Data Grid, Vertical Grid, TreeList).

New TimeOnly functions include:

BeforeMidday - Filters records that occur before 12:00 PM.
AfterMidday - Filters records that occur after 12:00 PM.
ThisHour - Filters records that occur during the current hour.
NextHour - Filters records that occur during the next hour.
LastHour - Filters records that occurred during the previous hour.
IsMorning - Filters records that occur between 6:00 AM and 12:00 PM.
IsAfternoon - Filters records that occur between 12:00 PM and 6:00 PM.
IsEvening - Filters records that occur between 6:00 PM and 9:00 PM.
IsNight - Filters records that occur between 9:00 PM and 6:00 AM.
IsWorkTime - Filters records that occur during work hours (9:00 AM to 5:00 PM).
IsFreeTime - Filters records that occur outside of work hours (9:00 AM to 5:00 PM).
IsLunchTime - Filters records that occur during lunch time (12:00 PM to 1:00 PM).
IsSameHour - Filters records that occur exactly at the specified hour (e.g., 2 PM).
IsSameMinute - Filters records that occur exactly at the specified hour and minute (2:35 PM).
TimeOnlyFromParts - Returns the time value for the specified time with a specified precision (hour, minute, [seconds], [milliseconds]).

Applies to:

Criteria Operators
Filtering UI (Column Filter Popup, Filter Editor)
Expression Editor
Conditional Formatting Rules
Unbound Columns

You can use these new TimeOnly functions in your DevExpress-powered .NET and .NET Framework Windows Forms applications.

Documentation

TimeOnly Range Filter within the Filter Popup

The Excel-Style Column Filter ships with a new Time Range Editor (by default). In addition to traditional date filtering options, users can now filter records based on specific time intervals (such as hours, minutes, or custom time ranges).

Features include:

Full-Day Coverage: The Time Range Editor allows users to specify a From/To range that spans the entire day (00:00 to 23:59).
Track-Bar Sliders: Users can use intuitive track-bar sliders to modify time range values.
Text Editors with Time Mask: Range selectors are accompanied by text editors that utilize a TimeOnly mask (passed from column editor settings).
Fine-Grained Control: The minimum step for modifying slider values is set to a 5-minute interval (offering a balance between ease of use and precision). Users can enter an exact time within text editors.
Tooltips for Visual Feedback: To enhance usability, tooltips appear over sliders as users modify time range values.

Use the following code for backward compatibility:

ExcelFilterOptions.Default.PreferredTimeValuesTabFilterType = ExcelFilterOptions.TimeValuesTabFilterType.Tree;

Minute Rounding for TimeOnly Values

Within all DevExpress Filtering UIs (including Column Filter Popups and the Filter Editor), TimeOnly values are rounded to minutes, ignoring seconds and milliseconds.

On the UI side, we automatically simplify interval-based criteria into a more readable format within the Filter Panel and AutoFilter Row. For instance, a condition like [Time] >= 7:44 and [Time] < 7:45 is visually condensed to [Time] = 7:44. This representation enhances the user experience by removing unnecessary time components, such as seconds and milliseconds (often irrelevant for everyday use cases).

Guidance on New Desktop Development Standards

The architecture of desktop/Windows-based applications has shifted significantly over the last few years - from straightforward two-tier "client/server" models to distributed systems. This shift places new demands on how developers design, secure, and optimize applications:

Backend and Frontend Separation
Increased Complexity in Data Persistence
Asynchronous UI Clients (Frontend)

To help guide our loyal WinForms/WPF/VCL/.NET MAUI/XAF customers through new/tightened security requirements (and associated complexities) for Windows desktop application development, we've written a series of blog posts, docs and created associated demo applications:

Artificial Intelligence (AI)

Common

DevExpress AI-powered APIs allow you to integrate the following AI services into your DevExpress-powered WinForms application:

OpenAI
Azure OpenAI
Ollama

AI services and DevExpress AI extensions (behaviors) follow a "bring your own key" approach. DevExpress does not provide a REST API or include built-in LLMs/SLMs. To use AI services, you need an active Azure/OpenAI subscription to obtain the necessary REST API endpoint, key, and model deployment name. This information must be provided at application startup to register AI clients and enable DevExpress AI-powered features in your WinForms application.

The following code snippet registers an Azure OpenAI client:

using Azure.AI.OpenAI;
using DevExpress.AIIntegration;

internal static class Program
{
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        AIExtensionsContainerDesktop.Default.RegisterChatClientOpenAIService(
            new AzureOpenAIClient(new Uri(AzureOpenAIEndpoint), new System.ClientModel.ApiKeyCredential(AzureOpenAIKey)),
            deploymentName: DeploymentName
        );
        Application.Run(new Form1());
    }
    static string AzureOpenAIEndpoint { get { return Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT"); } }
    static string AzureOpenAIKey { get { return Environment.GetEnvironmentVariable("AZURE_OPENAI_APIKEY"); } }
    static string DeploymentName { get { return Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENTNAME"); } }
}

Review the following help topic for additional information on prerequisites, installation guidelines, and AI client registration processes: DevExpress AI-Powered Extensions for WinForms.

AI-Powered Smart Paste

Smart Paste is an AI-ready feature that transforms traditional copy-paste operations. Designed to improve productivity, Smart Paste analyses copied content and intelligently assigns correct values to appropriate fields/row cells in the DevExpress Data Grid and Layout Control-powered forms.

When Smart Paste is activated, the "Smart Paste" command is automatically added to a control's popup menu. When a user copies data from a source (such as a spreadsheet, document, or web page) and pastes it into a Data Grid or Layout Control-powered form, Smart Paste automatically interprets content and maps the data to the correct data fields or cells.

Review the following help topic for additional information and examples, including how to register an AI-related client and configure Smart Paste behaviors: AI-powered Smart Paste

AI-Powered Smart Search

DevExpress WinForms Ribbon and Accordion controls now support AI-powered smart search. Smart Search works alongside traditional search algorithms to deliver a more powerful and user-friendly search experience.

When the user pauses text entry in the search field (within the Ribbon or Accordion control), the control sends the current search query to an AI service that understands context, synonyms, and user intent beyond exact keyword matches. Once the AI service returns results, the control filters items accordingly.

AI-Powered Text Processing

NLP-powered text transform extensions (behaviors) allow you to enhance the way users interact with and manage text content. These extensions leverage advanced natural language processing (NLP) technologies to provide automated, intelligent text manipulation capabilities directly within your Windows Forms applications.

AI-powered text transform extensions include:

Expand
Explain
Explain Formular (in the Spreadsheet control)
Shorten
Summarize
Adjust Tone
Proofread
Rewrite
Translate
Ask AI (Custom Prompt)

AI-powered text transform extensions can be used in the following DevExpress WinForms controls:

MemoEdit
Rich Text Editor
Spreadsheet

To add this capability in your DevExpress-powered WinForms app, simply drop the DevExpress Behavior Manager component from the Toolbox onto a Form, add required AI-powered text transform behaviors in the Behavior Editor, attach behaviors to DevExpress controls, and configure behavior settings as needed:

Run the application, select text, invoke the popup menu, and click the appropriate AI-related command. AI will process the command and generate an answer. The AI-generated answer will be displayed within a dialog.

You can insert the answer directly into a document or text field with a single click. You can insert the answer above/below selected text or cursor, replace all content or selected text, or copy the answer to the clipboard.

CustomRequestBehavior displays an "Ask AI" item in the context menu. "Ask AI" invokes a dialog and allows users to directly interact with an AI-powered assistant. A user can enter a question or prompt. The AI assistant will process the query and generate an answer.

Review the following help topic for additional information: AI-Powered Text Transform Extensions.

AI-Powered Behaviors in Rich Text and Spreadsheet Editors for WinForms

Please review the following blog post for more information: Office-Inspired Controls (WinForms & WPF) — Early Access Preview (v24.2) — AI-Powered Behaviors and Accessibility Enhancements.

Accessibility and Globalization

Keyboard Navigation between Toolbars

Users can now switch between toolbars using the Ctrl+Tab keyboard shortcut.

When/if a Main Menu is not included in an application, set the Bar Manager's AllowFocusBarWithoutMainMenu property to true to enable keyboard navigation between toolbars.

Accessibility Enhancements - Alt Text Dialogs

In v24.2, we implemented new AI-Powered Alt Text dialogs for WinForms Rich Text Editors and Spreadsheet Controls.
The Alt Text dialog allows you to set accessible descriptions for shape objects in Word and Excel documents or mark non-informative document graphics as Decorative (this setting allows screen readers to ignore decorative graphics when scanning documents).
In addition, you can use the Alt Text dialog to generate the meaningful descriptions for document images using the power of the AI behavior. To enable this functionality, follow the steps from the previous section of the current blog post to register the AI service and then, attach the DevExpress.AIIntegration.WinForms.GenerateDescriptionBehavior behavior for RichEditControl or SpreadsheetControl in a WinForms application.

The Generate button is disabled if the GenerateDescriptionBehavior isn't registed for Rich Text Editor or Spreadsheet Control. Descriptions can be generated only for document images. The Generate option is disabled when a shape or chart object is selected.

The new built-in dialogs are available from the shape’s context menu. To activate the Alt Text dialog, select a document shape, or image, or chart, open the context menu and click the “View Alt Text…” context menu item.

WinForms Scheduler Enhancements

Reminder Form – New 'RemindersFormAction' Event

This EAP ships with a new WinForms Scheduler RemindersFormAction event. The event occurs when a user clicks the Dismiss, Dismiss All, or Snooze button on Reminders Forms (or if the user closes the form).

Use the e.ActionType event parameter to obtain the user action that triggered the event. For example, you can display personalized notifications when users take specific actions, or you can cancel the default action by setting the e.Handled parameter to true and execute custom logic as necessary.

Resources Tree – Auto-Populate Columns

Once the Resources Tree component is added to a Form that includes a DevExpress Scheduler control, the Resources Tree component automatically generates columns based on resource mappings configured in the underlying data storage. This enhancement reduces manual setup and ensures that the Resources Tree immediately reflects the resource structure defined for the schedule.

This EAP also includes a "Generate Columns" command in the Resources Tree's smart tag menu. This command allows you to quickly refresh columns. It clears existing columns and repopulates them based on resource mappings.

To enhance runtime flexibility, we also added a PopulateColumns method. This method auto-generates Resources Tree columns. The PopulateColumns method clears the ResourcesTree.Columns collection, creates new columns, binds them to corresponding data fields, and adds columns to the collection.

WinForms Report Viewer and Designer

New Aztec Barcode

We extended barcode support and now allow you to generate the Aztec code. Aztec barcodes offer a compact/efficient way to encode large amounts of data without requiring a quiet zone, making them ideal for space-constrained documents.

To create the Aztec Barcode, set the XRBarCode.Symbology property value to AztecCode and specify appropriate barcode properties:

You can also specify barcode data using Text or BinaryData properties as follows:

using DevExpress.XtraPrinting.BarCode;
using DevExpress.XtraReports.UI;
// ...

XRBarCode barCode = new XRBarCode();
barCode.Symbology = new AztecCodeGenerator();
barCode.Text = "YourData";
//OR
//barCode.BinaryData = GetAztecCodeData();

New Micro QR Code

You can now create Micro QR Codes (a smaller alternative to traditional QR Codes). Micro QR Codes are suitable for space-limited documents, where only small amounts of data (35 characters or 128 bits) require encoding.

To create a Micro QR Code, set the XRBarCode.Symbology property value to MicroQRCode and specify appropriate barcode properties:

You can also specify barcode data using Text or BinaryData properties as follows:

using DevExpress.XtraPrinting.BarCode;
using DevExpress.XtraReports.UI;
// ...

XRBarCode barCode = new XRBarCode();
barCode.Symbology = new MicroQRCodeGenerator();
barCode.Text = "123ABC";
//OR
//barCode.BinaryData = GetMicroCodeData();

HTML Export — Preserve Rotated Text

The XRLabel control now preserves text rotation defined by its Angle property (supported angles are 90 degrees, 180 degrees, and 270 degrees, and their negative counterparts) when exporting reports to HTML files.

PDF Export — Export Bookmarks

The new PdfExportOptions.ExportBookmarks property allows you to control bookmark visibility in exported PDF documents.

Resolve Missing Fonts

We added a new DXFontRepository.QueryNotFoundFont event for fonts used within a document but missing in an application’s hosting environment. This feature allows you to identify and resolve missing fonts by adding them to DXFontRepository before document generation begins (using the e.FontFileData event argument). In the following code snippet, we use Google Fonts to locate/add fonts to DXFontRepository :

DXFontRepository.QueryNotFoundFont+= QueryNotFoundFont;

void QueryNotFoundFont(object sender, NotFoundFontEventArgs e) {
    var service = new FontCollectorService();
    var fontData = service.ProcessFont(e.RequestedFont).Result;
    e.FontFileData = fontData;
}

With this enhancement, you will be able to identify and address document appearance issues, ensuring that reports appear as designed, regardless of the hosting platform.

Our components will also log font names in the application output for debugging purposes. Please review the following example for additional information: Reporting for WinForms - Add missing fonts into DXFontRepository from Google.

Duplicate Conditional Formatting Rules in WinForms Data-Bound Controls

Duplicate Rules allows you to duplicate existing conditional formatting rules at both runtime and design time (to simplify reuse or modify rules without recreating them from scratch).

"Duplicate Rules" is available in the following DevExpress WinForms controls:

Data Grid
PivotGrid
TreeList
Vertical Grid

You can use the Visual Studio Designer to duplicate existing rules with just a few clicks. This makes it easier to create variations of conditional formatting rules for different columns/rows/fields.

And yes, users can also duplicate conditional format rules at runtime:

Security Enhancements

Environment Policy

We added a new Environment Policy that allows you to apply global environment access restrictions, track app-initiated requests (initiated by a DevExpress UI control) and execute custom actions in response.

You can apply global restrictions using various methods like SuppressAll() to block all environment access or more specific options such as preventing DevExpress UI controls from reading or writing environment variables, exiting processes, altering the current directory, or reading paths to system special folders.

Event handlers allow you to track and manage environment operations. For example, you can detect when DevExpress UI controls attempt to read or modify environment variables, process data, or system directories and enable conditional responses based on specific conditions.

Documentation

Registry Access Policy

DevExpress UI controls can save, read, and modify configuration settings and options in the system registry. These requests can be initiated in code or through the internal control engine. The Registry Access Policy allows you to apply global registry access restrictions, track user/app-initiated requests, and execute custom actions in response.

Documentation

Your Feedback Matters

We value your thoughts/feedback. Please take a minute to respond to the following question and let us know how we can best serve your WinForms-related development needs now and into the future:

If you have yet to review the features/capabilities introduced in our most recent major update (v24.1), please visit the following webpage and let us know what you think of this release by responding to our online WinForms v24.1 survey.

WinForms — Year-End Roadmap (v24.2)

Dennis Garavsky (DevExpress) — Tue, 23 Jul 2024 02:08:00 Z

This blog post outlines some of our WinForms-related development plans for the second half of 2024 (v24.2). As you will read below, key focus areas will be .NET Core UX, AI, and Accessibility.

.NET Core / .NET

.NET 9 Support

We will support .NET 9 across our WinForms product line (v24.2 and v24.1) after November 2024. Currently, we support the most recent .NET 9 preview builds for those using v24.1 (early adopter testing). If you're wondering what lies ahead for the WinForms platform itself, be sure to check out the following Microsoft presentation from Build 2024: What's New with WinForms in .NET 9.

.NET 8, .NET Framework 4.6.2, Visual Studio 2019 Will Be Minimally Supported Versions for DevExpress Libraries (v24.2+)

Learn more about this global change in this announcement.

Source Code Builder Enhancements

In v24.2, we will simplify procedures used to rebuild assemblies from source code:

Our source builder tool will ship in the DevExpress Unified Component Installer.
Our source builder tool will be more stable (we added more internal tests for the rebuild process on our build farm) and will require fewer steps to initiate/complete source rebuild.
It will be easier to rebuild .NET Core/.NET projects (currently, it is a manual process) and generate the corresponding NuGet packages (including the localization packages).

Easier Upgrade to .NET from .NET Framework

We expect to improve integration with Microsoft's .NET Upgrade Assistant Tool. We also expect to offer predefined mappings for appropriate DevExpress packages (allowing Microsoft's tool to map DevExpress assembly references to corresponding DevExpress NuGet package references). If .NET Upgrade Assistant Tool mappings fail to meet our expectations, we will make necessary changes to the DevExpress Project Converter instead. NOTE: We will remove the old DevExpress .NET Core Migration Tool in our v24.2 release cycle (because of the aforementioned changes).

Enhanced UX with the WinForms .NET Core Designer

As you may already know from my earlier post, we continue our collaboration with Microsoft (reporting issues and suggestions, testing new implementations, etc.) to make the .NET Core design-time experience better than that of the .NET Framework. Microsoft is also very serious about the WinForms .NET Core designer experience and we are ready to review issues together in a timely manner.

For v24.2, we expect to address a few usability and stability-related issues. We encourage you to report any issue you encounter when using our UI components alongside the WinForms .NET Core designer (submit support tickets via the Support Center).

Additional DateOnly and TimeOnly Enhancements

We first introduced support for DateOnly/TimeOnly .NET types in our v24.1 release cycle (learn more). With v24.2, we will add the following enhancements to our current implementation:

Support TimeOnly in our TimeEdit component.
Support TimeOnly-specific criteria functions like IsAfternoon, InMorning, InEvening in criteria language and UI components.
Support more TimeOnly operations at the filtering UI-level, for example, a range filter instead of tree and smart equality (with second rounding).

Enhanced Project and Item Templates for .NET Core / .NET

In our upcoming release, we will add more .NET Core-based templates and also update all template code to follow .NET best practices. While we cannot make guarantees, we hope to add a Blazor Hybrid-powered project template with DevExpress WinForms and Blazor UI components, Dependency Injection (DI) support, etc.

Our DevExpress Template Gallery may undergo internal changes as well, because we utilize CLI templates more and more under the hood across a variety of DevExpress products (due to the popularity of .NET Core and NuGet). In general, CLI templates offer more opportunities for us to support VS Code and Rider IDE by reusing the same template code (a common denominator for various IDEs and operating systems). CLI templates are also easier to test/evolve in the long run.

Guidance on New Desktop Development Standards

As you may recall from an earlier post, we want to help guide our loyal WinForms/WPF/VCL/.NET MAUI/XAF customers through new/tightened security requirements (and associated complexities) for Windows desktop application development. For context, here are the main points from our overview post:

Separation of backend and frontend logic has changed: Where simple structures like client/server used to be the norm, distributed systems of varying complexity are typical today.
For data persistence, the number of commonly used options has increased: It now includes NoSQL solutions as well as distributed structures such as Event Sourcing backends.
UI apps need to take new architectural concerns into account and work asynchronously, which creates technical challenges for developers (for instance, to consume external AI or Web API services). If you watched What's New with WinForms in .NET 9? from Build 2024, you will also know that async programming or MVVM are no longer specific to ASP.NET Core or WPF apps - both concepts are becoming `a first-class citizen` in WinForms. Accessibility has also become a non-optional requirement for many today.

For more information, see our first post in the series: WinForms — Connect a .NET Desktop Client to a Secure Backend Web API Service (EF Core with OData).

Accessibility and Globalization

Final Accessibility and UI Automation Enhancements

As you know, we extended accessibility support in our v24.1 release cycle (learn more).

We expect to finalize our accessibility-related initiatives in our v24.2 release cycle:

Fix remaining accessibility-related issues from our prioritized list.
Keyboard navigation between menu bars in BarManager
Extend keyboard support in the DevExpress WinForms TreeList (to help navigate and expand/collapse nodes).

Accessibility Enhancements for WinForms PDF Viewer

We continue to enhance the accessibility support for desktop document viewers. In the next release cycle, we will introduce screen reader support for WinForms PDF Viewer. With this functionality, you will be able to read the contents in Accessible PDF documents (based on their tagged structure).

German Localization Enhancements

As you may recall, we introduced new .NET localization APIs and UI client in our v23.2 release cycle (learn more). At present, our Localization Service contains translations/resources compiled by the DevExpress developer community and thus these translations/resources may be inaccurate and/or incomplete.

In v24.2, we want to leverage our new API and tools to improve German localization resources for consistency/accuracy. In particular, we will remove duplicates, incomplete strings with missing/extra spaces, and review remaining strings as needed. Our ultimate goal is to provide the best possible translation for the German language (other popular languages and products may follow in future versions).

Artificial Intelligence (AI)

Smart/AI-Powered Functions in our WinForms Data Grid and Editors

We expect to make it easier to integrate smart/AI-powered functions across a variety of DevExpress WinForms UI components. AI-related integrations may include the following:

Core libraries for WinForms, WPF, Blazor, JS and other platforms to easily integrate and access AI features within your project. To leverage these capabilities, you will need to use your own Microsoft Azure Open AI API key or use offline open-source models powered by Ollama and/or Onnx Runtime.
AI Prompt/Chat to enable end-user communication with chat bots and other AI services for your DevExpress-powered WinForms app.
Various AI-powered functions such as smart search (example) within the DevExpress WinForms Data Grid, auto-complete and smart paste in our WinForms Memo (and other WinForms Text Editors), and AI-powered context-dependent menus.

Smart / AI-Powered Functions in Office-inspired Components for WinForms

We will integrate AI-Powered features into our WinForms and WPF Rich Text and Spreadsheet components. These enhancements will allow users to quickly understand the underlying essence of individual documents via Generative AI summaries and translate documents to a preferred language using AI-powered translations. In addition, we plan to give you the ability to describe images used within Office documents using AI-powered APIs.

Smart / AI-Powered Functions in Report Viewer for WinForms

We will integrate AI-Powered Summarize and Translate features into our Report Viewer components. These enhancements will allow users to quickly understand/analyze core insights associated with a given report (using Generative AI summaries) and convert report documents to a desired language with AI-powered translation tools.

Reporting, Scheduler and Other Office-Inspired UI Components

Report Viewer and Designer for WinForms

DateOnly & TimeOnly Support

We will introduce support for DateOnly and TimeOnly values across DevExpress Reports. This update will allow you to utilize the aforementioned types when:

creating expression bindings
report and query parameters
calculated fields
and when sorting, grouping, and filtering data.

Refer to the What's New in v24.1 to learn more about recent enhancements in this particular space.

Report Designer — Dimension Notations

To simplify the report design process, v24.2 will introduce dimension notations within the DevExpress Report Designer. When you resize controls, the designer will provide precise visual feedback and display dimension notations based on a specified ReportUnit property value (such as inches, centimeters, or pixels).

New Barcode Types — Aztec & Micro QR Code

Our next major update will support the following Barcode types: Aztec and Micro QR Code

Aztec barcodes offer a compact/efficient way to encode large amounts of data without requiring a quiet zone, making them ideal for space-constrained documents.
Micro QR Codes offer a smaller alternative to traditional QR Codes, suitable for space-limited output (where only small amounts of data require encoding).

Scheduler API Enhancements for WinForms

Based on community feedback, we expect to ship the following DevExpress Scheduler control features in our next major update:

Add events for the reminder form
Add Resource Tree columns automatically
Display additional fields within our FlyoutTooltip
Hide specific days within the Scheduler's DayView

Word Processing Document API and Rich Text Editor for WinForms

Page Borders

Our Word-processing components will support Page Borders within Word documents. You will be able to import and save documents with page borders to supported Word formats without content loss. Page borders will be properly displayed when you preview the document, print it, or export it to the PDF. APIs to manage page borders in code will be also available.

Small Caps Formatting Support

With v24.2, our Word processing tools will support Small Caps character formatting. Small Caps formatting will be applied when you preview the document inside the UI control and when you print/export to PDF. We will also introduce API settings to manage Small Caps formatting in code (and enhance the Font dialog for our desktop Rich Text Editors (WinForms & WPF) to apply formatting via the UI).

Spreadsheet Document API and Spreadsheet for WinForms

You need a license for the DevExpress Office File API Subscription or DevExpress Universal Subscription to use the libraries/features listed below in production code.

Dynamic Array Formulas

Dynamic arrays are a modern and powerful way to work with Excel document formulas. Unlike standard array formulas, which return a single value for each cell with a formula, dynamic array functions return a dynamic array of values (this array of values automatically spills into neighboring cells). Dynamic arrays offer many advantages, including new functions (XLOOKUP, XMATCH, Sort, etc.).

We expect to enhance our formula calculation engine and integrate dynamic arrays into relevant DevExpress Spreadsheet-processing tools. Core functionality will include the following:

Dynamic array calculations (formulas) and Spill Range support.
New formula error type (#SPILL!).
Spill range reference (# symbol).
Implicit intersection operator (@ symbol) to return a single formula value instead of an array.

Embed Images in Cells

Modern versions of Microsoft Excel support a new locate image feature - "Place in Cell" (available from the Insert->Picture menu). This option gives you the ability to embed an image directly into a cell instead of placing it over worksheet content.

With v24.2, our Spreadsheet Document API library and desktop Spreadsheet UI controls (WinForms & WPF) will ship with "Place in Cell" image placement support. As you would expect, this new feature will allow you to import documents with images embedded in worksheet cells and save these documents to supported Excel formats without the content loss. Embedded cell images will be correctly displayed when you preview workbooks using our desktop Spreadsheet editors (WinForms & WPF) and when you print/export documents to PDF (and of course, we'll offer new APIs to manage embedded images in code).

PDF Document API and PDF Viewer for WinForms

You need a license for the DevExpress Office File API Subscription or DevExpress Universal Subscription to use the libraries/features listed below in production code.

Signature Validation Enhancements

v24.2 will ship with enhanced PDF Signature Validation APIs. New capabilities will include:

APIs to verify certificate revocation based on Online Certificate Status Protocol (OCSP) responses.
APIs to verify certificate revocation based on Certificate Revocation List (CRL).
APIs to validate Long Term Validation (LTV) signatures.
APIs to validate Document Level Timestamps.

Export PDF Documents to SVG

We will finalize "SVG Export" options for our Office File API libraries and extend existing image export APIs for the PDF Document Processor library (to convert PDF file pages to SVG images). This enhancement will allow you to generate vector document previews from PDF files in both Windows and non-Windows environments.

Image Extraction API

To improve user experiences when extracting PDF content and analyzing document structure, we plan to enhance our image extraction APIs for the PDF Document API library. With our new APIs, you will be able to obtain additional information about PDF page images and determine image size and location on a page.

Your Feedback Matters

We value your thoughts/feedback. Please take a minute to respond to the following question and let us know how we can best serve your WinForms-related development needs now and into the future:

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

WinForms — Connect a .NET Desktop Client to a Secure Backend Web API Service (EF Core with OData)

Dennis Garavsky (DevExpress) — Wed, 17 Jul 2024 23:24:00 Z

Series Overview

As you may recall from an earlier post (Modern Desktop Apps And Their Complex Architectures), we want to help guide our loyal WinForms/WPF/VCL/.NET MAUI/XAF customers through new/tightened security requirements (and associated complexities) for Windows desktop application development. For context, here are the main points from our overview post:

Separation of backend and frontend logic has changed: Where simple structures like client/server used to be the norm, distributed systems of varying complexity are typical today.
For data persistence, the number of commonly used options has increased: It now includes NoSQL solutions as well as distributed structures such as Event Sourcing backends.
UI apps need to take new architectural concerns into account and work asynchronously, which creates technical challenges for developers.

Target Audience

We believe our post and solutions will be interesting to .NET customers who are currently using ADO.NET and direct SQL (with or without DataSet), EF Core or XPO ORM (with or without authentication and authorization systems), OData or custom Web API endpoints, and who wish to save time when implementing the requirements above.

Even if you have already addressed these requirements (for instance, your DBA configures security permissions in SQL Server manually), our solutions may help optimize implementation/maintenance costs and avoid reinventing the wheel (for instance, by migrating to a component that already does most of the work for you).

Separation of Backend and Frontend (Data Access Security, Code Sharing, API Services)

Our first look is the separation of backend and frontend within application systems by example of a WinForms UI client with ASP.NET Core Web API/OData v4, Entity Framework Core (EF Core) and our DevExpress Web API Service as a backend. This separation/architecture is critical, because of the following:

Certain environments/business apps cannot maintain direct database connections because of security considerations. A built-in security system (with authentication and access control) is required to filter out secured server data based on permissions granted to users/roles. With this additional layer of protection, UI clients cannot access database connection information or read/modify database tables directly.
Developers are often required to build multiple UI clients (desktop, web, mobile) and reuse shared databases/business logic/external systems. API services is a natural choice or solution here from a usability and maintenance point of view, not just security.
Developers want to build REST API services quickly and often require flexible filtering, grouping, paging options out-of-the-box (learn more). OData remains a good option here - many DevExpress customers (across all platforms) are still happily using OData in their desktop, mobile and web apps. We have many related support tickets annually for DevExtreme (Angular, React, Vue), WinForms, WPF, XAF, .NET MAUI, Blazor.

WinForms Code Example

Supported Use-Cases

We added a WinForms project on GitHub to demonstrate the following:

Build a data model for application business entities and security policies with EF Core (you can use our Web API Service with the DevExpress XPO ORM as well);
Securely load data from OData endpoints to a WinForms UI client using our WinForms Grid control;
Activate authentication and authorization for the WinForms app using custom Web API endpoints;
Create a logon form and customize the UI based on access permissions (for instance, to prevent data edit operations).

Some of you may already be familiar with similar requirements and our OData-based Web API Service solution (from a blog series for JavaScript, Blazor and .NET MAUI:

Related Customer Testimonials

This customer especially liked the ease of integration and configuration in our Web API Service:

The aspects of your Web API Service that particularly piqued our interest, beyond the standard Create, Read, Update, and Delete (CRUD) capabilities, are twofold:
- Firstly, the simplicity of its implementation process stands out, facilitating a seamless integration into our existing systems.
- Secondly, the extensive array of configuration options available offers a level of flexibility that is greatly appreciated, enabling us to tailor the service to our specific needs with ease.
We discovered your service through several of your publications regarding product updates, which highlighted these beneficial features and encouraged us to explore its potential for our projects.

Another customer also liked our integration capabilities:

I'm working on an Angular XAF WebApi project. The harmony between the two surprised me. Perfect operation, incredible performance and a great time saver.

Here is a nice quote from one of our customers, who bought a DevExpress Universal license because of our Web API Service:

Using this Web API Service in the majority of my new projects:
- Ease-to-use API Service and "embedded" OData Layer. Auto-generated endpoints on each Business Object are handy and significantly decrease development time. Just great for building front-end UI using properly organized request service, since most of the filtration can be handled without body, using only URL params.
- Supplies all of the basic requirements of the API. But custom functions aren't always easy to do. The documentation contains all the required information for product use, but from a newcomer's POV, sometimes it's hard to completely understand it.

For more feedback from our customers (for example, about our built-in security system), please visit this page.

Future Considerations

Our next series may cover one of the following scenarios in the context of distributed client-server applications, where a client is a typical CRUD WinForms/WPF/VCL application:

WinForms — Connect a .NET Desktop Client to a Secure Backend with the Middle Tier Application Server (EF Core without OData)
With our Middle Tier solution, EF Core or XPO ORM developers can retain their standard DbContext or Session and initiate remote connections to a data store from any .NET client (like WinForms, WPF, .NET MAUI, etc.). In a nutshell, these developers need to either retrofit their "fat clients" for Windows (#1) or redo everything from scratch using current-day Web technologies and Cloud services (#2). Our Middle Tier solution allows you to choose the "easier" and potentially more reliable route (#1), and to "replace" direct database connections with middleware.

WinForms — Connect a .NET Desktop Client to Azure Databases with Data API Builder
This should be similar to the previous examples where we bind our data grid/other components to APIs, but using different middleware. Data API Builder (DAB) is relatively new option on the market (from Microsoft). You can consider it as a competitor to our own Web API Service. DAB replaces custom CRUD API (Create, Read, Update, Delete) operations against a database. DAB is cross-platform, open-source, and independent of language, technology, and frameworks. It requires zero code and a single configuration file. Best of all, it's free, with no premium tier, and can run in any cloud.

WinForms — Connect a .NET Desktop Client to GraphQL APIs
GraphQL and REST are two common architectural patterns for building APIs. Unlike REST APIs (they use standard HTTP methods to access resources through dedicated endpoints), GraphQL is an intermediary layer that takes a single API request and responds to it with data from multiple sources. It allows you to be very specific, and does not include unnecessary data in its responses. We had a DevExtreme/JS-based example in the past and want to explore how this option can work with .NET desktop apps. According to Postman’s 2023 State of the API report, 86% of developers use REST, while 29% use GraphQL.

Our considerations and questions for you include the following:

Not everybody is using good ol' OData (for example, many people implement ASP.NET Core Web API endpoints from scratch) or even EF Core ORM.
GraphQL appears to be exclusively adopted by our DevExtreme/JS-based React or Vue customers. We are not sure that many desktop apps need to consume GraphQL.
Are you integrating with GraphQL, Data API Builder, gRPC, native SQL Server APIs, or Microsoft Graph (besides DevExpress Scheduler control synchronization with Microsoft 365 or Google) in desktop apps? How do you implement access control or authorization for your data and APIs?

Your Feedback Matters

Please share your feedback on proposed API integration options based on past requirements or upcoming projects with DevExpress WinForms/WPF/VCL components.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

WinForms — How to Integrate Semantic Similarity Search in the Grid Control (Powered by Embedding Models)

Dennis Garavsky (DevExpress) — Tue, 04 Jun 2024 03:38:00 Z

I am sure many of you remember Introducing .NET Smart Components – AI-powered UI controls by Daniel Roth and Steve Sanderson (both from Microsoft) and the excitement this article generated within the community. While this is still an ongoing experiment, many loved the example (myself included) because of the following:

Thanks to its simplicity, developers can "ride AI" locally without earning an Azure or OpenAI PhD - smart functions are available using a single NuGet package.
"Smart search" is made possible by Local Embeddings, and its beauty lies in its ability to run locally, without external AI services.
Associated usage scenarios simply make sense - many line of business (LOB) applications can benefit from this implementation immediately. Take semantic similarity search as an example: End users can search for the word "furniture" when using the DevExpress Data Grid, Lookup or other data-aware controls, and the implementation is smart enough to return records such as "chair", "table", "sofa", "wardrobe", etc.

Problem/Usage Scenario

The original post referenced above featured ASP.NET Core Blazor and MVC/Razor integrations. In this post, I'll demonstrate the ease with which you can introduce "smart search" using our award-winning Data Grid for WinForms. Integrations for other data-aware DevExpress UI controls will be similar - you will simply need to use appropriate events to achieve the desired result. You can download the example referenced in this post using the following link.

Implementation Details

1. Microsoft's SmartComponents.LocalEmbeddings NuGet package (available as an experimental GitHub repo) lies at the core of our "smart search" implementation - we simply added it to our WinForms project along with our DevExpress.Win.Grid package. Nothing more, nothing less.

Let's take a closer look at Local Embeddings from Microsoft's GitHub repo:

Embeddings are used for semantic similarity search. Natural-language strings are converted into numerical vectors called embeddings. The more conceptually related are two strings, the closer their vectors. While you can use an external AI service to compute embeddings, in many cases you can simply compute them locally on your server (no need for a GPU - the CPU will work fine). SmartComponents.LocalEmbeddings is a package to simplify doing this. With SmartComponents.LocalEmbeddings, you can compute embeddings in under a millisecond, and perform semantic search over hundreds of thousands of candidates in single-digit milliseconds.

The SmartComponents.LocalEmbeddings NuGet package does not actually contain any ML model, but it is configured to download a model when you first build your application. You can configure which model is downloaded

For additional information in this regard, please review Understand embeddings in Azure OpenAI Service or search for similar articles on the web. The ONNX embeddings model (powered by Microsoft.ML.OnnxRuntime.dll) is automatically added to your Bin folder from the SmartComponents.LocalEmbeddings NuGet package - it is 16MB in size.

2. Our WinForms Grid is bound to a collection of Item records (ID, Name, Description). Test data was AI generated (a time saver). We handle the Grid's ColumnView.CustomRowFilter event to determine row visibility (based on item text similarity - in this example Name and optionally Description) for search strings. We also trigger the filtering routine when handling keyboard input or changing search options (like similarity threshold).

        void OnCustomRowFilter(object sender, RowFilterEventArgs e) {
            Item? item = ((ColumnView)sender).DataController.GetRowByListSourceIndex(e.ListSourceRow) as Item;
            if(item == null)
                return;
            string filter = teFilter.Text;
            if(string.IsNullOrEmpty(filter))
                return;
            float threshold = (float)tbThreshold.Value / 100;
            e.Visible = SmartFilterProvider.IsSimilarTo(filter, item.Name, threshold);
            if(!e.Visible && cbIncludeDescription.Checked)
                e.Visible = SmartFilterProvider.IsSimilarTo(filter, item.Description, threshold);
            e.Handled = true;
        }

3. "Smart search" is made possible by the SmartFilterProvider class - which calls the SmartComponents.LocalEmbeddings API based on documentation published in the GitHub repo.

namespace SmartAIFilter.Provider {
    using SmartComponents.LocalEmbeddings;

    public static class SmartFilterProvider {
        readonly static LocalEmbedder Embedder = new LocalEmbedder(caseSensitive: false);
        readonly static ConcurrentDictionary<string, EmbeddingF32> cache =
            new ConcurrentDictionary<string, EmbeddingF32>(StringComparer.OrdinalIgnoreCase);
        public static bool IsSimilarTo(string filter, string text, float threshold = 0.75f) {
            EmbeddingF32 eText = cache.GetOrAdd(text, x => Embedder.Embed(x));
            EmbeddingF32 eFilter = cache.GetOrAdd(filter, x => Embedder.Embed(x));
            return eFilter.Similarity(eText) > threshold;
        }
    }
}

The LocalEmbedder class above uses the ONNX runtime - which can execute many different CPU or GPU embedding models (and often, CPU works faster for such small models).

The SmartComponents.LocalEmbeddings NuGet package does not actually contain any ML model, but it is configured to download a model when you first build your application. As mentioned earlier, you can configure which model is downloaded.

As a developer, you can tune this example based on your specific use-case scenario/project requirement. For example, you can use online (OpenAI, Azure, etc.) or offline models (Ollama, ONNX) as needed. You can download the example referenced in this post using the following link.

Your Feedback Matters

As always, your feedback is very important. Please let us know whether additional AI-related samples/solutions are of interest to you and how you expect AI to change your development strategies in the next 12-months.

Thanks,
Dennis Garavsky
Principal Product Manager
dennis@devexpress.com

WinForms Team Blog

WinForms — Generate Custom SVG Skin Palettes with AI (v25.2)

How AI-Powered Palette Generation Works

Real-World Use Cases

Try the Feature with a GitHub Demo

Prerequisites

Getting Started

Ready-to-Use Project

Under the Hood: Implementation Highlights

Share Your Feedback

Additional Resources

WinForms — June 2026 Roadmap (v26.1)

Security

Fluent Icons

Localization Tool Enhancements

DateTimeOffset Core Support

AI Agents API

AI Chat Enhancements

MemoEdit — Automatic Scrollbar

Monaco-Based Code Editor (Example)

Spreadsheet — New Excel Functions

Reporting

Accessibility & Export Compliance

DOCX/HTML Export — AccessibleDescription Support

PDF/UA Export Enhancements

Data Source Enhancements

DateTimeOffset Support

End-User Experience

WinForms End-User Report Designer — Startup Optimization

XRLabel & XRPanel — Custom Border Styles Example

IDE Integration

DevExpress Report Designer for JetBrains Rider — .NET Projects Support

AI-powered Enhancements

AI Prompt-to-Report Wizard — Optimization

Report Designer — AI-powered Chat Assistant

AGENTS.md for AI Coding Assistants

Your Feedback Matters

WinForms — Year-End Roadmap (v25.2)

.NET 10 Support

DevExpress MCP Server for AI-Powered Documentation Access

AI Chat Control

Tool Calling API

Visual Tool Execution Indicators

Resources

RAG Project Template

AI-Powered Expression Generation

Rider Support

Designer

DevExpress Template Kit

Charts — DateOnly & TimeOnly Support

Data Grid — Column Header Navigation

Data Grid — Multi-Cell Editing

Editors — Screen Reader Enhancements

Ribbon Control — Right Pane

Rich Text Editor

Word to PDF/UA Conversion

Enhanced Master-Detail Mail Merge

Spreadsheet Editor

Excel to PDF/UA Conversion

OLE Object Support Enhancements

New Excel Functions

Reports

Enhanced PDF Export — Accessibility Enhancements

Enhanced DOCX Export — Accessibility Enhancements

Report Design Analyzer — Accessibility Checker

DevExpress Report Designer for JetBrains Rider

AI-Powered Enhancements

End-User Report Designer — Settings Window

DevExpress Report Designer Data Source Wizard — Pinned Data Sources

Time Zone Conversion

Your Feedback Counts

WinForms — Early Access Preview (v25.1)

AI–driven Semantic Search within the WinForms Data Grid

JSON Serialization

Enhancements in WinForms Grid–based Controls

ItemsView – Data Validation

Adjust Horizontal Scrolling on Touchpad

WinForms Data Editors

WinForms Step Progress Bar - UX Enhancements

WinForms SearchLookUpEdit - Synchronized Find Panel Text