Noramlly, we have methods like:

    void execute(string login, string password, Stream inputStream) {

        if (login:password is wrong)
            throw new Exception("login failed");

        // forward or process the stream in chunks

    }

The WS framework does allow transferring streams (serialized objects, binary 
data). However, the Stream class is not a valid web method parameter. WSE3 
demonstrates how to (de-)serialize objects to/from XML stream:

// A service to get/put data from/to server
[WebService]
public class WebService1 : WebService {

    public WebService1() {}

    public XmlSerializableFile  GetFile(string fileName) {
        return  new XmlSerializableFile(fileName);
    }

    public void PutFile(XmlSerializableFile request) {
        Conlose.WriteLine("input stream has been buffered into " + 
request.fileName);
    }

}

// An object serializable to file
[XmlSchemaProvider("GetMySchema")]
class XmlSerializableFile {

    public string fileName;

    XmlSerializableFile (string fileName) { this.fileName = fileName; }
    public XmlSchema GetSchema() { return null; }

    public static XmlQualifiedName GetMySchema(XmlSchemaSet xss) {
        return new XmlQualifiedName("base64Binary", 
"http://www.w3.org/2001/XMLSchema");
    }

    /// restore the input stream data into a new file
    public void ReadXml(XmlReader r) {
        r.ReadStartElement(); // Read the open tag of the encapsulating 
element

        fileName = TempFileName(); // create a new file
        using (FileStream fs = new FileStream(, FileMode.CreateNew)) {
            byte[] buf = new byte[1024];
            int numRead = 0;
            while ((numRead = reader.ReadContentAsBase64(buf, 0, 1024)) > 0)
                    fs.Write(buf, 0, numRead);
        }

        r.ReadEndElement(); // Read the close tag of the encapsulating 
element
    }

    /// write a whole file into xml stream
    public void WriteXml(XmlWriter w) {
        using (FileStream fs = new FileStream(fileName, FileMode.Open, 
FileAccess.Read)) {
            byte[] buf = new byte[1024];
            int numRead = 0;
            while ((numRead = fs.Read(buf, 0, 1024)) > 0)
                w.WriteBase64(buf, 0, numRead);
        }
    }

}


You see, the (de)serialization routine processes the whole stream (buffering 
it into the memory or into a file). In result, all the featuring advantage 
of streaming -- keeping the working set low -- is lost. Who needs such a 
streaming? Pheahaps I'm just missing something and you know how to deliver a 
stream right into a web method? I think it is normal to process a stream 
depending on other method arguments.