vielen Dank für die Unterstützung!
Ich konnte das Problem mit einem Eventhandler zwischenzeitlich lösen.

ja, es handelt sich um einen Datenstrom eines externen Programms ==> die Daten werden über einen NamedPiperServer eingelesen.
Wenn ich das Programm starte, kann ich in MainWindow die Daten auch lesen.

Wegen des MVVM Models möchte ich einen Aufruf aus MainWindow vermeiden.
Wenn ich es richtig verstanden habe, muss der Datenabruf im ViewModel erfolgen und hier fehlt mir das Wissen, wie dies zu erfolgen hat.
Die einfache Zuweisung an die Property scheint ja nicht zu funktionieren...

Was heißt "appenden" ==> das kenne ich nur bei files und nicht bei Properties?

Hallo an das Forum,

ich nutze ein MVVM Model für mein WPF Programm.
In meinem ViewModel verwende ich folgenden Code:

      CurrentData = myDataStream.ToString(); //??

       private string _currentData;
       public string CurrentData
        {
            get => _currentData;
            set
            {
                if (_currentData != value)
                {
                    _currentData = value;
                    this.RaisePropertyChanged();
                }
            }
        }

Das Binding zu Xaml und RaisePropertyChanged() sind funktionsfähig.
Mit einer anderen Property kann ich z.B. in einer TextBox meine Daten verändern.

Ich möchte aus einer externen Quelle myDataStream in einer TextBox anzeigen;
hierbei handelt es sich (vereinfacht) um Zahlen von 0 - 100.
Der bisherige Entwicklungsstand zeigt nur eine 0, obwohl ich bei Verwendung von
RaisePropertyChanged() erwartet hätte, dass die Zahlen sich bis 100 verändern.
Ist es erforderlich einen zusätzlichen Eventhandler zu erstellen, brauche ich eine
ObservableCollection oder was ich des Rätsels Lösung?
Vielen Dank für die Unterstützung!

Hallo Abt,

vielen Dank für den Hinweis.

Meine Methode verwendet folgen Code, in den 1000 Daten (CurrentInt) geschrieben werden.

     internal int NewInt(int CurrentInt)
        {
            PrevIntList.Add(CurrentInt);
            for (int i = 0; i < PrevIntList.Count; i++) { if (i >= 1) prevIntListValue = PrevIntList[i - 1]; }
            return prevIntListValue;
        }

Um zu testen, ob die Berechnung korrekt ist, muss ich die Methode(!) wenigstens zweimal aufrufen, um einen Vorgängerwert zu erhalten.
Die von Mosalla beschriebenen Methoden lösen dieses Problem nach meinem Verständnis nicht.
Mit InlinaData kann ich CurrentInt ändern; ich kann aber keinen Vorgängerwert testen.
Mit anderen Worten: Mein Verständnis von "Datenreihe" bezieht sich auf den Test der Methode und
nicht auf die verwendeten Variablen, worauf Du Dich zu beziehen scheinst.

Wie teste ich meine Methode korrekt oder ist das mit XUnit nicht möglich?

Danke

Hallo an das Forum,

derzeit arbeite ich mich in das Thema XUnit ein und möchte meine Auswertungen einer Datenreihe testen.
Als Beispiel habe ich eine Datenreihe mit den Werten value = 0,3,10,12,14. Für diese benötige ich den Vorgängerwert, den ich
mittels einer List als prevValue an der Stelle x - 1 also 0,3,10,12 ermittle.

Ich finde im Internet keine Lösung für dieses Problem, sondern nur die Möglichkeit mit [InlineData] einzelne Berechnungen
durchzuführen (Beispiel result = value1 + value2, wobei value1 und value2 unterschiedliche Werte zugewiesen werden können)

Meine Frage lautet also: Wie kann ich eine beliebige Datenreihe an der Stelle 0, 1, 2, 3 usw. auf den Vorgängerwert
oder mittels [InlineData] auf andere Kriterien testen?

Vielen Dank für die Unterstützung
KuGBeginner

Eigentlich sollte Visual Studio deine DLL automatisch kompilieren, wenn dein Konsolenprojekt sie braucht und sich darin auch etwas geändert hat.

Das funktioniert bei mit nicht ==> Console arbeitet auf Net 6.0 und die dll mit Framework 4.8.
Bisher habe ich in meinen Programmen keine weiteren Fehler entdecken können, die auf diese Kombination zurückzuführen wären ....
Sollte ich darüber noch einmal nachdenken?

Vielen Dank für den Hinweis ==> mit einem ShortCut ist es eine deutliche Arbeitserleichterung!

Hallo an das Forum,

ich bearbeite derzeit ein c# Consolen Projekt mit einer eingebundenen dll in VisualStudio 2022 in einer Projektmappe.
Wenn ich die dll ändere, lege ich das Startprojekt auf die dll fest und kompiliere die Änderung.
Anschließend muss ich die Console als Startprojekt festlegen und erneut kompilieren.

Wenn ich mehrere Startprojekte verwende, muss ich das kompilieren ebenfalls zwei mal ausführen ...

Gibt es die Möglichkeit, diesen Prozess zu vereinfachen und "mit einem Klick" diese Aufgabe zu erledigen?
Vielen Dank für die Unterstützung!

Hallo Abt,
vielen Dank für den Hinweis auf den Umfang der Programmierung ==> macht viel Mut!?
Ich verwende tatsächlich die von Dir vorgeschlagenen Snippets.
Im Grunde ist auch alles funktionsfähig, außer dass das Rückschreiben der Daten an Progamm1 nicht funktioniert.
Ich habe jetzt ein Callback einfügt; kann dieses aber in Write nicht aufrufen

while (true)
{
     string? readData = await reader.ReadLineAsync();
     Console.WriteLine("Data Received from NT " + readData);
     if (readData?.Length == 0) { break; }
     //Create a new read event args
     ServerMessageEventArgs newMessage = new ServerMessageEventArgs(readData);
     // das Event wird erkannt
     OnStringReceived?.Invoke(newMessage);
}

Wie kann ich im Writer OnStringReceived aufrufen?

Hallo Abt,
vielen Dank für Deinen Hinweis ==> ich habe die statische Variable geändert.
Ich möchte gerne mit NamedPipeStream weiterarbeiten.
Damit bleibt die Frage, wie ich die Daten von Read nach Write übertragen kann.
Ist es eine Lösung in Read die Daten in einer List zu speichern und in Write den jeweiligen Index 1 zu lesen
und nach dem Schreiben zu löschen?
while(true) scheint zum Lesen der List erforderlich zu sein.
Es verbleibt damit das Ausgangsproblem ==> Wie weise ich Write an, mit dem Schreiben zu beginnen oder es zu beenden ....

Hallo an das Forum,
Ich bitte um Unterstützung bei folgender Frage:
Über einen NamedPipeStream möchte ich ca. 1000 string Daten von Programm1 lesen, in Programm2 bearbeiten und anschließend von Programm2 an Programm1 zurückschreiben.
Der Arbeitsstand ist, dass ich Daten von Programm1 in Programm2 lesen, formatieren und bearbeiten kann.

Die Rückgabe der bearbeiteten Daten bereitet mir allerdings Probleme
Zum Lesen verwende ich folgenden Code

While (true)
transferData = await reader.ReadLineAsync();

transferData ist eine statische string Variable

Den Inhalt von transferData übergebe ich meinem streamWriter mit folgendem Code

streamWriter.AutoFlush = true;
while (true)
{
    await streamWriter.WriteLineAsync(transferData);
    if (transferData?.Length == 0) break; //??
}

Das Ergebnis ist, dass die Daten zwar gelesen und geschrieben werden; allerdings erhalte ich eine Vielzahl von mehrfach geschriebenen Daten.
Der Schreibvorgang wird auch fortgesetzt, obwohl keinen neuen Daten mehr gelesen werden.
Offensichtlich ist while(true) der falsche Aufruf. Ich habe aber bisher keine korrekte Lösung gefunden.
(die Verwendung eines "SynchronisationsCounters" funktioniert; ist aber unzumutbar langsam)
Wie kann ich das Problem lösen? Der Schreibvorgang soll möglichst synchron mit der Auswertung der gelesenen Daten erfolgen.
Herzlichen Dank für Eure Hinweise!

Hallo T-Virus,
vielen Dank für Deine Rückmeldung!
Programm 1 schreibt über einen Client an Programm 2 Server und ich übergebe x-mal einen String mit den beschriebenen 15 Variablen.
Diese müssen im Server formatiert werden. Das funktioniert aber nicht, weil der Lesevorgang nicht immer das Ende des einzelnen Strings erkennt.
Der Datenaustausch soll so lange erfolgen, wie Programm 1 aktiv ist (mehrere Stunden).

Es verbleibt bei meiner Frage, wie ich die EndRead(ar)- Methode zum korrekten Lesen am Ende eines Strings bringen kann.
Vielen Dank für die Hilfe!

Hallo an das Forum,
ich bitte um Unterstützung bei folgender Fragestellung.

Ich möchte Daten von Programm1 an Programm2 übergeben, in Programm2 bearbeiten und diese Daten an Programm1 zurückgeben.
Es handelt sich um wenigstens 1000 historische Daten und realtime um 60 Daten pro Minute.
Es sollen ca. 15 Variablen (int, double, string und bool) in einer Reihe als string übergeben werden.
Hierzu verwende ich einen NamedPipeServer, der die Daten empfängt und grundsätzlich auch korrekt formatiert.
Mein Problem ist, dass „EndRead(ar)“ nicht immer das korrekte Ende der Reihe findet.
Ich verwende folgenden Code:

private async void ReadStream(IAsyncResult ar)
{
    ClientMessage cmo = (ClientMessage)ar.AsyncState; //Get the message object
    if (_currentServer == null) return;
    int recv = _currentServer.EndRead(ar);  //Receive data  FEHLER

    if (recv > 0)   //If data received
    {
       //Convert msg to string
       byte[] read = new byte[recv];
       Buffer.BlockCopy(cmo.buffer, 0, read, 0, recv);
       string message = Encoding.Unicode.GetString(read);
	 // ……
	
    }

Array.Clear(cmo.buffer, 0, cmo.buffer.Length);    //Free the byte array

if (_currentServer != null)				//Copy
_currentServer.BeginRead(cmo.buffer, 0, cmo.buffer.Length, new AsyncCallback(ReadStream), cmo);

Im Dateianhang wird von Zähler 1 bis 80 der string korrekt ausgegeben.
Von Zähler 81 bis 85 wird der string als ein Gesamtstring gelesen, weshalb die Reihenfolge der Daten nicht mehr korrekt ist und als Folgefehler ab diesem Bereich eine Zuweisung der Daten im korrekten Format nicht mehr möglich ist.

Meine Frage lautet deshalb: Wie kann man das fehlerhafte Lesen unterbinden?
Mein Arbeitsstand:
• Task.Delay(1).Wait(); in Programm 1 führt nicht immer zu korrekten Ergebnissen und verlangsamt den Prozess deutlich
• Die Übergabe von /r/n oder „EOF“ löst das Problem nicht (oder ich habe es nicht korrekt programmiert?)
• Die Synchronisation über identische Counter funktioniert nicht; es fehlen die Daten => 81-85 wird nicht gezählt
• .Contains(); .Split() usw. des Strings funktionieren nicht, weil die erforderlichen Daten fehlen

Vielen Dank für die Unterstützung!

PS: Eigentlich sollte es sich bei meinem Anliegen um ein Standardproblem handeln; kann jemand im Forum ein funktionierendes Codebeispiel empfehlen?

Ganz herzlichen Dank an das Forum für die zahlreichen Meldungen; ein solches Feedback ist außergewöhnlich!
Ich konnte mein Problem mittlerweile über linq ==> Skip und Take lösen! 😁

Gruß KuGBeginner

Hallo an das Forum,

ich fülle myArray mit 20 unterschiedlichen Werten.
Mit myArray.Max kann ich den höchsten Wert des Arrays ermitteln.

Ich möchte jetzt aber nach 10 Werten den höchsten Wert der ersten 10 Werte und nach 20 Werten den höchsten Wert der letzten 10 Werte ermitteln. Bei meinen Versuchen habe ich es nur erreicht, den höchsten Wert aller 20 Werte zu ermitteln.

Die Variable, die den Maximalwert ausliest, auf 0 zu setzen brachte keinen Erfolg.
Wenn ich eine Kopie des ersten 10er Blocks und des zweiten 10er Blocks erstelle und die Kopie auswerte, erhalte ich wieder nur das Gesamtergebnis.
Ich habe bisher keine Lösung gefunden, myArrayMax an der Stelle 11 zu löschen....

Wie kann ich das Problem lösen?
Vielen Dank für die Unterstützung!

Hallo Abt,

vielen Dank für den Hinweis!
Die verwendete Datenserie ist überschaubar und ich möchte nicht viel Aufwand betreiben ==> wie formuliere ich den Konstruktor?

Gruß KuG

Hallo an das Forum,
ich ermittle in einer public class Read eine Datenserie, die ich in einer class Write verwenden möchte.

In der class Read weise ich Daten zu:

	
public static class DevelopStatic
    {
        public static Series  <double> StaticSeries;
    }

public class Read
{DevelopStatic.StaticSeries[0] = testValue;}

Die Daten werden in class Read korrekt gelesen und ausgegeben ...

Wenn ich in meiner class Write auf die Datenserie der class Read zugreifen möchte, gibt der Compiler bei

	
Print (Time[0] + " StaticSeries " + DevelopStatic.StaticSeries[0]); 

keine Fehlermeldung ...

Zur Laufzeit erhalte ich die Fehlermeldung: > Fehlermeldung:

Der Objektverweis wurde nicht auf eine Objektinstanz festgelegt.

	
DevelopStatic.StaticSeries = new Series<double> (this);

verhindert die Fehlermeldung, liefert aber verständlicherweise keine Daten aus class Read.

Offensichtlich benötige ich einen Konstruktor für die statische Datenserie ...
Meine Programmier- und Rechercheversuche sind erfolglos.

Wie kann ich den (statischen?) Konstruktor formulieren?

Viele Dank für die Unterstützung
KuG

das Problem liegt m.E. nicht in equilla, da hier Daten nur gelesen und geschrieben werden… Dieser Prozess funktioniert fehlerfrei.
Denken wir equilla weg und stellen wir uns vor, es wird über Interface 1 minütlich ein Wasserstand aktualisiert...

Diesen Wert möchte ich auslesen und speichern. Schon dabei scheitere ich grandios ….

Alle Versuche

interfaceIIOTestRead (Interface 1) ,    
public class class1 : IIOTestRead, EquillaExtension.IEquillaExtension (Klasse1 )  
oder eine neue Klasse "Transfer"  

zu modifizieren und als Zwischenspeicher zu verwenden, scheitern.

Meine konkreten Fragen lauten:

1. Kann ich überhaupt aus dem Komplex Interface 1 und der Klasse 1 Daten in einen Zwischenspeicher auslesen?
2. Wie muss Interface 1 gestaltet sein, dass dies funktioniert? (abstrakt, {get; set;}, Variable, andere Variante)
3. Kann ich den Wert "summe" oder" ReadRangeEquity" in Klasse 1 als eigenständige Variable (z.B. Transfer) speichern oder muss dies in einer anderen Klasse erfolgen.
4. Kann dies in Klasse 2 erfolgen?
5. Wie muss ich das zu Klasse 2 gehörige Interface einrichten, dass dieser Vorgang funktioniert?
6. Würde es für das Auslösen der Write-Methode (so erforderlich) ausreichen, von equilla ein Signal (bool) Start_Write zu bekommen?

Anbei ein Beispiel meines Unvermögens(Fleißes, Frustes ...):

public interface IIOTestRead
    {
        [Description("Lese ReadRangeEquity")]
        double ReadEquity(EquillaExtension.IDoubleSeries ReadRangeEquity);

        [Description("Initialisiere Transfer")]
        //double Transfer {get;set;}    // ==> muss in Class implementiert werden; wird hier akzeptiert; public class erzeugt Fehler
        //void Transfer();                // + double - public class gibt Fehler
        void transfer(Wert w);
    }


public class class1 : IIOTestRead, EquillaExtension.IEquillaExtension
    {
        double IIOTestRead.ReadEquity(EquillaExtension.IDoubleSeries ReadRangeEquity) // dieser Rückgabewert soll an Interface 2 übertragen werden
        {
            //double transfer = 0;              // überflüssig, weil der Wert transfer schon vorhanden
            //double transfer {get;set;}        // Fehler implemtiert nicht transfer-

            //public double Transfer;           // public -
            /*double Transfer;                    // + class1 -
            {
                get{return Transfer;}           // 
            }
            */
            
            double summe = 0;                   //{Set;}; -                               
            double laenge = 1;
            for (int i = 0; i < laenge; ++i)
                summe += ReadRangeEquity.GetValue(i);
            // hier kann "set" nicht verwendet werden
            // this.MemberwiseClone = (ReadRangeEquity); cannot assign to MemberwiseClone because it is a methodgroup
            //summe = transfer;
            //transfer {get;}
            return summe;
            

            //transfer transfer = new Trans (); 
            //transfer.
            // void transfer;                   // kann hier nicht verwendet werden
            //double transfer = summe;            // + Warning unreachable code ==> summe?
            //transfer = summe;

            //double Transfer = new double { transfer(summe)}; // Fehler
            {
            }
        }

und so weiter und so weiter ....
bin hat ein C# Analphabet 8o

?( 😭 🙁

Es handelt sich um eine .dll, die über eine COM-API Erweiterung in equilla eingebunden wird.

Die Daten werden von equilla geliefert und sollen an unterschiedliche Arbeitsbereiche in equilla zurückgegeben werden.
Dort erfolgt die Weiterverarbeitung. Der equilla Code ist vollständig und funktionsfähig.

Die Zwischenspeicherung soll in C# erfolgen, weil die equilla Lösung (printtofile) zu langsam und fehleranfällig ist.

Da ich nur die jeweiligen Werte (ohne jede weitere Bearbeitung aber zur Laufzeit) übertragen möchte,
würde ich in equilla ReadRangeEquity als Globale Variable deklarieren und in Interface 2 einlesen.

Gibt es keine vergleichbare (einfache) Lösung in C#?

Hallo an das Forum,

als Anfänger bei C# bitte ich um Unterstützung bei folgendem Problem:

Über Interface 1 lese ich eine historische (1000 Werte) und eine sich minütlich aktualisierende Datenserie aus einem Programm (equilla) aus
und übertrage sie zurück an dieses Programm (dieser Ablauf funktioniert fehlerfrei).

Die Datenserie aus Interface 1 möchte ich nun über ein Interface 2 erneut an einen anderen Programmteil von equilla übertragen.
Die Rückgabe einer einzelnen Variablen wird von equilla erkannt und korrekt gelesen.

Mein Problem ist der interne Übertrag der Datenserie innerhalb von C#.

Meine Frage lautet:

Wie kann ich den Rückgabewert "ReadRangeEquity" oder "summe"(?) an "writerangeequity" übergeben?

Vielen Dank für die Unterstützung!

using System.Runtime.InteropServices;
using System.ComponentModel;
using System;

namespace ReadFromEquillaAndWriteToEquilla
{
    /* Hier werden Werte aus equilla ausgelesen und an equilla zurückgegeben
     * Das Interface IIOTestRead übergibt den korrekten Wert*/
    
    [ComVisible(true)]
    [Guid("ae35cb40-5e14-457d-9146-28f40969921e")]
    public interface IIOTestRead
    {
        [Description("Lese ReadRangeEquity")]
        double ReadEquity(EquillaExtension.IDoubleSeries ReadRangeEquity); 
    }

    /* Hier wird der Wert aus equilla ausgelesen und an das Interface IIOTestRead zurückgegeben 
     * die Verarbeitung ist korrekt
     */

    [ComVisible(true)]
    [Guid("b5014f84-bfd6-4b1a-b8ae-610dabf5b664")]
    [ComDefaultInterface(typeof(IIOTestRead))]
    [ProgId("IORead")]

    public class Class1 : IIOTestRead, EquillaExtension.IEquillaExtension
    {
        double IIOTestRead.ReadEquity(EquillaExtension.IDoubleSeries ReadRangeEquity) // dieser Rückgabewert soll an Interface 2 übertragen werden
        { 
            double summe = 0;                               
            double laenge = 1;                              
            for (int i = 0; i < laenge; ++i)
                summe += ReadRangeEquity.GetValue(i);
            // hier kann "set" nicht verwendet werden
            // this.MemberwiseClone = (ReadRangeEquity); cannot assign to MemberwiseClone because it is a methodgroup
            return summe;                                   
        }

        void EquillaExtension.IEquillaExtension.Attach(EquillaExtension.IEquillaHost Host) { }
        void EquillaExtension.IEquillaExtension.Detach() { }

        interface IEquillaExtensionSession
        {
            void Attach();
            void Detach();
        }
    }
}
//----------------------------------------------------------------------------------------------------------------

/* Hier  soll der Wert ReadRangeEquity an equilla übergeben werden
 * eine Zahl lässt sich übertragen; aber nicht der Wert ReadRangeEquity aus dem namespace IOTestRead 
 * 
 */

namespace GetValueFromReadFromEquillaAndWriteThisValueToEquilla
{
    [ComVisible(true)]
    [Guid("e018ee3e-415a-463f-9683-27db9de85090")]
    public interface IIOTestWrite
    {
        [Description("Schreibe ReadRangeEquity")]
        double WriteEquity(EquillaExtension.IDoubleSeries WriteRangeEquity); 
    }

    /* Hier soll der Rückgabewert "ReadRangeEquity" oder "summe"? aus public class Class1 : IIOTestRead gespeichert
     * und an equilla übergeben werden 
     */
    
    [ComVisible(true)]
    [Guid("1b28069e-9623-4435-aae5-93d5a6ffb851")]
    [ComDefaultInterface(typeof(IIOTestWrite))]
    [ProgId("IOWrite")]

    public class Class1 : IIOTestWrite, EquillaExtension.IEquillaExtension
    {
        double IIOTestWrite.WriteEquity(EquillaExtension.IDoubleSeries WriteRangeEquity)
        {
            //WriteRangeEquity.GetValue(ReadRangeEquity);    // erkennt ReadRangeEquity nicht
            //double summe = ReadRangeEquity;                // erkennt ReadRangeEquity nicht
            //WriteRangeEquity.GetValue();
            double writerangeequity = summe;                  // erkennt summe nicht 
            return writerangeequity;

            //double writerangeequity = 100;                  // die Übergabe des Wertes 100 an equilla funktioniert
            //return writerangeequity;
        }

        void EquillaExtension.IEquillaExtension.Attach(EquillaExtension.IEquillaHost Host) { }
        void EquillaExtension.IEquillaExtension.Detach() { }

        interface IEquillaExtensionSession
        {
            void Attach();
            void Detach();
        }
    }
}