/// <summary>
/// Copia los archivos
/// </summary>
private void CopyFiles(string sourcePath, string targetPath, NormalizedDictionary <object> parameters)
{
// Crea el directorio
//? Sí, está dos veces, no sé porqué si se ejecuta dos veces consecutivas este método, la segunda vez no crea el directorio a menos que
//? ejecute dos veces la instrucción
HelperFiles.MakePath(targetPath);
HelperFiles.MakePath(targetPath);
// Copia los archivos
foreach (string file in System.IO.Directory.EnumerateFiles(sourcePath))
{
if (MustCopy(file))
{
string targetFile = System.IO.Path.Combine(targetPath, System.IO.Path.GetFileName(file));
// Copia los archivos de Python sin cambios, los de SQL los convierte
if (file.EndsWith(".py", StringComparison.CurrentCultureIgnoreCase))
{
SaveFileWithoutBom(targetFile, HelperFiles.LoadTextFile(file));
}
else if (file.EndsWith(".sql", StringComparison.CurrentCultureIgnoreCase))
{
SaveFileWithoutBom(targetFile, TransformSql(file, parameters));
}
}
}
}
/// <summary>
/// Graba un archivo de texto
/// </summary>
internal void Save(string fileName, string content)
{
// Crea el directorio de salida
HelperFiles.MakePath(Path);
// Graba el contenido
HelperFiles.SaveTextFile(System.IO.Path.Combine(Path, fileName), content);
}
public static IEnumerable <IEnumerable <string> > GetKeyUsedInPath(string key, string path)
{
foreach (var file in HelperFiles.GetFileInfos(new[] { "*.cs", ".xaml" }, path))
{
yield return(GetKeyUsedInFile(key, File.Open(file.FullName, FileMode.Open)));
}
}
/// <summary>
/// Procesa el informe interpretado
/// </summary>
private void RenderFile(string fileParsed, string fileName)
{
foreach (DeploymentModel.ReportFormat format in Deployment.ReportFormatTypes)
{
try
{
switch (format)
{
case DeploymentModel.ReportFormat.Xml:
HelperFiles.CopyFile(fileParsed, ChangeExtension(fileParsed, ".xml"));
break;
case DeploymentModel.ReportFormat.Html:
if (!ExistsFormat(DeploymentModel.ReportFormat.HtmlConverted, Deployment.ReportFormatTypes))
{
HelperFiles.CopyFile(fileParsed, ChangeExtension(fileParsed, ".html"));
}
break;
case DeploymentModel.ReportFormat.HtmlConverted:
new LibReports.Renderer.Html.RendererHTML().Render(ChangeExtension(fileParsed, ".html"), fileParsed);
break;
case DeploymentModel.ReportFormat.Pdf:
new LibReports.Renderer.PDF.RendererPdf().Render(ChangeExtension(fileParsed, ".pdf"), fileParsed);
break;
}
}
catch (Exception exception)
{
RaiseEvent(fileName, $"Error when render file {fileName} to format {format.ToString()}. {exception.Message}", 0, 0, true);
}
}
}
/// <summary>
/// Descarga los archivos
/// </summary>
public async Task DownloadFilesAsync()
{
var webClient = new LibCommonHelper.Communications.HttpWebClient();
// Descarga los eventos
foreach (MediaFileModel file in Files)
{
string fileName = GetDownloadFileName(file);
// Descarga el archivo
if (!string.IsNullOrEmpty(fileName) && !File.Exists(fileName))
{
// Lanza el evento de descarga
RaiseEvent(file, Files.IndexOf(file), Files.Count);
// Crea el directorio
HelperFiles.MakePath(Path.GetDirectoryName(fileName));
// Descarga el archivo
try
{
// Descarga el archivo
await webClient.DownloadFileAsync(file.Url, fileName);
// Asigna el nombre del archivo descargado
file.FileName = fileName;
}
catch {}
}
}
// Lanza el evento de fin
EndDownload?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Compila el libro
/// </summary>
public bool Compile(BookModel book, string title, string description, string keyWords, string content, string pathTarget,
out string error)
{
bool compiled = false;
string pathTemp = Path.Combine(Path.GetTempPath(), HelperFiles.Normalize(book.Name));
// Inicializa los argumentos de salida
error = "";
// Compila el libro
try
{
// Compila el libro
Compile(new LibEBook.BookFactory().Load(LibEBook.BookFactory.BookType.ePub, book.FileName, pathTemp),
pathTemp, title, description, keyWords, content, pathTarget);
// Borra el directorio temporal
HelperFiles.KillPath(pathTemp);
// Indica que se ha compilado el libro
compiled = true;
}
catch (Exception exception)
{
error = "Error en la compilación. " + exception.Message;
}
// Devuelve el valor que indica si se ha compilado correctamente
return(compiled);
}
/// <summary>
/// Crea el documento de las páginas
/// </summary>
private void CreatePage(string strBookTitle, string pathTemp, DocWriterFactory writerFactory, DocumentModel documentRoot, IndexItem page)
{
string fileName = GetFileName(pathTemp, page);
// Crea la página
if (File.Exists(fileName))
{
string content = ConvertPageToNhtml(HelperFiles.LoadTextFile(fileName));
DocumentModel document;
// Si hay algo que meter en el documento ...
if (!content.IsEmpty())
{
document = writerFactory.CreatePage(documentRoot,
$"{page.PageNumber:000}. {page.Name}",
strBookTitle + " - " + page.Name,
documentRoot.Description + " - " + page.Name,
documentRoot.KeyWords, content);
}
else
{
document = documentRoot;
}
// Crea los documentos de las páginas hija
if (page.Items != null && page.Items.Count > 0)
{
foreach (IndexItem item in page.Items)
{
CreatePage(strBookTitle, pathTemp, writerFactory, document, item);
}
}
}
}
/// <summary>
/// Graba los datos
/// </summary>
protected override void Save()
{
if (ValidateData())
{
string targetPath = System.IO.Path.Combine(PathTarget, Name);
string fileName = HelperFiles.CombineFileName(targetPath, HelperFiles.Normalize(Name),
ProjectsDefinition.SelectedItem.Project.Extension);
ProjectModel project;
// Crea el directorio
HelperFiles.MakePath(targetPath);
// Crea el proyecto (después de crear el directorio)
project = new ProjectModel(_solution, ProjectsDefinition.SelectedItem.Project, fileName);
// Crea el archivo de proyecto (vacío)
HelperFiles.SaveTextFile(fileName, "");
// Añade el proyecto a la solución
if (_folder == null)
{
_solution.Projects.Add(project);
}
else
{
_folder.Projects.Add(project);
}
// Crea el proyecto
SourceEditorViewModel.Instance.MessagesController.OpenFile(project.Definition, project, true);
// Cierra el formulario
RaiseEventClose(true);
}
}
protected void afuArchivo_OnUploadedComplete(object sender, AsyncFileUploadEventArgs e)
{
try
{
List <HelperFiles> files = Session["selectedFiles"] == null ? new List <HelperFiles>() : (List <HelperFiles>)Session["selectedFiles"];
if (!files.Any(a => a.NombreArchivo.Contains(afuArchivo.FileName)))
{
Int64 sumaArchivos = Int64.Parse(Session["FileSize"].ToString());
sumaArchivos += int.Parse(e.FileSize);
if ((sumaArchivos / 1024) > (1024 * 1024))
{
throw new Exception(string.Format("El tamaño maximo de carga es de {0}MB", "10"));
}
afuArchivo.PostedFile.SaveAs(BusinessVariables.Directorios.RepositorioTemporalInformacionConsulta + afuArchivo.FileName);
HelperFiles hFiles = new HelperFiles {
NombreArchivo = e.FileName.Split('\\').Last(), Tamaño = BusinessFile.ConvertirTamaño(e.FileSize), Extension = Path.GetExtension(afuArchivo.FileName)
};
files.Add(hFiles);
Session["FileSize"] = int.Parse(Session["FileSize"].ToString()) + int.Parse(e.FileSize);
Session["selectedFiles"] = files;
}
LlenaArchivosCargados();
}
catch (Exception ex)
{
if (_lstError == null)
{
_lstError = new List <string>();
}
_lstError.Add(ex.Message);
AlertaGeneral = _lstError;
}
}
/// <summary>
/// Sube un archivo
/// </summary>
internal void UploadFile(string fileName)
{
if (!IsUrl(Manager.UrlDownload))
{
HelperFiles.CopyFile(fileName, GetFileName(System.IO.Path.GetFileName(fileName), true));
}
else
{
UploadFile(Manager.UrlDownload.GetUrl(), fileName);
}
}
/// <summary>
/// Obtiene el contenido normalizado de un notebook
/// </summary>
private string NormalizeNotebookContent(string fileName)
{
string content = HelperFiles.LoadTextFile(fileName);
// Sustituye los argumentos de tipo $Xxxx por getArgument("xxxx")
content = ConvertArgumentsToGetArgument(content, "$");
// Pasa los nombres de archivo a minúsculas
ConvertFileNameToLower(content);
// Devuelve la cadena normalizada
return(content);
}
public static bool AnyKeyUsedInPath(KeyModel key, string path)
{
foreach (var file in HelperFiles.GetFileInfos(new[] { "*.*" /*, "*.cs", ".xaml"*/ }, path))
{
if (AnyKeyUsedInFile(key, file.FullName))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Sube un texto
/// </summary>
internal void UploadText(string text)
{
string fileName = GetFileName("output.txt", true);
// Graba el archivo
HelperFiles.SaveTextFile(fileName, text);
// ... y lo sube
if (IsUrl(Manager.UrlDownload))
{
UploadFile(Manager.UrlDownload.GetUrl(), fileName);
HelperFiles.KillFile(fileName);
}
}
/// <summary>
/// Carga las líneas de un archivo
/// </summary>
private List <string> LoadLines()
{
List <string> objColLines = new List <string>();
string strContent = HelperFiles.LoadTextFile(FileName);
// Carga el archivo y lo separa en líneas
if (!strContent.IsEmpty())
{
objColLines = strContent.SplitByString("\n");
}
// Devuelve las líneas del archivo
return(objColLines);
}
/// <summary>
/// Exporta los archivos
/// </summary>
public void Export()
{
using (BlockLogModel block = Logger.Default.CreateBlock(LogModel.LogType.Info, "Start copy files"))
{
// Elimina el directorio destino
HelperFiles.KillPath(Options.TargetPath);
// Copia los directorios
CopyPath(block, Options.SourcePath, Options.TargetPath);
// Borra los directorios vacíos
HelperFiles.KillEmptyPaths(Options.TargetPath);
// Log
block.Info("End copy files");
}
}
/// <summary>
/// Copia las imágenes de un libro
/// </summary>
private void CopyImages(Book book, string pathTemp, string pathTarget)
{
foreach (PageFile file in book.Files)
{
if (!file.FileName.IsEmpty() && IsImage(file.FileName))
{
string fileNameTarget = Path.Combine(pathTarget, RemoveFirstPath(file.FileName));
// Crea el directorio destino
HelperFiles.MakePath(Path.GetDirectoryName(fileNameTarget));
// Copia el archivo
HelperFiles.CopyFile(Path.Combine(pathTemp, file.FileName), fileNameTarget);
}
}
}
/// <summary>
/// Copia los archivos del proyecto que no precisan compilación
/// </summary>
internal override void Process()
{
foreach (FileTargetModel file in Data.Files)
{
if (MustCopy(file))
{
string fileName = file.GetFullFileName(Processor);
// Crea el directorio destino
HelperFiles.MakePath(System.IO.Path.GetDirectoryName(fileName));
// Copia el archivo
HelperFiles.CopyFile(file.File.FullFileName, fileName);
}
}
}
/// <summary>
/// Descarga un archivo
/// </summary>
private void DownloadFile(Uri url, string fileTarget)
{
if (url != null)
{
WebClient webClient = new WebClient();
// Elimina el archivo antiguo
HelperFiles.KillFile(fileTarget);
// Descarga el archivo
try
{
webClient.DownloadFile(url, fileTarget);
}
catch {}
}
}
/// <summary>
/// Copia los archivos
/// </summary>
private void CopyFiles(string sourcePath, string targetPath)
{
// Crea el directorio
//? Sí, está dos veces, no sé porqué si se ejecuta dos veces consecutivas este método, la segunda vez no crea el directorio a menos que
//? ejecute dos veces la instrucción
HelperFiles.MakePath(targetPath);
HelperFiles.MakePath(targetPath);
// Copia los archivos
foreach (string file in System.IO.Directory.EnumerateFiles(sourcePath))
{
if (MustCopy(file))
{
GetFileTransformer(targetPath, file).Transform();
}
}
}
/// <summary>
/// Obtiene el nombre del archivo de descarga
/// </summary>
private string GetDownloadFileName(MediaFileModel file)
{
string fileName = string.Empty;
// Calcula el nombre del archivo
if (!string.IsNullOrEmpty(file.Url))
{
// Obtiene el nombre de archivo
fileName = Path.Combine(PathBase, HelperFiles.Normalize(file.Album.Name),
HelperFiles.Normalize(Path.GetFileName(file.Url)));
// Ajusta el nombre de archivo
fileName = HelperFiles.GetConsecutiveFileName(Path.GetDirectoryName(fileName), Path.GetFileName(fileName));
}
// Devuelve el nombre de archivo
return(fileName);
}
/// <summary>
/// Copia un directorio o crea una referencia
/// </summary>
private void Copy(ProjectModel projectSource, ProjectModel projectTarget, string fileSource, string pathTarget, bool isRecursive)
{
if (Directory.Exists(fileSource))
{
string [] files = Directory.GetFiles(fileSource);
// Copia los archivos
foreach (string fileName in files)
{
Copy(projectSource, projectTarget, fileName, pathTarget, isRecursive);
}
// Copia los directorios
if (isRecursive)
{
// Obtiene los directorios
files = Directory.GetDirectories(fileSource);
// Copia los archivos
foreach (string fileName in files)
{
Copy(projectSource, projectTarget, fileName, Path.Combine(pathTarget, Path.GetFileName(fileName)), isRecursive);
}
}
}
else if (File.Exists(fileSource))
{
string fileTarget = Path.Combine(pathTarget, Path.GetFileName(fileSource));
if (!File.Exists(fileTarget))
{
ReferenceModel reference;
// Cambia la extensión al archivo final de referencia
fileTarget = fileTarget + new Model.Solutions.FileModel(null).GetExtension(FileModel.DocumentType.Reference);
// Crea el objeto de referencia
reference = new ReferenceModel(new Solutions.FileFactory().GetInstance(projectTarget, fileTarget));
reference.ProjectName = projectSource.Name;
reference.FileNameReference = HelperFiles.GetFileNameRelative(projectSource.File.Path, fileSource);
// Crea el directorio
HelperFiles.MakePath(pathTarget);
// Crea el archivo de referencia
new ReferenceRepository().Save(reference);
}
}
}
/// <summary>
/// Obtiene un nombre de archivo
/// </summary>
private string GetFileName(string file, bool consecutive)
{
string path = Manager.UrlDownload;
// Obtiene el directorio
if (string.IsNullOrEmpty(path) || !System.IO.Directory.Exists(path))
{
path = Manager.PathBase;
}
// Obtiene el nombre de archivo
if (consecutive)
{
return(HelperFiles.GetConsecutiveFileName(path, file));
}
else
{
return(System.IO.Path.Combine(path, file));
}
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
if (Session["PreviewAltaDataConsulta"] != null && Request.QueryString["evaluacion"] != null)
{
InformacionConsulta info = (InformacionConsulta)Session["PreviewAltaDataConsulta"];
List <HelperFiles> lstArchivos = new List <HelperFiles>();
foreach (InformacionConsultaDocumentos docto in info.InformacionConsultaDocumentos)
{
if (!File.Exists(BusinessVariables.Directorios.RepositorioInformacionConsulta + docto.Archivo))
{
Alerta = new List <string> {
string.Format("El archivo {0} no esta disponible.", docto.Archivo)
};
continue;
}
HelperFiles hf = new HelperFiles
{
NombreArchivo = docto.Archivo,
Tamaño = BusinessFile.ConvertirTamaño(new FileInfo(BusinessVariables.Directorios.RepositorioInformacionConsulta + docto.Archivo).Length.ToString())
};
BusinessFile.CopiarArchivoDescarga(BusinessVariables.Directorios.RepositorioInformacionConsulta, docto.Archivo, BusinessVariables.Directorios.RepositorioTemporalInformacionConsulta);
lstArchivos.Add(hf);
}
Session["selectedFiles"] = lstArchivos;
MuestraPreview(info);
divEvaluacion.Visible = bool.Parse(Request.QueryString["evaluacion"]);
}
}
catch (Exception ex)
{
if (_lstError == null)
{
_lstError = new List <string>();
}
_lstError.Add(ex.Message);
Alerta = _lstError;
}
}
/// <summary>
/// Graba los datos de una conexión
/// </summary>
internal void Save(FtpConnectionModel connection, string fileName)
{
MLFile fileML = new MLFile();
MLNode nodeML = fileML.Nodes.Add(TagConnection);
// Crea el directorio
HelperFiles.MakePath(System.IO.Path.GetDirectoryName(fileName));
// Añade los atributos de la conexión
nodeML.Attributes.Add(TagGlobalId, connection.GlobalId);
nodeML.Attributes.Add(TagServer, connection.Server);
nodeML.Attributes.Add(TagProtocol, (int)connection.FtpProtocol);
nodeML.Attributes.Add(TagPort, connection.Port);
nodeML.Attributes.Add(TagTimeOut, connection.TimeOut);
// Añade los nodos de la conexión
nodeML.Nodes.Add(TagName, connection.Name);
nodeML.Nodes.Add(TagDescription, connection.Description);
nodeML.Nodes.Add(TagServer, connection.Server);
nodeML.Nodes.Add(TagUser, connection.User);
nodeML.Nodes.Add(TagPassword, connection.Password);
// Graba el archivo
new XMLWriter().Save(fileName, fileML);
}
/// <summary>
/// Exporta los archivos
/// </summary>
internal void Export(Models.Deployments.DeploymentModel deployment)
{
using (BlockLogModel block = Manager.Logger.Default.CreateBlock(LogModel.LogType.Debug, "Comienzo de la copia de directorios"))
{
(NormalizedDictionary <object> parameters, string error) = GetParameters(deployment.JsonParameters);
if (!string.IsNullOrWhiteSpace(error))
{
block.Error(error);
}
else
{
// Elimina el directorio destino
HelperFiles.KillPath(deployment.TargetPath);
// Copia los directorios
CopyPath(block, deployment.SourcePath, deployment.TargetPath, parameters);
// Borra los directorios vacíos
HelperFiles.KillEmptyPaths(deployment.TargetPath);
// Log
block.Debug("Fin de la copia de directorios");
}
}
}
/// <summary>
/// Compila el contenido del libro
/// </summary>
private void Compile(Book book, string pathTemp, string title, string description,
string keyWords, string content, string pathTarget)
{
DocWriterFactory writerFactory = new DocWriterFactory(pathTarget);
ProjectModel project = writerFactory.CreateProject();
DocumentModel documentRoot;
// Crea el documento raíz
documentRoot = CreateRoot(title, description, keyWords, content, writerFactory);
// Crea los documentos de las páginas
foreach (IndexItem page in book.Index)
{
CreatePage(title, pathTemp, writerFactory, documentRoot, page);
}
// Crea el índice y graba de nuevo el documento raíz
documentRoot.Content += Environment.NewLine + GetIndex(project, documentRoot);
new LibDocWriter.Application.Bussiness.Documents.DocumentBussiness().Save(documentRoot);
// Copia las imágenes
CopyImages(book, pathTemp, documentRoot.File.FullFileName);
// Borra el archivo de proyecto y el archivo de solución
HelperFiles.KillFile(project.File.FullFileName);
HelperFiles.KillFile(project.Solution.FullFileName);
}
/// <summary>
/// Procesa el informe
/// </summary>
private void ProcessReport(ScriptModel script, string fileName)
{
ReportManager manager = new ReportManager(GetDataProviders(Deployment));
string fileParsed = Path.Combine(Deployment.PathFilesTarget, Path.GetFileNameWithoutExtension(fileName) + ".generated");
// Log
RaiseMessage($"Procesando el informe {Path.GetFileName(fileName)}");
// Procesa el informe
manager.GenerateByFile(fileName, fileParsed, GetParameters(Deployment.Parameters, script.Parameters));
// Añade los errores
if (manager.Errors.Count > 0)
{
foreach (string error in manager.Errors)
{
RaiseEvent(fileName, error, 0, 0, true);
}
}
else
{
RenderFile(fileParsed, fileName);
}
// Elimina el archivo intermedio
HelperFiles.KillFile(fileParsed);
}
/// <summary>
/// Copia un archivo
/// </summary>
private void CopyFile(string fileSource, string fileTarget)
{
HelperFiles.KillFile(fileTarget);
HelperFiles.CopyFile(fileSource, fileTarget);
}
/// <summary>
/// Graba un texto en un archivo con codificación UTF8 pero sin los caracteres iniciales de BOM.
/// </summary>
/// <remarks>
/// Databricks no reconoce en los notebook los archivos de texto UTF8 que se graban con los caracteres iniciales
/// que indican que el archivo es UTF8, por eso se tiene que indicar en la codificación que se omitan estos caracteres
/// <see cref="https://stackoverflow.com/questions/2502990/create-text-file-without-bom"/>
/// </remarks>
private void SaveFileWithoutBom(string fileName, string content)
{
HelperFiles.SaveTextFile(fileName, content, new System.Text.UTF8Encoding(false));
}
static void Main(string[] args)
{
#if DEBUG
var pathMaster = @"D:\Projets\Test";
#else
var pathMaster = args[0];
#endif
foreach (var path in Directory.GetDirectories(pathMaster))
{
Console.WriteLine("*****************************");
Console.WriteLine(path);
Console.WriteLine("*****************************");
// Load Keys
var filesRes = HelperFiles.GetFileInfos(new[] { "*.resx" }, Path.Combine(path, "Properties"));
var keysnotused = new List <KeyModel>();
var count = filesRes.Sum(f => Resource.GetKeysResources(f.FullName).Count());
var index = 0;
var pourcent = 0;
Console.WriteLine($"Chargement des clés: 0 %");
foreach (var file in filesRes)
{
foreach (var key in Resource.GetKeysResources(file.FullName))
{
keysnotused.Add(new KeyModel(key.Item1, key.Item2, file.FullName)
{
NotUsed = true
});
index++;
var newpourcent = index * 100 / count;
if (pourcent < newpourcent)
{
pourcent = newpourcent;
Console.SetCursorPosition(0, Console.CursorTop - 1);
Console.WriteLine($"Chargement des clés: {pourcent} %");
}
}
}
// search Keys not used
var files = HelperFiles.GetFileInfos(new[] { "*.cs", "*.xaml" }, path).Where(f => !f.FullName.TrimEnd().EndsWith(".Designer.cs"));
count = files.Count();
index = 0;
pourcent = 0;
Console.WriteLine($"Recherche des clés inutilisées: 0 %");
foreach (var file in files)
{
foreach (var key in keysnotused.Where(k => k.NotUsed).ToArray())
{
if (HelperCleaner.AnyKeyUsedInFile(key, file.FullName))
{
key.NotUsed = false;
}
}
index++;
var newpourcent = index * 100 / count;
if (pourcent < newpourcent)
{
pourcent = newpourcent;
//var pos = Console.CursorTop;
Console.SetCursorPosition(0, Console.CursorTop - 1);
Console.WriteLine($"Recherche des clés inutilisées: {pourcent} %");
}
}
// display results
Console.WriteLine("clé non utilisé: " + keysnotused.Count(k => k.NotUsed));
Console.WriteLine("clé valide: " + keysnotused.Count(k => !k.NotUsed));
foreach (var key in keysnotused.Where(k => k.NotUsed).GroupBy(k => k.File))
{
Console.WriteLine(key.Key);
foreach (var item in key)
{
ResultsCleaner.KeysNotUsed.Add(item);
Console.WriteLine($"\t - {item.Key} => {item.Label}");
}
}
}
// display results
Console.WriteLine("clé non utilisé: " + ResultsCleaner.KeysNotUsed.Count());
Console.WriteLine("clé valide: " + ResultsCleaner.Keys.Count());
using (var sw = new StreamWriter(File.Open(Path.Combine(pathMaster, DateTime.Now.ToString("yyyyMMdd_HHmmss") + "KeyError.csv"), FileMode.CreateNew), Encoding.Unicode))
{
try
{
sw.WriteLine($"Fichier ; Clé ; Libellé");
foreach (var key in ResultsCleaner.KeysNotUsed.OrderBy(k => k.File))
{
sw.WriteLine($"{key.File}; {key.Key} ; {key.Label}");
}
}
finally
{
sw.Close();
}
}
using (var sw = new StreamWriter(File.Open(Path.Combine(pathMaster, DateTime.Now.ToString("yyyyMMdd_HHmmss") + "KeyValid.csv"), FileMode.CreateNew), Encoding.Unicode))
{
try
{
sw.WriteLine($" Clé ; Fichier ; numéro ligne ; ligne");
foreach (var file in ResultsCleaner.Files.OrderBy(f => f.Key))
{
foreach (var key in file.Value.Values)
{
foreach (var item in key.Value)
{
sw.WriteLine($"{key.Key}; {file.Key} ; {item.Num} ; {item.Line}");
}
}
}
sw.Close();
}
finally
{
sw.Close();
}
}
Console.WriteLine("Press Key for finish...");
Console.ReadKey();
}
