• Levenshtein distance
• Jaro-Winkler distance
• N-gram

Reader-writer locks naturally fit together with caches, as caches are only effective if reads far outnumber writes.

Here is a general pattern for using a reader-writer lock with a cache:

1. Acquire a reader lock.
2. Check the cache for the value. If it exists, save the value and go to step 8.
3. Upgrade the reader lock to a writer lock.
4. Check the cache for the value. If it exists, save the value and go to step 7.
5. Calculate the value (expensive, otherwise we wouldn’t cache it)
6. Insert the value into the cache.
7. Release the writer lock.
8. Release the reader lock.
9. Return the value.

The reason why we have to check the cache for the value again in step (4) is because of the following possibility (assume step 4 doesn’t exist):

Thread 1                         Thread 2
============================     ===============================
- Acquire reader lock            - Acquire reader lock
- Check cache for value          - Check cache for value
  with key A (not found)           with key A (not found)
- Upgrade to writer lock         - (block)
- Calculate value (expensive)
- Insert value into cache
- Release writer lock
- Release reader lock
                                 - Upgrade to writer lock
                                 - Calculate value (expensive)
                                   (We are paying this cost
                                   twice)
                                 - Insert value into cache
                                   (We are inserting two values
                                   with the same key, which may
                                   be fatal)

With step 4 it becomes:

Thread 1                         Thread 2
============================     ===============================
- Acquire reader lock            - Acquire reader lock
- Check cache for value          - Check cache for value
  with key A (not found)           with key A (not found)
- Upgrade to writer lock         - (block)
- Calculate value (expensive)
- Insert value into cache
- Release writer lock
- Release reader lock
                                 - Upgrade to writer lock
                                 - Check cache for value
                                   with key A (found)
                                 - Release writer lock
                                 - Release reader lock
- Return value                   - Return value

Pricing models like the arbitrage pricing theory or the Fama-French factor models simply assume that prices are right, then extrapolate from that what the relevant risk factors must be that determine prices.

Fox, Justin. What we talk about when we talk about the efficient market hypothesis. The Curious Capitalist Blog: 8 October 2009.

Exactly!

If the user has provided multiple parameters with the same key in the query string, HttpRequest.QueryString[key] will return all the values concatenated together with commas.  If you would rather process the values individually, use HttpRequest.QueryString.GetValues(key), which will return an array of all the provided values.

For example:

URL: http://example.com?a=1&a=2
HttpRequest.QueryString["a"] = "1,2"
HttpRequest.QueryString.GetValues("a") = { "1", "2" }

Fond memories.