.NET Practice Exercises

This problem covers choosing how long each service should live, so a counter shared by the whole application keeps counting while a value that belongs to one request starts fresh every time.

This problem covers letting the container build a whole chain of collaborating objects, so a service and everything beneath it arrives ready to use instead of being constructed by hand at the top.

This problem covers applying a chain of discount rules to a price one after another, with the rules coming from the container as a set rather than being listed by hand, and the order they were registered in deciding the order they apply.

This problem covers reading email server settings out of configuration into a typed class, then using those settings to report the connection details and to preview how an email would be sent.

This problem covers layering settings from a base file, an environment specific file and environment variables, so each setting takes its value from the highest layer that sets it and falls back to the layer below when it does not.

This problem covers checking configuration values as the application starts, so a bad setting stops it straight away with a message naming what is wrong, instead of failing later inside a request.

This problem covers the three basic endpoints of a resource, listing everything, fetching one by its id, and adding a new one, each answering with the right status code and pointing the caller at what was just created.

This problem covers letting the routing table itself reject a badly formed URL, so a lookup by order number only matches whole numbers and a lookup by tracking code only matches a real code, and anything else never reaches the code behind it.

This problem covers taking search filters straight from the query string as typed handler parameters, each falling back to a sensible default when the caller leaves it out, and turning away a value that is not of the right type.

This problem covers taking a JSON signup body straight into a typed record on the handler, filling in defaults for anything left out, and turning away a body that cannot be read or arrives as the wrong kind of content.

This problem covers stating the rules a product has to satisfy on the product itself, then storing one that passes and answering one that fails with the names of the fields that were wrong.

This problem covers pulling one value out of a request header and another out of the query string straight into handler parameters, requiring the header, defaulting the query value, and answering differently depending on which one is wrong.

This problem covers timing every request as it passes through the application and leaving one log entry for it, recording the method, the path, the status it ended with and how long it took, without changing the answer itself.

This problem covers putting a switch in front of the whole application, so that while it is on every request is turned away with the same notice and told when to come back, and while it is off nothing about the normal answers changes.

This problem covers putting the stages a request passes through into the right order, so failures anywhere are caught and turned into a proper answer, and a protected endpoint is guarded before it ever runs.

This problem covers turning the catalog the warehouse keeps into a listing a customer can see, dropping what is out of stock or outside the asked-for price range, ordering what is left by price, and leaving the internal fields behind.

This problem covers gathering recorded sales into one line per category, reporting how many each holds, what they add up to and what they average, and listing the richest category first with ties settled by name.

This problem covers taking a handover report and settling it then and there, so the copy kept says what the log said at that moment however the log changes afterwards, while a fresh run always reports the log as it stands.