public void ReturnParameter_OrThrowIfWhiteSpace_Ok()
        {
            const string valueToTest = "Hello";

            Assert.DoesNotThrow(() => ReturnParameter.OrThrowIfWhitespace(valueToTest, "test"));
            Assert.AreEqual(ReturnParameter.OrThrowIfWhitespace(valueToTest, "test"), valueToTest);
        }
Ejemplo n.º 2
0
        public void ReturnParameter_OrThrowIfNull_Ok()
        {
            var obj = new object();

            Assert.DoesNotThrow(() => ReturnParameter.OrThrowIfNull(obj, "test"));
            Assert.AreEqual(ReturnParameter.OrThrowIfNull(obj, "test"), obj);
        }
Ejemplo n.º 3
0
        public void ReturnParameterMultipleSkipableTest()
        {
            var view = new ViewWithButton {
                BindingContext = new ViewModelSimleHandling()
            };
            var behavior = new EventToMultipleHandlersBehavior {
                EventName = "Clicked"
            };
            var handlerWithReturn = new EventToMethodHandler <int> {
                MethodName = "MethodWithReturnInt"
            };
            var handlerWithReturnParameter = new EventToMethodHandler {
                MethodName = "MethodWithParameterInt"
            };
            var returnParameter = new ReturnParameter <int>();

            handlerWithReturnParameter.Parameters.Add(returnParameter);
            behavior.Handlers.Add(handlerWithReturn);
            behavior.Handlers.Add(new DelayEventHandler());
            behavior.Handlers.Add(new DelayEventHandler());
            behavior.Handlers.Add(new DelayEventHandler());
            behavior.Handlers.Add(handlerWithReturnParameter);
            view.Button.Behaviors.Add(behavior);

            view.Button.SendClicked();

            returnParameter.GetValue().Should().Be(9);
            view.BindingContext.GetFieldValue("_parameterValue").Should().Be(9);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// 获取数据
        /// </summary>
        /// <param name="getMessage"></param>
        internal void Get(QueueTaskThread.GetMessage getMessage)
        {
            ReturnType returnType = ReturnType.MessageQueueNotFoundReader;

            try
            {
                if (isDisposed == 0)
                {
                    if (getMessage.Identity == Identity)
                    {
                        if (onGetMessage == null || !onGetMessage(new ReturnParameter {
                            Type = ReturnType.Success
                        }))
                        {
                            onGetMessage       = getMessage.OnReturn;
                            isGetMessageStream = getMessage.IsReturnStream;
                            ulong endIdentity = Math.Min(Identity + config.SendClientCount, writeIdentity);
                            sendIdentity     = Identity;
                            sendMessageIndex = messageIndex;
                            getMessage       = null;
                            ReturnParameter returnParameter = new ReturnParameter {
                                IsDeSerializeStream = isGetMessageStream, Type = ReturnType.Success
                            };
                            while (sendIdentity != endIdentity)
                            {
                                returnParameter.Parameter = messages[sendMessageIndex].Data;
                                if (onGetMessage(returnParameter))
                                {
                                    nextSendIndex();
                                }
                                else
                                {
                                    onGetMessage = null;
                                    return;
                                }
                            }
                            return;
                        }
                        else
                        {
                            returnType = ReturnType.MessageQueueGetMessageExists;
                        }
                    }
                    else
                    {
                        returnType = ReturnType.MessageQueueReaderIdentityError;
                    }
                }
            }
            finally
            {
                if (getMessage != null)
                {
                    getMessage.OnReturn(new ReturnParameter {
                        Type = returnType
                    });
                }
            }
        }
        internal void CallOnReturn(uint sendCount)
        {
            ReturnParameter returnParameter = default(ReturnParameter);

            returnParameter.Parameter.ReturnParameterSet(sendCount);
            onReturn.Callback(returnParameter);
            onReturn = null;
        }
Ejemplo n.º 6
0
        internal void CallOnReturn(ulong identity)
        {
            ReturnParameter returnParameter = default(ReturnParameter);

            returnParameter.Parameter.ReturnParameterSet(identity);
            onReturn.Callback(returnParameter);
            onReturn = null;
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Applies a member mapping to this method body's implementation,
        /// 'this' parameter, parameter list and return parameter.
        /// The result is returned as a new method body.
        /// </summary>
        /// <param name="memberMapping">The member mapping to apply.</param>
        /// <returns>A new method body.</returns>
        public MethodBody Map(MemberMapping memberMapping)
        {
            var newRetParam  = ReturnParameter.Map(memberMapping);
            var newThisParam = ThisParameter.Map(memberMapping);
            var newParamList = Parameter.MapAll(Parameters, memberMapping);
            var newImpl      = Implementation.Map(memberMapping);

            return(new MethodBody(newRetParam, newThisParam, newParamList, newImpl));
        }
        public void ReturnParameter_OrThrowIfNullOrEmpty_Collection_Ok()
        {
            var testColl = new List <int> {
                1, 2, 3
            };

            Assert.DoesNotThrow(() => ReturnParameter.OrThrowIfNullOrEmpty(testColl, "list"));
            Assert.That(ReturnParameter.OrThrowIfNullOrEmpty(testColl, "list"), Is.EqualTo(testColl));
        }
Ejemplo n.º 9
0
        public void ReturnParameterForParallelTest()
        {
            var view = new ViewWithButton {
                BindingContext = new ViewModelSimleHandling()
            };
            var behavior = new EventToMultipleHandlersBehavior {
                EventName = "Clicked"
            };
            var handlerWithReturn = new EventToMethodHandler <int> {
                MethodName = "MethodWithReturnInt"
            };
            var parallelExecutor      = new ParallelHandlerExecutor();
            var innerParallelExecutor = new ParallelHandlerExecutor();
            var handlerWithMethod     = new EventToMethodHandler {
                MethodName = "Method"
            };

            var handlerWithReturnParameter1 = new EventToMethodHandler {
                MethodName = "MethodWithParameterInt"
            };
            var returnParameter1 = new ReturnParameter <int>();

            handlerWithReturnParameter1.Parameters.Add(returnParameter1);
            var handlerWithReturnParameter2 = new EventToMethodHandler {
                MethodName = "MethodWithParameterInt"
            };
            var returnParameter2 = new ReturnParameter <int>();

            handlerWithReturnParameter2.Parameters.Add(returnParameter2);
            var handlerWithReturnParameter3 = new EventToMethodHandler {
                MethodName = "MethodWithParameterInt"
            };
            var returnParameter3 = new ReturnParameter <int>();

            handlerWithReturnParameter3.Parameters.Add(returnParameter3);

            parallelExecutor.Handlers.Add(handlerWithReturnParameter1);
            parallelExecutor.Handlers.Add(handlerWithMethod);
            parallelExecutor.Handlers.Add(innerParallelExecutor);
            parallelExecutor.Handlers.Add(handlerWithReturnParameter2);

            innerParallelExecutor.Handlers.Add(handlerWithReturnParameter3);
            innerParallelExecutor.Handlers.Add(handlerWithMethod);

            behavior.Handlers.Add(handlerWithReturn);
            behavior.Handlers.Add(handlerWithMethod);
            behavior.Handlers.Add(new DelayEventHandler());
            behavior.Handlers.Add(parallelExecutor);
            view.Button.Behaviors.Add(behavior);

            view.Button.SendClicked();

            returnParameter1.GetValue().Should().Be(9);
            returnParameter2.GetValue().Should().Be(9);
            returnParameter3.GetValue().Should().Be(9);
        }
        /// <summary>
        /// 搜索树字典获取数据
        /// </summary>
        public override void RunTask()
        {
            ReturnParameter returnParameter = default(ReturnParameter);

            try
            {
                returnParameter.Parameter.ReturnParameterSetBinary(new ReturnArray <valueType>(getCount > 0 ? dictionary.Dictionary.GetRange(skipCount, getCount) : dictionary.Dictionary.GetRangeDesc(skipCount, -getCount)));
            }
            finally { OnReturn.Callback(returnParameter); }
        }
Ejemplo n.º 11
0
 private Buffer callback()
 {
     if (onReturn != null)
     {
         ReturnParameter returnParameter = new ReturnParameter();
         returnParameter.Parameter.ReturnParameterSet(true);
         onReturn.Callback(returnParameter);
         onReturn = null;
     }
     return(LinkNext);
 }
Ejemplo n.º 12
0
        private void UpdateParameterTypes()
        {
            // Update implicit parameters.
            ReturnParameter.SetParameterTypeInternal(_owner.Signature.ReturnType);
            ThisParameter?.SetParameterTypeInternal(GetThisParameterType());

            // Update remaining parameter types.
            for (int i = 0; i < _parameters.Count; i++)
            {
                _parameters[i].SetParameterTypeInternal(_owner.Signature.ParameterTypes[i]);
            }
        }
Ejemplo n.º 13
0
 private void callback(ref Buffer next)
 {
     next     = LinkNext;
     LinkNext = null;
     if (onReturn != null)
     {
         ReturnParameter returnParameter = new ReturnParameter();
         returnParameter.Parameter.ReturnParameterSet(true);
         onReturn.Callback(returnParameter);
         onReturn = null;
     }
 }
Ejemplo n.º 14
0
        /// <summary>
        /// 获取数据
        /// </summary>
        /// <param name="getMessage"></param>
        internal void Get(QueueTaskThread.GetMessage getMessage)
        {
            ReturnType returnType = ReturnType.MessageQueueNotFoundReader;

            try
            {
                if (isDisposed == 0)
                {
                    if (getMessage.Identity == Identity)
                    {
                        if (onGetMessage == null || !onGetMessage.Callback(new ReturnParameter(ReturnType.Success)))
                        {
                            onGetMessage       = getMessage.OnReturn;
                            isGetMessageStream = getMessage.IsReturnStream;
                            ulong endIdentity = Math.Min(Identity + Config.SendClientCount, writeIdentity);
                            sendIdentity     = Identity;
                            sendMessageIndex = messageIndex;
                            getMessage       = null;
                            ReturnParameter returnParameter = default(ReturnParameter);
                            while (sendIdentity != endIdentity)
                            {
                                returnParameter.Set(messages[sendMessageIndex].Data, isGetMessageStream);
                                if (onGetMessage.Callback(returnParameter))
                                {
                                    nextSendIndex();
                                }
                                else
                                {
                                    onGetMessage = null;
                                    return;
                                }
                            }
                            return;
                        }
                        else
                        {
                            returnType = ReturnType.MessageQueueGetMessageExists;
                        }
                    }
                    else
                    {
                        returnType = ReturnType.MessageQueueReaderIdentityError;
                    }
                }
            }
            finally
            {
                if (getMessage != null)
                {
                    getMessage.OnReturn.Callback(new ReturnParameter(returnType));
                }
            }
        }
Ejemplo n.º 15
0
        /// <summary>
        /// 申请锁
        /// </summary>
        /// <returns></returns>
        internal bool Enter()
        {
            ReturnParameter returnParameter = new ReturnParameter();

            returnParameter.Parameter.ReturnParameterSet(++node.RandomNo);
            if (OnReturn.Callback(returnParameter))
            {
                AutoCSer.Threading.SecondTimer.InternalTaskArray.Append(onTimeout, AutoCSer.Threading.SecondTimer.SetNow().AddTicks(timeOutTicks));
                return(true);
            }
            return(false);
        }
Ejemplo n.º 16
0
        /// <summary>
        /// 申请锁
        /// </summary>
        /// <returns></returns>
        internal bool Enter()
        {
            ReturnParameter returnParameter = new ReturnParameter();

            returnParameter.Parameter.ReturnParameterSet(++node.RandomNo);
            if (OnReturn(returnParameter))
            {
                AutoCSer.Threading.TimerTask.Default.Add(onTimeout, Date.NowTime.Set().AddTicks(timeOutTicks));
                return(true);
            }
            return(false);
        }
Ejemplo n.º 17
0
        public void MapReturnValue()
        {
            ReturnParameter e = new ReturnParameter();

            using (DbManager db = new DbManager())
            {
                db
                .SetSpCommand("Scalar_ReturnParameter")
                .ExecuteNonQuery("Value", e);
            }

            Assert.AreEqual(12345, e.Value);
        }
        public void TestAlgorithm2()
        {
            decimal a, b;

            a = 0.1m;
            b = 0.5m;
            var function = FunctionType.Algorithm2;

            TestProject.Services.Repository.CalculateAlgotithm calculateAlgotithm = new CalculateAlgotithm();
            ReturnParameter param = calculateAlgotithm.CalAlgorithm(a, b, function);

            Assert.AreEqual(0.55m, Convert.ToDecimal(param.Var));
        }
        /// <summary>
        /// 搜索树字典获取数据
        /// </summary>
        public override void Call()
        {
            ReturnParameter returnParameter = default(ReturnParameter);

            try
            {
                returnParameter.Parameter.ReturnParameterSetBinary(new ReturnArray <valueType>(getCount > 0 ? dictionary.Dictionary.GetRange(skipCount, getCount) : dictionary.Dictionary.GetRangeDesc(skipCount, -getCount)));
            }
            catch (Exception error)
            {
                cache.TcpServer.AddLog(error);
            }
            finally { OnReturn.Callback(returnParameter); }
        }
Ejemplo n.º 20
0
 private bool onGetSendCount(ref ReturnParameter sendCount)
 {
     switch (sendCount.Parameter.ReturnType)
     {
     case ReturnType.Success:
         if (sendCount.Parameter.Type == ValueData.DataType.UInt && consumer.IsProcessor(this))
         {
             getMessageKeepCallback = consumer.GetMessage(onGetMessage);
             return(true);
         }
         break;
     }
     return(false);
 }
Ejemplo n.º 21
0
        public static void Write(Stream stream, List <SpawnPoint> items)
        {
            stream.Write(2);
            stream.Write(items.Count);
            foreach (var item in items)
            {
                BinaryMapping.WriteObject(stream, new Raw
                {
                    Type                 = item.Type,
                    Flag                 = item.Flag,
                    Id                   = item.Id,
                    EntityCount          = (short)item.Entities.Count,
                    EventActivatorCount  = (short)item.EventActivators.Count,
                    WalkPathCount        = (short)item.WalkPath.Count,
                    ReturnParameterCount = (short)item.ReturnParameters.Count,
                    SignalCount          = (short)item.Signals.Count,
                    Reserved10           = 0,
                    Reserved14           = 0,
                    Reserved18           = 0,
                    Place                = item.Teleport.Place,
                    Door                 = item.Teleport.Door,
                    World                = item.Teleport.World,
                    Unk1f                = item.Teleport.Unknown,
                    Unk20                = item.Unk20,
                    Unk24                = item.Unk24,
                    Unk28                = 0,
                });

                foreach (var spawnPoint in item.Entities)
                {
                    Entity.Write(stream, spawnPoint);
                }
                foreach (var unk in item.EventActivators)
                {
                    EventActivator.Write(stream, unk);
                }
                foreach (var unk in item.WalkPath)
                {
                    WalkPathDesc.Write(stream, unk);
                }
                foreach (var unk in item.ReturnParameters)
                {
                    ReturnParameter.Write(stream, unk);
                }
                foreach (var unk in item.Signals)
                {
                    Signal.Write(stream, unk);
                }
            }
        }
Ejemplo n.º 22
0
        public override void ApplyAttributeBuilder(Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
        {
            if (a.Target == AttributeTargets.ReturnValue)
            {
                if (return_attributes == null)
                {
                    return_attributes = new ReturnParameter(this, InvokeBuilder.MethodBuilder, Location);
                }

                return_attributes.ApplyAttributeBuilder(a, ctor, cdata, pa);
                return;
            }

            base.ApplyAttributeBuilder(a, ctor, cdata, pa);
        }
Ejemplo n.º 23
0
 private bool onGetDequeueIdentity(ref ReturnParameter identity)
 {
     switch (identity.Parameter.ReturnType)
     {
     case ReturnType.Success:
         if (identity.Parameter.Type == ValueData.DataType.ULong && consumer.IsProcessor(this))
         {
             messageTime            = Date.NowTime.Now;
             sendClientCount        = (consumer.Config.SendClientCount >> 1) | 1U;
             getMessageKeepCallback = consumer.GetMessage(this.identity = identity.Parameter.Int64.ULong, onGetMessage);
             return(true);
         }
         break;
     }
     return(false);
 }
Ejemplo n.º 24
0
        public void ReturnParameterTest()
        {
            var intParameter    = new ReturnParameter <int>();
            var stringParameter = new ReturnParameter <string>();

            intParameter.SetReturnValue(3);
            stringParameter.SetReturnValue("qwerty1234");

            intParameter.GetParamType().Should().BeAssignableTo <int>();
            intParameter.GetValue().Should().Be(3);
            intParameter.Should().BeAssignableTo <IReturnable>();

            stringParameter.GetParamType().Should().BeAssignableTo <string>();
            stringParameter.GetValue().Should().Be("qwerty1234");
            stringParameter.Should().BeAssignableTo <IReturnable>();
        }
Ejemplo n.º 25
0
        internal IEnumerable <ITypeModelDifference> FindDifferences(MethodDescription actualMethod)
        {
            var differences = new List <ITypeModelDifference>();

            differences.AddRange(ReturnParameter.FindDifferences(actualMethod.ReturnParameter));
            if (Parameters.Length != actualMethod.Parameters.Length)
            {
                differences.Add(new ParameterCountMismatch(this, actualMethod));
            }
            else
            {
                for (int i = 0; i < Parameters.Length; ++i)
                {
                    var expectedParameter = Parameters[i];
                    var actualParameter   = actualMethod.Parameters[i];
                    differences.AddRange(expectedParameter.FindDifferences(actualParameter));
                }
            }
            return(differences);
        }
Ejemplo n.º 26
0
        /// <summary>
        /// 释放锁
        /// </summary>
        /// <param name="exit"></param>
        internal void Exit(QueueTaskThread.Exit exit)
        {
            ReturnParameter returnParameter = new ReturnParameter(ReturnType.NotFoundLock);

            try
            {
                if (head != null && RandomNo == exit.RandomNo)
                {
                    returnParameter.Parameter.ReturnParameterSet(true);
                    do
                    {
                        if ((head = head.Next) == null)
                        {
                            end = null;
                            return;
                        }
                    }while (!head.Enter());
                }
            }
            finally { exit.OnReturn.Callback(returnParameter); }
        }
Ejemplo n.º 27
0
        public IActionResult Index(AlgorithmModel algorithmModel)
        {
            if (ModelState.IsValid)
            {
                decimal result = 0;

                ReturnParameter param = _calculateAlgotithm.CalAlgorithm(algorithmModel.a, algorithmModel.b, algorithmModel.FunctionType);

                if (param.Flag == true)
                {
                    result = Convert.ToDecimal(param.Var);
                    _log.LogData(algorithmModel.FunctionType, algorithmModel.a, algorithmModel.b, result.ToString());

                    result = Math.Round(result, 2);
                    return(RedirectToAction("Result", "Home", new { @result = param.Var }));
                }
                else
                {
                    _log.LogData(algorithmModel.FunctionType, algorithmModel.a, algorithmModel.b, param.Message);
                    return(RedirectToAction("Result", "Home", new { @result = param.Message }));
                }
            }
            return(View());
        }
Ejemplo n.º 28
0
        public override void Emit()
        {
            base.Emit();

            if (ReturnType.Type != null)
            {
                if (ReturnType.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
                {
                    return_attributes = new ReturnParameter(this, InvokeBuilder.MethodBuilder, Location);
                    Module.PredefinedAttributes.Dynamic.EmitAttribute(return_attributes.Builder);
                }
                else if (ReturnType.Type.HasDynamicElement)
                {
                    return_attributes = new ReturnParameter(this, InvokeBuilder.MethodBuilder, Location);
                    Module.PredefinedAttributes.Dynamic.EmitAttribute(return_attributes.Builder, ReturnType.Type, Location);
                }

                ConstraintChecker.Check(this, ReturnType.Type, ReturnType.Location);
            }

            Constructor.ParameterInfo.ApplyAttributes(this, Constructor.ConstructorBuilder);
            Constructor.ConstructorBuilder.SetImplementationFlags(MethodImplAttributes.Runtime);

            parameters.CheckConstraints(this);
            parameters.ApplyAttributes(this, InvokeBuilder.MethodBuilder);
            InvokeBuilder.MethodBuilder.SetImplementationFlags(MethodImplAttributes.Runtime);

            if (BeginInvokeBuilder != null)
            {
                BeginInvokeBuilder.ParameterInfo.ApplyAttributes(this, BeginInvokeBuilder.MethodBuilder);
                EndInvokeBuilder.ParameterInfo.ApplyAttributes(this, EndInvokeBuilder.MethodBuilder);

                BeginInvokeBuilder.MethodBuilder.SetImplementationFlags(MethodImplAttributes.Runtime);
                EndInvokeBuilder.MethodBuilder.SetImplementationFlags(MethodImplAttributes.Runtime);
            }
        }
Ejemplo n.º 29
0
 public                         CustomAttributeBuilder[] CloneReturnAttributes() => ReturnParameter.CloneAttributes();
Ejemplo n.º 30
0
		public void MapReturnValue()
		{
			ReturnParameter e = new ReturnParameter();

			using (DbManager db = new DbManager())
			{
				db
					.SetSpCommand("Scalar_ReturnParameter")
					.ExecuteNonQuery("Value", e);
			}

			Assert.AreEqual(12345, e.Value);
		}
Ejemplo n.º 31
0
 public override TReturn Do <TReturn>(Func <TSuccess, TReturn> onSuccess, [AllowedToBeNull] Func <TFailure, TReturn> onFailure)
 {
     return(ReturnParameter.OrThrowIfNull(onSuccess, "onSuccess")(this.item));
 }
Ejemplo n.º 32
0
 internal MethodDefSignatureConverter(PEFileToObjectModel peFileToObjectModel, MethodDefinition moduleMethod, MemoryReader signatureMemoryReader)
   : base(peFileToObjectModel, signatureMemoryReader, moduleMethod) {
   //  TODO: Check minimum required size of the signature...
   this.FirstByte = this.SignatureMemoryReader.ReadByte();
   if (SignatureHeader.IsGeneric(this.FirstByte)) {
     this.GenericParamCount = (uint)this.SignatureMemoryReader.ReadCompressedUInt32();
   }
   this.paramCount = this.SignatureMemoryReader.ReadCompressedUInt32();
   bool dummyPinned;
   this.ReturnCustomModifiers = this.GetCustomModifiers(out dummyPinned);
   byte retByte = this.SignatureMemoryReader.PeekByte(0);
   bool isReturnByReference = false;
   if (retByte == ElementType.Void) {
     this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemVoid;
     this.SignatureMemoryReader.SkipBytes(1);
   } else if (retByte == ElementType.TypedReference) {
     this.ReturnTypeReference = peFileToObjectModel.PlatformType.SystemTypedReference;
     this.SignatureMemoryReader.SkipBytes(1);
   } else {
     if (retByte == ElementType.ByReference) {
       isReturnByReference = true;
       this.SignatureMemoryReader.SkipBytes(1);
     }
     this.ReturnTypeReference = this.GetTypeReference();
   }
   PEFileReader peFileReader = peFileToObjectModel.PEFileReader;
   uint paramRowCount;
   uint paramRowStart = peFileReader.GetParamInformation(moduleMethod.MethodDefRowId, out paramRowCount);
   uint paramRowEnd = paramRowStart + paramRowCount;
   ParamInfo[] paramInfoArray = new ParamInfo[paramRowCount];
   if (peFileReader.UseParamPtrTable) {
     for (uint paramRowIter = paramRowStart; paramRowIter < paramRowEnd; ++paramRowIter) {
       uint paramRowId = peFileReader.ParamPtrTable.GetParamFor(paramRowIter);
       ParamRow paramRow = peFileReader.ParamTable[paramRowId];
       //  TODO: Error check if seqence is in proper range...
       paramInfoArray[paramRowId - paramRowStart] = new ParamInfo(paramRowId, paramRow.Sequence, peFileToObjectModel.GetNameFromOffset(paramRow.Name), paramRow.Flags);
     }
   } else {
     for (uint paramRowId = paramRowStart; paramRowId < paramRowEnd; ++paramRowId) {
       ParamRow paramRow = peFileReader.ParamTable[paramRowId];
       //  TODO: Error check if seqence is in proper range...
       paramInfoArray[paramRowId - paramRowStart] = new ParamInfo(paramRowId, paramRow.Sequence, peFileToObjectModel.GetNameFromOffset(paramRow.Name), paramRow.Flags);
     }
   }
   if (paramRowCount > 0 && paramInfoArray[0].ParamSequence == 0) {
     ParamFlags paramFlag = paramInfoArray[0].ParamFlags;
     if (isReturnByReference) {
       paramFlag |= ParamFlags.ByReference;
     }
     this.ReturnParameter = new ReturnParameter(this.PEFileToObjectModel, paramInfoArray[0].ParamName, paramFlag, paramInfoArray[0].ParamRowId);
   } else {
     this.ReturnParameter = new ReturnParameter(this.PEFileToObjectModel, Dummy.Name, isReturnByReference ? ParamFlags.ByReference : 0, 0);
   }
   this.ParamInfoArray = paramInfoArray;
   if (this.paramCount > 0) {
     IParameterDefinition[] moduleParamArr = this.GetModuleParameters(true, moduleMethod, this.paramCount);
     this.paramCount = moduleParamArr.Length;
     if (this.paramCount > 0) this.Parameters = moduleParamArr;
   }
 }