Hallo zusammen,
ich steh vor folgendem Problem: Mein Programm läuft von der Syntax her soweit ohne Probleme, sofern man nur ein bzw. wenige Dateien in den zu überwachenden Ordner ablegt. Sobald dann aber eine größere Anzahl von Dateien verschoben werden und es zu bearbeiten
gilt, steigt das Programm an verschiedenen Stellen aus mit der Begründung, dass ein anderer Prozess die Datei verwendet. Ich nehme stark an, dass der Filesystemwatcher sich da selbst irgendwo in die Quere kommt. Wenn man das Programm debuggt und in Einzelschritten
testet, kommt der Fehler nie auf, mit Sleeps möchte ich aber ungern arbeiten. Streamreader und so sollten eigentlich alle auch geclosed sein, sofern ich einen aufgemacht hab. Eine einfache Möglichkeit alle momentanen Zugriffe abzubrechen gibt es nicht, oder?
Die Fehler tauchen immer auf, wo ich try and catch momentan gesetzt habe, also am Anfang von workonfile() und in startCreate().
Anbei der etwas gekürzte Code, vielleicht könnt Ihr mir da ja etwas auf die Sprünge helfen:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Text;
using System.IO;
namespace TypeSort
{
class Program
{
string source, ziel1, ziel2, ziel3, archiv, logfile, logdir;
string filecontent, filetype, destination, filepath, writethis, filename, date, logentry, matParam, tempFile;
FileSystemWatcher fsw001, fsw002;
string[] content, content_folgejob, content_hauptjob, existingFiles;
StreamReader reader;
StreamWriter writer;
string job, material;
DateTime dt;
int tempState;
static void Main(string[] args)
{
Program run = new Program();
run.process();
}
/// <summary>
/// Konstruktor
/// Zwei Filewatcher, je für die 001 und 002 Files
/// </summary>
public void process()
{
tempFile = matParam = logentry = date = job = material = filecontent = filetype = destination = filepath = writethis = filename = null;
tempState = 0;
content = new string[54];
content_folgejob = new string[54];
content_hauptjob = new string[54];
fsw001 = new FileSystemWatcher();
fsw002 = new FileSystemWatcher();
source = @"C:\source\";
ziel1= @"C:\ziel1\";
ziel2= @"C:\ziel2\";
ziel3= @"C:\ziel3\";
archiv = @"C:\archiv\";
logfile = @"C:\log\log.txt";
logdir = @"C:\log\";
fsw001.Path = source;
fsw002.Path = source;
fsw001.Filter = "*.001";
fsw002.Filter = "*.002";
fsw001.NotifyFilter = NotifyFilters.FileName | NotifyFilters.CreationTime;
fsw002.NotifyFilter = NotifyFilters.FileName | NotifyFilters.CreationTime;
fsw001.Created += new FileSystemEventHandler(fsw_Created001);
fsw002.Created += new FileSystemEventHandler(fsw_Created002);
existingFiles = Directory.GetFiles(source, "*.001");
foreach (string file in existingFiles)
{
filetype = "001";
tempFile = Path.GetFileName(file);
workonfile(tempFile, filetype);
}
existingFiles = Directory.GetFiles(source, "*.002");
foreach (string file in existingFiles)
{
filetype = "002";
tempFile = Path.GetFileName(file);
workonfile(tempFile, filetype);
}
fsw001.EnableRaisingEvents = true;
fsw002.EnableRaisingEvents = true;
Console.Title = "Sortierung läuft";
Console.ReadLine();
}
/// <summary>
/// Event wenn eine 001 Datei abgelegt wurde
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Filename</param>
private void fsw_Created001(object sender, FileSystemEventArgs e)
{
filename = e.Name;
filetype = "001";
workonfile(filename, filetype);
}
/// <summary>
/// Event wenn eine 002 Datei abgelegt wurde
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Filename</param>
private void fsw_Created002(object sender, FileSystemEventArgs e)
{
filename = e.Name;
filetype = "002";
workonfile(filename, filetype);
}
/// <summary>
/// Lese die Datei aus in ein Array und lösche sie
/// Splitte die Dateien bei den Rauten # und kürzer Leerzeichen
/// Unterscheide ob Folgejob verarbeitet wird oder nicht
/// Rufe die Methode sort auf und übergebe den Array
/// </summary>
/// <param name="filename">Pfad zur bearbeitenden Datei</param>
/// <param name="filetype">Differenzierung 001 oder 002</param>
private void workonfile(string filename, string filetype)
{
try
{
reader = new StreamReader(source + filename);
filecontent = reader.ReadToEnd();
reader.Close();
File.Delete(@source + filename);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
content = filecontent.Split('#');
for (int i = 0; i < content.Length; i++)
{
content[i] = content[i].Trim();
content_folgejob[i] = content[i];
content_hauptjob[i] = content[i];
}
// temp 1 nur hauptjob
// temp 2 haupt und folgejob
if (filetype == "002")
{
content_hauptjob[50] = "";
content_hauptjob[51] = "";
content_hauptjob[52] = "";
tempState = 1;
}
else //filetype == "001"
{
content_hauptjob[50] = "";
content_hauptjob[51] = "";
content_hauptjob[52] = "";
tempState = 1;
if (content_folgejob[50] != "" && content_folgejob[50] != " ")
{
content_folgejob[1] = content_folgejob[50];
content_folgejob[2] = content_folgejob[51];
content_folgejob[3] = content_folgejob[52];
content_folgejob[50] = "";
content_folgejob[51] = "";
content_folgejob[52] = "";
tempState = 2;
}
}
if (mappingMatches(content) == true && mappingMatches(content_folgejob) == true && mappingMatches(content_hauptjob) == true)
{
if (content_hauptjob[3] == "1")
{ matParam = "K"; }
else
{ matParam = "M"; }
sort(content_hauptjob, matParam + filename);
if (tempState == 2)
{
if (content_folgejob[3] == "1")
{ matParam = "K"; }
else
{ matParam = "M"; }
sort(content_folgejob, matParam + filename);
}
startCreate("archiv", content, filename); // ins Archiv
}
else
{
startCreate("fehler", content, filename); // ins Log
}
// Arrays leeren, weiterarbeiten
Array.Clear(content, 0, content.Length);
Array.Clear(content_hauptjob, 0, content_hauptjob.Length);
Array.Clear(content_folgejob, 0, content_folgejob.Length);
}
/// <summary>
/// Unterscheidung der verschiedenen Mappings zur Sortierung
/// Aufruf der Verschiebe/Kopierfunktion
/// </summary>
/// <param name="content">zu verarbeitendes Array</param>
/// <param name="filename">Dateiname</param>
private void sort(string[] content, string filename)
{
// ...
// setze destination
// ...
startCreate(destination, content, filename);
}
/// <summary>
/// Erstellt die Dateien neu in den passenden Ordnern
/// Ruft writeLog danach auf
/// </summary>
/// <param name="destination">Zielordner</param>
/// <param name="content">zu verarbeitendes Array</param>
/// <param name="filename">Dateiname</param>
private void startCreate(string destination, string[] content, string filename)
{
// ...
// setze filepath
// ...
for (int k = 0; k < content.Length; k++)
{
writethis = writethis + content[k] + "#";
}
try
{
while (File.Exists(filepath) == true)
{
filepath = filepath + ".001";
filename = filename + ".001";
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
try
{
writer = File.CreateText(filepath);
writer.Write(writethis);
writer.Close();
writethis = "";
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
writeLog(destination, filename, content[1], content[3], content[0]);
}
/// <summary>
/// schreibt einen Logeintrag mit Uhrzeit und ein paar Angaben zu den verarbeiteten Jobs
/// in eine Textdatei
/// </summary>
/// <param name="destination">Zielordner</param>
/// <param name="filename">benutzer Dateiname</param>
/// <param name="job">Welcher Job</param>
/// <param name="material">Welches Material</param>
/// <param name="anzahl">Wie viele Schilder</param>
private void writeLog(string destination, string filename, string job, string material, string anzahl)
{
dt = DateTime.Now;
date = dt.ToString();
logentry = date + " : " + destination + "; " + filename + "; " + job + "; " + material + "; " + anzahl + "; ";
if (File.Exists(logfile) == true)
{
using (StreamWriter sw = File.AppendText(logfile))
{
sw.WriteLine(logentry);
sw.Close();
}
}
else // Datei erzeugen
{
using (StreamWriter sw = File.CreateText(logfile))
{
sw.WriteLine(logentry);
sw.Close();
}
}
Console.WriteLine(logentry);
}
/// <summary>
/// Überprüft das übergebene Array in Position 1 und 3, also auf Job und Material,
/// ob es mit dem vorgegebenen Mapping übereinstimmt und antwortet
/// </summary>
/// <param name="checkContent">zu prüfendes Array</param>
/// <returns>true wenn alles passt</returns>
private bool mappingMatches(string[] checkContent)
{
// ...
// verschiedene Mappingmöglichkeiten werden getestet
// ...
}
Bin noch nicht lange beim Programmieren, suche mir auch vieles zusammen, aber hier hackt es leider...
Gruß,
Florian
Filesystemwatcher - Datei ist bereits in Zugriff durch anderen Prozess - Exception
