دوره ASP.NET Core: Background Services همراه با فلش‌کارت آموزشی — ارائه روی فلش مموری

🎓 دوره آموزشی جامع

📚 اطلاعات دوره

عنوان دوره: دوره ASP.NET Core: Background Services

موضوع کلی: برنامه نویسی

موضوع میانی: ای‌اس‌پی دات نت کور (ASP.NET Core)

📋 سرفصل‌های دوره

• 1. Introduction to Background Services
• 2. Why Background Services? Use Cases
• 3. Synchronous vs. Asynchronous Operations
• 4. Understanding `IHost` and `IHostBuilder`
• 5. Dependency Injection Basics in ASP.NET Core
• 6. `Microsoft.Extensions.Hosting` Namespace
• 7. The Role of `IHostedService`
• 8. Building Your First `IHostedService`
• 9. `StartAsync` and `StopAsync` Methods
• 10. `CancellationToken` for Graceful Shutdown
• 11. Introducing the `BackgroundService` Base Class
• 12. Implementing `BackgroundService` with `ExecuteAsync`
• 13. Differences Between `IHostedService` and `BackgroundService`
• 14. Looping Tasks in `ExecuteAsync`
• 15. Handling Delays in Background Tasks
• 16. Basic Logging within Background Services
• 17. Configuration Access in `BackgroundService`
• 18. Injecting Dependencies into `BackgroundService`
• 19. Running Multiple Background Services
• 20. Order of Execution for `IHostedService`
• 21. Introduction to Queued Background Tasks
• 22. The Producer-Consumer Pattern
• 23. Implementing an In-Memory Background Task Queue
• 24. `System.Threading.Channels` for Queues
• 25. `Channel<T>` Basics: Readers and Writers
• 26. Creating a `Channel<T>`-based `IBackgroundTaskQueue`
• 27. Enqueuing Work Items: The Producer
• 28. Dequeuing and Processing Work Items: The Consumer Service
• 29. Handling Concurrent Queue Processing
• 30. Error Handling in Queued Tasks
• 31. Limiting Queue Size and Backpressure
• 32. Using `ConcurrentQueue<T>` (for simpler scenarios)
• 33. Task Item Prioritization in Queues
• 34. Monitoring Queue Length
• 35. Scoped Services within Queued Tasks
• 36. Long-Running Operations and Blocking Calls
• 37. Asynchronous Best Practices for `ExecuteAsync`
• 38. Handling Application Shutdown Events
• 39. `HostApplicationLifetime` Interface
• 40. Registering Shutdown Callbacks
• 41. Resource Cleanup During `StopAsync`
• 42. `IHostLifetime` Interface
• 43. Waiting for Tasks to Complete on Shutdown
• 44. Preventing Deadlocks in Shutdown
• 45. Debugging Background Service Lifecycles
• 46. Accessing `IConfiguration` in Background Services
• 47. Loading Custom Configuration Sections
• 48. The Options Pattern (`IOptions<T>`)
• 49. Creating Custom Options Classes
• 50. Registering Options in `Program.cs`
• 51. Using `IOptionsMonitor<T>` for Reloadable Options
• 52. `IOptionsSnapshot<T>` for Scoped Options
• 53. Validating Options for Background Services
• 54. Environment-Specific Configuration
• 55. Storing Secrets for Background Services
• 56. Comprehensive Error Logging with `ILogger`
• 57. Structured Logging for Background Tasks
• 58. Handling Unhandled Exceptions in `ExecuteAsync`
• 59. Implementing Retry Logic (e.g., custom, Polly)
• 60. The Polly Library: An Introduction
• 61. Circuit Breaker Pattern for External Dependencies
• 62. Timeout Strategies for Long-Running Operations
• 63. Health Checks for Background Services
• 64. Custom Health Check Implementations
• 65. Integrating with Monitoring Tools (e.g., Prometheus)
• 66. Making HTTP Requests from Background Services (`HttpClient`)
• 67. Using `IHttpClientFactory` for HTTP Client Management
• 68. Database Operations with Entity Framework Core
• 69. Managing Database Context Lifetimes
• 70. Working with Message Queues (e.g., RabbitMQ, Azure Service Bus)
• 71. Sending Messages from Background Services
• 72. Consuming Messages in Background Services
• 73. Integrating with Third-Party APIs
• 74. Asynchronous File System Operations
• 75. Securing External Interactions (API Keys, OAuth)
• 76. Simple Time-Based Scheduling
• 77. Introduction to Cron Expressions
• 78. Implementing a Custom Cron Scheduler
• 79. Introduction to Quartz.NET
• 80. Setting up Quartz.NET in ASP.NET Core
• 81. Defining Jobs and Triggers in Quartz.NET
• 82. Persisting Quartz.NET Job Store (Database)
• 83. Introduction to Hangfire
• 84. Integrating Hangfire for Persistent Background Jobs
• 85. Advantages and Disadvantages of External Schedulers
• 86. Unit Testing `ExecuteAsync` Logic
• 87. Mocking Dependencies for Unit Tests
• 88. Integration Testing Background Services
• 89. Using `WebApplicationFactory` for Hosting Integration Tests
• 90. Deploying Background Services as Windows Services
• 91. Hosting Background Services as Linux Daemons
• 92. Containerizing Background Services with Docker
• 93. Deploying to Azure App Service as WebJobs (or Hosted Services)
• 94. Orchestrating Background Services with Kubernetes
• 95. Scaling Background Services Horizontally
• 96. Handling Idempotency in Background Tasks
• 97. Distributed Transaction Management (Conceptual)
• 98. Performance Considerations for Background Services
• 99. Best Practices for Developing Robust Background Services
• 100. Future Trends in ASP.NET Core Background Processing