Chad Z. Hower aka Kudzu said:
But it is very useful - how can you create a stream if you dont know what
kind of stream the user wants, or even what parameters the stream needs to
be created? or if the user wants you to write in a stream that already has
data?
You provide whichever version of a stream you want to, and clients can
read from it, treating it just as a stream.
.Net Im sure has many such examples. Many constructers relating to stream
accept other stream type objects. Same thing.
But those are for creating new objects which effectively wrap a stream
- and carry the same "direction". You're using stream as a sort of
bidirectional thing - you write to it and then the client reads from
it. That seems odd to me.
However, I don't want to get bogged down by this - I'm certainly not
asking for a change here.
They dont. They just create it, Indy sizes and fills it.
Ah. That's a different matter then, and not well explained in your
article - I think an example is really called for on the page.
You could even do:
HTTP.Get(URL, new new StringAdaptor(new string array)))
But then of course you would have no reference to it to read it.
But if you already *have* a string array and provide a new
StringAdaptor, it won't be able to resize that original array...
Yes, that exactly the same as the code I posted. The FCL stream instance
was MyDotNetStream which is already created by you.
Yes indeed. I think we've got our wires seriously crossed here.
TIdCLRStream is a class of ours that remaps TStreams methods to call the
matching methods in the .net STream. So we operate directly on your stream
internally, via a translator. Same for strings[].
Except it's *not* the same for strings, because you can't resize an
array in .NET, which it sounds like you need to for your string array
adaptor.
Your IL based change would yes. But not your type convertor suggestion to
which I was referring in this case.
No, my type convertor version would cover that as well. Here's a
complete sample program in C# to show what I mean. If the .NET part of
Delphi can provide implicit conversions, I don't see why exactly the
same shouldn't be accomplished for Indy. You'd need to use an IFDEF for
the implicit conversions, but only on the adaptors, which I don't
expect would be too arduous.
using System;
using System.IO;
// Analogous to TIdCLRStream, I *think*!
public class StreamAdaptor
{
Stream baseStream;
public StreamAdaptor(Stream baseStream)
{
this.baseStream = baseStream;
}
public static implicit operator Stream (StreamAdaptor adaptor)
{
return adaptor.baseStream;
}
public static implicit operator StreamAdaptor (Stream baseStream)
{
return new StreamAdaptor (baseStream);
}
public void Write (byte[] bytes)
{
// Presumably in your real adaptor, you'd be doing more
// interesting stuff, I don't know
baseStream.Write(bytes, 0, bytes.Length);
baseStream.Flush();
}
}
// Analogous to an HTTP client class or whatever
public class SampleClient
{
public void Write5Bytes(StreamAdaptor adaptor)
{
adaptor.Write (new byte[] {0, 1, 2, 3, 4});
}
}
public class Test
{
static void Main()
{
MemoryStream ms = new MemoryStream();
SampleClient sample = new SampleClient();
// Observe the miracles of implicit conversion...
sample.Write5Bytes(ms);
Console.WriteLine (ms.Length);
}
}
