<!-- XAML の基本構文 -->
<Window
    x:Class="MyApp.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="My Application" Height="600" Width="800">
 
    <Grid>
        <!-- 行と列の定義 -->
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>
 
        <!-- ヘッダー -->
        <TextBlock Grid.Row="0" Text="ヘッダー"
                   FontSize="24" Margin="16" />
 
        <!-- コンテンツ -->
        <StackPanel Grid.Row="1" Margin="16">
            <TextBox x:Name="NameInput"
                     PlaceholderText="名前を入力"
                     Text="{x:Bind ViewModel.Name, Mode=TwoWay}" />
 
            <Button Content="挨拶"
                    Click="OnGreetClick"
                    Margin="0,8,0,0" />
 
            <TextBlock Text="{x:Bind ViewModel.Greeting, Mode=OneWay}"
                       Margin="0,16,0,0" />
        </StackPanel>
 
        <!-- フッター -->
        <TextBlock Grid.Row="2" Text="(C) 2024" Margin="16" />
    </Grid>
</Window>

<!-- 名前空間の詳細 -->
<Page
    <!-- デフォルトの XAML 名前空間（UI コントロール） -->
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 
    <!-- x: 名前空間（XAML 組み込み機能: x:Name, x:Class, x:Bind） -->
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 
    <!-- ローカルの名前空間（自作クラスの参照） -->
    xmlns:local="using:MyApp"
 
    <!-- ViewModel 名前空間 -->
    xmlns:vm="using:MyApp.ViewModels"
 
    <!-- CommunityToolkit のコントロール -->
    xmlns:toolkit="using:CommunityToolkit.WinUI.UI.Controls"
 
    <!-- デザイン時データ（実行時は無視される） -->
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="600"
    d:DesignWidth="800">
 
    <!-- ページ内容 -->
</Page>

<!-- StackPanel: 水平または垂直の直列配置 -->
<StackPanel Orientation="Vertical" Spacing="8">
    <TextBlock Text="項目1" />
    <TextBlock Text="項目2" />
    <TextBlock Text="項目3" />
</StackPanel>
 
<!-- Grid: 行と列のマトリックス配置 -->
<Grid ColumnSpacing="16" RowSpacing="8" Padding="24">
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="Auto" />   <!-- コンテンツに合わせる -->
        <ColumnDefinition Width="*" />      <!-- 残りのスペースを占有 -->
        <ColumnDefinition Width="2*" />     <!-- 残りの2倍 -->
        <ColumnDefinition Width="200" />    <!-- 固定幅 -->
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto" />
        <RowDefinition Height="*" />
    </Grid.RowDefinitions>
 
    <TextBlock Grid.Row="0" Grid.Column="0" Text="左上" />
    <TextBlock Grid.Row="0" Grid.Column="1" Grid.ColumnSpan="2" Text="2列にまたがる" />
    <TextBlock Grid.Row="1" Grid.Column="0" Grid.RowSpan="1" Text="左下" />
</Grid>
 
<!-- RelativePanel: 相対位置指定 -->
<RelativePanel>
    <TextBlock x:Name="Header" Text="ヘッダー"
               RelativePanel.AlignTopWithPanel="True"
               RelativePanel.AlignLeftWithPanel="True"
               RelativePanel.AlignRightWithPanel="True" />
 
    <TextBox x:Name="SearchBox"
             RelativePanel.Below="Header"
             RelativePanel.AlignLeftWithPanel="True"
             Width="300" Margin="0,8,0,0" />
 
    <Button Content="検索"
            RelativePanel.Below="Header"
            RelativePanel.RightOf="SearchBox"
            Margin="8,8,0,0" />
</RelativePanel>
 
<!-- Canvas: 絶対座標指定 -->
<Canvas Width="400" Height="300">
    <Rectangle Canvas.Left="10" Canvas.Top="10"
               Width="100" Height="80"
               Fill="Blue" />
    <Ellipse Canvas.Left="150" Canvas.Top="50"
             Width="80" Height="80"
             Fill="Red" />
</Canvas>

<!-- リソースの定義と使用 -->
<Page.Resources>
    <!-- 色の定義 -->
    <Color x:Key="PrimaryColor">#6366F1</Color>
    <SolidColorBrush x:Key="PrimaryBrush" Color="{StaticResource PrimaryColor}" />
 
    <!-- マージンの共通定義 -->
    <Thickness x:Key="StandardMargin">16,8,16,8</Thickness>
 
    <!-- 文字列リソース -->
    <x:String x:Key="AppTitle">マイアプリケーション</x:String>
 
    <!-- ボタンのスタイル定義 -->
    <Style x:Key="PrimaryButtonStyle" TargetType="Button">
        <Setter Property="Background" Value="{StaticResource PrimaryBrush}" />
        <Setter Property="Foreground" Value="White" />
        <Setter Property="CornerRadius" Value="8" />
        <Setter Property="Padding" Value="24,12" />
        <Setter Property="FontWeight" Value="SemiBold" />
    </Style>
 
    <!-- 暗黙的スタイル（x:Key なし → 全ての TextBlock に適用） -->
    <Style TargetType="TextBlock">
        <Setter Property="FontFamily" Value="Segoe UI" />
        <Setter Property="FontSize" Value="14" />
    </Style>
 
    <!-- スタイルの継承 -->
    <Style x:Key="DangerButtonStyle" TargetType="Button"
           BasedOn="{StaticResource PrimaryButtonStyle}">
        <Setter Property="Background" Value="#EF4444" />
    </Style>
</Page.Resources>
 
<!-- リソースの使用 -->
<StackPanel>
    <TextBlock Text="{StaticResource AppTitle}" />
    <Button Style="{StaticResource PrimaryButtonStyle}" Content="保存" />
    <Button Style="{StaticResource DangerButtonStyle}" Content="削除" />
</StackPanel>

<!-- x:Bind（コンパイル時バインディング） — WinUI 3 推奨 -->
<!-- 利点: 型安全、コンパイル時エラー検出、高速 -->
<TextBlock Text="{x:Bind ViewModel.Name, Mode=OneWay}" />
<TextBox Text="{x:Bind ViewModel.Email, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
<Button Command="{x:Bind ViewModel.SaveCommand}" />
 
<!-- Binding（ランタイムバインディング） — WPF 互換 -->
<!-- 利点: DataContext を経由した柔軟なバインディング -->
<TextBlock Text="{Binding Name}" />
<TextBox Text="{Binding Email, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
<Button Command="{Binding SaveCommand}" />
 
<!--
x:Bind vs Binding の比較:

-->

// ViewModel — INotifyPropertyChanged 実装（手動）
public class MainViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;
 
    private string _name = "";
    public string Name
    {
        get => _name;
        set
        {
            if (_name != value)
            {
                _name = value;
                OnPropertyChanged(nameof(Name));
                OnPropertyChanged(nameof(Greeting));
            }
        }
    }
 
    private string _email = "";
    public string Email
    {
        get => _email;
        set
        {
            if (_email != value)
            {
                _email = value;
                OnPropertyChanged(nameof(Email));
                OnPropertyChanged(nameof(IsValid));
            }
        }
    }
 
    public string Greeting => string.IsNullOrEmpty(Name)
        ? ""
        : $"Hello, {Name}!";
 
    public bool IsValid => !string.IsNullOrEmpty(Name) &&
                           !string.IsNullOrEmpty(Email) &&
                           Email.Contains('@');
 
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

// ObservableCollection を使ったリストバインディング
using System.Collections.ObjectModel;
 
public class TaskListViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;
 
    // ObservableCollection: 追加・削除が自動で UI に反映される
    public ObservableCollection<TaskItem> Tasks { get; } = new();
 
    private TaskItem? _selectedTask;
    public TaskItem? SelectedTask
    {
        get => _selectedTask;
        set
        {
            _selectedTask = value;
            OnPropertyChanged(nameof(SelectedTask));
            OnPropertyChanged(nameof(HasSelection));
        }
    }
 
    public bool HasSelection => SelectedTask != null;
 
    public void AddTask(string title)
    {
        Tasks.Add(new TaskItem { Title = title, CreatedAt = DateTime.Now });
    }
 
    public void RemoveTask(TaskItem task)
    {
        Tasks.Remove(task);
        if (SelectedTask == task) SelectedTask = null;
    }
 
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}
 
public class TaskItem : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler? PropertyChanged;
 
    private string _title = "";
    public string Title
    {
        get => _title;
        set { _title = value; PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Title))); }
    }
 
    private bool _isCompleted;
    public bool IsCompleted
    {
        get => _isCompleted;
        set { _isCompleted = value; PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(IsCompleted))); }
    }
 
    public DateTime CreatedAt { get; set; }
}

<!-- リストのバインディング -->
<ListView ItemsSource="{x:Bind ViewModel.Tasks}"
          SelectedItem="{x:Bind ViewModel.SelectedTask, Mode=TwoWay}">
    <ListView.ItemTemplate>
        <DataTemplate x:DataType="local:TaskItem">
            <StackPanel Orientation="Horizontal" Spacing="8" Padding="8">
                <CheckBox IsChecked="{x:Bind IsCompleted, Mode=TwoWay}" />
                <TextBlock Text="{x:Bind Title}" VerticalAlignment="Center" />
                <TextBlock Text="{x:Bind CreatedAt}" Opacity="0.6"
                           VerticalAlignment="Center" FontSize="12" />
            </StackPanel>
        </DataTemplate>
    </ListView.ItemTemplate>
</ListView>
 
<!-- 選択状態に応じた UI 表示制御 -->
<Button Content="削除"
        IsEnabled="{x:Bind ViewModel.HasSelection, Mode=OneWay}"
        Click="OnDeleteClick" />

// 値コンバーター: bool → Visibility 変換
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Data;
 
public class BoolToVisibilityConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, string language)
    {
        if (value is bool boolValue)
        {
            // parameter が "Invert" なら反転
            bool invert = parameter?.ToString() == "Invert";
            bool isVisible = invert ? !boolValue : boolValue;
            return isVisible ? Visibility.Visible : Visibility.Collapsed;
        }
        return Visibility.Collapsed;
    }
 
    public object ConvertBack(object value, Type targetType, object parameter, string language)
    {
        if (value is Visibility visibility)
        {
            bool invert = parameter?.ToString() == "Invert";
            bool result = visibility == Visibility.Visible;
            return invert ? !result : result;
        }
        return false;
    }
}
 
// 日付フォーマットコンバーター
public class DateFormatConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, string language)
    {
        if (value is DateTime dateTime)
        {
            string format = parameter?.ToString() ?? "yyyy/MM/dd HH:mm";
            return dateTime.ToString(format);
        }
        return value?.ToString() ?? "";
    }
 
    public object ConvertBack(object value, Type targetType, object parameter, string language)
    {
        if (value is string str && DateTime.TryParse(str, out var result))
        {
            return result;
        }
        return DateTime.MinValue;
    }
}
 
// 数値 → 色の変換（例: 優先度に応じた色）
public class PriorityToColorConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, string language)
    {
        if (value is string priority)
        {
            return priority switch
            {
                "high" => new SolidColorBrush(Windows.UI.Color.FromArgb(255, 239, 68, 68)),   // 赤
                "medium" => new SolidColorBrush(Windows.UI.Color.FromArgb(255, 245, 158, 11)), // 黄
                "low" => new SolidColorBrush(Windows.UI.Color.FromArgb(255, 34, 197, 94)),     // 緑
                _ => new SolidColorBrush(Windows.UI.Color.FromArgb(255, 156, 163, 175)),       // グレー
            };
        }
        return new SolidColorBrush(Windows.UI.Color.FromArgb(255, 156, 163, 175));
    }
 
    public object ConvertBack(object value, Type targetType, object parameter, string language)
    {
        throw new NotImplementedException();
    }
}

<!-- コンバーターの使用 -->
<Page.Resources>
    <local:BoolToVisibilityConverter x:Key="BoolToVisibility" />
    <local:DateFormatConverter x:Key="DateFormat" />
    <local:PriorityToColorConverter x:Key="PriorityColor" />
</Page.Resources>
 
<!-- Visibility の制御 -->
<ProgressRing Visibility="{x:Bind ViewModel.IsLoading, Mode=OneWay,
              Converter={StaticResource BoolToVisibility}}" />
 
<!-- 非表示にする場合は parameter に Invert を指定 -->
<TextBlock Text="データなし"
           Visibility="{x:Bind ViewModel.HasData, Mode=OneWay,
           Converter={StaticResource BoolToVisibility}, ConverterParameter=Invert}" />
 
<!-- 日付のフォーマット -->
<TextBlock Text="{x:Bind ViewModel.CreatedAt, Mode=OneWay,
           Converter={StaticResource DateFormat}, ConverterParameter='yyyy年MM月dd日'}" />
 
<!-- 優先度に応じた色表示 -->
<Border Background="{x:Bind Priority, Converter={StaticResource PriorityColor}}"
        CornerRadius="4" Padding="8,4">
    <TextBlock Text="{x:Bind Priority}" Foreground="White" />
</Border>

// CommunityToolkit.Mvvm を使った簡潔な ViewModel
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
 
public partial class MainViewModel : ObservableObject
{
    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(Greeting))]
    private string _name = "";
 
    public string Greeting => string.IsNullOrEmpty(Name)
        ? "" : $"Hello, {Name}!";
 
    [RelayCommand]
    private async Task SaveAsync()
    {
        await _fileService.SaveAsync(Name);
    }
}

// サービスの定義
public interface ITaskService
{
    Task<IReadOnlyList<TaskItem>> GetAllAsync();
    Task<TaskItem> CreateAsync(string title);
    Task UpdateAsync(TaskItem task);
    Task DeleteAsync(int id);
}
 
// サービスの実装
public class TaskService : ITaskService
{
    private readonly HttpClient _httpClient;
 
    public TaskService(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }
 
    public async Task<IReadOnlyList<TaskItem>> GetAllAsync()
    {
        var response = await _httpClient.GetAsync("/api/tasks");
        response.EnsureSuccessStatusCode();
        var tasks = await response.Content.ReadFromJsonAsync<List<TaskItem>>();
        return tasks ?? new List<TaskItem>();
    }
 
    public async Task<TaskItem> CreateAsync(string title)
    {
        var response = await _httpClient.PostAsJsonAsync("/api/tasks", new { title });
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<TaskItem>()
            ?? throw new InvalidOperationException("タスクの作成に失敗しました");
    }
 
    public async Task UpdateAsync(TaskItem task)
    {
        var response = await _httpClient.PutAsJsonAsync($"/api/tasks/{task.Id}", task);
        response.EnsureSuccessStatusCode();
    }
 
    public async Task DeleteAsync(int id)
    {
        var response = await _httpClient.DeleteAsync($"/api/tasks/{id}");
        response.EnsureSuccessStatusCode();
    }
}
 
// ViewModel: サービスを依存性注入で受け取る
public partial class TaskListViewModel : ObservableObject
{
    private readonly ITaskService _taskService;
 
    public TaskListViewModel(ITaskService taskService)
    {
        _taskService = taskService;
    }
 
    [ObservableProperty]
    private ObservableCollection<TaskItem> _tasks = new();
 
    [ObservableProperty]
    private bool _isLoading;
 
    [ObservableProperty]
    [NotifyCanExecuteChangedFor(nameof(DeleteTaskCommand))]
    private TaskItem? _selectedTask;
 
    [ObservableProperty]
    private string _newTaskTitle = "";
 
    [RelayCommand]
    private async Task LoadTasksAsync()
    {
        try
        {
            IsLoading = true;
            var tasks = await _taskService.GetAllAsync();
            Tasks = new ObservableCollection<TaskItem>(tasks);
        }
        catch (Exception ex)
        {
            // エラーハンドリング
            Debug.WriteLine($"タスク読み込みエラー: {ex.Message}");
        }
        finally
        {
            IsLoading = false;
        }
    }
 
    [RelayCommand]
    private async Task AddTaskAsync()
    {
        if (string.IsNullOrWhiteSpace(NewTaskTitle)) return;
 
        var task = await _taskService.CreateAsync(NewTaskTitle);
        Tasks.Add(task);
        NewTaskTitle = "";
    }
 
    private bool CanDeleteTask() => SelectedTask != null;
 
    [RelayCommand(CanExecute = nameof(CanDeleteTask))]
    private async Task DeleteTaskAsync()
    {
        if (SelectedTask == null) return;
 
        await _taskService.DeleteAsync(SelectedTask.Id);
        Tasks.Remove(SelectedTask);
        SelectedTask = null;
    }
}

// App.xaml.cs — DI コンテナの設定
using Microsoft.Extensions.DependencyInjection;
using Microsoft.UI.Xaml;
 
public partial class App : Application
{
    public IServiceProvider Services { get; }
    public static new App Current => (App)Application.Current;
 
    public App()
    {
        this.InitializeComponent();
 
        // DI コンテナの構築
        var services = new ServiceCollection();
 
        // サービスの登録
        services.AddHttpClient<ITaskService, TaskService>(client =>
        {
            client.BaseAddress = new Uri("https://api.example.com");
        });
 
        // ViewModel の登録
        services.AddTransient<MainViewModel>();
        services.AddTransient<TaskListViewModel>();
        services.AddTransient<SettingsViewModel>();
 
        // ナビゲーションサービスの登録
        services.AddSingleton<INavigationService, NavigationService>();
 
        Services = services.BuildServiceProvider();
    }
 
    protected override void OnLaunched(LaunchActivatedEventArgs args)
    {
        var window = new MainWindow();
        window.Activate();
    }
}
 
// ページでの ViewModel 取得
public sealed partial class TaskListPage : Page
{
    public TaskListViewModel ViewModel { get; }
 
    public TaskListPage()
    {
        ViewModel = App.Current.Services.GetRequiredService<TaskListViewModel>();
        this.InitializeComponent();
 
        // ページ読み込み時にデータを取得
        Loaded += async (_, _) => await ViewModel.LoadTasksCommand.ExecuteAsync(null);
    }
}

// WPF: MainWindow.xaml.cs
using System.Windows;
 
namespace WpfApp;
 
public partial class MainWindow : Window
{
    public MainViewModel ViewModel { get; }
 
    public MainWindow()
    {
        ViewModel = new MainViewModel();
        DataContext = ViewModel;
        InitializeComponent();
    }
}

<!-- WPF: MainWindow.xaml -->
<Window x:Class="WpfApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="WPF App" Height="400" Width="600">
    <StackPanel Margin="16">
        <!-- WPF では Binding（ランタイム）を使用 -->
        <TextBox Text="{Binding Name, UpdateSourceTrigger=PropertyChanged}"
                 Margin="0,0,0,8" />
        <Button Content="挨拶" Command="{Binding GreetCommand}"
                Margin="0,0,0,8" />
        <TextBlock Text="{Binding Greeting}" FontSize="18" />
    </StackPanel>
</Window>

// WinUI 3: MainWindow.xaml.cs
using Microsoft.UI.Xaml;
 
namespace WinUIApp;
 
public sealed partial class MainWindow : Window
{
    public MainViewModel ViewModel { get; } = new();
 
    public MainWindow()
    {
        this.InitializeComponent();
    }
}

<!-- WinUI 3: MainWindow.xaml -->
<Window x:Class="WinUIApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="WinUI 3 App">
    <StackPanel Margin="16" Spacing="8">
        <!-- WinUI 3 では x:Bind（コンパイル時）を推奨 -->
        <TextBox Text="{x:Bind ViewModel.Name, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
        <Button Content="挨拶" Command="{x:Bind ViewModel.GreetCommand}" />
        <TextBlock Text="{x:Bind ViewModel.Greeting, Mode=OneWay}"
                   Style="{StaticResource SubtitleTextBlockStyle}" />
    </StackPanel>
</Window>

// MAUI: MainPage.xaml.cs
namespace MauiApp;
 
public partial class MainPage : ContentPage
{
    public MainViewModel ViewModel { get; } = new();
 
    public MainPage()
    {
        BindingContext = ViewModel;
        InitializeComponent();
    }
}

<!-- MAUI: MainPage.xaml -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="MauiApp.MainPage">
    <VerticalStackLayout Spacing="8" Padding="16">
        <!-- MAUI では Binding を使用 -->
        <Entry Text="{Binding Name}" Placeholder="名前を入力" />
        <Button Text="挨拶" Command="{Binding GreetCommand}" />
        <Label Text="{Binding Greeting}" FontSize="18" />
    </VerticalStackLayout>
</ContentPage>

// Before: Windows Forms のイベント駆動スタイル
// ボタンクリック → 直接 DB 操作 → UI 更新
public partial class OrderForm : Form
{
    private void btnSubmit_Click(object sender, EventArgs e)
    {
        // ビジネスロジックが UI に密結合
        var order = new Order
        {
            CustomerName = txtCustomerName.Text,
            Amount = decimal.Parse(txtAmount.Text),
        };
 
        using var conn = new SqlConnection(connectionString);
        conn.Open();
        // ... SQL 実行
 
        lblStatus.Text = "注文が完了しました";
        txtCustomerName.Text = "";
        txtAmount.Text = "";
    }
}

// After: MVVM パターン（WPF / WinUI 3）
// ViewModel: UI から完全に独立したロジック
public partial class OrderViewModel : ObservableObject
{
    private readonly IOrderService _orderService;
 
    public OrderViewModel(IOrderService orderService)
    {
        _orderService = orderService;
    }
 
    [ObservableProperty]
    private string _customerName = "";
 
    [ObservableProperty]
    private string _amount = "";
 
    [ObservableProperty]
    private string _statusMessage = "";
 
    [RelayCommand]
    private async Task SubmitOrderAsync()
    {
        if (!decimal.TryParse(Amount, out var amountValue))
        {
            StatusMessage = "金額が不正です";
            return;
        }
 
        var order = new Order
        {
            CustomerName = CustomerName,
            Amount = amountValue,
        };
 
        await _orderService.CreateAsync(order);
        StatusMessage = "注文が完了しました";
        CustomerName = "";
        Amount = "";
    }
}

// WinUI 3 でのアクセシビリティ実装例
// AutomationProperties で支援技術に情報を提供

<!-- アクセシビリティ対応の XAML -->
<StackPanel>
    <!-- スクリーンリーダー向けの名前設定 -->
    <TextBox
        AutomationProperties.Name="ユーザー名入力欄"
        AutomationProperties.HelpText="ログインに使用するユーザー名を入力してください"
        PlaceholderText="ユーザー名" />
 
    <!-- ランドマークの設定 -->
    <NavigationView
        AutomationProperties.LandmarkType="Navigation"
        AutomationProperties.Name="メインナビゲーション">
        <!-- ... -->
    </NavigationView>
 
    <!-- ライブリージョン（動的に変化するテキスト） -->
    <TextBlock
        x:Name="StatusText"
        AutomationProperties.LiveSetting="Polite"
        AutomationProperties.Name="ステータスメッセージ" />
 
    <!-- 高コントラストモード対応 -->
    <Button Content="保存"
            Style="{ThemeResource AccentButtonStyle}">
        <!-- ThemeResource を使用すれば高コントラストモードに自動対応 -->
    </Button>
 
    <!-- キーボードナビゲーション -->
    <Grid KeyboardAcceleratorPlacementMode="Hidden">
        <Grid.KeyboardAccelerators>
            <KeyboardAccelerator Key="S" Modifiers="Control"
                                 Invoked="SaveAccelerator_Invoked" />
        </Grid.KeyboardAccelerators>
    </Grid>
</StackPanel>

// タブオーダーの制御
public sealed partial class LoginPage : Page
{
    public LoginPage()
    {
        InitializeComponent();
 
        // タブオーダーの明示的な設定
        UsernameBox.TabIndex = 1;
        PasswordBox.TabIndex = 2;
        LoginButton.TabIndex = 3;
        ForgotPasswordLink.TabIndex = 4;
 
        // フォーカスの初期設定
        Loaded += (_, _) => UsernameBox.Focus(FocusState.Programmatic);
    }
}

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md