C# – Writing a Compiler – .reloc section of the COFF

I don't see anything hard about this, you can just create the interface (using asynchronous method for Read()) and then implement it three times:

interface ISomeDataSource
{
    Task<int> ReadAsync(byte[] buffer, int offset, int count);
    long Seek(long offset, SeekOrigin origin);
}

Both signatures are copied from Stream. Which is another option: use Stream instead of your interface. It has ReadAsync(), Seek() and more.

You can do this since System.IO and System.IO.IsolatedStorage directly use Stream (FileStream in System.IO and IsolatedStorageFileStream in System.IO.IsolatedStorage). WinRT has its own stream types, but you can convert those to Stream using extension methods from WindowsRuntimeStreamExtensions.

Generally singletons are considered bad:

...if you still feel the need to use Singleton objects, consider using the Factory Method pattern instead. It gives you all of the flexibility of the Singleton, with nowhere near as many problems.

...and you're supposed to inject the logger implementation into any class that uses it (or inject a logger factory if you only want the logger object to exist for as long as your class is using it), so:

interface IMyLogger
{
    void Log(string whatever);
}

class MyClass
{
    private readonly IMyLogger logger;

    public(IMyLogger logger)
    {
        if(logger == null) throw new ArgumentNullException("logger");
        this.logger = logger;
    }

    void someOtherMethod()
    {
        this.logger.Log("Something");
    }
}

This allows you to inject various different logger implementations. If you decide to go the shortcut route and use a Singleton, and then use the built-in one from log4net then you're pretty much coupling every class that uses it directly to your implementation, which is generally a bad idea.