Ich habe das jetzt für mich gelöst, vielleicht hilft das auch noch anderen:

Programming Klasse:

        public EventHandler<DataProcessedEventArgs> ProcessInformation;
        public class DataProcessedEventArgs : EventArgs
        {
            public string Data { get; set; }
            public DataProcessedEventArgs(string data)
            {
                Data = data;
            }
        }
        
        void OutputHandler(object sendingProcess, DataReceivedEventArgs outLine)
        {        
             ProcessInformation?.Invoke(this, new DataProcessedEventArgs(dataLine));
        }

Form1:

        async void work_A(COM_Port)
        {
        	prog.ProcessInformation += ProcessInformationen;
        	await Task.Run(() => prog.programming(COM_Port, PathFile));
        }
        
        private void ProcessInformationen(object sender, DataProcessedEventArgs e)
        {
            Console.WriteLine($"Daten: {e.Data}");
            SafeSetText(Form1.Instance.tb_A_Infobox, e.Data);
        }

        public static void SafeSetText(Control control, string text)
        {
            if (control.InvokeRequired)
            {
                control.Invoke((MethodInvoker)(() => control.Text = text));
            }
            else
            {
                control.Text = text;
            }
        }       

Danke für die Info. Mit den Events werde ich mich jetzt beschäftigen.

"Wie ist das gemeint? Jeder Code ist für Programmierung od. verstehe ich hier den Hintergrund nicht." → das war nur eine grobe Info was der Code macht, für das Problem quasi egal.

Hallo zusammen,

ich habe eine Code der eine Programmierung übernimmt. Die Programmierung wird als Taks aufgerufen und in einer anderen Klasse abgelaufen.

await Task.Run(() => prog.programming(COM\_Port, PathFile));  

Es läuft auch sehr gut. Die Ausgaben werden über einen OutputHandler erfasst und in der Console ausgegeben zudem in einer Variablen.

Meine Frage ist jetzt, ob es irgendwie möglich ist, die Daten aus der Variablen mit dem Programmier Fortschritt der sonst in die Console ausgegeben werde, an die Form1 zu schicken um diese dort in einer Textbox auszugeben?

Gruß

Stefan

Hallo,

ich habe ein kleines Problem das ich nicht verstehe. Ich habe ein Process das ein Kommandozeilentool aufruft. Es funktioniert soweit ganz gut, allerdings kann ich die Daten aus dem Kommandozeilentool nur lesen wenn ich den StandartInput schließe mit proc.StandardInput.Close();. Das Problem ist, das ich dann natürlich keine neuen Befehle an das Tool schicken kann. Ich möchte aber auf die Ausgaben reagieren und dann etwas dahin schicken. Ich habe das ein paar mal ausprobiert, sobald der StandartInput geschlossen wird, kommen die Daten.

Habe ich da einen Denkfehler oder kann mir einer erklären warum der StandartInput den Output blockiert?

MFG

private void Test4()
       {
           var proc = new Process
           {
               StartInfo = new ProcessStartInfo
               {
                   FileName = "C:\\Program Files (x86)\\Elprotronic\\MSP430\\FET-Pro430\\CMD-Line\\FP430-commandline.exe",
                   UseShellExecute = false,
                   RedirectStandardOutput = true,
                   RedirectStandardInput = true,
                   CreateNoWindow = false
               }
           };
           proc.Start();
           StringBuilder sb = new StringBuilder();
           var outStream = proc.StandardOutput;
           var inStream = proc.StandardInput;
           inStream.WriteLine("help()");
           List<string> lines = new List<string>();
           Task.Run(() =>
           {
               while (true)
               {
                   Console.WriteLine(outStream.ReadLine());
                   lines.Add(outStream.ReadLine());
               }
           });
           var timer = new Stopwatch();
           timer.Start();
           bool ProgResult = false;
           inStream.WriteLine("F_Initialization()");
           proc.StandardInput.Close();
           while (!ProgResult)
           {
               Thread.Sleep(100);
               //Print Results
               tb_programmingInfo.Text = String.Join(" \r\n - ", lines.ToArray());
               tb_programmingInfo.Update();
               //Abort Function
               TimeSpan timeTaken = timer.Elapsed;
               if (timeTaken.TotalSeconds > 10 || lines.Count() > 100)
                   ProgResult = true;
           }
           timer.Stop();
           //proc.StandardInput.Flush();
           //proc.StandardInput.Close();
           proc.WaitForExit(2000);
           if (!proc.HasExited)
               proc.Kill();
       }

Hallo,

ich hab ein Problem mit der referenz zur einer Variable.

Ich habe eine Variable (prodData) die ich in eine Funktion übergebe:

using static Programming.FormInterface;

public errorCode programProfinet(ref productionData prodData)

In dieser Funktion möchte ich die Variable in eine andere Variable speichern und gewissen Sachen darin verändern.

    productionData prodDataProfinet = new productionData();
    prodDataProfinet = prodData;
    prodDataProfinet.prodSW = null;

Aber die Basis-Variable prodData wird dabei auch verändert. Kann mir jemand erklären wieso das passiert? Ich mache doch gar nichts mit der Variablen, wieso ist die mit der neuen Variablen verbunden und wie kann ich diese Verbindung aufheben?

Oder ist es möglich Einfluss darauf zu nehmen, wie die DLL später aufgerufen wird? Weil scheinbar, wenn die DLL von einem dritt Programm aufgerufen wird was keine Visual Studio Anwendung ist, funktioniert es ja nicht mehr. Da würde ich davon ausgehen das diese Anwendung dann die DLL nicht mehr als x64 oder x86 aufrufst, oder liege ich da falsch?

Danke für die schnelle Antwort. Als ich den Begriff "Working Directory" gelesen habe, ist es mir auch direkt wieder eingefallen.

Das Thema mit der Prozessverwaltung und die Shell von Windows habe ich noch nicht ganz verstanden. Ich habe mein Tool jetzt auch so umgestellt das ich kein Batch-File mehr nutze sondern einfach die cmd.exe. Die hat aber das selbe Problem. Aber ich wollte von dem Batch-File Abstand gewinnen, damit es allgemeiner ist. 
Kannst du mir zu der WOW64 oder zu dem Thema allgemein vielleicht ein paar mehr Infos geben? Ist das WOW64 eine Möglichkeit eine 32-Bit Anwendung vorzugeben damit er das in dieser Version starten muss?

Hallo,

ich habe eine DLL geschrieben in der ich ein .Batchfile aufrufe und eingaben dahin schicke. Das Funktioniert auch sehr gut. Ich musste dafür aber im Konfigurationsmanager die Plattform von "Any CPU" auf "x64" ändern damit es funktioniert. Das konnte ich mir bisher auch noch nicht erklären.

Wenn ich den Pfad des Batch-Files jetzt aber auf eine andere Festplatte festlege, dann funktioniert es nicht mehr. Kann mir jemand erklären wieso das so ist? (Der Pfad passt und da gibt es keinen Fehler das dieser falsch wäre). Die Datei liegt neu im "öffentlich" Ordner, wo die Zugriffsrechte passen sollten.

Gruß

Stefan

Hallo,

Danke für die schnellen Antworten. Es lag am Gerät selbst, vielen Dank für die Hilfe.

Hallo,

ich habe eine dll geschrieben, in der ich eine Serielle Kommunikation betreibe. Aus einer Gui lassen sich die Befehle über die dll auch ansteuern und ich bekomme auch meine Daten zurück. Jedoch bricht die Kommunikation konstant nach 40 Sekunden ein. Es bringt auch nichts kontienuirlich Nachrichten zu schicken und eine Antwort zu erhalten.

Kann das mit dem Garbage Collector zusammenhängen, das der meine Funktion oder wichtige Teile davon nach 40s abräumt? Oder muss ich dem DataReceivedHandler immer wieder einen Anstoß geben?

Hier mein Code:

SerialPort serialPort1 = new SerialPort();
        public bool SerialPortOpen(string ComPort, string Baudrate, out string DeviceInfo)
       {
           try
           {
               serialPort1.PortName = ComPort;
               serialPort1.BaudRate = Convert.ToInt32(Baudrate);
               serialPort1.Parity = Parity.None;
               serialPort1.DataBits = 8;
               serialPort1.StopBits = StopBits.One;
               serialPort1.Handshake = Handshake.None;
               serialPort1.WriteTimeout = 200;
               serialPort1.ReadTimeout = 200;
               serialPort1.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
               serialPort1.Open();
               serialPort1.DiscardInBuffer();
               serialPort1.DiscardOutBuffer();
               
               if (serialPort1.IsOpen)
               {
                   isOpen = true;
}}}
        private void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
       {
           try
           {
               int intBuffer;
               intBuffer = serialPort1.BytesToRead;
               byte[] byteBuffer = new byte[intBuffer];
               serialPort1.Read(byteBuffer, 0, intBuffer);
               recievedBytes.Add(byteBuffer);               
           }
           catch
           {
           }
       }