C# IReadOnlyList.AsParallel方法代码示例

        public IEnumerable<IDocument> Minify(IReadOnlyList<IDocument> inputs, IExecutionContext context, Func<string, MinificationResultBase> minify, string minifierType)
        {
            return inputs.AsParallel().Select(input =>
            {
                try
                {
                    MinificationResultBase result = minify(input.Content);

                    if (result.Errors.Count > 0)
                    {
                        Trace.Error("{0} errors found while minifying {4} for {1}:{2}{3}", result.Errors.Count, input.Source, Environment.NewLine, string.Join(Environment.NewLine, result.Errors.Select(x => MinificationErrorInfoToString(x))), minifierType);
                        return input;
                    }

                    if (result.Warnings.Count > 0)
                    {
                        Trace.Warning("{0} warnings found while minifying {4} for {1}:{2}{3}", result.Warnings.Count, input.Source, Environment.NewLine, string.Join(Environment.NewLine, result.Warnings.Select(x => MinificationErrorInfoToString(x))), minifierType);
                    }

                    return context.GetDocument(input, result.MinifiedContent);
                }
                catch (Exception ex)
                {
                    Trace.Error("Exception while minifying {2} for {0}: {1}", input.Source, ex.Message, minifierType);
                    return input;
                }
            });
        }

 public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
 {
     return inputs
         .AsParallel()
         .SelectMany(input =>
         {
             List<Dictionary<string, object>> documentMetadata = new List<Dictionary<string, object>>();
             using (TextReader contentReader = new StringReader(input.Content))
             {
                 YamlStream yamlStream = new YamlStream();
                 yamlStream.Load(contentReader);
                 foreach (YamlDocument document in yamlStream.Documents)
                 {
                     // If this is a sequence, get a document for each item
                     YamlSequenceNode rootSequence = document.RootNode as YamlSequenceNode;
                     if (rootSequence != null)
                     {
                         documentMetadata.AddRange(rootSequence.Children.Select(GetDocumentMetadata));
                     }
                     else
                     {
                         // Otherwise, just get a single set of metadata
                         documentMetadata.Add(GetDocumentMetadata(document.RootNode));
                     }
                 }
             }
             return documentMetadata.Select(metadata => context.GetDocument(input, metadata));
         })
         .Where(x => x != null);
 }

 public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
 {
     return inputs
        .AsParallel()
        .Select(input =>
        {
            try
            {
                object data = _data(input, context);
                if (data != null)
                {
                    string result = JsonConvert.SerializeObject(data,
                        _indenting ? Formatting.Indented : Formatting.None);
                    if (string.IsNullOrEmpty(_destinationKey))
                    {
                        return context.GetDocument(input, result);
                    }
                    return context.GetDocument(input, new MetadataItems
                    {
                        {_destinationKey, result}
                    });
                }
            }
            catch (Exception ex)
            {
                Trace.Error("Error serializing JSON for {0}: {1}", input.Source, ex.ToString());
            }
            return input;
        })
        .Where(x => x != null);
 }

 public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
 {
     GitHubClient github = new GitHubClient(new ProductHeaderValue("Wyam"), _url ?? GitHubClient.GitHubApiUrl);
     if (_credentials != null)
     {
         github.Credentials = _credentials;
     }
     return inputs.AsParallel().Select(input =>
     {
         ConcurrentDictionary<string, object> results = new ConcurrentDictionary<string, object>();
         foreach (KeyValuePair<string, Func<IDocument, IExecutionContext, GitHubClient, object>> request in _requests.AsParallel())
         {
             Trace.Verbose("Submitting {0} GitHub request for {1}", request.Key, input.Source);
             try
             {
                 results[request.Key] = request.Value(input, context, github);
             }
             catch (Exception ex)
             {
                 Trace.Warning("Exception while submitting {0} GitHub request for {1}: {2}", request.Key, input.Source, ex.ToString());
             }
         }
         return context.GetDocument(input, results);
     });
 }

 public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
 {
     return _path != null
         ? Execute(null, _path, context)
         : inputs.AsParallel().SelectMany(input =>
             Execute(input, _pathDelegate.Invoke<string>(input, context), context));
 }

        public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
        {
            DotlessConfiguration config = DotlessConfiguration.GetDefault();
            config.Logger = typeof (LessLogger);
            EngineFactory engineFactory = new EngineFactory(config);

            return inputs.AsParallel().Select(x =>
            {
                context.Trace.Verbose("Processing Less for {0}", x.Source);
                ILessEngine engine = engineFactory.GetEngine();

                // TODO: Get rid of RefelectionMagic and this ugly hack as soon as dotless gets better external DI support
                engine.AsDynamic().Underlying.Cache = new LessCache(context.ExecutionCache);

                string path = x.Get<string>("SourceFilePath", null);
                string fileName = null;
                if (path != null)
                {
                    engine.CurrentDirectory = Path.GetDirectoryName(path);
                    fileName = Path.GetFileName(path);
                }
                else
                {
                    engine.CurrentDirectory = context.InputFolder;
                    fileName = Path.GetRandomFileName();
                }
                string content = engine.TransformToCss(x.Content, fileName);
                return x.Clone(content);
            });
        }

 public virtual IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
 {
     return inputs.AsParallel().Select(input =>
     {
         if (ShouldProcess(input, context))
         {
             string path = GetPath(input, context);
             if (path != null)
             {
                 string pathDirectory = Path.GetDirectoryName(path);
                 if (pathDirectory != null && !Directory.Exists(pathDirectory))
                 {
                     Directory.CreateDirectory(pathDirectory);
                 }
                 FileStream outputStream = File.Open(path, FileMode.Create);
                 using (Stream inputStream = input.GetStream())
                 {
                     inputStream.CopyTo(outputStream);
                 }
                 context.Trace.Verbose("Wrote file {0}", path);
                 return input.Clone(outputStream, new []
                 {
                     Metadata.Create(MetadataKeys.DestinationFileBase, Path.GetFileNameWithoutExtension(path)),
                     Metadata.Create(MetadataKeys.DestinationFileExt, Path.GetExtension(path)),
                     Metadata.Create(MetadataKeys.DestinationFileName, Path.GetFileName(path)),
                     Metadata.Create(MetadataKeys.DestinationFileDir, Path.GetDirectoryName(path)),
                     Metadata.Create(MetadataKeys.DestinationFilePath, path),
                     Metadata.Create(MetadataKeys.DestinationFilePathBase, PathHelper.RemoveExtension(path))
                 });
             }
         }
         return input;
     });
 }

        public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
        {
            DotlessConfiguration config = DotlessConfiguration.GetDefault();
            config.Logger = typeof (LessLogger);
            EngineFactory engineFactory = new EngineFactory(config);
            FileSystemReader fileSystemReader = new FileSystemReader(context.FileSystem);
            
            return inputs.AsParallel().Select(input =>
            {
                Trace.Verbose("Processing Less for {0}", input.SourceString());
                ILessEngine engine = engineFactory.GetEngine();
                
                // TODO: Get rid of RefelectionMagic and this ugly hack as soon as dotless gets better external DI support
                engine.AsDynamic().Underlying.Cache = new LessCache(context.ExecutionCache);
                engine.AsDynamic().Underlying.Underlying.Parser.Importer.FileReader = fileSystemReader;

                FilePath path = input.FilePath(Keys.RelativeFilePath);
                string fileName = null;
                if (path != null)
                {
                    engine.CurrentDirectory = path.Directory.FullPath;
                    fileName = path.FileName.FullPath;
                }
                else
                {
                    engine.CurrentDirectory = string.Empty;
                    fileName = Path.GetRandomFileName();
                }
                string content = engine.TransformToCss(input.Content, fileName);
                return context.GetDocument(input, content);
            });
        }

 public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
 {
     HtmlParser parser = new HtmlParser();
     return inputs.AsParallel().Select(x =>
     {
         try
         {
             IHtmlDocument htmlDocument;
             using (Stream stream = x.GetStream())
             {
                 htmlDocument = parser.Parse(stream);
             }
             IElement element = htmlDocument.QuerySelector(_querySelector);
             if (element != null)
             {
                 return x.Clone(new Dictionary<string, object>()
                 {
                     {_metadataKey, _outerHtml ? element.OuterHtml : element.InnerHtml}
                 });
             }
             return x;
         }
         catch (Exception ex)
         {
             context.Trace.Warning("Exception while parsing HTML for {0}: {1}", x.Source, ex.Message);
             return x;
         }
     });
 }

        public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
        {
            return inputs.AsParallel().SelectMany(input =>
            {
                object existingValue;
                var hasExistingKey = input.TryGetValue(_fromKey, out existingValue);

                if (hasExistingKey)
                {
                    if (_format != null)
                    {
                        if (existingValue is DateTime)
                        {
                            existingValue = ((DateTime)existingValue).ToString(_format);
                        }
                        else
                        {
                            existingValue = string.Format(_format, existingValue);
                        }
                    }

                    if (_execute != null)
                    {
                        existingValue = _execute.Invoke(existingValue.ToString());
                    }

                    return new[] { context.GetDocument(input, new[] { new KeyValuePair<string, object>(_toKey, existingValue) }) };
                }
                else
                {
                    return new[] { input };
                }
            });
        }

        public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
        {
            HtmlParser parser = new HtmlParser();
            return inputs.AsParallel().SelectMany(x =>
            {
                // Parse the HTML content
                IHtmlDocument htmlDocument;
                try
                {
                    using (Stream stream = x.GetStream())
                    {
                        htmlDocument = parser.Parse(stream);
                    }
                }
                catch (Exception ex)
                {
                    context.Trace.Warning("Exception while parsing HTML for {0}: {1}", x.Source, ex.Message);
                    return new [] { x };
                }

                // Evaluate the query selector
                try
                {
                    if (!string.IsNullOrWhiteSpace(_querySelector))
                    {
                        IElement[] elements = _first
                            ? new[] {htmlDocument.QuerySelector(_querySelector)}
                            : htmlDocument.QuerySelectorAll(_querySelector).ToArray();
                        if (elements.Length > 0 && elements[0] != null)
                        {
                            List<IDocument> documents = new List<IDocument>();
                            foreach (IElement element in elements)
                            {
                                // Get the metadata
                                Dictionary<string, object> metadata = new Dictionary<string, object>();
                                foreach (Action<IElement, Dictionary<string, object>> metadataAction in _metadataActions)
                                {
                                    metadataAction(element, metadata);
                                }

                                // Clone the document and optionally change content to the HTML element
                                documents.Add(_outerHtmlContent.HasValue
                                    ? x.Clone(_outerHtmlContent.Value ? element.OuterHtml : element.InnerHtml, metadata.Count == 0 ? null : metadata)
                                    : x.Clone(metadata));
                            }
                            return (IEnumerable<IDocument>) documents;
                        }
                    }
                    return new[] { x };
                }
                catch (Exception ex)
                {
                    context.Trace.Warning("Exception while processing HTML for {0}: {1}", x.Source, ex.Message);
                    return new[] { x };
                }
            });
        }

        public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
        {
            return inputs
                .AsParallel()
                .Select(x =>
                {
                    try
                    {
                        Dictionary<string, object> items = new Dictionary<string, object>();
                        using (TextReader contentReader = new StringReader(x.Content))
                        {
                            YamlStream yamlStream = new YamlStream();
                            yamlStream.Load(contentReader);
                            if (yamlStream.Documents.Count > 0)
                            {
                                if (!string.IsNullOrEmpty(_key))
                                {
                                    items[_key] = new DynamicYaml(yamlStream.Documents[0].RootNode);
                                }
                                if (_flatten)
                                {
                                    foreach (YamlDocument document in yamlStream.Documents)
                                    {
                                        // Map scalar-to-scalar children
                                        foreach (KeyValuePair<YamlNode, YamlNode> child in
                                            ((YamlMappingNode)document.RootNode).Children.Where(y => y.Key is YamlScalarNode && y.Value is YamlScalarNode))
                                        {
                                            items[((YamlScalarNode)child.Key).Value] = ((YamlScalarNode)child.Value).Value;
                                        }

                                        // Map simple sequences
                                        foreach (KeyValuePair<YamlNode, YamlNode> child in
                                            ((YamlMappingNode) document.RootNode).Children.Where(y => y.Key is YamlScalarNode && y.Value is YamlSequenceNode && ((YamlSequenceNode)y.Value).All(z => z is YamlScalarNode)))
                                        {
                                            items[((YamlScalarNode)child.Key).Value] = ((YamlSequenceNode)child.Value).Select(a => ((YamlScalarNode)a).Value).ToArray();
                                        }
                                    }
                                }
                            }
                        }
                        return x.Clone(items);
                    }
                    catch (Exception ex)
                    {
                        context.Trace.Error("Error processing YAML for {0}: {1}", x.Source, ex.ToString());
                    }
                    return null;
                })
                .Where(x => x != null);
        }

        public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
        {
            return inputs.AsParallel().Select(input =>
            {
                try
                {
                    XslCompiledTransform xslt = new XslCompiledTransform();

                    if (_xsltPath != null)
                    {
                        FilePath path = _xsltPath.Invoke<FilePath>(input, context);
                        if (path != null)
                        {
                            IFile file = context.FileSystem.GetInputFile(path);
                            if (file.Exists)
                            {
                                using (Stream fileStream = file.OpenRead())
                                {
                                    xslt.Load(XmlReader.Create(fileStream));
                                }
                            }
                        }
                    }
                    else if (_xsltGeneration != null)
                    {
                        IDocument xsltDocument = context.Execute(_xsltGeneration, new[] {input}).Single();
                        using (Stream stream = xsltDocument.GetStream())
                        {
                            xslt.Load(XmlReader.Create(stream));
                        }
                    }
                    using (Stream stream = input.GetStream())
                    {
                        StringWriter str = new StringWriter();
                        using (XmlTextWriter writer = new XmlTextWriter(str))
                        {
                            xslt.Transform(XmlReader.Create(stream), writer);
                        }
                        return context.GetDocument(input, str.ToString());
                    }

                }
                catch (Exception e)
                {
                    Trace.Error($"An {e.GetType().Name} occurred: {e.Message}");
                    return null;
                }
            }).Where(x => x != null);
        }

 public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
 {
     return inputs.AsParallel().Select(x =>
     {
         context.Trace.Verbose("Processing Markdown for {0}", x.Source);
         string result;
         IExecutionCache executionCache = context.ExecutionCache;
         if (!executionCache.TryGetValue<string>(x, out result))
         {
             result = CommonMark.CommonMarkConverter.Convert(x.Content);
             executionCache.Set(x, result);
         }
         return x.Clone(result);
     });
 }

 public override IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
 {
     return inputs.AsParallel().Select(input =>
     {
         if (ShouldProcess(input, context))
         {
             string path = GetPath(input, context);
             if (path != null)
             {
                 string pathDirectory = Path.GetDirectoryName(path);
                 if ((pathDirectory != null && Directory.Exists(pathDirectory) && File.Exists(path)) || (pathDirectory == null && File.Exists(path)))
                 {
                     return null;
                 }
             }
         }
         return input;
     }).Where(x => x != null);
 }