C# MethodDefinition.IsAsyncStateMachine方法代码示例

    void InnerProcess(MethodDefinition method)
    {
        var localValidationFlags = validationFlags;

        var attribute = method.DeclaringType.GetNullGuardAttribute();
        if (attribute != null)
        {
            localValidationFlags = (ValidationFlags)attribute.ConstructorArguments[0].Value;
        }

        if ((!localValidationFlags.HasFlag(ValidationFlags.NonPublic) && (!(method.IsPublic || method.IsExplicitInterfaceMethod()) || !method.DeclaringType.IsPublicOrNestedPublic())))
            return;

        var body = method.Body;

        var sequencePoint = body.Instructions.Select(i => i.SequencePoint).FirstOrDefault();

        body.SimplifyMacros();

        if (localValidationFlags.HasFlag(ValidationFlags.Arguments))
        {
            InjectMethodArgumentGuards(method, body, sequencePoint);
        }

        if (!method.IsAsyncStateMachine() &&
            !method.IsIteratorStateMachine())
        {
            InjectMethodReturnGuard(localValidationFlags, method, body, sequencePoint);
        }

        if (method.IsAsyncStateMachine())
        {
            var returnType = method.ReturnType;
            var genericReturnType = method.ReturnType as GenericInstanceType;
	        if (genericReturnType != null && genericReturnType.HasGenericArguments && genericReturnType.Name.StartsWith("Task"))
	        {
		        returnType = genericReturnType.GenericArguments[0];
	        }

            if (localValidationFlags.HasFlag(ValidationFlags.ReturnValues) &&
                !method.AllowsNullReturnValue() &&
                returnType.IsRefType() &&
                returnType.FullName != typeof(void).FullName)
            {
                InjectMethodReturnGuardAsync(body, string.Format(CultureInfo.InvariantCulture, ReturnValueOfMethodIsNull, method.FullName), method.FullName);
            }
        }

        body.InitLocals = true;
        body.OptimizeMacros();
    }

    private void InnerProcess(MethodDefinition method)
    {
        var localValidationFlags = validationFlags;

        var attribute = method.DeclaringType.GetNullGuardAttribute();
        if (attribute != null)
        {
            localValidationFlags = (ValidationFlags)attribute.ConstructorArguments[0].Value;
        }

        if ((!localValidationFlags.HasFlag(ValidationFlags.NonPublic) && (!method.IsPublic || !method.DeclaringType.IsPublic))
            || method.IsProperty()
            )
            return;

        var body = method.Body;
        body.SimplifyMacros();

        if (localValidationFlags.HasFlag(ValidationFlags.Arguments))
        {
            InjectMethodArgumentGuards(method, body);
        }

        if (!method.IsAsyncStateMachine() &&
            !method.IsIteratorStateMachine())
        {
            InjectMethodReturnGuard(localValidationFlags, method, body);
        }

        if (method.IsAsyncStateMachine())
        {
            var returnType = method.ReturnType;
            if (method.ReturnType.HasGenericParameters && method.ReturnType.Name.StartsWith("Task"))
                returnType = method.ReturnType.GenericParameters[0];

            if (localValidationFlags.HasFlag(ValidationFlags.ReturnValues) &&
                !method.MethodReturnType.AllowsNull() &&
                returnType.IsRefType() &&
                returnType.FullName != typeof(void).FullName)
            {
                InjectMethodReturnGuardAsync(body, String.Format(CultureInfo.InvariantCulture, STR_ReturnValueOfMethodIsNull, method.FullName));
            }
        }

        body.InitLocals = true;
        body.OptimizeMacros();
    }

    private void ProcessBody(MethodDefinition method)
    {
        if (method.IsAsyncStateMachine())
        {
            LogTo.Information("Async method '{0}' cannot be modified by Usable.", method.FullName);
            return;
        }

        method.Body.SimplifyMacros();

        var ilProcessor = method.Body.GetILProcessor();

        if (method.Body.Instructions.Last().OpCode == OpCodes.Throw)
            ilProcessor.Append(ilProcessor.Create(OpCodes.Ret));

        method.Body.OptimizeMacros();
        method.Body.SimplifyMacros();

        var ilMethod = Decompile(method);

        var visitor = new UsableVisitor(method);
        visitor.Visit(ilMethod);

        if (!visitor.UsingRanges.Any())
        {
            method.Body.OptimizeMacros();
            return;
        }

        // Convert early returns to branches to the last return
        if (visitor.EarlyReturns.Any() && method.Body.Instructions.Last().OpCode == OpCodes.Ret)
            FixEarlyReturns(method.Body, visitor.EarlyReturns);

        // Inserts nops to ensure nested trys are not overlapping
        var usingBlocks = FixUsingBlocks(ilProcessor,
            visitor.UsingRanges
                .Select(r => Tuple.Create(method.Body.Instructions.AtOffset(r.From), method.Body.Instructions.BeforeOffset(r.To)))
                .ToList());

        // Add the usings
        foreach (var usingBlock in usingBlocks.OrderBy(u => u.Item1.Offset))
            AddUsing(method.Body, usingBlock);

        method.Body.OptimizeMacros();
        method.Body.SimplifyMacros();

        // Sort exception handlers so inner trys are before outer ones
        method.Body.ExceptionHandlers.ReplaceCollection(method.Body.ExceptionHandlers.OrderBy(x => x, new ExceptionHandlerComparer()));

        // Any branches in a try branching to outside must be converted to leaves
        foreach (var handler in method.Body.ExceptionHandlers)
            ReplaceBranchesWithLeaves(ilProcessor, handler);

        method.Body.OptimizeMacros();
    }