Class-based dependencies in FastAPI - Performance & Optimization

Performance: Class-based dependencies

MEDIUM IMPACT

This affects server response time and resource usage during request handling in FastAPI.

Injecting dependencies in FastAPI endpoints

FastAPI

from fastapi import Depends

from fastapi import FastAPI
app = FastAPI()

class DBSession:
    def __init__(self):
        self.db = create_db_session()
    def __enter__(self):
        return self.db
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.db.close()

def get_db(session: DBSession = Depends(DBSession)):
    with session as db:
        yield db

@app.get("/items/")
async def read_items(db=Depends(get_db)):
    return db.query(Item).all()

Encapsulates setup and teardown in a class, improving code reuse and clarity with slight overhead for instance creation.

📈 Performance GainSingle instance creation per request; better maintainability with negligible performance cost.

Injecting dependencies in FastAPI endpoints

FastAPI

from fastapi import Depends

from fastapi import FastAPI
app = FastAPI()

def get_db():
    db = create_db_session()
    try:
        yield db
    finally:
        db.close()

@app.get("/items/")
async def read_items(db=Depends(get_db)):
    return db.query(Item).all()

Using function-based dependencies can lead to repeated setup and teardown logic scattered across functions, making it harder to manage complex state.

📉 Performance CostTriggers setup and teardown per request; minimal overhead but can increase complexity and risk of errors.

Performance Comparison

Pattern	Instance Creation	Setup/Teardown Calls	Memory Usage	Verdict
Function-based dependency	No instance, function call only	Setup/teardown logic repeated per call	Lower memory per request	[!] OK
Class-based dependency	One instance per request	Encapsulated setup/teardown in class	Slightly higher memory per request	[OK] Good

Rendering Pipeline

Class-based dependencies are instantiated during request handling before endpoint execution. This affects the server's CPU and memory usage but does not impact browser rendering directly.

→Request Handling

→Dependency Injection

⚠️ BottleneckInstance creation and resource management per request

Optimization Tips

1Class-based dependencies add slight CPU and memory overhead per request due to instance creation.

2Encapsulate setup and teardown logic in classes to improve code clarity and maintainability.

3Reuse instances or minimize heavy initialization to optimize performance.

Performance Quiz - 3 Questions

What is a main performance impact of using class-based dependencies in FastAPI?

A Increased browser rendering time

B Slight overhead due to instance creation per request

C Triggers multiple reflows in the browser

D Blocks CSS loading

DevTools: Network and Performance panels

How to check: Use Performance panel to record server response times; check Network panel for request durations.

What to look for: Look for consistent and low server response times; no spikes caused by dependency initialization.