Modernise your WinForms or WPF app Preview

For software houses with a desktop application that has to stay a desktop application: replace the DataGridView first, then panel by panel, then the shell. The business logic stays where it is, and the application ships the whole time.

Ask for a free pilot Read the technical guide

Everything on this page is part of ArionUI Core — open source under Apache-2.0 — and exists in 0.1.0-preview.1. It is a preview: the API still moves between versions.

No rewrite, no move to the web

A rewrite stops feature work for months and throws away tested business rules. A move to the web trades a desktop app your customers know for a new set of problems. ArionUI takes a third way: it goes into the existing window as ordinary controls — ArionGridControl and ArionControlSurface on WinForms, ArionGrid and ArionControlSurface on WPF — and each replaces one piece of the old window while the code around it keeps running.

The path: inside out

The order is fixed by the technique: ArionUI goes into an old window, but an old native control cannot go inside an ArionUI board. So the work starts where it usually hurts first.

1. Swap the grid

   The DataGridView becomes an ArionGridControl on the same DataTable or BindingSource. Columns, the table's rules and the current row come along; the old event handlers stay.

2. Then panel by panel

   A detail form, a filter bar, a figures panel becomes a board bound to a view model. It reads the old state and calls the old methods.

3. Then the shell

   Side bar, header and status line become ArionUI. The old forms keep their place next to them until they are replaced too.

Before and after

Step one on a WinForms form with a DataGridView on a BindingSource over a DataTable. The table stays, the binding source stays, the handlers stay; one control changes.

panelOrders.Controls.Add(new DataGridView { Dock = DockStyle.Fill, DataSource = orders });

var grid = new ArionGridControl
{
    Dock = DockStyle.Fill,
    DataSource = orders,                     // a DataTable, a DataView or a BindingSource over one
    VisualTheme = ArionTheme.FromSystem(),   // the window's colours and font
};
panelOrders.Controls.Add(grid);

// The old handlers stay. Only the event they hang on changes.
grid.Api.Events.RowActivated += item => OpenOrder((DataRowView)item);
grid.Api.CommandInputs.EditRefused += reason => toolStripStatus.Text = reason;

A side-by-side comparison of DataGridView and ArionGridControl on the same data is in preparation. It will appear here when it is measured — until then, no numbers.

What stays

• The business logic. Validation, calculations and data access are not touched; the new UI calls the same methods.
• The data layer. DataTable, DataView and BindingSource go straight into DataSource; view models bind to boards with board.Bind.
• The release cycle. Every step is small enough to ship on its own. The old forms keep working next to the new parts.
• The look of a Windows app. ArionTheme.FromSystem() takes the system colours, the high-contrast scheme and the font, so the new parts do not look like a different application.

The repository has a sample, samples/ArionUI.Sample.WinFormsModernize: a classic order form and the same form after each of the three steps, sharing one file of business logic. The guide walks through it.

Honest limits

• .NET 10. An application on .NET Framework has to move to .NET first; that is a step of its own.
• No native control inside a board. A report viewer or a third-party control stays next to ArionUI, not inside it.
• No VB6, Delphi or Access. There is no ActiveX wrapper.
• Windows only so far, no designer, no docking. Boards and columns are written in C#.

The full list and the code for each step: Modernise a WinForms or WPF app in the documentation, and Limitations.