Esempio n. 1
0
        protected internal override Expression VisitAwait(AwaitCSharpExpression node)
        {
            var args = new List <object>();

            if (node.GetAwaiterMethod != null)
            {
                args.Add(new XAttribute(nameof(AwaitCSharpExpression.GetAwaiterMethod), node.GetAwaiterMethod));
            }
            else
            {
                var dynamic = node as DynamicAwaitCSharpExpression;
                if (dynamic != null)
                {
                    args.Add(new XAttribute("IsDynamic", true));

                    if (dynamic.Context != null)
                    {
                        args.Add(new XAttribute(nameof(dynamic.Context), dynamic.Context));
                    }
                }
            }

            args.Add(new XElement(nameof(node.Operand), Visit(node.Operand)));

            return(Push(node, args));
        }
        protected internal override Expression VisitAwait(AwaitCSharpExpression node)
        {
            var args = new List <object>
            {
                new XElement(nameof(node.Info), Visit(node.Info)),
                new XElement(nameof(node.Operand), Visit(node.Operand))
            };

            return(Push(node, args));
        }
        private static void ValidateAwaitPattern(Type operandType, ref MethodInfo getAwaiterMethod, out Type resultType)
        {
            if (getAwaiterMethod == null)
            {
                getAwaiterMethod = AwaitCSharpExpression.GetGetAwaiter(operandType);
            }

            //ContractUtils.RequiresNotNull(getAwaiterMethod, nameof(getAwaiterMethod));

            ValidateGetAwaiterMethod(operandType, getAwaiterMethod);
            ValidateAwaiterType(getAwaiterMethod.ReturnType, out resultType);
        }
        private static void ValidateAwaiterType(Type awaiterType, out Type resultType)
        {
            if (!typeof(INotifyCompletion).IsAssignableFrom(awaiterType))
            {
                throw Error.AwaiterTypeShouldImplementINotifyCompletion(awaiterType);
            }

            var isCompleted = awaiterType.GetProperty("IsCompleted", BindingFlags.Public | BindingFlags.Instance);

            if (isCompleted == null || isCompleted.GetMethod == null)
            {
                throw Error.AwaiterTypeShouldHaveIsCompletedProperty(awaiterType);
            }

            if (isCompleted.PropertyType != typeof(bool))
            {
                throw Error.AwaiterIsCompletedShouldReturnBool(awaiterType);
            }

            if (isCompleted.GetIndexParameters().Length != 0)
            {
                throw Error.AwaiterIsCompletedShouldNotBeIndexer(awaiterType);
            }

            var getResult = AwaitCSharpExpression.GetGetResult(awaiterType);

            if (getResult == null || getResult.IsGenericMethodDefinition)
            {
                throw Error.AwaiterTypeShouldHaveGetResultMethod(awaiterType);
            }

            var returnType = getResult.ReturnType;

            if (returnType.IsByRef || returnType.IsPointer)
            {
                throw Error.AwaiterGetResultTypeInvalid(awaiterType);
            }

            resultType = returnType;
        }
 protected internal override Expression VisitAwait(AwaitCSharpExpression node)
 {
     return(node);
 }
Esempio n. 6
0
 protected internal virtual Expression VisitAwait(AwaitCSharpExpression node) =>
 node.Update(
     Visit(node.Operand),
     VisitAwaitInfo(node.Info)
     );
 public AwaitCSharpExpressionProxy(AwaitCSharpExpression node)
 {
     _node = node;
 }
 protected internal virtual Expression VisitAwait(AwaitCSharpExpression node)
 {
     return node.Update(Visit(node.Operand));
 }
            protected internal override Expression VisitAwait(AwaitCSharpExpression node)
            {
                Visited = true;

                return base.VisitAwait(node);
            }
 public AwaitCSharpExpressionProxy(AwaitCSharpExpression node)
 {
     _node = node;
 }
 protected internal virtual Expression VisitAwait(AwaitCSharpExpression node)
 {
     return(node.Update(Visit(node.Operand)));
 }