public static void Write(TextWriter writer, IEnumerable<Dictionary<string, string>> records)
{
if (records == null) return; //AOT
var allKeys = new HashSet<string>();
var cachedRecords = new List<IDictionary<string, string>>();
foreach (var record in records)
{
foreach (var key in record.Keys)
{
if (!allKeys.Contains(key))
{
allKeys.Add(key);
}
}
cachedRecords.Add(record);
}
var headers = allKeys.OrderBy(key => key).ToList();
if (!CsvConfig<Dictionary<string, string>>.OmitHeaders)
{
WriteRow(writer, headers);
}
foreach (var cachedRecord in cachedRecords)
{
var fullRecord = headers.ConvertAll(header =>
cachedRecord.ContainsKey(header) ? cachedRecord[header] : null);
WriteRow(writer, fullRecord);
}
}
public static int Solution2(Stopwatch timer)
{
timer.Restart();
var a = new HashSet<int>();
int maxlcm = 1;
int t = 0;
var results = new List<int>();
for (int i = 2; i <= 20; i++)
{
int k = i%2 == 0 ? 1 : 2;
for (int j = k; j < i; j+=2)
{
if (gcd(i, j) == 1)
{
a.Add(2*i*(i + j));
}
}
}
var sortedA = a.OrderBy(v => v).ToArray();
while (maxlcm < 1000)
{
maxlcm = lcm(maxlcm, sortedA[t]);
results.Add(maxlcm);
t++;
}
int res = results[results.Count - 2];
timer.Stop();
return res;
}
public void UpdateInfo()
{
if (Application.Session == null)
{
this.fileList.Items.Clear();
}
else
{
HashSet<string> files = new HashSet<string>(PathComparer.OSIndependentPath);
// Search for source files
foreach (ObjectCodeFile obj in Application.Session.LoadedImages)
{
foreach (string path in obj.SourceFiles)
{
files.Add(path);
}
}
// Add each file item
foreach (string file in files.OrderBy(x=>x, PathComparer.OSIndependentFilename))
{
// Ignore empty entries
if (!string.IsNullOrWhiteSpace(file))
{
var newItem = new SourceFileItem(file);
newItem.MouseDoubleClick += OnFileDoubleClick;
this.fileList.Items.Add(newItem);
}
}
}
}
/// <summary>
/// 获取一次Tcp端口快照信息
/// </summary>
/// <param name="ipVersion">ip版本</param>
/// <returns></returns>
public static unsafe PortOwnerPid[] Snapshot(AddressFamily ipVersion)
{
var size = 0;
var TCP_TABLE_OWNER_PID_ALL = 5;
TcpSnapshot.GetExtendedTcpTable(null, &size, false, ipVersion, TCP_TABLE_OWNER_PID_ALL, 0);
var pTable = stackalloc byte[size];
var state = TcpSnapshot.GetExtendedTcpTable(pTable, &size, false, ipVersion, TCP_TABLE_OWNER_PID_ALL, 0);
if (state != 0)
{
return new PortOwnerPid[0];
}
var hashSet = new HashSet<PortOwnerPid>();
var rowLength = *(int*)(pTable);
var pRow = pTable + Marshal.SizeOf(rowLength);
for (int i = 0; i < rowLength; i++)
{
var row = *(MIB_TCPROW_OWNER_PID*)pRow;
var port = ByteConverter.ToBytes(row.LocalPort, Endians.Little);
var portOwner = new PortOwnerPid
{
Port = ByteConverter.ToUInt16(port, 0, Endians.Big),
OwerPid = (int)row.OwningPid
};
hashSet.Add(portOwner);
pRow = pRow + Marshal.SizeOf(typeof(MIB_TCPROW_OWNER_PID));
}
return hashSet.OrderBy(item => item.Port).ToArray();
}
public void Walk(IGraphNode<LibraryDescription> root)
{
_assemblyFilePaths = new HashSet<string>(StringComparer.Ordinal);
_dependencyAssemblySources = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
_dependencyPackageSources = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal);
var libraries = new HashSet<LibraryDescription>();
root.DepthFirstPreOrderWalk(visitNode: (node, _) => VisitLibrary(node, _, libraries));
_reports.Information.WriteLine("\n[Target framework {0} ({1})]\n",
_framework.ToString(), VersionUtility.GetShortFrameworkName(_framework));
foreach (var assemblyFilePath in _assemblyFilePaths.OrderBy(assemblyName => assemblyName))
{
_reports.Information.WriteLine(assemblyFilePath);
if (_showDetails)
{
var assemblyName = Path.GetFileNameWithoutExtension(assemblyFilePath);
HashSet<string> packagesSources;
if (_dependencyPackageSources.TryGetValue(assemblyName, out packagesSources) && packagesSources.Any())
{
_reports.Information.WriteLine(" by package: {0}", string.Join(", ", packagesSources));
}
HashSet<string> assemblySources;
if (_dependencyAssemblySources.TryGetValue(assemblyName, out assemblySources) && assemblySources.Any())
{
_reports.Information.WriteLine(" by assembly: {0}", string.Join(", ", assemblySources));
}
}
}
}
public FeatureInteraction(HashSet<XgbTreeNode> interaction, double gain, double cover, double pathProbability, double depth, double treeIndex, double fScore = 1)
{
SplitValueHistogram = new SplitValueHistogram();
List<string> features = interaction.OrderBy(x => x.Feature).Select(y => y.Feature).ToList();
Name = string.Join("|", features);
Depth = interaction.Count - 1;
Gain = gain;
Cover = cover;
FScore = fScore;
FScoreWeighted = pathProbability;
AverageFScoreWeighted = FScoreWeighted / FScore;
AverageGain = Gain / FScore;
ExpectedGain = Gain * pathProbability;
TreeIndex = treeIndex;
TreeDepth = depth;
AverageTreeIndex = TreeIndex / FScore;
AverageTreeDepth = TreeDepth / FScore;
HasLeafStatistics = false;
if (Depth == 0)
{
SplitValueHistogram.AddValue(interaction.First().SplitValue);
}
}
public static void Main()
{
var generator = new TextGenerator(WordTypes.Name);
var names = generator.GenerateText(1000);
var trie = new Trie();
var words = new HashSet<string>();
names.Split(' ').ToList().ForEach(
x =>
{
words.Add(x);
trie.AddWord(x);
});
var result = new StringBuilder();
foreach (var word in words.OrderBy(x => x))
{
int occurenceCount;
trie.TryFindWord(word, out occurenceCount);
result.AppendFormat("{0} -> {1} times", word, occurenceCount).AppendLine();
}
Console.WriteLine(result);
}
//private static void ProcessNode(HtmlNode node, Stack<HtmlNode> stack)
//{
// var depth = stack.Count;
// var padding = String.Empty.PadLeft(depth, ' ');
// stack.Push(node);
// try
// {
// Debug.WriteLine(padding + "Node: " + node.Name);
// foreach (var child in node.ChildNodes)
// {
// ProcessNode(child, stack);
// }
// }
// finally
// {
// stack.Pop();
// }
//}
private void button_Click(object sender, RoutedEventArgs e)
{
using (var stream = File.OpenRead(@"C:\Documents\bookmarks_7_27_15.html"))
{
var doc = new HtmlDocument();
doc.Load(stream);
var rootFolder = new Folder { Name = "<root>" };
ProcessNode(doc.DocumentNode, rootFolder);
if (rootFolder.Folders.Count == 1)
rootFolder = rootFolder.Folders.Single();
treeView.Items.Add(GetTree(rootFolder));
var bookmarks = rootFolder.AllBookmarks.ToList();
bookmarks.Sort(
(l, r) => StringComparer.OrdinalIgnoreCase.Compare(l.Href.ToString(), r.Href.ToString()));
var lookupItem = new TreeViewItem { Header = "Lookup" };
var lookup = rootFolder.AllBookmarks.ToLookup(b => b.Href.ToString(), b => b.Folder, StringComparer.OrdinalIgnoreCase);
foreach (var key in lookup)
{
var folders = new HashSet<string>(key.Select(k => k.FullName), StringComparer.OrdinalIgnoreCase);
if (folders.Count > 1)
{
//folders.Sort((l, r) => StringComparer.OrdinalIgnoreCase.Compare(l.FullName, r.FullName));
var keyItem = new TreeViewItem { Header = key.Key + " (" + folders.Count + ")" };
foreach (var folder in folders.OrderBy(f => f, StringComparer.OrdinalIgnoreCase))
keyItem.Items.Add(new TreeViewItem { Header = folder });
lookupItem.Items.Add(keyItem);
}
}
lookupItem.ExpandSubtree();
treeView.Items.Add(lookupItem);
var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (var bookmark in rootFolder.AllBookmarks)
set.Add(bookmark.ToString());
foreach (var txt in set)
Debug.WriteLine(txt);
using (var output = File.OpenWrite(@"C:\Documents\output.html"))
{
output.SetLength(0);
using (var writer = new StreamWriter(output))
{
writer.WriteLine(@"<!DOCTYPE NETSCAPE-Bookmark-file-1>");
writer.WriteLine(@"<!-- This is an automatically generated file.");
writer.WriteLine(@" It will be read and overwritten.");
writer.WriteLine(@" DO NOT EDIT! -->");
writer.WriteLine(
"<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html;charset=UTF-8\">");
writer.WriteLine(@"<TITLE>Bookmarks</TITLE>");
WriteFolder(rootFolder, writer, new HashSet<string>(StringComparer.OrdinalIgnoreCase), "");
}
}
//Debugger.Break();
}
}
/// <summary>
/// Reduce a list of References to the smallest set of references that
/// covers the same set as the original.
/// </summary>
/// <param name="source">the list of references</param>
/// <returns>a reduced set of references</returns>
public static ICollection<Reference> Reduce(this IEnumerable<Reference> source)
{
Reference lastReference = null;
List<Reference> destination = new List<Reference>();
foreach (Reference check in source.OrderBy(r => r))
{
if (lastReference != null)
{
if (lastReference.Book.Equals(check.Book) && lastReference.Chapter == check.Chapter)
{
HashSet<int> uniqueVerses = new HashSet<int>(lastReference.Verses.Union(check.Verses));
lastReference.Verses = uniqueVerses.OrderBy(v => v).ToArray();
}
else
{
destination.Add(lastReference);
lastReference = null;
}
}
lastReference = check;
}
if (lastReference != null)
{
destination.Add(lastReference);
}
return destination;
}
static void Main(string[] args)
{
int N = int.Parse(Console.ReadLine());
HashSet<House> Houses = new HashSet<House>();
long amountOfCable = 0;
for (int i = 0; i < N; i++)
{
string[] inputs = Console.ReadLine().Split(' ');
Houses.Add(new House { X = int.Parse(inputs[0]), Y = int.Parse(inputs[1]) });
}
//Core: Calculate Average House Y index
double Avg = Houses.Sum(x => x.Y) / N;
//Core:find the house closest to the Avg Y and use its Y coordinate
int closest = Houses.OrderBy(x => Math.Abs(x.Y - Avg)).First().Y;
//lay the mainline
amountOfCable += (Houses.Max(x => x.X) - Houses.Min(x => x.X));
//per other House calculate distance from location to mainline
foreach (var i in Houses)
{
amountOfCable += i.Y > closest ? i.Y - closest : closest - i.Y;
}
// Write an action using Console.WriteLine()
// To debug: Console.Error.WriteLine("Debug messages...");
Console.WriteLine(amountOfCable);
}
/// <summary>
/// Retrieves all events across all aggregates that are related to the specified aggregate ids, in the order in which they were recorded.
/// </summary>
/// <param name="events">The events.</param>
/// <param name="relatedToAggregateIds">The aggregate ids to which the events relate.</param>
public static async Task<IEnumerable<StorableEvent>> RelatedEvents(
this IQueryable<StorableEvent> events,
params Guid[] relatedToAggregateIds)
{
var ids = new HashSet<Guid>(relatedToAggregateIds);
var relatedEvents = new HashSet<StorableEvent>();
int currentCount;
do
{
currentCount = relatedEvents.Count;
var unqueriedIds = ids.Where(id => ! relatedEvents.Select(e => e.AggregateId).Contains(id));
var newEvents = await events.Where(e => unqueriedIds.Any(id => id == e.AggregateId)).ToArrayAsync();
relatedEvents.UnionWith(newEvents);
var moreIds = newEvents
.SelectMany(e => e.Body.ExtractGuids())
.Distinct()
.ToArray();
if (!moreIds.Any())
{
break;
}
ids.UnionWith(moreIds);
} while (currentCount != relatedEvents.Count);
return relatedEvents.OrderBy(e => e.Id);
}
private List<int> Combinations(int num)
{
_digits = num.ToString().Select(c => Convert.ToInt32(c.ToString())).ToArray();
_combos = new HashSet<int>();
Helper(0);
return _combos.OrderBy(o => o).ToList();
}
static Version[] CalculateKnownVersions(ReportRepository repository)
{
const int blocks = 4;
const int versionsPerBlock = 2;
HashSet<Version> popularVersions = new HashSet<Version>();
DateTime startDate = repository.Sessions.Min(s => s.StartTime);
DateTime endDate = repository.Sessions.Max(s => s.StartTime);
TimeSpan span = endDate - startDate;
// last week has its own block, other 3 blocks are distributed evenly over the remaining timespan
if (span > new TimeSpan(30, 0, 0, 0))
span -= new TimeSpan(7, 0, 0, 0);
foreach (var groupByBlock in repository.Sessions.AsEnumerable().GroupBy(s => (s.StartTime.Ticks-startDate.Ticks)*(blocks-1)/span.Ticks).OrderBy(g => g.Key)) {
int versionsAddedThisBlock = 0;
foreach (var version in groupByBlock.GroupBy(s => s.AppVersion).OrderByDescending(g => g.Count())) {
if (popularVersions.Add(version.Key)) {
if (++versionsAddedThisBlock >= versionsPerBlock)
break;
}
}
}
return popularVersions.OrderBy(v => v).ToArray();
}
private void RenderMismatches(string format, HashSet<Tuple<string, string, string>> results)
{
foreach (var row in results.OrderBy(r => r.Item1))
{
_options.Reports.WriteInformation(string.Format(format, row.Item1, row.Item2, row.Item3));
}
}
/// <summary>
/// 对可行点进行排序。排序的依据为每个点的评分。
/// </summary>
/// <param name="set"></param>
/// <returns></returns>
public List<Point> SortPossiblePoint(HashSet<Point> set)
{
List<Point >list=new List<Point> ();
IEnumerable<Point> ie = set.OrderBy(p => p.Evaluate);
foreach (Point p in ie)
list.Add(p);
return list;
}
protected void WriteClaimSignatureSet( HashSet<string> claimSignatures)
{
Debug.WriteLine("Claim Signatures: ");
foreach (var claimSignature in claimSignatures.OrderBy(n => n))
{
Debug.WriteLine("\t" + claimSignature);
}
}
/// <summary>
/// Find all listener interfaces in the given assembly that are not somehow used in an event.
/// </summary>
internal static void Find(AssemblyDefinition assembly)
{
var usedInterfaces = new HashSet<string>();
var foundInterfaces = new HashSet<string>();
foreach (var type in assembly.MainModule.GetTypes())
{
if (type.IsInterface && type.Name.EndsWith("Listener"))
{
// Found possible listener interface
var fullName = GetFullName(type);
if (fullName == null)
continue;
if (!usedInterfaces.Contains(fullName))
{
foundInterfaces.Add(fullName);
}
}
else if (!type.IsInterface && type.HasEvents)
{
// Scan for events
foreach (var evt in type.Events.Where(x => x.HasCustomAttributes))
{
var attr = evt.CustomAttributes.FirstOrDefault(x => (x.AttributeType.Namespace == AttributeConstants.Dot42AttributeNamespace) &&
(x.AttributeType.Name == AttributeConstants.ListenerInterfaceAttributeName));
if (attr != null)
{
// Ctor argument can be string or type
var fullName = attr.ConstructorArguments[0].Value as string;
if (fullName == null)
{
var typeRef = (TypeReference)attr.ConstructorArguments[0].Value;
var intfType = typeRef.Resolve();
fullName = GetFullName(intfType);
}
if (fullName != null)
{
// Found event with ListenerInterfaceAttribute
usedInterfaces.Add(fullName);
foundInterfaces.Remove(fullName);
}
}
}
}
}
if (foundInterfaces.Count == 0)
return;
Console.WriteLine("Found {0} listener interfaces", foundInterfaces.Count);
foreach (var name in foundInterfaces.OrderBy(x => x))
{
Console.WriteLine(name);
}
Console.WriteLine();
}
private IEnumerable<UnityObject> Targets(IEnumerable<fiSerializedObject> backups) {
var targets = new HashSet<UnityObject>();
foreach (var backup in backups) {
targets.Add(backup.Target.Target);
}
return targets.OrderBy(obj => obj.name);
}
private IEnumerable<HgBundleFile> BuildBundleFiles(HgRepository hgRepository, HgRevset hgRevset, HashSet<string> paths)
{
var orderedPaths = paths.OrderBy(p => p).ToList();
foreach(var path in orderedPaths)
{
var bundleFile = BuildBundleFile(hgRepository, hgRevset, path);
if(bundleFile != null)
yield return bundleFile;
} // foreach
}
public static Vector3 GetClosestWardSpot(this Vector3 wallPosition)
{
// If the position is not a wall then return the input position
var flags = wallPosition.ToNavMeshCell().CollFlags;
if (!flags.HasFlag(CollisionFlags.Wall) && !flags.HasFlag(CollisionFlags.Building))
{
return wallPosition;
}
const int maxRange = 10;
const double step = 2 * Math.PI / 20;
var start = new Vector2(wallPosition.ToNavMeshCell().GridX, wallPosition.ToNavMeshCell().GridY);
var checkedCells = new HashSet<Vector2>();
// Get all directions
var directions = new List<Vector2>();
for (var theta = 0d; theta <= 2 * Math.PI + step; theta += step)
{
directions.Add((new Vector2((short) (start.X + Math.Cos(theta)), (short) (start.Y - Math.Sin(theta))) - start).Normalized());
}
var validPositions = new HashSet<Vector3>();
for (var range = 1; range < maxRange; range++)
{
foreach (var direction in directions)
{
// Get the position to check
var end = start + range * direction;
var testPoint = new Vector2((short) end.X, (short) end.Y);
if (checkedCells.Contains(testPoint))
{
continue;
}
checkedCells.Add(testPoint);
// Check the position for wall flags
flags = new NavMeshCell((short) testPoint.X, (short) testPoint.Y).CollFlags;
if (!flags.HasFlag(CollisionFlags.Wall) && !flags.HasFlag(CollisionFlags.Building))
{
// Add the position to the valid positions set
validPositions.Add(NavMesh.GridToWorld((short) testPoint.X, (short) testPoint.Y));
}
}
if (validPositions.Count > 0)
{
// Return the closest position to the initial wall position
return validPositions.OrderBy(o => o.Distance(start, true)).First();
}
}
// Nothing found return input
return wallPosition;
}
public TDPNode JumpPointSearch(int mStartX, int mStartY, int mTargetX, int mTargetY)
{
var startNode = GetNode(mStartX, mStartY);
var targetNode = GetNode(mTargetX, mTargetY);
var openContainer = new HashSet<TDPNode> {startNode};
var nodesToRefresh = new List<TDPNode> {startNode, targetNode};
while (openContainer.Count > 0)
{
var currentNode = openContainer.OrderBy(x => x.F).First();
openContainer.Remove(currentNode);
currentNode.IsClosed = true;
if (currentNode == targetNode)
{
var finalNode = targetNode;
while (finalNode.Parent != startNode) finalNode = finalNode.Parent;
foreach (var node in nodesToRefresh) node.Refresh();
return finalNode;
}
foreach (var neighbor in JPSFindNeighbors(currentNode))
{
var jumpPoint = JPSJump(neighbor, currentNode, targetNode);
if (jumpPoint == null) continue;
var x = currentNode.X;
var y = currentNode.Y;
var jx = jumpPoint.X;
var jy = jumpPoint.Y;
var jumpNode = GetNode(jx, jy);
if (jumpNode.IsClosed) continue;
var d = Math.Sqrt(TDLDistances.EuclideanDistanceSquared(jx, jy, x, y));
var ng = currentNode.G + d; // next `g` value
if (openContainer.Contains(jumpNode) && !(ng < jumpNode.G)) continue;
jumpNode.G = ng;
if (jumpNode.H == 0) jumpNode.H = Math.Sqrt(TDLDistances.EuclideanDistanceSquared(jx, jy, targetNode.X, targetNode.Y));
jumpNode.Parent = currentNode;
openContainer.Add(jumpNode);
nodesToRefresh.Add(jumpNode);
}
}
foreach (var node in nodesToRefresh) node.Refresh();
return null;
}
public IEnumerable<Student> OrderedByParticipation()
{
if (!this.students.Any())
{
throw new InvalidOperationException("There are no students to sort");
}
var copiedStudents = new HashSet<Student>(this.students);
var result = copiedStudents.OrderBy(st => st.Participations);
return result;
}
public void Should_visit_all_vertices_reachable_from_one()
{
var found = new HashSet<int>();
var algorithm = new DepthFirstSearchAlgorithm<int, SEdge<int>>(_adjacencyGraph);
algorithm.DiscoverVertex += v => found.Add(v);
algorithm.ExamineEdge += e => { if (algorithm.GetVertexColor(e.Target) != GraphColor.White) throw new Exception("cycle!"); };
algorithm.Compute(1);
Assert.That(found.OrderBy(i => i).ToArray(), Is.EquivalentTo(new[] {1, 2, 3, 4} ));
}
public override UInt160[] GetScriptHashesForVerifying()
{
HashSet<UInt160> hashes = new HashSet<UInt160>(base.GetScriptHashesForVerifying());
foreach (TransactionResult result in GetTransactionResults().Where(p => p.Amount < Fixed8.Zero))
{
RegisterTransaction tx = Blockchain.Default.GetTransaction(result.AssetId) as RegisterTransaction;
if (tx == null) throw new InvalidOperationException();
hashes.Add(tx.Admin);
}
return hashes.OrderBy(p => p).ToArray();
}
public static Dictionary<Target, int> GetTargetToInt(HashSet<Target> targets)
{
var mapping = new Dictionary<Target, int>();
int count = 0;
foreach (var target in targets.OrderBy(t => (int)t))
{
mapping[target] = count;
++count;
}
return mapping;
}
static List<int> Primes(int max)
{
HashSet<int> p = new HashSet<int>(Enumerable.Range(2, max - 1));
for (int i = 2; i <= max; i++) {
if (p.Contains(i)) {
for (int j = 2 * i; j <= max; j += i) {
p.Remove(j);
}
}
}
return p.OrderBy(i => i).ToList();
}
public static void CopyDirectory(string sourceDir, string destDir) {
sourceDir = sourceDir.TrimEnd('\\');
destDir = destDir.TrimEnd('\\');
try {
Directory.CreateDirectory(destDir);
} catch (IOException) {
}
var newDirectories = new HashSet<string>(from d in Directory.EnumerateDirectories(sourceDir, "*", SearchOption.AllDirectories)
where d.StartsWith(sourceDir)
select d.Substring(sourceDir.Length + 1), StringComparer.OrdinalIgnoreCase);
newDirectories.ExceptWith(from d in Directory.EnumerateDirectories(destDir, "*", SearchOption.AllDirectories)
where d.StartsWith(destDir)
select d.Substring(destDir.Length + 1));
foreach (var newDir in newDirectories.OrderBy(i => i.Length).Select(i => Path.Combine(destDir, i))) {
try {
if (newDir.Length < NativeMethods.MAX_FOLDER_PATH) {
Directory.CreateDirectory(newDir);
}
} catch {
Debug.WriteLine("Failed to create directory " + newDir);
}
}
var newFiles = new HashSet<string>(from f in Directory.EnumerateFiles(sourceDir, "*", SearchOption.AllDirectories)
where f.StartsWith(sourceDir)
select f.Substring(sourceDir.Length + 1), StringComparer.OrdinalIgnoreCase);
newFiles.ExceptWith(from f in Directory.EnumerateFiles(destDir, "*", SearchOption.AllDirectories)
where f.StartsWith(destDir)
select f.Substring(destDir.Length + 1));
foreach (var newFile in newFiles) {
var copyFrom = Path.Combine(sourceDir, newFile);
var copyTo = Path.Combine(destDir, newFile);
try {
if (copyTo.Length < NativeMethods.MAX_PATH && copyFrom.Length < NativeMethods.MAX_PATH) {
var copyToDir = Path.GetDirectoryName(copyTo);
if (copyToDir.Length < NativeMethods.MAX_FOLDER_PATH) {
File.Copy(copyFrom, copyTo);
File.SetAttributes(copyTo, FileAttributes.Normal);
} else {
Debug.WriteLine("Failed to copy " + copyFrom + " to " + copyTo + " due to max path limit");
}
} else {
Debug.WriteLine("Failed to copy " + copyFrom + " to " + copyTo + " due to max path limit");
}
} catch {
Debug.WriteLine("Failed to copy " + copyFrom + " to " + copyTo + " for unknown reason");
}
}
}
public void ConcurrentEmitsReachForEach()
{
var count = 100;
var howOften = 1000;
var source = AsyncEnumerable.Source<int>();
var evt = new ManualResetEventSlim();
var sem = new SemaphoreSlim(0);
var derived = source.Select(i => i).Where(i => true);
var values = new HashSet<int>();
var subscription = source.ForEach(i =>
{
lock (values)
{
values.Add(i);
}
});
for (int i = 0; i < count; i++)
{
var id = i;
var t = new Thread(() =>
{
evt.Wait();
for(int x = 0; x < howOften; x++)
source.Yield(id).Wait();
sem.Release();
});
t.IsBackground = true;
t.Start();
}
evt.Set();
for (int i = 0; i < count; i++)
sem.Wait();
var arr = values.OrderBy(a => a).ToArray();
Assert.AreEqual(count, arr.Length, "not all inputs processed");
for (int i = 0; i < count; i++)
{
Assert.AreEqual(i, arr[i]);
}
}
private List<string> BuildWords()
{
if (bible == null)
throw new InvalidOperationException();
var uniqueWords = new HashSet<string>(
bible.GetService<ITokenToVerseMap>().TokenFrequency()
.Where(tf => tf.Token.IsWord)
.Select(tf => (string) tf.Token),
comparer);
var sortedWords = uniqueWords.OrderBy(word => word, comparer);
return sortedWords.ToList();
}
private static IEnumerable<string> GetAllFactIds(IDictionary<string, IEnumerable<Fact>> parentChildDictionary)
{
var factList = new HashSet<string>();
foreach (var keyValuePair in parentChildDictionary)
{
factList.Add(keyValuePair.Key);
foreach (var fact in keyValuePair.Value)
{
factList.Add(fact.FactId);
}
}
return factList.OrderBy(Convert.ToInt32);
}
