ObjectCache | A simple cache for Objects in Android | Caching library

So I solved the problem by simplifying the set up. Instead of having a OneToMany relationship from reason to groups, I made the groups into a TextBlob. Here are the working objects:

Use SemaphoreSlim to lock other threads until cache is ready:

Your cache key is "cachedUser". Since the key is not unique for every user, the same result will be retrieved.

Once fix would be to cache on a unique field such as UserId. Something along the lines of -

cache.Set(userFromDB.Id, userFromDB, policy);

This is assuming that each user has a unique Id

The conf/ folder needs to be on the Java classpath. This is easiest done by running Nutch using one of the provided scripts bin/nutch or bin/crawl. If the binary package is used, the script location is apache-nutch-1.16/bin/nutch. With the source package it's apache-nutch-1.16/runtime/local/bin/nutch after ant runtime has been executed. Using the scripts also allows to have the configuration files in a different directory and point NUTCH_CONF_DIR to this directory. The scripts will just put this location in front of the classpath.

An asynchronous equivalent of lock is SemaphoreSlim.

If your desired code looks like this:

As other folks mentioned you SHOULD not use .Result because it's evil! but in your case that you are working with a legacy app you can use this workaround:

There could be several reasons depending on what device you are running (phone/emulator, Android version, was the error before/after giving the permission from the user, have permissions been denied).

The reason I suspect is that you are not handling Permissions properly, and the other probable cause could be that you are not running the file download work in the UI thread. So update the line to something like this

It's similar to declaring a variable or receiving a parameter of type Stream rather than FileStream or MemoryStream: the flexibility of not having to care which implementation you have.

ObjectCache is the base class of MemoryCache. At instantiation, you're creating a specific implementation, but elsewhere in your code, it shouldn't matter which implementation you have. What matters is the common interface provided by the base class. You can change the instantiation to create a different type and the code that uses the cache doesn't have to be modified.

Some thoughts here.

First, you're using @try/@catch. I believe that NSKeyedArchiver throws exceptions when it should actually return NSError objects. So, perhaps that's why you are doing it. But, you have to keep in mind that none of Apple's frameworks are guaranteed to be exception-safe. This means that catching exceptions can leave Apple's code (and, of course, your own) in inconsistent states that will prevent it from working correctly in the future.

I would strongly recommend either removing the @catch, or scoping it extremely tightly around the NSKeyedArchiver code, if that's why you are using it. This could be unintentionally introducing a variety of other bugs into your app.

Now, on to the specific crash. It's occurring in the runtime's memory management code. This points very strongly at heap corruption. This means you've got a pointer that doesn't point to a valid Objective-C object in memory. This can happen for many reasons, and is extremely common. The most common cause is known as a dangling pointer. However, it could also be caused by an over-release. And, I wouldn't be at all surprised if it is possible to use an @catch to trigger an over-release. (I know, I'm harping, but I've seen so many issues caused by this pattern)

What I generally recommend in these situations:

• Look for other crashes that look heap-corruption-related
• Try out Zombies in Instruments
• Try malloc scribble, or guardmalloc, two other good memory debugging tools

It's hard, and often even impossible, to reason about heap corruption. Replicating the bug can also be impossible, as memory corruption is typically not deterministic.

So, just try to find and fix as many issues as you can. It's totally possible that one of them is responsible for a variety of crashes, one of which could be this one.