Дорогие читатели, сегодня я хочу поделиться с вами интересной темой — Avalonia, мощной кроссплатформенной инфраструктурой пользовательского интерфейса .NET. Как бывший JAVA-разработчик, я знаю проблемы переключения стеков технологий. Однако в нынешней быстро меняющейся ИТ-индустрии адаптация к новым технологиям стала для нас обязательным курсом. Особенно в контексте бурно развивающейся индустрии информационных инноваций, Avalonia предоставляет нам прекрасную возможность плавно перейти к экосистеме .NET и продемонстрировать наши таланты в области кроссплатформенной разработки пользовательского интерфейса.

Давайте вместе отправимся в это захватывающее путешествие, чтобы открыть для себя очарование Авалонии и узнать, почему она является идеальным выбором для JAVA-разработчиков при переходе на .NET.

1. Знакомство с Авалонией

Avalonia — это современная кроссплатформенная среда пользовательского интерфейса, разработанная на основе платформы .NET. Его дизайн вдохновлен WPF (Windows Presentation Foundation), но в отличие от WPF, Avalonia не ограничивается платформами Windows, но также может работать на нескольких операционных системах, таких как Linux и macOS. Эта кросс-платформенная функция делает Avalonia идеальным выбором для разработки настольных приложений, особенно в средах Синьчуана, где адаптация отечественных операционных систем имеет решающее значение.

Для разработчиков, знакомых с JAVA, Avalonia можно сравнить с JavaFX, оба из которых представляют собой платформы для создания многофункциональных клиентских приложений. Однако Avalonia часто превосходит JavaFX с точки зрения производительности и кроссплатформенности, что является одной из причин, по которой многие разработчики предпочитают обращаться к Avalonia.

1. Avalonia vs JAVA Swing/JavaFX

Как разработчик JAVA, вы, возможно, уже знакомы с Swing или JavaFX. Давайте сравним сходства и различия между Avalonia и этими JAVA UI-фреймворками:

2.1 Кроссплатформенные возможности:

• Swing: Хотя он известен как «Напиши один раз, работай где угодно», его внешний вид и производительность на разных платформах сильно различаются.
• JavaFX: Улучшено по сравнению со Swing, но поддержку платформы Linux все еще необходимо усилить.
• Avalonia：серьезно Кросс-платформенныйрамка,Обеспечивает единообразную работу в Windows, Linux и macOS.

2.2 Производительность:

• Swing: поскольку это старая технология, ее производительность относительно низкая, особенно при работе со сложными пользовательскими интерфейсами.
• JavaFX: производительность выше, чем у Swing, но в некоторых сценариях все еще неудовлетворительна.
• Avalonia: благодаря высокопроизводительным функциям .NET Core Avalonia превосходно справляется с рендерингом и скоростью реагирования.

2.3 Эффективность разработки:

• Качели: развитие менее эффективно,Требуется много шаблонного кода.
• JavaFX: представлен FXML,Повышенная эффективность разработки,нокривая обучениякруче。
• Авалония: использование XAML для описания пользовательского интерфейса,Синтаксис краткий и понятный,Для тех, кто имеет опыт работы с WPF, стоимость обучения практически равна нулю.

2.4 Поддержка сообщества:

• Swing: Будучи зрелой технологией, она имеет много ресурсов, но мало новых функций.
• JavaFX: активность сообщества средняя, ​​и Oracle имеет ограниченную поддержку.
• Авалония: Несмотря на то, что сообщество относительно новое, оно очень активное, и постоянно появляются новые функции и улучшения.

1. Основные концепции Авалонии

Чтобы помочь JAVA-разработчикам лучше понять Avalonia, давайте рассмотрим некоторые основные концепции и сравним их с аналогичными концепциями в мире JAVA:

3.1 XAML (eXtensible Application Markup Language)

XAML — это язык разметки Avalonia для описания пользовательских интерфейсов. Он похож на FXML в JavaFX, но синтаксис более краткий и мощный. Для разработчиков JAVA XAML можно понимать как декларативный метод описания пользовательского интерфейса, аналогичный HTML для веб-разработки.

Пример кода XAML:

<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Welcome to Avalonia!">
    <StackPanel>
        <TextBlock Text="Hello, Avalonia!" HorizontalAlignment="Center" VerticalAlignment="Center"/>
        <Button Content="Click Me!" HorizontalAlignment="Center" Margin="0,20,0,0"/>
    </StackPanel>
</Window>

Этот код создает простое окно, содержащее текстовый блок и кнопку. Сравнивая FXML JavaFX, вы обнаружите, что синтаксис XAML более интуитивен и краток.

3.2 Привязка данных

Механизм привязки данных Avalonia аналогичен механизму JavaFX, но более мощный и гибкий. В Avalonia вы можете легко подключить элементы пользовательского интерфейса к базовой модели данных для автоматического обновления данных.

Пример кода:

<TextBlock Text="{Binding Username}"/>

Эта строка кода привязывает свойство Text TextBlock к свойству Username в ViewModel. При изменении имени пользователя пользовательский интерфейс автоматически обновится.

3.3 Стили и темы

Avalonia предоставляет мощную систему стилей, которая позволяет вам настроить внешний вид вашего приложения. Это похоже на поддержку CSS в JavaFX, но система стилей Avalonia более гибкая и мощная.

Пример стиля:

<Style Selector="Button">
    <Setter Property="Background" Value="#3498db"/>
    <Setter Property="Foreground" Value="White"/>
    <Setter Property="Padding" Value="10"/>
</Style>

Этот код определяет стиль по умолчанию для всех кнопок, устанавливая цвет фона, цвет переднего плана и отступы.

3.4 Элементы управления

Avalonia предоставляет богатый набор встроенных элементов управления, охватывающих наиболее распространенные элементы пользовательского интерфейса. Разработчикам JAVA вы найдете множество знакомых элементов управления, таких как Button, TextBox, ListView и т. д. Элементы управления Avalonia, как правило, более современны и настраиваемы, чем их аналоги Swing или JavaFX.

1. Построить Авалонию, развивать окружающую среду

Для разработчика JAVA первым шагом к переходу на разработку Avalonia является настройка подходящей среды разработки. Вот подробные шаги:

4.1 Установка .NET SDK

Сначала нам нужно установить .NET SDK. Посетите официальный сайт https://dotnet.microsoft.com/download, чтобы загрузить и установить пакет SDK для .NET, подходящий для вашей операционной системы.

Для разработчиков JAVA, привыкших к JDK, роль .NET SDK аналогична роли JDK. Он предоставляет все инструменты, необходимые для компиляции и запуска .NET-приложений.

4.2 Выбор IDE

Хотя для написания приложений Avalonia можно использовать любой текстовый редактор, я настоятельно рекомендую использовать профессиональную IDE для повышения эффективности разработки. Вот два популярных варианта:

• Visual Studio: официальная интегрированная среда разработки Microsoft.,Обеспечивает мощную поддержку .NETразвивания.
• JetBrains Rider: Если вы привыкли к IntelliJ IDEA, Rider станет хорошим выбором и обеспечит аналогичный пользовательский интерфейс.

4.3 Установка шаблона Авалония

Установка шаблона проекта Avalonia поможет вам быстро создавать новые проекты. Откройте командную строку и выполните следующую команду:

dotnet new --install Avalonia.Templates

Эта команда аналогична установке архетипа Maven в мире JAVA.

4.4 Создайте свой первый проект Авалония

Теперь давайте создадим простое приложение Avalonia. В командной строке перейдите в каталог, в котором вы хотите создать проект, и запустите:

dotnet new avalonia.app -n MyFirstAvaloniaApp

При этом будет создан новый проект Avalonia под названием MyFirstAvaloniaApp.

4.5 Запуск проекта

Перейдите в каталог проекта и выполните следующую команду, чтобы запустить приложение:

cd MyFirstAvaloniaApp
dotnet run

Поздравляем! Вы успешно запустили свое первое приложение Avalonia.

1. Структура проекта Авалония

Давайте подробнее рассмотрим структуру проекта Avalonia и сравним ее с типичным JAVA-проектом:

MyFirstAvaloniaApp/
│
├── Program.cs              # Точка входа приложения, аналогичная основному методу Java.
├── App.axaml               # XAML уровня приложения для определения глобальных ресурсов и стилей.
├── App.axaml.cs            # Резервный файл кода для App.axaml
├── MainWindow.axaml        # XAML-определение главного окна
├── MainWindow.axaml.cs     # Резервный файл кода MainWindow
│
├── ViewModels/             # Папка для хранения класса ViewModel
│   └── MainWindowViewModel.cs
│
├── Models/                 # Папка для хранения класса модели
│
├── Views/                  # Папка для хранения других представлений
│
└── Assets/                 # Папка для хранения файлов ресурсов, таких как изображения и шрифты.

Сравните структуру проекта JAVA:

• Program.cs эквивалентен классу Java, содержащему основной метод.
• Файлы .axaml аналогичны файлам .fxml JavaFX.
• Папка ViewModels похожа на папку Controller в шаблоне MVC.
• Папка «Модели» имеет ту же концепцию, что и «Модель» в проекте JAVA.
• Папка Assets аналогична папке ресурсов в проекте JAVA.

1. Основы Авалонии

6.1 Элементы управления и расположение

Avalonia предоставляет множество элементов управления и вариантов макета. Давайте рассмотрим несколько часто используемых примеров:

• Кнопка:

<Button Content="Click me!" Click="Button_Click"/>

• Текстовое поле:

<TextBox Text="{Binding UserInput}"/>

• Список:

<ListBox Items="{Binding ItemList}">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <TextBlock Text="{Binding}"/>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

Элементы управления макетом:

• StackPanel: размещает дочерние элементы по вертикали или по горизонтали.

<StackPanel Orientation="Vertical">
    <Button Content="Button 1"/>
    <Button Content="Button 2"/>
</StackPanel>

• Сетка: макет таблицы в стиле HTML.

<Grid>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="*"/>
        <ColumnDefinition Width="2*"/>
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto"/>
        <RowDefinition Height="*"/>
    </Grid.RowDefinitions>
    
    <TextBlock Grid.Column="0" Grid.Row="0" Text="Label:"/>
    <TextBox Grid.Column="1" Grid.Row="0"/>
    <Button Grid.Column="0" Grid.Row="1" Grid.ColumnSpan="2" Content="Submit"/>
</Grid>

6.2 Обработка событий

В Авалонии обработка событий очень интуитивно понятна. Вы объявляете обработчик событий в XAML, а затем реализуете его в резервном файле кода:

XAML:

<Button Content="Click me!" Click="Button_Click"/>

Код С#:

public void Button_Click(object sender, RoutedEventArgs e)
{
    // Обработка событий кликов
}

Это очень похоже на механизм обработки событий JavaFX.

6.3 Привязка данных

Привязка данных — одна из мощных функций Avalonia. Он позволяет подключать элементы пользовательского интерфейса к модели данных для автоматического обновления.

Пример:

ViewModel:

public class MainWindowViewModel : ViewModelBase
{
    private string _name;
    public string Name
    {
        get => _name;
        set => this.RaiseAndSetIfChanged(ref _name, value);
    }
}

XAML:

<TextBox Text="{Binding Name}"/>
<TextBlock Text="{Binding Name, StringFormat='Hello, {0}!'}"/>

В этом примере и TextBox, и TextBlock привязаны к свойству Name. Когда пользователь вводит текст в TextBox, TextBlock автоматически обновляется.

6.4 Стили и темы

Система стилей Avalonia позволяет вам настроить внешний вид вашего приложения. Вы можете определить глобальные стили в App.axaml или определить локальные стили в отдельных элементах управления.

общая ситуация Пример стиля:

<Application.Styles>
    <Style Selector="Button">
        <Setter Property="Background" Value="#3498db"/>
        <Setter Property="Foreground" Value="White"/>
    </Style>
</Application.Styles>

местный пример стиля:

<Button Content="Special Button">
    <Button.Styles>
        <Style Selector="Button">
            <Setter Property="Background" Value="Red"/>
        </Style>
    </Button.Styles>
</Button>

1. Применение паттерна MVVM в Авалонии

Шаблон Model-View-ViewModel (MVVM) — это широко используемый шаблон проектирования при разработке приложений Avalonia. Для разработчиков JAVA, знакомых с моделью MVC, MVVM можно рассматривать как развитую версию MVC, особенно подходящую для современных инфраструктур пользовательского интерфейса.

7.1 Компоненты MVVM:

• Модель: представляет данные и бизнес-логику, та же концепция, что и модель в JAVA.
• Представление: пользовательский интерфейс, обычно определяемый в XAML в Авалонии.
• ViewModel: средний уровень между представлением и моделью, обрабатывает бизнес-логику представления и преобразует данные модели в формат, который View может легко использовать.

7.2 Преимущества MVVM:

• обратите внимание на разделение точек: логика пользовательского интерфейса и бизнес-логика четко разделены.
• Тестируемость: ViewModel можно тестировать отдельно от пользовательского интерфейса.
• Удобство сопровождения: код легче поддерживать и расширять благодаря четкому разделению обязанностей.

7.3 Реализация MVVM в Авалонии

Давайте проиллюстрируем, как реализовать шаблон MVVM в Авалонии, на простом примере:

Пример: Создайте простое приложение со списком дел.

7.3.1 Model

первый,Мы определяем простойTodoItemкласс как нашModel：

public class TodoItem
{
    public string Title { get; set; }
    public bool IsCompleted { get; set; }
}

7.3.2 ViewModel

Следующий,мы создаемMainWindowViewModelкласс как нашViewModel：

using System.Collections.ObjectModel;
using ReactiveUI;

public class MainWindowViewModel : ReactiveObject
{
    private ObservableCollection<TodoItem> _todoItems;
    public ObservableCollection<TodoItem> TodoItems
    {
        get => _todoItems;
        set => this.RaiseAndSetIfChanged(ref _todoItems, value);
    }

    private string _newTodoTitle;
    public string NewTodoTitle
    {
        get => _newTodoTitle;
        set => this.RaiseAndSetIfChanged(ref _newTodoTitle, value);
    }

    public ReactiveCommand<Unit, Unit> AddTodoCommand { get; }

    public MainWindowViewModel()
    {
        TodoItems = new ObservableCollection<TodoItem>();
        AddTodoCommand = ReactiveCommand.Create(AddTodo);
    }

    private void AddTodo()
    {
        if (!string.IsNullOrWhiteSpace(NewTodoTitle))
        {
            TodoItems.Add(new TodoItem { Title = NewTodoTitle });
            NewTodoTitle = string.Empty;
        }
    }
}

В этой ViewModel мы:

• использоватьObservableCollection<T>для хранения дел,Таким образом, при сборе изменений,Пользовательский интерфейс обновится автоматически.
• ОсуществленныйINotifyPropertyChangedинтерфейс（по наследствуReactiveObject）,Это позволяет уведомлять пользовательский интерфейс об изменениях свойств.
• СоздалReactiveCommandдля обработки добавления нового элемента списка дел。

7.3.3 View

Наконец, мы определяем наше представление в XAML:

<Window xmlns="https://github.com/avaloniaui"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:vm="using:MyTodoApp.ViewModels"
        x:Class="MyTodoApp.Views.MainWindow"
        Icon="/Assets/avalonia-logo.ico"
        Title="My Todo App">

    <Design.DataContext>
        <vm:MainWindowViewModel/>
    </Design.DataContext>

    <DockPanel>
        <StackPanel DockPanel.Dock="Top" Orientation="Horizontal">
            <TextBox Text="{Binding NewTodoTitle}" Width="200" Margin="5"/>
            <Button Content="Add" Command="{Binding AddTodoCommand}" Margin="5"/>
        </StackPanel>
        
        <ListBox Items="{Binding TodoItems}">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <CheckBox Content="{Binding Title}" IsChecked="{Binding IsCompleted}"/>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </DockPanel>

</Window>

В этом представлении:

• Мы используем привязку данных для соединения элементов пользовательского интерфейса со свойствами и командами ViewModel.
• ListBoxПоказывает все задачи,Используйте один для каждого проектаCheckBoxвыражать。
• вершинаTextBoxиButtonИспользуется для добавления новых задач。

На этом примере мы можем увидеть, как шаблон MVVM элегантно реализован в Avalonia. ViewModel обрабатывает всю бизнес-логику и управление состоянием, а View отвечает только за отображение данных и сбор вводимых пользователем данных. Такое разделение делает код более модульным и простым в обслуживании.

1. Расширенные возможности Авалонии

Будучи современной платформой пользовательского интерфейса, Avalonia предоставляет множество расширенных функций, которые делают наши приложения более мощными и гибкими. Вот некоторые расширенные функции, на которые стоит обратить внимание:

8.1 Пользовательские элементы управления

Создавать собственные элементы управления в Avalonia очень просто. Вы можете реализовать собственные элементы управления, унаследовав существующие элементы управления или создав их с нуля. Это похоже на создание пользовательских компонентов в JavaFX.

Например, создайте простой элемент управления рейтингом:

public class RatingControl : Control
{
    public static readonly StyledProperty<int> ValueProperty = 
        AvaloniaProperty.Register<RatingControl, int>(nameof(Value));

    public int Value
    {
        get => GetValue(ValueProperty);
        set => SetValue(ValueProperty, value);
    }

    public RatingControl()
    {
        UpdatePseudoClasses(Value);
    }

    protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
    {
        base.OnPropertyChanged(change);

        if (change.Property == ValueProperty)
        {
            UpdatePseudoClasses(change.NewValue.GetValueOrDefault<int>());
        }
    }

    private void UpdatePseudoClasses(int value)
    {
        PseudoClasses.Set(":value1", value >= 1);
        PseudoClasses.Set(":value2", value >= 2);
        PseudoClasses.Set(":value3", value >= 3);
        PseudoClasses.Set(":value4", value >= 4);
        PseudoClasses.Set(":value5", value >= 5);
    }
}

Затем вы можете использовать этот пользовательский элемент управления в XAML:

<local:RatingControl Value="{Binding UserRating}"/>

8.2 Анимация

Avalonia предоставляет мощную систему анимации, которая позволяет создавать плавные переходы пользовательского интерфейса. Вы можете определить анимацию непосредственно в XAML или создать ее в коде.

Простая анимация Пример в XAML:

<Button Content="Hover me">
    <Button.Styles>
        <Style Selector="Button:pointerover">
            <Setter Property="RenderTransform">
                <Setter.Value>
                    <ScaleTransform ScaleX="1.1" ScaleY="1.1"/>
                </Setter.Value>
            </Setter>
        </Style>
    </Button.Styles>
    <Button.Transitions>
        <Transitions>
            <TransformOperationsTransition Property="RenderTransform" Duration="0:0:0.2"/>
        </Transitions>
    </Button.Transitions>
</Button>

В этом примере создается кнопка, масштаб которой плавно увеличивается при наведении на нее указателя мыши.

8.3 Реактивное программирование

Avalonia легко интегрируется с ReactiveUI, позволяя использовать парадигмы реактивного программирования. Это особенно полезно для обработки асинхронных операций и сложных взаимодействий пользовательского интерфейса.

Например, реализуйте окно поиска с функцией устранения дребезга:

public class SearchViewModel : ReactiveObject
{
    private string _searchTerm;
    public string SearchTerm
    {
        get => _searchTerm;
        set => this.RaiseAndSetIfChanged(ref _searchTerm, value);
    }

    public ObservableCollection<string> SearchResults { get; } = new ObservableCollection<string>();

    public SearchViewModel()
    {
        this.WhenAnyValue(x => x.SearchTerm)
            .Throttle(TimeSpan.FromMilliseconds(400))
            .Where(term => !string.IsNullOrWhiteSpace(term))
            .SelectMany(Search)
            .ObserveOn(RxApp.MainThreadScheduler)
            .Subscribe(results =>
            {
                SearchResults.Clear();
                foreach (var result in results)
                {
                    SearchResults.Add(result);
                }
            });
    }

    private async Task<IEnumerable<string>> Search(string term)
    {
        // Имитировать асинхронные поисковые операции
        await Task.Delay(1000);
        return new[] { $"Result 1 for {term}", $"Result 2 for {term}", $"Result 3 for {term}" };
    }
}

В этом примере показано, как использовать ReactiveUI для реализации функции поиска, которая будет выполнять поиск только через 400 миллисекунд после того, как пользователь перестанет печатать, что позволяет избежать частых бесполезных поисков.

8.4 Внедрение зависимостей

Avalonia поддерживает внедрение зависимостей, что упрощает управление созданием и жизненным циклом объектов, улучшая тестируемость и удобство сопровождения кода.

Настройте внедрение зависимостей в Program.cs:

public class Program
{
    public static void Main(string[] args)
    {
        var builder = BuildAvaloniaApp();
        builder.ConfigureServices((context, services) =>
        {
            services.AddSingleton<IDataService, DataService>();
            services.AddTransient<MainWindowViewModel>();
        });
        builder.StartWithClassicDesktopLifetime(args);
    }

    public static AppBuilder BuildAvaloniaApp()
        => AppBuilder.Configure<App>()
            .UsePlatformDetect()
            .LogToTrace();
}

Затем используйте внедренный сервис в ViewModel:

public class MainWindowViewModel
{
    private readonly IDataService _dataService;

    public MainWindowViewModel(IDataService dataService)
    {
        _dataService = dataService;
    }

    // использовать_dataService...
}

1. Оптимизация производительности

Будучи высокопроизводительной платформой пользовательского интерфейса, Avalonia предоставляет несколько способов оптимизации производительности приложений. Вот несколько важных советов по оптимизации производительности:

9.1 Виртуализация

При работе с большими объемами данных,использоватьвиртуализацияможет значительно улучшитьпроизводительность。AvaloniaизListBoxиItemsControlПоддерживается по умолчаниювиртуализация。

<ListBox Items="{Binding LargeDataSet}"
         VirtualizationMode="Simple">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <TextBlock Text="{Binding}"/>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

9.2 Асинхронная загрузка

Для трудоемких операций, таких как загрузка больших наборов данных или выполнение сложных вычислений, следует использовать асинхронные методы, чтобы избежать блокировки потока пользовательского интерфейса.

public async Task LoadDataAsync()
{
    var data = await _dataService.GetLargeDataSetAsync();
    Items = new ObservableCollection<Item>(data);
}

9.3 Кэширование

Для часто используемых, но редко изменяющихся данных можно использовать кэширование для повышения производительности.

private Dictionary<string, BitmapImage> _imageCache = new Dictionary<string, BitmapImage>();

public async Task<BitmapImage> LoadImageAsync(string url)
{
    if (_imageCache.TryGetValue(url, out var cachedImage))
    {
        return cachedImage;
    }

    var image = new BitmapImage(new Uri(url));
    await image.LoadAsync();
    _imageCache[url] = image;
    return image;
}

9.4 Использование скомпилированных привязок

Avalonia поддерживает скомпилированные привязки, что может значительно повысить производительность привязок. Чтобы включить скомпилированную привязку, добавьте следующее пространство имен в корневой элемент вашего файла XAML:

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:compiledBindings="using:Avalonia.Data.CompiledBindings"
mc:Ignorable="compiledBindings"
compiledBindings:DataType="{x:Type viewmodels:MainViewModel}"

Затем вы можете использовать скомпилированные привязки:

<TextBlock Text="{CompiledBinding Name}"/>

1. тест

Тестирование — важнейшая часть обеспечения качества приложения. Avalonia предоставляет различные методы тестирования, включая модульное тестирование и тестирование пользовательского интерфейса.

10.1 Модульное тестирование

Для модульного тестирования ViewModels вы можете использовать стандартные платформы тестирования .NET, такие как NUnit или xUnit. Например, использование xUnit для тестирования ViewModel:

public class MainViewModelTests
{
    [Fact]
    public void AddTodoCommand_Should_Add_New_TodoItem()
    {
        // Arrange
        var viewModel = new MainViewModel();
        viewModel.NewTodoTitle = "Test Todo";

        // Act
        viewModel.AddTodoCommand.Execute(null);

        // Assert
        Assert.Single(viewModel.TodoItems);
        Assert.Equal("Test Todo", viewModel.TodoItems[0].Title);
    }
}

10.2 Тестирование пользовательского интерфейса

AvaloniaпредоставилAvalonia.HeadlessСумка,Позволяет тестировать UI без визуального интерфейса. Это похоже на структуру TestFX JavaFX.

Ниже приведен UIтест Пример Avalonia.Headless:

using Avalonia.Controls;
using Avalonia.Headless;
using Avalonia.Headless.XUnit;
using Xunit;

public class MainWindowTests
{
    [AvaloniaFact]
    public void Button_Click_Should_Add_New_Todo_Item()
    {
        using var app = AppBuilder.Configure<App>()
            .UseHeadless()
            .StartWithClassicDesktopLifetime(Array.Empty<string>());

        var window = new MainWindow();
        var viewModel = new MainViewModel();
        window.DataContext = viewModel;

        var textBox = window.FindControl<TextBox>("NewTodoTextBox");
        var addButton = window.FindControl<Button>("AddTodoButton");
        var listBox = window.FindControl<ListBox>("TodoListBox");

        textBox.Text = "Test Todo";
        addButton.Command.Execute(null);

        Assert.Single(listBox.Items);
        Assert.Equal("Test Todo", ((TodoItem)listBox.Items[0]).Title);
    }
}

В этом тесте мы смоделировали пользователя, вводящего новый элемент списка дел и нажимающего кнопку «Добавить», а затем проверяли, что новый элемент списка дел был правильно добавлен в список.

1. развертывать

Развертывание приложений Avalonia на разных платформах — относительно простой процесс благодаря кроссплатформенности .NET. Ниже приведены шаги развертывания для разных платформ:

11.1 Windows

На платформах Windows вы можете создать автономный исполняемый файл с помощью следующей команды:

dotnet publish -c Release -r win-x64 --self-contained true

Это будет вbin/Release/netcoreapp3.1/win-x64/publishОглавление Создайте его под Сумка Содержит все необходимые зависимостиизисполняемый файл。

11.2 macOS

Для macOS используйте следующую команду:

dotnet publish -c Release -r osx-x64 --self-contained true

генерироватьиз Файл будет находиться вbin/Release/netcoreapp3.1/osx-x64/publishОглавление。

11.3 Linux

Для Linux команда выглядит следующим образом:

dotnet publish -c Release -r linux-x64 --self-contained true

Вывод будет вbin/Release/netcoreapp3.1/linux-x64/publishОглавлениесередина。

11.4 Создание установщика

Чтобы обеспечить удобство работы для конечных пользователей, вы можете создать установщики. Вот некоторые часто используемые инструменты:

• Windows: набор инструментов WiX и установка Inno.
• macOS: create-dmg
• Linux: AppImage или Flatpak.

Например, простые шаги по созданию установщика Windows с помощью WiX Toolset:

1. Установите набор инструментов WiX
2. Создайте файл .wxs с описанием вашего установщика.
3. Скомпилируйте и свяжите с помощью следующих команд:

candle YourApp.wxs
light YourApp.wixobj

Это создаст установочный файл .msi.

1. Avalonia vs WPF

Как бывший JAVA-разработчик, вы можете спросить: почему стоит выбрать Avalonia вместо более зрелой WPF? Давайте сравним эти два фреймворка:

12.1 Кроссплатформенные возможности

• Avalonia: Настоящая кроссплатформенность, поддерживающая Windows, macOS и Linux.
• WPF: только для платформы Windows.

12.2 Открытый исходный код и сообщество

• Авалония: Полностью открытый исходный код с активным сообществом.
• WPF: Частично открытый исходный код, но ядро ​​по-прежнему контролируется Microsoft.

12.3 Модернизация

• Авалония: дизайн стал более современным и его легче адаптировать к новым тенденциям пользовательского интерфейса.
• WPF: относительно старый и в некоторых аспектах может показаться устаревшим.

12.4 Производительность

• Авалония: воспользуйтесь преимуществами производительности .NET Core и в целом повысьте производительность.
• WPF: Производительность хорошая, но в некоторых сценариях она может быть не такой хорошей, как у Avalonia.

12.5 Кривая обучения

• Авалония: легко начать работу с развитием WPF,Но адаптация к JAVA-развиванию может занять некоторое время.
• WPF: Зрелый и стабильный, с большим количеством обучающих ресурсов, а также для JAVAразвивать кривую. обучения。

12.6 Библиотека управления

• Авалония: Библиотека управления относительно новая, но быстро развивается.
• WPF: Имеет богатую и зрелую библиотеку элементов управления.

Для бывших разработчиков Java кроссплатформенность Avalonia может быть более привлекательной, особенно если вам нужно разрабатывать приложения, работающие в нескольких операционных системах.

1. От JAVA до Avalonia: сравнение языков и концепций

Чтобы помочь разработчикам JAVA лучше понять Avalonia и C#, давайте сравним некоторые общие концепции и синтаксис:

13.1 Классы и объекты

JAVA:

public class Person {
    private String name;
    
    public Person(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
}

Person person = new Person("John");

C# (Avalonia):

public class Person
{
    public string Name { get; set; }
    
    public Person(string name)
    {
        Name = name;
    }
}

var person = new Person("John");

Обратите внимание на синтаксис свойств в C#, который упрощает написание методов получения и установки.

13.2 Интерфейс

JAVA:

public interface IDrawable {
    void draw();
}

public class Circle implements IDrawable {
    @Override
    public void draw() {
        // Реализация логики рисования
    }
}

C# (Avalonia):

public interface IDrawable
{
    void Draw();
}

public class Circle : IDrawable
{
    public void Draw()
    {
        // Реализация логики рисования
    }
}

13.3 Лямбда-выражения

JAVA:

button.setOnAction(event -> System.out.println("Button clicked"));

C# (Avalonia):

button.Click += (sender, args) => Console.WriteLine("Button clicked");

13.4 Асинхронное программирование

JAVA (с использованием CompletableFuture):

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // Асинхронные операции
    return "Result";
});

future.thenAccept(result -> System.out.println(result));

C# (Avalonia):

async Task<string> AsyncOperation()
{
    // Асинхронные операции
    return "Result";
}

var result = await AsyncOperation();
Console.WriteLine(result);

Синтаксис C# async/await делает асинхронное программирование более интуитивно понятным и простым для понимания.

13.5 Сбор

JAVA:

List<String> list = new ArrayList<>();
list.add("Item 1");

Map<String, Integer> map = new HashMap<>();
map.put("Key", 1);

C# (Avalonia):

var list = new List<string>();
list.Add("Item 1");

var dictionary = new Dictionary<string, int>();
dictionary["Key"] = 1;

13.6 XAML vs FXML

JavaFX (FXML):

<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.Button?>
<?import javafx.scene.layout.VBox?>

<VBox xmlns:fx="http://javafx.com/fxml">
    <Button text="Click me" onAction="#handleButtonClick"/>
</VBox>

Avalonia (XAML):

<VBox xmlns="https://github.com/avaloniaui">
    <Button Content="Click me" Click="HandleButtonClick"/>
</VBox>

Хотя синтаксис несколько отличается, общая структура аналогична.

1. Реальный проект: переход с JAVA на Avalonia

Чтобы лучше понять процесс преобразования JAVA в Avalonia, давайте продемонстрируем этот процесс с помощью простого приложения для задач. Сначала мы покажем версию JAVA, а затем эквивалентную версию Avalonia.

14.1 Версия JAVA (с использованием JavaFX)

Model:

public class TodoItem {
    private String title;
    private boolean completed;

    public TodoItem(String title) {
        this.title = title;
        this.completed = false;
    }

    // Getters and setters
}

ViewModel:

public class TodoViewModel {
    private ObservableList<TodoItem> todoItems = FXCollections.observableArrayList();
    private StringProperty newTodoTitle = new SimpleStringProperty();

    public void addTodo() {
        if (!newTodoTitle.get().isEmpty()) {
            todoItems.add(new TodoItem(newTodoTitle.get()));
            newTodoTitle.set("");
        }
    }

    // Getters for properties
}

View (FXML):

<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.*?>
<?import javafx.scene.layout.*?>

<VBox xmlns:fx="http://javafx.com/fxml">
    <HBox>
        <TextField fx:id="newTodoTextField"/>
        <Button text="Add" onAction="#addTodo"/>
    </HBox>
    <ListView fx:id="todoListView"/>
</VBox>

Controller:

public class TodoController {
    @FXML
    private TextField newTodoTextField;
    @FXML
    private ListView<TodoItem> todoListView;

    private TodoViewModel viewModel = new TodoViewModel();

    @FXML
    public void initialize() {
        newTodoTextField.textProperty().bindBidirectional(viewModel.newTodoTitleProperty());
        todoListView.setItems(viewModel.getTodoItems());
    }

    @FXML
    public void addTodo() {
        viewModel.addTodo();
    }
}

14.2 Версия Авалонии

Model:

public class TodoItem
{
    public string Title { get; set; }
    public bool IsCompleted { get; set; }

    public TodoItem(string title)
    {
        Title = title;
        IsCompleted = false;
    }
}

ViewModel:

public class TodoViewModel : ReactiveObject
{
    private ObservableCollection<TodoItem> _todoItems;
    public ObservableCollection<TodoItem> TodoItems
    {
        get => _todoItems;
        set => this.RaiseAndSetIfChanged(ref _todoItems, value);
    }

    private string _newTodoTitle;
    public string NewTodoTitle
    {
        get => _newTodoTitle;
        set => this.RaiseAndSetIfChanged(ref _newTodoTitle, value);
    }

    public ReactiveCommand<Unit, Unit> AddTodoCommand { get; }

    public TodoViewModel()
    {
        TodoItems = new ObservableCollection<TodoItem>();
        AddTodoCommand = ReactiveCommand.Create(AddTodo);
    }

    private void AddTodo()
    {
        if (!string.IsNullOrWhiteSpace(NewTodoTitle))
        {
            TodoItems.Add(new TodoItem(NewTodoTitle));
            NewTodoTitle = string.Empty;
        }
    }
}

View (XAML):

<UserControl xmlns="https://github.com/avaloniaui"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:vm="using:TodoApp.ViewModels">
  
  <Design.DataContext>
    <vm:TodoViewModel/>
  </Design.DataContext>

  <DockPanel>
    <StackPanel DockPanel.Dock="Top" Orientation="Horizontal">
      <TextBox Text="{Binding NewTodoTitle}" Width="200"/>
      <Button Content="Add" Command="{Binding AddTodoCommand}"/>
    </StackPanel>
    <ListBox Items="{Binding TodoItems}">
      <ListBox.ItemTemplate>
        <DataTemplate>
          <CheckBox Content="{Binding Title}" IsChecked="{Binding IsCompleted}"/>
        </DataTemplate>
      </ListBox.ItemTemplate>
    </ListBox>
  </DockPanel>
</UserControl>

Обратите внимание на основные отличия версии Avalonia:

1. Модель реактивного программирования (ReactiveUI) используется для упрощения обновления свойств и обработки команд.
2. XAML привязан непосредственно к ViewModel, отдельный контроллер не требуется.
3. Используйте командный режим для обработки нажатий кнопок вместо обработчиков событий.

В этом примере показан процесс преобразования JAVA/JavaFX в C#/Avalonia. Хотя существуют некоторые синтаксические и концептуальные различия, общая структура и идеи схожи, что позволяет разработчикам JAVA относительно легко переходить к разработке Avalonia.

1. Экосистема Авалонии

Будучи быстро развивающейся средой, Avalonia имеет богатую экосистему библиотек и инструментов, которые помогают разработчикам более эффективно создавать приложения. Вот некоторые проекты и инструменты, на которые стоит обратить внимание:

15.1 Avalonia UI Toolkit

Это официальная библиотека элементов управления пользовательского интерфейса Avalonia, которая предоставляет множество готовых элементов управления, таких как кнопки, текстовые поля, представления списков и т. д. Он разработан для обеспечения единообразного внешнего вида и поведения на разных платформах.

15.2 ReactiveUI

ReactiveUI — это платформа для создания адаптивных пользовательских интерфейсов, которая идеально интегрируется с Avalonia. Он предоставляет мощные инструменты для обработки асинхронных операций, привязки данных и управления состоянием.

15.3 Material.Avalonia

Это библиотека пользовательского интерфейса на основе Material Design, которая обеспечивает современный внешний вид приложений Avalonia. Если вам нравится стиль Material Design, эта библиотека — отличный выбор.

15.4 Avalonia.FuncUI

Это функциональная платформа пользовательского интерфейса, написанная на F#, которая позволяет создавать приложения Avalonia с использованием парадигм функционального программирования. Это интересный вариант для разработчиков, предпочитающих функциональное программирование.

15.5 AvalonStudio

AvalonStudio — это кроссплатформенная среда разработки, созданная на основе Avalonia. Это не только отличная демонстрация возможностей Avalonia, но и полезный инструмент разработки.

15.6 Dock

Dock — это настраиваемая система компоновки стыковок для Авалонии. Он позволяет создавать перетаскиваемые макеты окон с изменяемым размером, аналогичные Visual Studio.

15.7 OmniXAML

Это механизм XAML, который расширяет возможности XAML Avalonia, обеспечивая большую гибкость и расширяемость.

15.8 Avalonia.Diagnostics

Это инструмент отладки во время выполнения приложений Avalonia. Он помогает вам проверять и изменять работающие элементы пользовательского интерфейса, подобно инструментам разработчика в веб-разработке.

15.9 Avalonia.Xaml.Behaviors

Эта библиотека предоставляет систему поведения для Avalonia, позволяющую добавлять логику взаимодействия в XAML декларативным образом без написания файла кода программной части.

15.10 AvaloniaEdit

AvaloniaEdit — это высокопроизводительный текстовый редактор, основанный на Avalonia. Он поддерживает подсветку синтаксиса, свертывание кода и другие расширенные функции, что делает его идеальным для разработки редакторов кода или редакторов форматированного текста.

1. Будущие перспективы Авалонии

Будущее Авалонии, быстро развивающейся структуры, полно возможностей и проблем. Вот некоторые тенденции, за которыми стоит следить, и возможные направления:

16.1 Оптимизация производительности

Команда Avalonia постоянно работает над улучшением производительности фреймворка. В будущем может появиться больше оптимизаций рендеринга, оптимизации использования памяти и улучшенных возможностей крупномасштабной обработки данных.

16.2 Поддержка мобильных платформ

Хотя Avalonia в первую очередь ориентирована на разработку настольных приложений, постепенно улучшается поддержка мобильных платформ, таких как Android и iOS. В будущем мы можем увидеть более зрелую поддержку мобильной разработки.

16.3 Веб-платформа

По мере развития технологии WebAssembly Avalonia может добавить поддержку веб-платформы, что позволит разработчикам создавать веб-приложения, используя ту же базу кода.

16.4 Интеграция ИИ

Поскольку технология искусственного интеллекта становится все более популярной, Avalonia может предоставить больше инструментов и элементов управления для поддержки интеграции функций искусственного интеллекта, таких как распознавание речи, обработка изображений и т. д.

16.5 Улучшения доступности

Улучшение доступности приложений — это непрерывный процесс. Будущие версии Avalonia могут предоставить больше встроенных инструментов и элементов управления для создания доступных приложений.

16.6 Инструменты проектирования

Хотя некоторые инструменты дизайна уже существуют, в будущем мы можем увидеть более мощные и простые в использовании визуальные дизайнеры, которые сделают дизайн пользовательского интерфейса более интуитивно понятным и эффективным.

16.7 Межплатформенная согласованность

Со временем Avalonia может еще больше улучшить согласованность пользовательского интерфейса на разных платформах, сохраняя при этом возможность использовать преимущества функций, специфичных для платформы, когда это необходимо.

16.8 Более глубокая интеграция экосистемы

По мере развития экосистемы мы можем увидеть больше сторонних библиотек и инструментов, глубоко интегрированных с Avalonia, предоставляя разработчикам более широкий выбор.

1. От JAVA до Авалонии: лучшие практики

Если вы разработчик, переходящий с JAVA на Avalonia, вот несколько рекомендаций, которые помогут вам сделать переход более плавным:

17.1. Использование шаблона MVVM

Хотя вы, возможно, использовали шаблоны MVC или MVP в JAVA, MVVM более распространен и эффективен в Avalonia. Потратив время на глубокое понимание шаблона MVVM, вы значительно повысите эффективность своей разработки.

17.2 Изучение XAML

XAML — это основная часть Avalonia. Хотя он может выглядеть как XML, он имеет свои особенности и синтаксис. Углубленное изучение XAML поможет вам лучше создавать пользовательские интерфейсы.

17.3 Использование привязки данных

Система привязки данных Авалонии очень мощная. По возможности используйте привязку данных для подключения вашего пользовательского интерфейса и ViewModel вместо обновления элементов пользовательского интерфейса вручную.

17.4 Использование ReactiveUI

ReactiveUI глубоко интегрирован с Avalonia, предоставляя мощные инструменты для выполнения асинхронных операций и управления состоянием. Изучение и использование ReactiveUI может значительно упростить ваш код.

17.5 Написание кроссплатформенного кода

Хотя Avalonia позволяет вам писать код, специфичный для платформы, по возможности делайте свой код кроссплатформенным. Это облегчит поддержку и развертывание вашего приложения.

17.6 Использование стилей и тем

Avalonia предоставляет мощную систему укладки. Научившись использовать стили и темы, вы сможете сделать свой пользовательский интерфейс более единообразным и простым в обслуживании.

17.7 Оптимизация производительности

Хотя Avalonia уже достаточно эффективен, понимание того, как дополнительно оптимизировать производительность (например, с помощью виртуализации, асинхронной загрузки и т. д.), поможет вам создавать более плавные приложения.

17.8 Участвуйте в сообществе

В Авалонии активное сообщество. Участие в обсуждениях, задавание вопросов и внесение вклада поможет вам учиться и расти быстрее.

17.9 Непрерывное обучение

И Авалония, и экосистема .NET быстро растут. Продолжайте изучать новые функции и лучшие практики.

17.10 Написание модульных тестов

Avalonia и .NET предоставляют мощные инструменты тестирования. Выработайте привычку писать модульные тесты, которые помогут вам создавать более надежные приложения.

1. Заключение

Переход от JAVA к экосистеме Avalonia и .NET может показаться большим изменением, но на самом деле возможности, которые открывает этот переход, намного перевешивают проблемы. Avalonia предоставляет современную, эффективную и кроссплатформенную среду разработки пользовательского интерфейса, особенно подходящую для разработчиков, которым необходимо развертывать приложения в нескольких операционных системах.

Как бывший Java-разработчик, вы обнаружите, что многие знакомые концепции и шаблоны имеют свои аналоги в Авалонии. Такие концепции, как объектно-ориентированное программирование, шаблон MVVM (похожий на MVC) и реактивное программирование, хорошо поддерживаются и реализуются в Avalonia. В то же время многие современные возможности языка C#, такие как async/await, LINQ, свойства и т. д., сделают ваш опыт программирования более приятным и эффективным.

Особого внимания заслуживает кроссплатформенность Avalonia. В нынешней среде Синьчуана стало особенно важно иметь возможность легко развертывать приложения в различных операционных системах, включая отечественные операционные системы. Avalonia предлагает для этого идеальное решение.

Кроме того, активное сообщество и растущая экосистема Авалонии предоставляют вам множество ресурсов и поддержки. Независимо от того, изучаете ли вы что-то новое, решаете проблему или ищете подходящие библиотеки и инструменты, вы найдете помощь в сообществе Avalonia.

Конечно, смена стеков технологий всегда требует времени и терпения. Однако, благодаря знаниям и передовому опыту, изложенным в этой статье, я уверен, что вы имеете полное представление об Авалонии и готовы начать это захватывающее путешествие.

Помните, что основные концепции программирования универсальны. Опыт и знания, которые вы накопите в JAVA, сыграют важную роль в процессе изучения и использования Avalonia. Сохраняйте открытый и обучающий ум, и вы обнаружите, что Авалония открывает для вас новый мир возможностей.

Наконец, я хотел бы призвать всех разработчиков, которые рассматривают возможность перехода с JAVA на Avalonia: смело делайте первый шаг. Начните небольшой проект и испытайте очарование Авалонии на себе. Вы обнаружите, что это изменение не только расширит ваш технический кругозор, но и откроет новые возможности для карьерного роста.

Желаю вам плодотворного путешествия с Avalonia и создания потрясающих кроссплатформенных приложений!