internal async Task <bool> StartExtractAsync(ZipFileSettings zipSettings, CreatorRelayStation creatorRelayStation)
{
this.settings = zipSettings;
this.relayStation = creatorRelayStation;
if (!await this.createWorkFolderAsync())
{
return(false);
}
Debug.WriteLine("StartExtractAsync.createWorkFolderAsync 呼出し後");
var watch = Stopwatch.StartNew();
if (await this.hasExtractErrorAsync())
{
return(false);
}
watch.Stop();
Debug.WriteLine($"圧縮ファイル内トータルサイズ取得：{watch.ElapsedMilliseconds}[ms]");
// 圧縮ファイル内トータルサイズ取得(Debug.WriteLineあり)：5282[ms]
// 圧縮ファイル内トータルサイズ取得(Debug.WriteLineなし)：550[ms]
return(true);
}
private void moveImageFiles(SourceItem rootItem, ZipFileSettings settings, int volumeNumber)
{
var seq = 1;
var fileCountLength = rootItem.Children.Count.ToString().Length;
foreach (var imageItem in rootItem.Children.OrderBy(c => c.FileName))
{
if (!File.Exists(imageItem.ItemPath))
{
continue;
}
var destinationPath = this.getImageFileName(settings, volumeNumber, seq, fileCountLength, imageItem, rootItem);
if (!imageItem.IsSplit)
{
File.Move(imageItem.ItemPath, destinationPath);
seq++;
}
else
{
seq++;
var leftImagePath = this.getImageFileName(settings, volumeNumber, seq, fileCountLength, imageItem, rootItem);
ImageFile.SplitVerticalToFile(imageItem.ItemPath, leftImagePath, destinationPath);
seq++;
}
}
}
private async Task createDistributesRules(ZipFileSettings settings)
{
await Task.Run(() =>
{
Parallel.ForEach <ImageSource>(settings.ImageSources,
s =>
{
Parallel.ForEach <SourceItem>(s.Entries, e => e.CreateDistributionRule());
});
});
}
private async Task createWorkFolderAsync(ZipFileSettings settings)
{
if (Directory.Exists(settings.WorkRootFolderPath))
{
// workフォルダが存在した場合は削除
await Task.Run(() => Directory.Delete(settings.WorkRootFolderPath, true));
}
Directory.CreateDirectory(settings.WorkRootFolderPath);
var dirInfo = new DirectoryInfo(settings.WorkRootFolderPath);
dirInfo.Attributes |= FileAttributes.Hidden;
}
private string getImageFileName(ZipFileSettings settings,
int volumeNumber,
int pageSequence,
int fileCountLength,
SourceItem imageItem,
SourceItem rootItem)
{
var newFileName = settings.GetImageFileName(volumeNumber,
pageSequence,
fileCountLength) + Path.GetExtension(imageItem.ItemPath);
return(Path.Combine(rootItem.DestinationFolderPath, newFileName));
}
private void createDestinationFolder(SourceItem volumeRoot, ZipFileSettings settings, int volumeNumber)
{
if (!string.IsNullOrEmpty(volumeRoot.DestinationFolderPath))
{
return;
}
volumeRoot.DestinationFolderPath = Path.Combine(settings.ImageFilesExtractedFolder.Value, settings.GetVolumeRootFolderName(volumeNumber));
if (!Directory.Exists(volumeRoot.DestinationFolderPath))
{
Directory.CreateDirectory(volumeRoot.DestinationFolderPath);
}
}
internal async Task <bool> HasExtractError(ZipFileSettings zipSettings)
{
long total = 0;
var sumBlock = new ActionBlock <IArchiveEntry>(async e =>
await Task.Run(() => total += e.Size), new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = DataflowBlockOptions.Unbounded
});
var extractTasks = new List <Task>();
foreach (var imageSource in zipSettings.ImageSources)
{
if (imageSource.SourceKind.Value != ImageSourceType.File)
{
continue;
}
extractTasks.Add(Task.Run(() =>
{
using (var archive = ArchiveFactory.Open(imageSource.Path.Value))
{
imageSource.ArchiveEntryTotalCount = archive.Entries.Where(e => !e.IsDirectory).Count();
foreach (var entry in archive.Entries)
{
if (SourceItem.IsTargetFile(entry))
{
imageSource.ArchiveEntryTargetCount++;
sumBlock.Post(entry);
}
}
}
}));
}
await Task.WhenAll(extractTasks);
sumBlock.Complete();
await sumBlock.Completion;
var freeSpace = zipSettings.GetExtractPathFreeSpace();
return(total < freeSpace);
}
internal bool HasExtractError(ZipFileSettings zipSettings)
{
long totalSize = 0;
var watch = Stopwatch.StartNew();
Parallel.ForEach <ImageSource>(zipSettings.ImageSources, src =>
{
Debug.WriteLine($"容量取得：{src.Path.Value}");
using (var archive = ArchiveFactory.Open(src.Path.Value))
{
src.ArchiveEntryTotalCount = archive.Entries.Where(e => !e.IsDirectory).Count();
var entries = archive.Entries.Where(e => SourceItem.IsTargetFile(e));
src.ArchiveEntryTargetCount = entries.Count();
Parallel.ForEach <IArchiveEntry, long>
(
entries,
() => 0,
(entry, state, local) =>
{
local += entry.Size;
//Debug.WriteLine($"容量取得(entry)：{entry.Key}");
return(local);
},
local => Interlocked.Add(ref totalSize, local)
);
}
});
var freeSpace = zipSettings.GetExtractPathFreeSpace();
watch.Stop();
// 圧縮ファイル内トータルサイズ取得：215[ms]
// 圧縮ファイル内トータルサイズ取得(Debug.WriteLineあり)：6828[ms]
// 圧縮ファイル内トータルサイズ取得(Debug.WriteLineなし)：221[ms]
return(totalSize < freeSpace);
}
internal async Task ExtractAsync(ZipFileSettings settings)
{
await Task.Run(() =>
{
var watch = Stopwatch.StartNew();
var agent = new ImageAgent();
Parallel.ForEach <ImageSource>(settings.ImageSources,
s =>
{
s.ExtractedRootDirectory = Path.Combine(settings.WorkRootFolderPath, s.FileNameWithoutExtension);
Directory.CreateDirectory(s.ExtractedRootDirectory);
this.extractImageSourceAsync(s, agent);
});
watch.Stop();
this.relayStation.AddLog($"展開完了！");
this.relayStation.AddLog($"総展開時間：{watch.ElapsedMilliseconds / 1000}[sec]");
});
}
private async Task distributesSourceItems(ZipFileSettings settings)
{
await Task.Run(() =>
{
var seq = 1;
foreach (var imgSrc in settings.ImageSources)
{
imgSrc.Entries
.OrderBy(e => e.FileName)
.ToList()
.ForEach(e =>
{
this.createDestinationFolder(e, settings, seq);
this.moveImageFiles(e, settings, seq);
seq++;
});
}
this.relay.AddLog($"************ 配置まですべて完了 ************");
});
}
internal void CheckSourceFiles(ZipFileSettings settings)
{
foreach (var imgSrc in settings.ImageSources)
{
}
}
