转换NSInputStream和NSOutputStream到System.IO.Stream - Xamarin.iO

Question

我目前正忙着用MonoTouch开发一个iOS应用。

当连接到外部配件并建立EASession时，我需要将NSInputStream和NSOutputStream传递给另一个方法，为输入和输出流期待System.IO.Stream。

我不知道如何继续这个，因为我正在使用一些c#库，编写为平台独立，因此我不能改变方法期望NSInputStream/NSOutputStream。

将这些流转换为System.IO.Stream的最佳方法是什么?

谢谢

Answer 1

目前没有内置的方法将NSInputStream/NSOutputStream转换为System.IO。但是你可以很容易地编写自己的System.IO.Stream包装器，就像这样:

class MyInputStream : System.IO.Stream
{
    NSInputStream input_stream;
    public MyInputStream (NSInputStream str)
    {
        input_stream = str;
    }
    public override void Flush ()
    {
        throw new NotSupportedException ();
    }
    public override int Read (byte[] buffer, int offset, int count)
    {
        if (offset != 0)
            throw new NotSupportedException ();
        return input_stream.Read (buffer, count);
    }
    public override long Seek (long offset, System.IO.SeekOrigin origin)
    {
        throw new NotSupportedException ();
    }
    public override void SetLength (long value)
    {
        throw new NotSupportedException ();
    }
    public override void Write (byte[] buffer, int offset, int count)
    {
        throw new NotSupportedException ();
    }
    public override bool CanRead {
        get {
            return true;
        }
    }
    public override bool CanSeek {
        get {
            return false;
        }
    }
    public override bool CanWrite {
        get {
            return false;
        }
    }
    public override long Length {
        get {
            throw new NotSupportedException ();
        }
    }
    public override long Position {
        get {
            throw new NotSupportedException ();
        }
        set {
            throw new NotSupportedException ();
        }
    }
}

Answer 2

这就是我如何使它正常工作的。如果有人有什么建议，请告诉我。

InputStream非常直接，但是OutputStream有点不同。下面的代码将允许您调用Write()和WriteByte()方法。我已经在Console.WriteLine()中留下了，让人们看看它是如何工作的。

InputStream:

class CustomInputStream : System.IO.Stream
{
    NSInputStream input_stream;
    public CustomInputStream (NSInputStream str)
    {
        input_stream = str;
    }
    public override void Flush ()
    {
        throw new NotSupportedException ();
    }
    public override int Read(byte[] buffer, int offset, int count)
    {
        if (offset != 0)
            throw new NotSupportedException ();
        return input_stream.Read (buffer, (uint)count);
    }
    public override long Seek (long offset, System.IO.SeekOrigin origin)
    {
        throw new NotSupportedException ();
    }
    public override void SetLength (long value)
    {
        throw new NotSupportedException ();
    }
    public override void Write (byte[] buffer, int offset, int count)
    {
        throw new NotSupportedException ();
    }
    public override bool CanRead {
        get {
            return true;
        }
    }
    public override bool CanSeek {
        get {
            return false;
        }
    }
    public override bool CanWrite {
        get {
            return false;
        }
    }
    public override long Length {
        get {
            throw new NotSupportedException ();
        }
    }
    public override long Position {
        get {
            throw new NotSupportedException ();
        }
        set {
            throw new NotSupportedException ();
        }
    }
}

OutputStream:

class CustomOutputStream : System.IO.Stream
{
    NSOutputStream output_stream;
    List<byte> buffer;
    public CustomOutputStream (NSOutputStream str)
    {
        output_stream = str;
        buffer = new List<byte>();
    }
    public override void Flush ()
    {
        Write(buffer.ToArray(),0,buffer.Count);
        buffer.Clear();
    }
    public override int Read (byte[] buffer, int offset, int count)
    {       
            throw new NotSupportedException ();
    }
    public override long Seek (long offset, System.IO.SeekOrigin origin)
    {
        throw new NotSupportedException ();
    }
    public override void SetLength (long value)
    {
        throw new NotSupportedException ();
    }
    public override void Write (byte[] buffer, int offset, int count)
    {
        if (offset != 0)
            throw new NotSupportedException ();
        int sent = 0;
        var stillToSend = new byte[buffer.Length-offset];
        buffer.CopyTo(stillToSend, offset);
        Console.WriteLine("out while begin (buffer: {0})",buffer.LongLength);   
        while (count > 0)
        {       
            if (output_stream.HasSpaceAvailable()) 
            {   
                Console.WriteLine("in while has space");
                var bytesWritten = output_stream.Write(buffer, (uint)count);
                if (bytesWritten == -1)
                {
                    Console.WriteLine(@"write error");
                    break;
                }
                else if (bytesWritten > 0)
                {
                    Console.WriteLine("Bytes written: "+ bytesWritten.ToString());
                    count -= bytesWritten;
                    if (0 == count)
                        break;
                    var temp = new List<byte>();
                    for (var i=bytesWritten; i<stillToSend.Length; i++)
                    {
                        temp.Add(stillToSend[i]);
                    }
                    stillToSend = temp.ToArray();
                }
            }
            else 
            {
                Console.WriteLine("in while has NO space");
            }
        }

    }
    public override void WriteByte (byte value)
    {
        buffer.Add(value);
    }
    public override bool CanRead {
        get {
            return false;
        }
    }

    public override bool CanSeek {
        get {
            return false;
        }
    }
    public override bool CanWrite {
        get {
            return true;
        }
    }
    public override long Length {
        get {
            throw new NotSupportedException ();
        }
    }
    public override long Position {
        get {
            throw new NotSupportedException ();
        }
        set {
            throw new NotSupportedException ();
        }
    }
}