From 6cdebce6d64a22a9f0af4a482b6515e7ee46f63c Mon Sep 17 00:00:00 2001
From: ShadyNagy <shadynagi@gmail.com>
Date: Sat, 23 Mar 2024 00:07:35 +0200
Subject: [PATCH] V1.0.8

---
 DynamicDiToolkit.nuspec                       |  2 +-
 README.md                                     | 23 +++++++++++++++++++
 .../Interfaces/IServiceFactory.cs             |  1 +
 3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/DynamicDiToolkit.nuspec b/DynamicDiToolkit.nuspec
index 648f798..a88fa67 100644
--- a/DynamicDiToolkit.nuspec
+++ b/DynamicDiToolkit.nuspec
@@ -3,7 +3,7 @@
   <metadata>
     <id>DynamicDiToolkit</id>
     <title>Dynamic DI Toolkit</title>
-    <version>1.0.7</version>
+    <version>1.0.8</version>
     <authors>ShadyNagy</authors>
     <description>
 		Dynamic DI Toolkit Package
diff --git a/README.md b/README.md
index eeab435..f6f76fd 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,29 @@
 
 # Dynamic DI Toolkit
 
+## Problem Statement
+
+In modern software development, particularly within complex projects, managing dependencies can become cumbersome and rigid, leading to challenges in maintaining, testing, and evolving the application architecture. Traditional Dependency Injection (DI) practices, while powerful, often require a static setup that does not easily adapt to changing requirements or dynamic runtime conditions. This can lead to:
+
+- **Tight coupling** between components, making it hard to swap implementations or integrate third-party services dynamically.
+- **Complex configuration** setups, where changes to the DI container require extensive manual adjustments.
+- **Limited flexibility** in scenarios where dependencies need to be resolved based on runtime data or when integrating plugins and modular systems.
+- **Difficulties in testing**, especially when trying to mock or replace services for integration or unit tests without affecting the overall DI setup.
+
+Developers need a solution that brings more flexibility and dynamism to dependency injection, allowing applications to be more modular, easier to maintain, and ready to adapt to new requirements as they arise.
+
+## The Solution: Dynamic DI Toolkit
+
+`DynamicDiToolkit` addresses these challenges by providing a dynamic dependency injection framework designed for .NET applications. It enables developers to:
+
+- **Dynamically register and resolve dependencies** based on runtime conditions, making the application more adaptable and modular.
+- **Simplify the configuration** of the DI container, with support for automatic registration and resolution strategies that reduce boilerplate code.
+- **Enhance testing capabilities**, allowing for easy swapping of implementations in tests without overhauling the DI setup, facilitating both unit and integration testing.
+- **Improve maintainability and scalability** of projects, by enabling a cleaner, more flexible approach to managing dependencies.
+
+By leveraging `DynamicDiToolkit`, developers can overcome the limitations of traditional DI mechanisms, paving the way for more dynamic, maintainable, and testable applications.
+
+
 In the program/startup
 ```csharp
 services.AddScopedDynamicDiToolkitServices();
diff --git a/src/DynamicDiToolkit/Interfaces/IServiceFactory.cs b/src/DynamicDiToolkit/Interfaces/IServiceFactory.cs
index 7533cf6..98a5527 100644
--- a/src/DynamicDiToolkit/Interfaces/IServiceFactory.cs
+++ b/src/DynamicDiToolkit/Interfaces/IServiceFactory.cs
@@ -38,4 +38,5 @@ public interface IServiceFactory
 	/// <param name="type">The entity type for which to retrieve the service.</param>
 	/// <returns>A service instance for the specified type.</returns>
 	object GetService(Type type);
+
 }