// MVC: Clear sequential flow with explicit orchestration public class OrderController : Controller { public async Task<IActionResult> ProcessOrder(OrderDto order) { // Step 1: Validate if (!ModelState.IsValid) return BadRequest(ModelState); // Step 2: Check inventory var inventoryResult = await _inventoryService.CheckAsync(order.Items); if (!inventoryResult.Available) return View("OutOfStock", inventoryResult); // Step 3: Process payment var paymentResult = await _paymentService.ProcessAsync(order.Payment); if (!paymentResult.Success) return View("PaymentFailed", paymentResult); // Step 4: Create order var confirmedOrder = await _orderService.CreateAsync(order, paymentResult); // Step 5: Return result return View("OrderConfirmation", confirmedOrder); } } 

// MVVM: Multiple simultaneous reactive flows public class OrderViewModel : ViewModelBase { public OrderViewModel() { // Flow 1: User input triggers validation PropertyChanged += (s, e) => { if (IsOrderProperty(e.PropertyName)) ValidateOrderAsync().FireAndForget(); }; // Flow 2: Validation triggers UI updates ValidationErrors.CollectionChanged += (s, e) => { OnPropertyChanged(nameof(CanSubmit)); OnPropertyChanged(nameof(ValidationSummary)); }; // Flow 3: External events update state _inventoryService.StockChanged += async (s, e) => { await Application.Current.Dispatcher.InvokeAsync(() => { UpdateAvailability(e.Items); RecalculateTotals(); }); }; // Flow 4: Commands trigger complex operations SubmitCommand = new RelayCommand( async () => await ProcessOrderAsync(), () => CanSubmit ); } // Multiple flows can trigger this simultaneously private async Task RecalculateTotals() { Subtotal = Items.Sum(i => i.Price * i.Quantity); Tax = await _taxService.CalculateAsync(Subtotal, ShippingAddress); Shipping = await _shippingService.CalculateAsync(Items, ShippingAddress); Total = Subtotal + Tax + Shipping; // Each property change triggers more flows } } 

// MVC: Performance is largely about optimizing the pipeline public class PerformantController : Controller { private readonly IMemoryCache _cache; [HttpGet("products")] [ResponseCache(Duration = 300)] public async Task<IActionResult> GetProducts( int page = 1, int pageSize = 20, string category = null) { // Performance optimization points: // 1. Database query optimization var query = _context.Products .Include(p => p.Category) // Eager loading .AsNoTracking(); // Read-only optimization if (!string.IsNullOrEmpty(category)) query = query.Where(p => p.Category.Name == category); // 2. Pagination at database level var products = await query .Skip((page - 1) * pageSize) .Take(pageSize) .ToListAsync(); // 3. Response caching Response.Headers.Add("X-Total-Count", await GetTotalCountAsync(category)); // 4. Minimal serialization var dto = products.Select(p => new ProductDto { Id = p.Id, Name = p.Name, Price = p.Price // Only include requested fields }); return Ok(dto); } private async Task<string> GetTotalCountAsync(string category) { // Cache frequently accessed counts var cacheKey = $"product-count-{category ?? "all"}"; if (!_cache.TryGetValue(cacheKey, out int count)) { count = await _context.Products .Where(p => category == null || p.Category.Name == category) .CountAsync(); _cache.Set(cacheKey, count, TimeSpan.FromMinutes(5)); } return count.ToString(); } } 

// MVVM: Performance is about managing binding overhead and change propagation public class PerformantViewModel : ViewModelBase { private readonly DispatcherTimer _updateTimer; private readonly List<PriceUpdate> _pendingUpdates = new(); private bool _isBatchUpdating; public PerformantViewModel() { // Batch updates to prevent UI flooding _updateTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(100) }; _updateTimer.Tick += ProcessBatchUpdates; } // Problem: Naive implementation causes performance issues public decimal TotalValue_Naive => Items.Sum(i => i.Quantity * i.Price); // Recalculates on every access! // Solution: Cached calculation with explicit invalidation private decimal? _totalValueCache; public decimal TotalValue { get { if (!_totalValueCache.HasValue) { _totalValueCache = Items.Sum(i => i.Quantity * i.Price); } return _totalValueCache.Value; } } // Virtualization for large collections public VirtualizingObservableCollection<ItemViewModel> Items { get; } // Suspend notifications during bulk operations public async Task LoadItemsAsync() { using (Items.SuspendNotifications()) { Items.Clear(); var data = await _service.GetItemsAsync(); foreach (var item in data) { Items.Add(new ItemViewModel(item)); } } // Single CollectionChanged event fired here InvalidateTotalValue(); } // Throttle high-frequency updates public void OnPriceUpdate(PriceUpdate update) { lock (_pendingUpdates) { _pendingUpdates.Add(update); if (!_updateTimer.IsEnabled) _updateTimer.Start(); } } private void ProcessBatchUpdates(object sender, EventArgs e) { _updateTimer.Stop(); List<PriceUpdate> updates; lock (_pendingUpdates) { updates = new List<PriceUpdate>(_pendingUpdates); _pendingUpdates.Clear(); } // Process all updates in one UI update cycle using (DeferPropertyChanges()) { foreach (var update in updates) { var item = Items.FirstOrDefault(i => i.Id == update.ItemId); if (item != null) { item.Price = update.NewPrice; } } InvalidateTotalValue(); } } private void InvalidateTotalValue() { _totalValueCache = null; OnPropertyChanged(nameof(TotalValue)); } } // Helper for managing binding performance public class VirtualizingObservableCollection<T> : ObservableCollection<T> { private bool _suppressNotification; public IDisposable SuspendNotifications() { _suppressNotification = true; return new NotificationSuspender(this); } protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) { if (!_suppressNotification) base.OnCollectionChanged(e); } private class NotificationSuspender : IDisposable { private readonly VirtualizingObservableCollection<T> _collection; public NotificationSuspender(VirtualizingObservableCollection<T> collection) { _collection = collection; } public void Dispose() { _collection._suppressNotification = false; _collection.OnCollectionChanged( new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Reset)); } } } 

// MVC: Test controllers in isolation with mocked dependencies [TestClass] public class OrderControllerTests { private OrderController _controller; private Mock<IOrderService> _orderServiceMock; private Mock<IInventoryService> _inventoryServiceMock; [TestInitialize] public void Setup() { _orderServiceMock = new Mock<IOrderService>(); _inventoryServiceMock = new Mock<IInventoryService>(); _controller = new OrderController( _orderServiceMock.Object, _inventoryServiceMock.Object ); } [TestMethod] public async Task ProcessOrder_WithValidOrder_ReturnsConfirmation() { // Arrange var order = new OrderDto { /* ... */ }; _inventoryServiceMock .Setup(x => x.CheckAsync(It.IsAny<List<OrderItem>>())) .ReturnsAsync(new InventoryResult { Available = true }); _orderServiceMock .Setup(x => x.CreateAsync(It.IsAny<OrderDto>(), It.IsAny<PaymentResult>())) .ReturnsAsync(new Order { Id = 123 }); // Act var result = await _controller.ProcessOrder(order); // Assert Assert.IsInstanceOfType(result, typeof(ViewResult)); var viewResult = (ViewResult)result; Assert.AreEqual("OrderConfirmation", viewResult.ViewName); Assert.IsNotNull(viewResult.Model); // Verify service calls occurred in correct order _inventoryServiceMock.Verify(x => x.CheckAsync(It.IsAny<List<OrderItem>>()), Times.Once); _orderServiceMock.Verify(x => x.CreateAsync(It.IsAny<OrderDto>(), It.IsAny<PaymentResult>()), Times.Once); } [TestMethod] public async Task ProcessOrder_Pipeline_Integration_Test() { // Integration test with actual middleware pipeline using var factory = new WebApplicationFactory<Startup>() .WithWebHostBuilder(builder => { builder.ConfigureServices(services => { // Replace real services with test doubles services.AddSingleton<IOrderService>(_orderServiceMock.Object); }); }); var client = factory.CreateClient(); // Test complete request/response cycle var response = await client.PostAsJsonAsync("/orders", new OrderDto()); Assert.AreEqual(HttpStatusCode.OK, response.StatusCode); // Verify middleware executed Assert.IsTrue(response.Headers.Contains("X-Processing-Time")); } } 

// MVVM: Test ViewModels with focus on property changes and commands [TestClass] public class OrderViewModelTests { private OrderViewModel _viewModel; private Mock<IOrderService> _orderServiceMock; private List<string> _propertyChanges; [TestInitialize] public void Setup() { _orderServiceMock = new Mock<IOrderService>(); _viewModel = new OrderViewModel(_orderServiceMock.Object); _propertyChanges = new List<string>(); _viewModel.PropertyChanged += (s, e) => _propertyChanges.Add(e.PropertyName); } [TestMethod] public async Task OrderTotal_UpdatesWhen_ItemsChange() { // Arrange _viewModel.Items.Add(new OrderItemViewModel { Price = 10, Quantity = 2 }); _propertyChanges.Clear(); // Act - Change quantity _viewModel.Items[0].Quantity = 3; // Assert - Verify cascade of property changes CollectionAssert.Contains(_propertyChanges, nameof(_viewModel.Subtotal)); CollectionAssert.Contains(_propertyChanges, nameof(_viewModel.Total)); Assert.AreEqual(30, _viewModel.Total); } [TestMethod] public void SubmitCommand_CanExecute_DependsOnValidation() { // Arrange var canExecuteChangedCount = 0; _viewModel.SubmitCommand.CanExecuteChanged += (s, e) => canExecuteChangedCount++; // Act - Trigger validation state change _viewModel.CustomerEmail = "invalid"; // Assert Assert.IsFalse(_viewModel.SubmitCommand.CanExecute(null)); Assert.IsTrue(canExecuteChangedCount > 0); // Act - Fix validation _viewModel.CustomerEmail = "valid@email.com"; // Assert Assert.IsTrue(_viewModel.SubmitCommand.CanExecute(null)); } [TestMethod] public async Task SimultaneousFlows_HandleCorrectly() { // Test multiple flows interacting var priceUpdateTask = Task.Run(() => { for (int i = 0; i < 100; i++) { _viewModel.UpdatePrice(i, Random.Shared.Next(1, 100)); } }); var validationTask = Task.Run(() => { for (int i = 0; i < 100; i++) { _viewModel.ValidateAsync().Wait(); } }); await Task.WhenAll(priceUpdateTask, validationTask); // Assert no race conditions or exceptions Assert.IsTrue(_viewModel.IsValid); Assert.AreEqual(100, _viewModel.Items.Count); } } // Testing binding behavior requires UI framework [TestClass] public class OrderViewIntegrationTests { [TestMethod] [STAThread] public void Binding_Updates_BothDirections() { // Requires UI thread context var viewModel = new OrderViewModel(); var view = new OrderView { DataContext = viewModel }; // Test View → ViewModel var textBox = view.FindControl<TextBox>("CustomerEmail"); textBox.Text = "test@example.com"; Assert.AreEqual("test@example.com", viewModel.CustomerEmail); // Test ViewModel → View viewModel.CustomerEmail = "updated@example.com"; Assert.AreEqual("updated@example.com", textBox.Text); } } 

// MVC: Memory is typically managed per request public class MemoryEfficientController : Controller { private readonly IDbContextFactory<AppDbContext> _contextFactory; // Scoped lifetime - disposed after request public async Task<IActionResult> GetLargeDataset() { // Context disposed automatically via DI container using var context = _contextFactory.CreateDbContext(); // Stream large results to avoid loading all in memory var query = context.LargeTable .Where(x => x.IsActive) .AsAsyncEnumerable(); // Use streaming response Response.ContentType = "application/json"; await Response.StartAsync(); await using var writer = new Utf8JsonWriter(Response.BodyWriter); writer.WriteStartArray(); await foreach (var item in query) { writer.WriteStartObject(); writer.WriteString("id", item.Id); writer.WriteString("name", item.Name); writer.WriteEndObject(); await writer.FlushAsync(); } writer.WriteEndArray(); await writer.FlushAsync(); return new EmptyResult(); } } 

// MVVM: Long-lived ViewModels require careful memory management public class MemoryAwareViewModel : ViewModelBase, IDisposable { private readonly CompositeDisposable _disposables = new(); private readonly WeakEventManager _eventManager = new(); public MemoryAwareViewModel() { // Problem: Strong event handlers cause memory leaks // BAD: _service.DataChanged += OnDataChanged; // Solution 1: Weak events WeakEventManager<IDataService, DataChangedEventArgs> .AddHandler(_service, nameof(IDataService.DataChanged), OnDataChanged); // Solution 2: Reactive Extensions with disposal var subscription = Observable .FromEventPattern<DataChangedEventArgs>(_service, nameof(IDataService.DataChanged)) .Throttle(TimeSpan.FromMilliseconds(100)) .ObserveOnDispatcher() .Subscribe(e => OnDataChanged(e.Sender, e.EventArgs)); _disposables.Add(subscription); // Solution 3: Weak references for child ViewModels InitializeChildViewModels(); } private void InitializeChildViewModels() { // Use weak references to prevent circular references var children = new List<WeakReference>(); foreach (var model in _models) { var childVm = new ChildViewModel(model); // Weak reference allows garbage collection children.Add(new WeakReference(childVm)); // Child can be GC'd even if parent is alive ChildViewModels.Add(childVm); } } // Implement IDisposable properly private bool _disposed; public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (_disposed) return; if (disposing) { // Dispose managed resources _disposables?.Dispose(); // Unsubscribe from events WeakEventManager<IDataService, DataChangedEventArgs> .RemoveHandler(_service, nameof(IDataService.DataChanged), OnDataChanged); // Clear collections ChildViewModels?.Clear(); } _disposed = true; } }