private object DoInput(MemoryStream inData, object[] arguments, Type returnType, HproseResultMode resultMode, HproseClientContext context)
        {
            for (int i = filters.Count - 1; i >= 0; --i)
            {
                inData.Position = 0;
#if (dotNET10 || dotNET11 || dotNETCF10 || dotNETMF)
                IHproseFilter filter = (IHproseFilter)filters[i];
                inData = filter.InputFilter(inData, context);
#else
                inData = filters[i].InputFilter(inData, context);
#endif
            }
            inData.Position = inData.Length - 1;
            int tag = inData.ReadByte();
            if (tag != HproseTags.TagEnd)
            {
                throw new HproseException("Wrong Response: \r\n" + HproseHelper.ReadWrongInfo(inData));
            }
            inData.Position = 0;
            if (resultMode == HproseResultMode.Raw)
            {
                inData.SetLength(inData.Length - 1);
            }
            if (resultMode == HproseResultMode.RawWithEndTag ||
                resultMode == HproseResultMode.Raw)
            {
                return(MemoryStreamToType(inData, returnType));
            }
            object result = null;
#if !dotNETMF
            HproseReader reader = new HproseReader(inData, mode);
#else
            HproseReader reader = new HproseReader(inData);
#endif
            while ((tag = inData.ReadByte()) != HproseTags.TagEnd)
            {
                switch (tag)
                {
                case HproseTags.TagResult:
                    if (resultMode == HproseResultMode.Normal)
                    {
                        reader.Reset();
                        result = reader.Unserialize(returnType);
                    }
                    else
                    {
                        result = MemoryStreamToType(reader.ReadRaw(), returnType);
                    }
                    break;

                case HproseTags.TagArgument:
                    reader.Reset();
                    Object[] args   = reader.ReadObjectArray();
                    int      length = arguments.Length;
                    if (length > args.Length)
                    {
                        length = args.Length;
                    }
                    Array.Copy(args, 0, arguments, 0, length);
                    break;

                case HproseTags.TagError:
                    reader.Reset();
                    result = new HproseException(reader.ReadString());
                    break;

                default:
                    throw new HproseException("Wrong Response: \r\n" + HproseHelper.ReadWrongInfo(inData));
                }
            }
            return(result);
        }
Exemple #2
0
        private object DoInput(object[] arguments, Type returnType, HproseResultMode resultMode, Stream istream)
        {
            int tag;

            if (filter != null)
            {
                istream = filter.InputFilter(istream);
            }
            object       result       = null;
            HproseReader hproseReader = new HproseReader(istream, mode);
            MemoryStream memstream    = null;

            if (resultMode == HproseResultMode.RawWithEndTag || resultMode == HproseResultMode.Raw)
            {
                memstream = new MemoryStream();
            }
            while ((tag = istream.ReadByte()) != HproseTags.TagEnd)
            {
                switch (tag)
                {
                case HproseTags.TagResult:
                    if (resultMode == HproseResultMode.Normal)
                    {
                        hproseReader.Reset();
                        result = hproseReader.Unserialize(returnType);
                    }
                    else if (resultMode == HproseResultMode.Serialized)
                    {
                        result = hproseReader.ReadRaw();
                    }
                    else
                    {
                        memstream.WriteByte(HproseTags.TagResult);
                        hproseReader.ReadRaw(memstream);
                    }
                    break;

                case HproseTags.TagArgument:
                    if (resultMode == HproseResultMode.RawWithEndTag || resultMode == HproseResultMode.Raw)
                    {
                        memstream.WriteByte(HproseTags.TagArgument);
                        hproseReader.ReadRaw(memstream);
                    }
                    else
                    {
                        hproseReader.Reset();
                        Object[] args   = hproseReader.ReadObjectArray();
                        int      length = arguments.Length;
                        if (length > args.Length)
                        {
                            length = args.Length;
                        }
                        Array.Copy(args, 0, arguments, 0, length);
                    }
                    break;

                case HproseTags.TagError:
                    if (resultMode == HproseResultMode.RawWithEndTag || resultMode == HproseResultMode.Raw)
                    {
                        memstream.WriteByte(HproseTags.TagError);
                        hproseReader.ReadRaw(memstream);
                    }
                    else
                    {
                        hproseReader.Reset();
                        result = new HproseException(hproseReader.ReadString());
                    }
                    break;

                default:
                    throw hproseReader.UnexpectedTag(tag, (char)HproseTags.TagResult + "" +
                                                     (char)HproseTags.TagArgument + "" +
                                                     (char)HproseTags.TagError + "" +
                                                     (char)HproseTags.TagEnd);
                }
            }
            if (resultMode == HproseResultMode.RawWithEndTag || resultMode == HproseResultMode.Raw)
            {
                if (resultMode == HproseResultMode.RawWithEndTag)
                {
                    memstream.WriteByte(HproseTags.TagEnd);
                }
                memstream.Position = 0;
                result             = memstream;
            }
            return(result);
        }
Exemple #3
0
        private object DoInput(object[] arguments, Type returnType, HproseResultMode resultMode, Stream istream)
        {
            int          tag;
            object       result       = null;
            HproseReader hproseReader = new HproseReader(istream, mode);
            MemoryStream memstream    = null;

            if (resultMode == HproseResultMode.RawWithEndTag || resultMode == HproseResultMode.Raw)
            {
                memstream = new MemoryStream();
            }
            while ((tag = hproseReader.CheckTags(
                        (char)HproseTags.TagResult + "" +
                        (char)HproseTags.TagArgument + "" +
                        (char)HproseTags.TagError + "" +
                        (char)HproseTags.TagEnd)) != HproseTags.TagEnd)
            {
                switch (tag)
                {
                case HproseTags.TagResult:
                    if (resultMode == HproseResultMode.Normal)
                    {
                        hproseReader.Reset();
                        result = hproseReader.Unserialize(returnType);
                    }
                    else if (resultMode == HproseResultMode.Serialized)
                    {
                        result = hproseReader.ReadRaw();
                    }
                    else
                    {
                        memstream.WriteByte(HproseTags.TagResult);
                        hproseReader.ReadRaw(memstream);
                    }
                    break;

                case HproseTags.TagArgument:
                    if (resultMode == HproseResultMode.RawWithEndTag || resultMode == HproseResultMode.Raw)
                    {
                        memstream.WriteByte(HproseTags.TagArgument);
                        hproseReader.ReadRaw(memstream);
                    }
                    else
                    {
                        hproseReader.Reset();
                        Object[] args = (Object[])hproseReader.ReadList(HproseHelper.typeofObjectArray);
                        Array.Copy(args, 0, arguments, 0, arguments.Length);
                    }
                    break;

                case HproseTags.TagError:
                    if (resultMode == HproseResultMode.RawWithEndTag || resultMode == HproseResultMode.Raw)
                    {
                        memstream.WriteByte(HproseTags.TagError);
                        hproseReader.ReadRaw(memstream);
                    }
                    else
                    {
                        hproseReader.Reset();
                        result = new HproseException((string)hproseReader.ReadString());
                    }
                    break;
                }
            }
            if (resultMode == HproseResultMode.RawWithEndTag || resultMode == HproseResultMode.Raw)
            {
                if (resultMode == HproseResultMode.RawWithEndTag)
                {
                    memstream.WriteByte(HproseTags.TagEnd);
                }
                memstream.Position = 0;
                result             = memstream;
            }
            return(result);
        }