Discussion Commanders log manual and data sample
- Thread starter Zac Antonaci
- Start date
Since the idea of getting full system data dump when viewing the system map was put forth (by me and others) in this thread, I’m also posting here a link to a fleshed-out proposal I posted in another sub-forum. Feel free to rep and/or comment 
lol that would explain that
also is there a entry for credits? like when they change value?
No single one, but I believe that every transaction that provides or receives credits is covered across the various events.
Nope, updates for me the moment an event happens. How are you trying to read from them?
I'm using C# FileSystemWatcher Class
The change event is triggered only when the file is created, which is when the game starts and when the game exits.
You have to poll for new content in the file stream. Check out my EliteDMX project on github for an example. Link in my signature.
What Toumal said, also it might be that you're locking ED out of the file? Fileaccess can be a mess in C#, I had some fights with it too.
I don't know if this is the right place to post this here but here is my code, i can't find anything wrong, but still it is not working.
View attachment MainWindow.txt
View attachment MainWindow.txt
I forgot to mention that this code snapshot is from Toumal solution.
I think i got what is the issue. the OnChanged event of the FileSystemWatcher is triggered when the file size changes. on the other hand, the game is updating the log file using the Flush method of the FileStream class, which does not cause Windows to flush the file’s metadata. The metadata is not flushed until the FileStream Close method is called.
I believe a fix for that, is to use Close method when a log is written and not to rely only only on Flush.
Last edited:
Hi Tommy, the trick is to not only rely on the FileWatcher. For instance, check out this bit of code: https://github.com/MagicMau/EliteJo...liteJournalReader/JournalWatcher.cs#L241-L256
It's just a basic loop over the currently active journal file that checks if there is more info written to the file. If so, read the new lines and parse them.
You can then use the FileWatcher to be notified if new files arrive (a new journal file for instance).
Hope that helps!
I had the same problem. My solution is to open
a read stream on the current file and polling it with
Code:
Thread.Sleep(1000)
if(!journalStreamReader.EndOfStream)
{
//do some work because there is a new event entry
// e.g. var newLine = journalStreamReader.ReadLine()
}it works 100%
Last edited:
No, it is completely normal.
For the full details from Raymond Chen: https://blogs.msdn.microsoft.com/oldnewthing/20111226-00/?p=8813
Duke's solution has been and remains the standard way to poll an open file for new data since at least UNIX/C in the 1970s.
Last edited:
My code uses the filesystemwatcher to find new logfiles as they are created. I use polling to check if new content is in the current logfile. Yes that is the classic way to do this, though under linux FAM works even for still open files.
If you take my polling code and the filesystemwatcher bits then you have all you need.
If you take my polling code and the filesystemwatcher bits then you have all you need.
Here's a class to read the stuff:
To use, do this:
I still recommend using the filesystemwatcher to handle the "create" event of files, that way you don't have to parse the logfile for the filename of the next logfile once it grows beyond max size.
Code:
public class AddedContentReader
{
private readonly FileStream _fileStream;
private readonly StreamReader _reader;
//Start position is from where to start reading first time. consequent read are managed by the Stream reader
public AddedContentReader(string fileName, long startPosition = 0)
{
//Open the file as FileStream
_fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
_reader = new StreamReader(_fileStream);
//Set the starting position
_fileStream.Position = startPosition;
}
//Get the current offset. You can save this when the application exits and on next reload
//set startPosition to value returned by this method to start reading from that location
public long CurrentOffset
{
get { return _fileStream.Position; }
}
public bool NewDataReady()
{
return (_fileStream.Length >= _fileStream.Position);
}
//Returns the lines added after this function was last called
public string GetAddedLine()
{
return _reader.ReadLine();
}
}To use, do this:
Code:
_continuousFileReader = new AddedContentReader(file.FullPath);
while (true) {
Thread.yield();
if (_continuousFileReader != null && _continuousFileReader.NewDataReady())
{
// Specify what is done when a file is changed, created, or deleted.
string newLines = _continuousFileReader.GetAddedLine();
if (newLines != null && newLines.Length > 0)
{
Console.WriteLine("New data: " + newLines);
//Do stuff
}
}
}I still recommend using the filesystemwatcher to handle the "create" event of files, that way you don't have to parse the logfile for the filename of the next logfile once it grows beyond max size.
Last edited: