static void Main()
{
var sw = new Stopwatch();
sw.Start();
var loadSourceFileToMemory = new TransformBlock <string, string>(async path =>
{
Console.WriteLine("Loading to memory '{0}'...", path);
using (StreamReader SourceReader = File.OpenText(path))
{
return(await SourceReader.ReadToEndAsync());
}
}, new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = MaxDegreeOfParallelismLoad
});
var generateTestClass = new TransformManyBlock <string, TestClass>(async text =>
{
Console.WriteLine("Generating test classes...");
TestClassGenerator classGenerator = new TestClassGenerator();
return(classGenerator.GenerateTestClasses(text));
}, new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = MaxDegreeOfParallelismGenerate
});
var saveTestClassToFile = new ActionBlock <TestClass>(async testClass =>
{
using (StreamWriter DestinationWriter = File.CreateText(DestPath + testClass.FileName))
{
Console.WriteLine("Saving '{0}' on disk...", testClass.FileName);
await DestinationWriter.WriteAsync(testClass.Source);
Console.WriteLine("Saved '{0}'!", testClass.FileName);
}
}, new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = MaxDegreeOfParallelismSave
});
var linkOptions = new DataflowLinkOptions {
PropagateCompletion = true
};
loadSourceFileToMemory.LinkTo(generateTestClass, linkOptions);
generateTestClass.LinkTo(saveTestClassToFile, linkOptions);
foreach (var path in _input)
{
loadSourceFileToMemory.Post(path);
}
loadSourceFileToMemory.Complete();
saveTestClassToFile.Completion.Wait();
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
}
static void Main(string[] args)
{
int fileCounter = 0;
string outputDirectory = ".";
TestClassGenerator generator = new TestClassGenerator();
int maxLoading = 0;
var downloadString = new TransformBlock <string, Task <string> >(path =>
{
while (fileLoadingCounter >= maxFileLoading)
{
;
}
StreamReader sr = new StreamReader(path);
Task <string> result = sr.ReadToEndAsync();
fileLoadingCounter++;
if (maxLoading < fileLoadingCounter)
{
maxLoading = fileLoadingCounter;
}
result.ContinueWith(str => { fileLoadingCounter--; });
return(result);
});
var generateClass = new TransformBlock <Task <string>, Task <string> >(async sourceTask =>
{
while (testsGeneratingCounter >= maxTestsGenerating)
{
;
}
testsGeneratingCounter++;
Task <string> task = generator.GenerateTestAsync(await sourceTask);
Task temp = task.ContinueWith(str => { testsGeneratingCounter--; });
return(task);
});
var outputString = new ActionBlock <Task <string> >(async sourceTask =>
{
string source = await sourceTask;
while (fileWritingCounter >= maxFileWriting)
{
;
}
fileWritingCounter++;
fileCounter++;
StreamWriter sw = new StreamWriter($"{outputDirectory}/Test{fileCounter}.cs");
Task t = sw.WriteAsync(source);
Task temp = t.ContinueWith((str) => { fileWritingCounter--; });
t.Wait();
sw.Close();
});
var linkOptions = new DataflowLinkOptions {
PropagateCompletion = true
};
downloadString.LinkTo(generateClass, linkOptions);
generateClass.LinkTo(outputString, linkOptions);
List <string> fileNames = new List <string>()
{
"Program.cs", "AssemblyGetter.cs",
"StudentExtension.cs", "Factorizer.cs"
};
foreach (var name in fileNames)
{
downloadString.Post(name);
}
downloadString.Complete();
outputString.Completion.Wait();
Console.WriteLine(maxLoading);
Console.ReadLine();
}
