我有一个控制器,它覆盖了Controller基类的OnException方法.

public class ControllerFiltersController : Controller {

    public ActionResult Index() {

        throw new NotImplementedException();
    }

    protected override void OnException(ExceptionContext filterContext) {

        Trace.Traceinformation(
            "ControllerFiltersController Exception: " + DateTime.Now.ToString("hh:mm:ss.fff")
        );
    }
}

我还有一个自定义的ExceptionFilter,如下所示：

public class HandleErrorCustom : IExceptionFilter {

    public void OnException(ExceptionContext filterContext) {

        Trace.Traceinformation(
            "HandleErrorCustom Exception Message: " + DateTime.Now.ToString("hh:mm:ss.fff")
        );
    }
}

然后,我将其注册为全局过滤器：

public static void RegisterGlobalFilters(GlobalFilterCollection filters) {

    filters.Add(new HandleErrorCustom());
}

我期望控制器实例过滤器在全局过滤器之前运行,因为ControllerInstanceFilterProvider提供的过滤器顺序是Int32.MinValue,它们的范围是FilterScope.First.

正如此处所述：ASP.NET MVC 3 Service Location,Part 4: Filters

但结果却不同：

iisexpress.exe information: 0 : HandleErrorCustom Exception Message:
06:56:49.972

iisexpress.exe information: 0 : ControllerFiltersController Exception:
06:56:49.974

这是一个ASP.NET MVC 4应用程序,我不知道任何影响ASP.NET MVC 3的过滤器排序行为的更改.我在这里缺少什么？

过滤器排序取决于信息流动的方向.如果信息流入动作,那么订单就像您期望的那样;如果信息流回动作,那么订单将被撤销.

例如,假设您按此顺序有三个过滤器：F1,F2,F3.假设这些是动作过滤器(意思是,它们正在侦听ActionExecuting和ActionExecuted).系统将运行它们的顺序如下：

F1.ActionExecuting()
F2.ActionExecuting()
F3.ActionExecuting()
Action()
F3.ActionExecuted()
F2.ActionExecuted()
F1.ActionExecuted()

根据定义,错误处理程序是在操作的返回端运行的过滤器,因此它们的顺序是相反的.

public JvmOptions(PathToFileResolver resolver) {
    this.bootstrapClasspath = new DefaultConfigurableFileCollection(resolver,null);
    immutableSystemProperties.put(FILE_ENCODING_KEY,Charset.defaultCharset().name());
    immutableSystemProperties.put(USER_LANGUAGE_KEY,DEFAULT_LOCALE.getLanguage());
    immutableSystemProperties.put(USER_COUNTRY_KEY,DEFAULT_LOCALE.getCountry());
    immutableSystemProperties.put(USER_VARIANT_KEY,DEFAULT_LOCALE.getvariant());
}

public JavaExecHandleBuilder(FileResolver fileResolver) {
    super(fileResolver);
    this.fileResolver = fileResolver;
    javaoptions = new DefaultJavaForkOptions(fileResolver);
    classpath = new DefaultConfigurableFileCollection(fileResolver,null);
    executable(javaoptions.getExecutable());
}

public DefaultSourceSetoutput(String sourceSetdisplayName,FileResolver fileResolver,TaskResolver taskResolver) {
    this.fileResolver = fileResolver;
    String displayName = sourceSetdisplayName + " classes";
    outputDirectories = new DefaultConfigurableFileCollection(displayName,fileResolver,taskResolver,new Callable() {
        public Object call() throws Exception {
            return getClassesDir();
        }
    },new Callable() {
        public Object call() throws Exception {
            return getResourcesDir();
        }
    });
    dirs = new DefaultConfigurableFileCollection("dirs",taskResolver);
}

private static void fixTestTaskSources(@NonNull Test testTask) {
    // We are running in afterEvaluate,so the JavaBasePlugin has already added a
    // callback to add test classes to the list of source files of the newly created task.
    // The problem is that we haven't configured the test classes yet (JavaBasePlugin
    // assumes all Test tasks are fully configured at this point),so we have to remove the
    // "directory null" entry from source files and add the right value.
    //
    // This is an ugly hack,since we assume sourceFiles is an instance of
    // DefaultConfigurableFileCollection.
    ((DefaultConfigurableFileCollection) testTask.getInputs().getSourceFiles()).getFrom().clear();
}

public JvmOptions(FileResolver resolver) {
    this.bootstrapClasspath = new DefaultConfigurableFileCollection(resolver,DEFAULT_LOCALE.getvariant());
}

public JavaExecHandleBuilder(FileResolver fileResolver) {
    super(fileResolver);
    this.fileResolver = fileResolver;
    javaoptions = new DefaultJavaForkOptions(fileResolver);
    classpath = new DefaultConfigurableFileCollection(fileResolver,null);
    executable(javaoptions.getExecutable());
}

public DefaultSourceSetoutput(String sourceSetdisplayName,TaskResolver taskResolver) {
    this.fileResolver = fileResolver;
    String displayName = String.format("%s output",sourceSetdisplayName);
    outputDirectories = new DefaultConfigurableFileCollection(displayName,taskResolver);
}

public DefaultClasspath(FileResolver fileResolver,TaskResolver taskResolver) {
    files = new DefaultConfigurableFileCollection(fileResolver,taskResolver);
}

public FileCollectionInternal resolveFiles(Object... paths) {
    if (paths.length == 1 && paths[0] instanceof FileCollection) {
        return Cast.cast(FileCollectionInternal.class,paths[0]);
    }
    return new DefaultConfigurableFileCollection(this,null,paths);
}

public ConfigurableFileCollection files(Object... paths) {
    return new DefaultConfigurableFileCollection(fileResolver,paths);
}

public DefaultClasspath(FileResolver fileResolver,taskResolver);
}

public DefaultTaskInputs(FileResolver resolver,TaskInternal task,TaskMutator taskMutator) {
    this.resolver = resolver;
    this.taskMutator = taskMutator;
    inputFiles = new DefaultConfigurableFileCollection(String.format("%s input files",task),resolver,null);
    sourceFiles = new DefaultConfigurableFileCollection(String.format("%s source files",null);
}

public DefaultTaskOutputs(FileResolver resolver,TaskMutator taskMutator) {
    this.taskMutator = taskMutator;
    outputFiles = new DefaultConfigurableFileCollection(String.format("%s output files",null);
    outputFiles.builtBy(task);
}

public FileCollection resolveFiles(Object... paths) {
    if (paths.length == 1 && paths[0] instanceof FileCollection) {
        return (FileCollection) paths[0];
    }
    return new DefaultConfigurableFileCollection(this,paths);
}

public ConfigurableFileCollection files(Object... paths) {
    return new DefaultConfigurableFileCollection(fileResolver,paths);
}

public DefaultTaskInputs(FileResolver resolver,TaskStatusNagger taskStatusNagger) {
    this.resolver = resolver;
    this.taskStatusNagger = taskStatusNagger;
    inputFiles = new DefaultConfigurableFileCollection(String.format("%s input files",TaskStatusNagger taskStatusNagger) {
    this.taskStatusNagger = taskStatusNagger;
    outputFiles = new DefaultConfigurableFileCollection(String.format("%s output files",null);
    outputFiles.builtBy(task);
}

public JvmOptions(FileResolver resolver) {
    this.bootstrapClasspath = new DefaultConfigurableFileCollection(resolver,Charset.defaultCharset().name());
}

private void resolveAndFilterSourceFiles(final GroovyJavaJointCompileSpec spec) {
    final List<String> fileExtensions = CollectionUtils.collect(spec.getGroovyCompileOptions().getFileExtensions(),new Transformer<String,String>() {
        @Override
        public String transform(String extension) {
            return '.' + extension;
        }
    });
    FileCollection filtered = spec.getSource().filter(new Spec<File>() {
        public boolean isSatisfiedBy(File element) {
            for (String fileExtension : fileExtensions) {
                if (hasExtension(element,fileExtension)) {
                    return true;
                }
            }
            return false;
        }
    });

    spec.setSource(new SimpleFileCollection(filtered.getFiles()));
}

public void initializeCompilation(JavaCompileSpec spec,Collection<String> staleClasses) {
    if (staleClasses.isEmpty()) {
        spec.setSource(new SimpleFileCollection());
        return; //do nothing. No classes need recompilation.
    }

    Factory<PatternSet> patternSetFactory = fileOperations.getFileResolver().getPatternSetFactory();
    PatternSet classesToDelete = patternSetFactory.create();
    PatternSet sourcetoCompile = patternSetFactory.create();

    preparePatterns(staleClasses,classesToDelete,sourcetoCompile);

    //selectively configure the source
    spec.setSource(spec.getSource().getAsfiletree().matching(sourcetoCompile));
    //since we're compiling selectively we need to include the classes compiled prevIoUsly
    spec.setClasspath(Iterables.concat(spec.getClasspath(),asList(spec.getDestinationDir())));
    //get rid of stale files
    filetree deleteMe = fileOperations.filetree(spec.getDestinationDir()).matching(classesToDelete);
    fileOperations.delete(deleteMe);
}

private void addResourcesIfNecessary() {
    if (this.addResources) {
        SourceSet mainSourceSet = SourceSets.findMainSourceSet(getProject());
        final File outputDir = (mainSourceSet == null ? null
                : mainSourceSet.getoutput().getResourcesDir());
        final Set<File> resources = new LinkedHashSet<File>();
        if (mainSourceSet != null) {
            resources.addAll(mainSourceSet.getResources().getSrcDirs());
        }
        List<File> classpath = new ArrayList<File>(getClasspath().getFiles());
        classpath.addAll(0,resources);
        getLogger().info("Adding classpath: " + resources);
        setClasspath(new SimpleFileCollection(classpath));
        if (outputDir != null) {
            for (File directory : resources) {
                FileUtils.removeDuplicatesFromOutputDirectory(outputDir,directory);
            }
        }
    }
}

private void addResourcesIfNecessary() {
    if (this.addResources) {
        SourceSet mainSourceSet = SourceSets.findMainSourceSet(getProject());
        final File outputDir = (mainSourceSet == null ? null
                : mainSourceSet.getoutput().getResourcesDir());
        final Set<File> resources = new LinkedHashSet<File>();
        if (mainSourceSet != null) {
            resources.addAll(mainSourceSet.getResources().getSrcDirs());
        }
        List<File> classpath = new ArrayList<File>(getClasspath().getFiles());
        classpath.addAll(0,directory);
            }
        }
    }
}

private void addResourcesIfNecessary() {
    if (this.addResources) {
        SourceSet mainSourceSet = SourceSets.findMainSourceSet(getProject());
        final File outputDir = (mainSourceSet == null ? null
                : mainSourceSet.getoutput().getResourcesDir());
        final Set<File> resources = new LinkedHashSet<File>();
        if (mainSourceSet != null) {
            resources.addAll(mainSourceSet.getResources().getSrcDirs());
        }
        List<File> classpath = new ArrayList<File>(getClasspath().getFiles());
        classpath.addAll(0,directory);
            }
        }
    }
}

static FileCollection fromLocalClassloader() {
    Set<File> files = new LinkedHashSet<>();
    Consumer<Class<?>> addPeerClasses = clazz -> {
        urlclassloader urlclassloader = (urlclassloader) clazz.getClassLoader();
        for (URL url : urlclassloader.getURLs()) {
            String name = url.getFile();
            if (name != null) {
                files.add(new File(name));
            }
        }
    };
    // add the classes that goomph needs
    addPeerClasses.accept(JavaExecable.class);
    // add the gradle API
    addPeerClasses.accept(JavaExec.class);

    return new SimpleFileCollection(files);
}

public void initializeCompilation(JavaCompileSpec spec,Collection<String> staleClasses) {
    if (staleClasses.isEmpty()) {
        spec.setSource(new SimpleFileCollection());
        return; //do nothing. No classes need recompilation.
    }

    PatternSet classesToDelete = new PatternSet();
    PatternSet sourcetoCompile = new PatternSet();

    preparePatterns(staleClasses,asList(spec.getDestinationDir())));
    //get rid of stale files
    filetree deleteMe = fileOperations.filetree(spec.getDestinationDir()).matching(classesToDelete);
    fileOperations.delete(deleteMe);
}

private EnumMap<SysProp,String> getMetadataInternal(File jdkPath) {
    JavaExecAction exec = factory.newJavaExecAction();
    exec.executable(javaExe(jdkPath,"java"));
    File workingDir = Files.createTempDir();
    exec.setWorkingDir(workingDir);
    exec.setClasspath(new SimpleFileCollection(workingDir));
    try {
        writeProbe(workingDir);
        exec.setMain(JavaProbe.CLASSNAME);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        exec.setStandardOutput(baos);
        ByteArrayOutputStream errorOutput = new ByteArrayOutputStream();
        exec.setErrorOutput(errorOutput);
        exec.setIgnoreExitValue(true);
        ExecResult result = exec.execute();
        int exitValue = result.getExitValue();
        if (exitValue == 0) {
            return parseExecOutput(baos.toString());
        }
        return error("Command returned unexpected result code: " + exitValue + "\nError output:\n" + errorOutput);
    } catch (ExecException ex) {
        return error(ex.getMessage());
    } finally {
        try {
            FileUtils.deleteDirectory(workingDir);
        } catch (IOException e) {
            throw new GradleException("Unable to delete temp directory",e);
        }
    }
}

private void resolveAndFilterSourceFiles(JavaCompileSpec spec) {
    // this mimics the behavior of the Ant javac task (and therefore AntJavaCompiler),// which silently excludes files not ending in .java
    FileCollection javaOnly = spec.getSource().filter(new Spec<File>() {
        public boolean isSatisfiedBy(File element) {
            return hasExtension(element,".java");
        }
    });

    spec.setSource(new SimpleFileCollection(javaOnly.getFiles()));
}

@Override
public FileCollectionInternal createDelegate() {
    ImmutableSet.Builder<File> files = ImmutableSet.builder();
    for (ResolvedArtifact artifact : configuration.getResolvedConfiguration().getResolvedArtifacts()) {
        if ((artifact.getId().getComponentIdentifier() instanceof ProjectComponentIdentifier) == matchProjectComponents) {
            files.add(artifact.getFile());
        }
    }
    return new SimpleFileCollection(files.build());
}

private void resolveAndFilterSourceFiles(final GroovyJavaJointCompileSpec spec) {
    FileCollection filtered = spec.getSource().filter(new Spec<File>() {
        public boolean isSatisfiedBy(File element) {
            for (String fileExtension : spec.getGroovyCompileOptions().getFileExtensions()) {
                if (element.getName().endsWith("." + fileExtension)) {
                    return true;
                }
            }
            return false;
        }
    });

    spec.setSource(new SimpleFileCollection(filtered.getFiles()));
}

private void resolveAndFilterSourceFiles(JavaCompileSpec spec) {
    // this mimics the behavior of the Ant javac task (and therefore AntJavaCompiler),// which silently excludes files not ending in .java
    FileCollection javaOnly = spec.getSource().filter(new Spec<File>() {
        public boolean isSatisfiedBy(File element) {
            return element.getName().endsWith(".java");
        }
    });

    spec.setSource(new SimpleFileCollection(javaOnly.getFiles()));
}

public FileCollection getFiles() {
    List<File> files = new ArrayList<File>();
    for (Map.Entry<String,IncrementalFileSnapshot> entry : snapshots.entrySet()) {
        if (entry.getValue() instanceof filehashSnapshot) {
            files.add(new File(entry.getKey()));
        }
    }
    return new SimpleFileCollection(files);
}

private void resolveClasspath(ScalaJavaJointCompileSpec spec) {
    spec.setClasspath(new SimpleFileCollection(Lists.newArrayList(spec.getClasspath())));
    spec.setScalaClasspath(new SimpleFileCollection(Lists.newArrayList(spec.getScalaClasspath())));
    spec.setZincclasspath(new SimpleFileCollection(Lists.newArrayList(spec.getZincclasspath())));

    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Class path: {}",spec.getClasspath());
        LOGGER.debug("Scala class path: {}",spec.getScalaClasspath());
        LOGGER.debug("Zinc class path: {}",spec.getZincclasspath());
    }
}

public FileCollection getFiles() {
    List<File> files = new ArrayList<File>();
    for (Map.Entry<String,FileSnapshot> entry : snapshots.entrySet()) {
        if (entry.getValue() instanceof filehashSnapshot) {
            files.add(new File(entry.getKey()));
        }
    }
    return new SimpleFileCollection(files);
}

public SelectiveCompilation(IncrementalTaskInputs inputs,filetree source,FileCollection compileClasspath,final File compileDestination,final ClassDependencyInfoSerializer dependencyInfoSerializer,final JarSnapshotCache jarSnapshotCache,final SelectiveJavaCompiler compiler,Iterable<File> sourceDirs,final FileOperations operations) {
    this.operations = operations;
    this.jarSnapshotFeeder = new JarSnapshotFeeder(jarSnapshotCache,new JarSnapshotter(new DefaultHasher()));
    this.compiler = compiler;

    Clock clock = new Clock();
    final InputOutputMapper mapper = new InputOutputMapper(sourceDirs,compileDestination);

    //load dependency info
    final ClassDependencyInfo dependencyInfo = dependencyInfoSerializer.readInfo();

    //including only source java classes that were changed
    final PatternSet changedSourceOnly = new PatternSet();
    InputFileDetailsAction action = new InputFileDetailsAction(mapper,compiler,changedSourceOnly,dependencyInfo);
    inputs.outOfDate(action);
    inputs.removed(action);
    if (fullRebuildNeeded != null) {
        LOG.lifecycle("Stale classes detection completed in {}. Rebuild needed: {}.",clock.getTime(),fullRebuildNeeded);
        this.classpath = compileClasspath;
        this.source = source;
        return;
    }

    compiler.deleteStaleClasses();
    Set<File> filesToCompile = source.matching(changedSourceOnly).getFiles();
    if (filesToCompile.isEmpty()) {
        this.compilationNeeded = false;
        this.classpath = compileClasspath;
        this.source = source;
    } else {
        this.classpath = compileClasspath.plus(new SimpleFileCollection(compileDestination));
        this.source = source.matching(changedSourceOnly);
    }
    LOG.lifecycle("Stale classes detection completed in {}. Compile include patterns: {}.",changedSourceOnly.getIncludes());
}

@Override
public FileCollection getoutputFiles() {
    ArrayList<File> newOuputFiles = new ArrayList<>();
    for (File file : mTaskExecutionHistory.getoutputFiles()) {
        newOuputFiles.add(
                FileUtils.inFolder(file,mResFiles) ?
                        new IgnoreResFileFile(file.getPath(),mResFiles) : file);
    }
    return new SimpleFileCollection(newOuputFiles);
}

private FileCollection readlistofDepConfigs(@Nonnull final File pDepConfigDir)
{
    File[] listofFiles = pDepConfigDir.listFiles(new PropertyFileFilter());
    if (listofFiles == null) {
        throw new GradleException("no dependency configurations found in dir: " + pDepConfigDir);
    }
    return new SimpleFileCollection(listofFiles);
}

private FileCollection empty() {
    return new SimpleFileCollection();
}

@Override
public FileCollection getFiles() {
    return new SimpleFileCollection();
}

private void resolveClasspath(JavaCompileSpec spec) {
    spec.setClasspath(new SimpleFileCollection(Lists.newArrayList(spec.getClasspath())));
}

private void resolveAndFilterSourceFiles(final ScalaJavaJointCompileSpec spec) {
    spec.setSource(new SimpleFileCollection(spec.getSource().getFiles()));
}

public CacheableTaskOutputCompositeFilePropertyElementSpec(CompositeTaskOutputPropertySpec parentProperty,String propertySuffix,File file) {
    this.parentProperty = parentProperty;
    this.propertySuffix = propertySuffix;
    this.files = new SimpleFileCollection(Collections.singleton(file));
    this.file = file;
}

@Mutate
void createTestTasks(ModelMap<Task> tasks,@Path("binaries") ModelMap<PlayApplicationBinarySpecInternal> playBinaries,final PlayPluginConfigurations configurations,final FileResolver fileResolver,final ProjectIdentifier projectIdentifier,@Path("buildDir") final File buildDir) {
    for (final PlayApplicationBinarySpecInternal binary : playBinaries) {
        final PlayToolProvider playToolProvider = binary.getToolChain().select(binary.getTargetPlatform());
        final FileCollection testCompileClasspath = getTestCompileClasspath(binary,playToolProvider,configurations);

        final String testCompileTaskName = binary.getTasks().taskName("compile","tests");
        final File testSourceDir = fileResolver.resolve("test");
        final FileCollection testSources = new SimpleFileCollection(testSourceDir).getAsfiletree().matching(new PatternSet().include("**/*.scala","**/*.java"));
        final File testClassesDir = new File(buildDir,binary.getProjectScopedname() + "/testClasses");
        tasks.create(testCompileTaskName,PlatformScalaCompile.class,new Action<PlatformScalaCompile>() {
            public void execute(PlatformScalaCompile scalaCompile) {
                scalaCompile.setDescription("Compiles the scala and java test sources for the " + binary.getdisplayName() + ".");

                scalaCompile.setClasspath(testCompileClasspath);

                scalaCompile.dependsOn(binary.getBuildTask());
                scalaCompile.setPlatform(binary.getTargetPlatform().getScalaPlatform());
                scalaCompile.setDestinationDir(testClassesDir);
                scalaCompile.setSource(testSources);
                String targetCompatibility = binary.getTargetPlatform().getJavaPlatform().getTargetCompatibility().getMajorVersion();
                scalaCompile.setSourceCompatibility(targetCompatibility);
                scalaCompile.setTargetCompatibility(targetCompatibility);

                IncrementalCompileOptions incrementalOptions = scalaCompile.getScalaCompileOptions().getIncrementalOptions();
                incrementalOptions.setAnalysisFile(new File(buildDir,"tmp/scala/compilerAnalysis/" + testCompileTaskName + ".analysis"));
            }
        });

        final String testTaskName = binary.getTasks().taskName("test");
        final File binaryBuildDir = new File(buildDir,binary.getProjectScopedname());
        tasks.create(testTaskName,Test.class,new Action<Test>() {
            public void execute(Test test) {
                test.setDescription("Runs " + WordUtils.uncapitalize(binary.getdisplayName() + "."));

                test.setClasspath(getRuntimeClasspath(testClassesDir,testCompileClasspath));

                test.setTestClassesDir(testClassesDir);
                test.setBinResultsDir(new File(binaryBuildDir,"results/" + testTaskName + "/bin"));
                test.getReports().getJunitXml().setDestination(new File(binaryBuildDir,"reports/test/xml"));
                test.getReports().getHtml().setDestination(new File(binaryBuildDir,"reports/test"));
                test.dependsOn(testCompileTaskName);
                test.setWorkingDir(projectIdentifier.getProjectDir());
            }
        });
        binary.getTasks().add(tasks.get(testTaskName));
    }
}

private FileCollection getTestCompileClasspath(PlayApplicationBinarySpec binary,PlayToolProvider playToolProvider,PlayPluginConfigurations configurations) {
    return new SimpleFileCollection(binary.getJarFile()).plus(configurations.getPlaytest().getAllArtifacts());
}

private FileCollection getRuntimeClasspath(File testClassesDir,FileCollection testCompileClasspath) {
    return new SimpleFileCollection(testClassesDir).plus(testCompileClasspath);
}

private FileCollection newSignatureFileCollection(Function<Signature,File> getFile) {
    return new SimpleFileCollection(collectSignatureFiles(getFile));
}

private void resolveAndFilterSourceFiles(final ScalaJavaJointCompileSpec spec) {
    spec.setSource(new SimpleFileCollection(spec.getSource().getFiles()));
}

private FileCollection empty() {
    return new SimpleFileCollection();
}

public FileCollection getLinkFiles() {
    return new SimpleFileCollection();
}

public FileCollection getRuntimeFiles() {
    return new SimpleFileCollection();
}

public FileCollection getRuntimeFiles() {
    return new SimpleFileCollection();
}

public FileCollection getHeaderDirs() {
    return new SimpleFileCollection(library.getHeaders().getSrcDirs());
}

public FileCollection getRuntimeFiles() {
    return new SimpleFileCollection();
}

private FileCollection toFileCollection(Iterable<File> classpath) {
    if (classpath instanceof FileCollection) {
        return (FileCollection) classpath;
    }
    return new SimpleFileCollection(Lists.newArrayList(classpath));
}

private void resolveClasspath(JavaCompileSpec spec) {
    spec.setClasspath(new SimpleFileCollection(Lists.newArrayList(spec.getClasspath())));
}

public FileCollection getFiles() {
    return new SimpleFileCollection();
}

public FileCollection getoutputFiles() {
    TaskExecution lastExecution = history.getPrevIoUsExecution();
    return lastExecution != null && lastExecution.getoutputFilesSnapshot() != null ? lastExecution.getoutputFilesSnapshot().getFiles() : new SimpleFileCollection();
}