# Request context

Request's context was already demonstrated previously. This page gives some tips about general approach to passing objects to handlers. Request context may not always be the best option: it's type-unsafe (you must do explicit type-assertion), it's verbose, [it's slow](#user-content-fn-1)[^1].  It might sometimes be quite a challenge to update the value in runtime. 

Let's consider we need a dynamic web-page. We are going to use the `html/template` for it. Reading the file with it would be quite expensive and inefficient, but storing it all the time in memory is also not a good choice, as at the development stage we would like to see the changes instantly. In this case, we can simply make our handler a method to a structure, which would contain our `*html.Template` and mutex in order to synchronize access:

```go
import (
	"html/template"
	"log"
	"sync"

	"github.com/indigo-web/indigo"
	"github.com/indigo-web/indigo/http"
	"github.com/indigo-web/indigo/router/inbuilt"
)

type Home struct {
	mu sync.RWMutex
	tmpl *template.Template
}

func NewHome() *Home {
	// initialize the Home here
}

func (h *Home) Get(request *http.Request) *http.Response {
	h.mu.RLock()
	defer h.mu.RUnlock()

	resp := request.Respond()
	if err := h.tmpl.Execute(resp, "some value"); err != nil {
		return http.Error(request, err)
	}

	return resp
}

func (h *Home) ReloadTemplate(request *http.Request) *http.Response {
	h.mu.Lock()
	defer h.mu.Unlock()
	// reload the template here
}

func main() {
	home := NewHome()
	
	r := inbuilt.New().
		Get("/", home.Get).
		Get("/reload-template", home.ReloadTemplate)

	log.Fatal(
		indigo.New(":8080").Serve(r),
	)
}
```

Simply share the same underlying structure for multiple handlers and protect it by mutex. This is currently the only way to do DI.

[^1]: It uses `any` for both key and value arguments, which makes them escape to heap, and the lookup time is O(n), which may on some cases not be the best option