本文整理汇总了C#中IReadOnlyList.AsParallel方法的典型用法代码示例。如果您正苦于以下问题:C# IReadOnlyList.AsParallel方法的具体用法?C# IReadOnlyList.AsParallel怎么用?C# IReadOnlyList.AsParallel使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类IReadOnlyList
的用法示例。
在下文中一共展示了IReadOnlyList.AsParallel方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: Minify
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;
}
});
}
示例2: Execute
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);
}
示例3: Execute
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);
}
示例4: Execute
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);
});
}
示例5: Execute
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));
}
示例6: Execute
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);
});
}
示例7: Execute
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;
});
}
示例8: Execute
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);
});
}
示例9: Execute
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;
}
});
}
示例10: Execute
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 };
}
});
}
示例11: Execute
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 };
}
});
}
示例12: Execute
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);
}
示例13: Execute
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);
}
示例14: Execute
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);
});
}
示例15: Execute
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);
}