APM and the unresolved System.AccessViolationException mystery on breakpoints

Question

Consider the following function:

static void Main(string[] args)
{
    FileStream fs = new FileStream("e:\\temp.txt", FileMode.Open);
    int size = (int)fs.Length;

    byte[] data = new byte[size];
    IAsyncResult result = fs.BeginRead(data, 0, size, new AsyncCallback(Callback), fs);

    Console.ReadLine();
}

Question1: If I put a breakpoint on BeginRead line, and run the program in debug mode, I get the following error:

An unhandled exception of type 'System.AccessViolationException' occurred in MyApp.exe.

However, if I put the breakpoint on the ReadLine line and do the same the error doesn't occur. I believe passing the FileStream instance as the last parameter to the BeginRead function causes the problem, however, I've no idea what is happening there.

---UPDATE1: You might ask why I'm trying to pass "fs" to the callback. Yes, I can hold it as a member variable however what if I was going to read multiple files asynchronously? That way, holding an array (or list) of file streams would be irrational.

Question2: AFAIK, IAsyncResult is defined as follows:

[ComVisible(true)]
public interface IAsyncResult
{
    object AsyncState { get; }
    WaitHandle AsyncWaitHandle { get; }
    bool CompletedSynchronously { get; }
    bool IsCompleted { get; }
}

However, when tracing the code, I've noticed other members on IAsyncResult:

How's this possible? The IAsyncResult is obviously implemented by ReadWriteTask class (in this case), however, I don't get where those other properties come from.

---Update 2: I tried to mimic the same using the following code:

public interface IMyInterface
{
    int Prop1 { get; }
}

public class Impl : IMyInterface
{
    public int Prop1 { get { return 101; } }
    public int Prop2 { get { return 202; } }
}

public class MyClass
{
    public IMyInterface GetMyInterface()
    {
        Impl impl = new Impl();
        return impl;
    }
}

And to invoke the method, I just instantiate a MyClass and call the GetMyInterface method as follows:

MyClass c = new MyClass();
IMyInterface my = c.GetMyInterface();

However, when I watch the my variable in Quickwatch, I see the non-flattened result which is totally OK with me. However, this is not the same case for IAsyncResult / ReadWriteTask. What's the difference?

Answer 1

IAsyncResult is just an interface. You can easily see that the actual type of the variable in this case is System.IO.Stream.ReadWriteTask - it just implements the interface IAsyncResult. That means it has to have the properties of IAsyncResult, but it can have whatever else it wants as well. If you cast the variable to ReadWriteTask, you'll see the other properties and methods in IntelliSense too, and you can use them (although you probably shouldn't). You might want to brush up on what class and interface is.

Make sure the file is actually accessible. You might be doing something that prevents you from successfully opening the file in code - e.g. having the file open in some other application.

There's no reason to pass the file stream as state. It shouldn't hurt either, though.

Also, why are you using BeginRead? You're running .NET 4.5 (as evidenced by the ReadWriteTask returned by BeginRead), so why not simply use var bytesRead = await fs.ReadAsync(...);? In fact, with proper usage, you wouldn't need the ReadLine at all - you should wait for the completion of whatever it is you're actually doing instead.

Of course, in this case, asynchronous I/O is pointless anyway, but I assume this is just a sample and you intend to do something more useful with it.

EDIT:

This is a full working snippet that doesn't display your error:

using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AsyncFileStream
{
  class Program
  {
    static void Main(string[] args)
    {
      FileStream fs = new FileStream("d:\\temp.txt", FileMode.Open);
      int size = (int)fs.Length;

      byte[] data = new byte[size];

      var result = 
          fs.BeginRead(data, 0, size, (ar) => Callback(fs, ar, data), null);

      if (result.CompletedSynchronously) Callback(fs, result, data);

      Console.ReadLine();
    }

    static void Callback(FileStream fs, IAsyncResult ar, byte[] data)
    {
      var bytesRead = fs.EndRead(ar);

      Console.WriteLine(UTF8Encoding.UTF8.GetString(data, 0, bytesRead));
    }
  }
}

Does this display the same error you were having with your code? If not, you might want to add code for your callback method and probably some more relevant information.

Disclaimer: This is still a bad way to read from a file. There's no guarantee that you'll get all the data in one read, and in fact, very often, reading the whole file at once is a huge waste of resources and completely unnecessary.