✅ Requirements That Call for Multiple Instances

1. Modeling Real-World Entities
   Each entity should have its own set of data, hence its own instance.

Example:

class Customer
{
public string Name { get; set; }
public int Age { get; set; }
}

✅ Use case: A shopping app where each Customer represents a different user.

1. Stateless Service Calls or Independent Processing
   When each instance needs to perform a different task independently.

Example:

class ReportGenerator
{
public string GenerateReport(string data) => $”Report for {data}”;
}

✅ Use case: Generating multiple reports at the same time with different data.

1. Thread Safety
   When you need isolated instances per thread to avoid conflicts or shared state.

Example:

class Logger
{
public void Log(string message) => Console.WriteLine(message);
}

✅ Use case: A separate logger per thread for better log management and no race conditions.

1. Temporary or Session-Based Data
   For objects that are valid only for a short duration or specific session.

Example:

class ShoppingCart
{
public List Items = new List();
}

✅ Use case: One shopping cart per user session in an e-commerce app.

1. Different Configurations or Behaviors
   Each instance behaves differently based on how it was initialized.

Example:

class Printer
{
public string PrinterName { get; }
public Printer(string name) => PrinterName = name;
}

✅ Use case: Managing multiple printers with different names or settings.

1. Unit Testing / Isolation
   When testing classes, you create separate instances to ensure isolation and no state carry-over.

✅ Use case: In xUnit, each test creates its own object instance to test independently.

1. Factory Pattern or Dependency Injection
   You might need new instances per request or scope.

Example:

services.AddTransient(); // Creates new instance every time

✅ Use case: ASP.NET Core DI where services have different lifetimes.

❗When NOT to go for multiple instances?
When the class holds global/shared state (e.g., ConfigurationManager, Logger).

If the object is expensive to create and can be reused safely (use singleton).

When only one instance should exist logically (like a DatabaseConnectionManager).

TL;DR – You Need Multiple Instances When:
Each object represents a unique item or person

Each instance holds different data/state

You need thread isolation or short-lived usage

Independent behavior/config is required