<UserControl x:Class="TradingApp.StockTickerView">
    <Grid>
        <VisualStateManager.VisualStateGroups>
            <VisualStateGroup x:Name="PriceStates">
                <VisualState x:Name="PriceUp">
                    <Storyboard>
                        <ColorAnimation Storyboard.TargetName="PricePanel"
                                      Storyboard.TargetProperty="Background.Color"
                                      To="LightGreen" Duration="0:0:0.3"/>
                        <DoubleAnimation Storyboard.TargetName="ArrowUp"
                                       Storyboard.TargetProperty="Opacity"
                                       To="1" Duration="0:0:0.3"/>
                    </Storyboard>
                </VisualState>
                <VisualState x:Name="PriceDown">
                    <Storyboard>
                        <ColorAnimation Storyboard.TargetName="PricePanel"
                                      Storyboard.TargetProperty="Background.Color"
                                      To="LightPink" Duration="0:0:0.3"/>
                        <DoubleAnimation Storyboard.TargetName="ArrowDown"
                                       Storyboard.TargetProperty="Opacity"
                                       To="1" Duration="0:0:0.3"/>
                    </Storyboard>
                </VisualState>
            </VisualStateGroup>
        </VisualStateManager.VisualStateGroups>
        <i:Interaction.Triggers>
            <ei:DataTrigger Binding="{Binding PriceDirection}" Value="Up">
                <ei:GoToStateAction StateName="PriceUp"/>
            </ei:DataTrigger>
            <ei:DataTrigger Binding="{Binding PriceDirection}" Value="Down">
                <ei:GoToStateAction StateName="PriceDown"/>
            </ei:DataTrigger>
        </i:Interaction.Triggers>
        <Border x:Name="PricePanel">
            <TextBlock Text="{Binding Price, StringFormat=C}"/>
        </Border>
    </Grid>
</UserControl>

<Window x:Class="DashboardApp.MainWindow">
    <Grid>
        <ComboBox x:Name="RegionSelector" 
                  ItemsSource="{Binding Regions}"
                  SelectedItem="{Binding SelectedRegion}"/>
        <TabControl>
            <TabItem Header="Sales" 
                     Visibility="{Binding SelectedRegion.HasSalesData, 
                                         Converter={StaticResource BoolToVisibility}}">
                <DataGrid ItemsSource="{Binding SelectedRegion.SalesData}"/>
            </TabItem>
            <TabItem Header="Inventory">
                <StackPanel>
                    <ComboBox ItemsSource="{Binding SelectedRegion.Warehouses}"
                            SelectedItem="{Binding SelectedWarehouse}"/>
                    <DataGrid ItemsSource="{Binding SelectedWarehouse.Products}">
                        <DataGrid.RowDetailsTemplate>
                            <DataTemplate>
                                <ItemsControl ItemsSource="{Binding StockMovements}"/>
                            </DataTemplate>
                        </DataGrid.RowDetailsTemplate>
                    </DataGrid>
                </StackPanel>
            </TabItem>
        </TabControl>
        <TextBlock>
            <TextBlock.Text>
                <MultiBinding StringFormat="Region: {0}, Sales: {1:C}, Products: {2}">
                    <Binding Path="SelectedRegion.Name"/>
                    <Binding Path="SelectedRegion.TotalSales"/>
                    <Binding Path="SelectedWarehouse.Products.Count"/>
                </MultiBinding>
            </TextBlock.Text>
        </TextBlock>
    </Grid>
</Window>

public class OrderViewModel : ViewModelBase
{
    private readonly IOrderService _orderService;
    private bool _isProcessing;

    public OrderViewModel(IOrderService orderService)
    {
        _orderService = orderService;
        SubmitOrderCommand = new RelayCommand(
            execute: async () => await SubmitOrderAsync(),
            canExecute: () => !_isProcessing && IsOrderValid()
        );
        PropertyChanged += (s, e) =>
        {
            if (e.PropertyName == nameof(IsProcessing) || 
                e.PropertyName == nameof(OrderItems))
            {
                SubmitOrderCommand.RaiseCanExecuteChanged();
            }
        };
    }

    public ICommand SubmitOrderCommand { get; }

    private async Task SubmitOrderAsync()
    {
        IsProcessing = true;
        try
        {
            var order = await _orderService.SubmitOrderAsync(OrderItems);
            OrderConfirmation = order;
            OrderItems.Clear();
        }
        catch (Exception ex)
        {
            ErrorMessage = ex.Message;
            ErrorVisibility = Visibility.Visible;
        }
        finally
        {
            IsProcessing = false;
        }
    }
}

public class WeatherViewModel : ViewModelBase
{
    private readonly IWeatherService _weatherService;

    public WeatherViewModel()
    {
        RefreshCommand = new RelayCommand(async () => await RefreshWeatherAsync());
        InitializeAutoRefresh();
    }

    private void InitializeAutoRefresh()
    {
        var timer = new DispatcherTimer { Interval = TimeSpan.FromMinutes(5) };
        timer.Tick += async (s, e) =>
        {
            if (AutoRefreshEnabled)
                await RefreshWeatherAsync();
        };
        timer.Start();
    }

    private async Task RefreshWeatherAsync()
    {
        IsRefreshing = true;
        try
        {
            var location = await _locationService.GetCurrentLocationAsync();
            var weather = await _weatherService.GetWeatherAsync(location);
            CurrentWeather = weather;
        }
        finally
        {
            IsRefreshing = false;
        }
    }
}

public class StockPortfolioViewModel : ViewModelBase, IDisposable
{
    private readonly IStockPriceService _priceService;
    public ObservableCollection<StockViewModel> Stocks { get; }

    public StockPortfolioViewModel(IStockPriceService priceService)
    {
        _priceService = priceService;
        Stocks = new ObservableCollection<StockViewModel>();
        var subscription = _priceService.PriceUpdates.Subscribe(update =>
        {
            var stock = Stocks.FirstOrDefault(s => s.Symbol == update.Symbol);
            if (stock != null)
            {
                stock.Price = update.Price;
            }
        });
    }
}

public class OrderPlacedMessage
{
    public Order Order { get; set; }
}

public class OrderViewModel : ViewModelBase
{
    private readonly IMessenger _messenger;

    private async Task PlaceOrderAsync()
    {
        var order = await _orderService.CreateOrderAsync(Items);
        _messenger.Send(new OrderPlacedMessage { Order = order });
    }
}

public class DashboardViewModel : ViewModelBase
{
    public DashboardViewModel(IMessenger messenger)
    {
        messenger.Register<OrderPlacedMessage>(this, message =>
        {
            RecentOrders.Insert(0, new OrderSummary(message.Order));
        });
    }
}

public class CustomerManagementViewModel : ViewModelBase
{
    private readonly ICustomerRepository _repository;

    public CustomerManagementViewModel(ICustomerRepository repository)
    {
        _repository = repository;
        LoadCustomersCommand = new RelayCommand(async () => await LoadCustomersAsync());
    }
}

public class RegistrationViewModel : ValidatableViewModelBase
{
    public string Email
    {
        get => _email;
        set
        {
            if (SetProperty(ref _email, value))
            {
                ValidateProperty();
            }
        }
    }
}