Bei mir geht es uebrigens um eine Server-Komponente und da um eine Klasse aus einer DLL. Mir ist bewusst geworden, dass ich einfach IDispose implementieren muss, damit das alles sauber abgebaut wird. Insofern ist die Exception ein Feature und ich muss halt ordentlich aufraeumen 😉 Ich hatte zwar einen Destruktor definiert - aber dispose ist wohl das richtige.

Ich benutze Mono und beende ein Programm mittels

System.Environment.Exit(0); 

Das Programm besteht aus mehreren Threads. Bei dem Beenden bekomme ich nun eine Exception, weil ein Socket, der in mehren Threads benutzt wird, in der falschen Reihenfolge verschwindet. Ist das nun ein Bug oder ein Feature, dass nach System.Environment.Exit(0); noch eine Exception passiert?

Command Pattern und jede Phase des Spiels als Klasse mit gleichem Interface executre darzustellen widersprechen sich fuer mich nicht - insbesondere falls mal mehrere Pokervarianten angeboten werden...
Der Ablauf Karten verdeckt/offen fuer Spieler/Gemeintschaft ausgeben und Wetten ist immer gleich - ansonsten faellt mir gar nix fuer Vererbung ein...

Wenn Du unbedingt Vererbung erzwingen willst,
dann wuerde ich Preflop, Flop, Turn und River als Objekte in Deinem Programm definieren.
Wahrscheinlich am besten ueber Interface-Vererbung, damit Du zeigst, dass alle 3 Phasen die gleiche Reihenfolge (Karten auslegen, Wetten, Nachfolger aufrufen) haben.
Nachfolger fuer den River waere dann ein Showdown-Objekt.
Schau Dir mal Larmann - Applying UML and Patterns an - da wird sehr haarklein und genau Monopoly modeliert - sehr lehrreich.

Du wechselst schon mit Thread.Sleep(0) den Thread, aber die Frage ist, wann wieder der Kontext-Switch zurueck erfolgt - ich wuerde auf den Flush verzichten und den automatisch durchfuehren lassen, wenn der Buffer wirklich voll ist - sonst sehe ich nix, was ein Problem sein sollte.

Thread.Sleep(0) bringt Dir nix - Dein Programm wird dort unnötig Ressourcen verbrauchen.
Wenn die Monitor-Klasse nicht vollständig unterstützt wird, dann ist es wahrscheinlich fraglich, ob Du überhaupt mit Threads arbeiten solltest, da der Overhead von Threads nur etwas bringt, wenn Du solche Techniken verfügbar sind. Ich denke, dass Threads nur dann Sinn machen, wenn Du eine klare Richtung hast und nur mit lock auskommst (z.B. für das Loggen, wo Du jede Sekunde mal schauen kannst, ob es etwas zu loggen gibt).

DLLs, die nicht COM oder .NET sind, sind per Definition C und nicht C++ - ergo musst Du den Zugriff auf die C++ Funktion kapseln, indem Du eine C Funktion mit einem void Pointer als Parameter anbietest.
Der Void Pointer muss dann in das Objekt gecastet werden und dann kannst Du das Ergebnis der Funktion anbieten. Nicht elegant - ab der einzig gangbare Weg.

Der Timeout sind Micro- und nicht Millisekunden.
Ergo muss ich den Timeout nicht mal 1000, sondern mit 1000*1000 multiplizieren.

MSDN Poll

Fast jede Börse verlangt von allen ausser den Börsenmitgliedern Geld für Realtime-Nutzer.
Insofern muss jeder Anbieter garantieren, dass er keine Realtime-Daten an Liesschen Müller weitergibt und auch fuer jeden Nutzer brav bezahlen.
Für Perl kenne ich etwas von Yahoo für verzögerte Kurse...Ist ein Web-Service...

3 Trifft zu 100% nicht zu - ich habe einen zweiten Thread, der alle x Sekunden eine Echo Message auf dem StreamWriter erzeugt und auf die der Server antwortet.
Diese Antwort kann ich auch ohne Probleme lesen, nur ist mein timeOutDuration nicht X Sekunden, sondern x*50 oder noch mehr und dann faengt timeOutDuration wieder bei 0 an, wenn der Echo beantwortet wird...

Leider nein - da ich einiges kompliziertes Zeug mache mit Verschluesselung des Kenntworts, so dass ich ueberhaupt den Socket benutzen kann.
Ich versuchs trotzdem mal den entscheidenen Code rauszuschneiden...
Konstruktor:

              tcpClient = new TcpClient(server, port);
                ns = tcpClient.GetStream();                
                writer = new System.IO.StreamWriter(ns);
                reader = new System.IO.StreamReader(ns);
                writer.AutoFlush = true;

Reader-Thread:

            int timeOutDuration = 0;            
            DateTime lastCheckPoint = DateTime.Now;
            TimeSpan checkPointDuration = new TimeSpan();
            TimeSpan oneSecond = new TimeSpan(0, 0, 1);//constant for one second
            int messageCounter=0;
            String[] help = new string[6];

            while (true)
            {
                string line=null;
                if (tcpClient.Available>0 || tcpClient.Client.Poll(5000,SelectMode.SelectRead) )
                {
                    line = reader.ReadLine();
                    readMsg++;
                    timeOutDuration = 0;
                }
                else
                {
                    Console.WriteLine("Timeout of" + timeOutInterval + " detected!"); 
                    if (onTimeOut != null)
                    {
                        timeOutDuration += timeOutInterval/1000;
                        onTimeOut(timeOutDuration);
                    }
                    continue;
                }                                   

Genau - statt 5 Sekunden zu versuchen einen Read zdurchzufuehren, sagt er sofort Timeout - Ich weiss, dass ich normalerweise maximal 6 Timeouts haben kann, aber es kommen sehr viel mehr...
Das mit den Headern war mehr der Frust, dass es in anderen Sprachen soviel einfacher war den Timeout zu bekommen...

Ich habe es jetzt zum Beispiel mit Poll versuchsweisae implementiert.
Es wird nicht x Sekunden versucht einen Read durchzufueren, sondern es wird sofern eine Timeout getriggert.

                if (tcpClient.Client.Poll(this.timeOutInterval,SelectMode.SelectRead))
                {
                    line = reader.ReadLine();
                    readMsg++;
                    timeOutDuration = 0;
                }
                else
                {
                    Console.WriteLine("Timeout of" + timeOutInterval + " detected!"); 
                    if (onTimeOut != null)
                    {
                        timeOutDuration += timeOutInterval/1000;
                        onTimeOut(timeOutDuration);
                    }
                    continue;
                }                               
    

Dieses Ding hat das gleiche Problem. timeOutInterval ist 5000.
Irgendwie denke ich, dass Poll fuer Server und nicht fuer Clients gedacht ist. Ich stehe echt auf dem Schlauch - dabei habe ich mit socket.h und select.h schon viel gerarbeitet - bin total verwirrt...

Sie macht leider nicht das, was ich erwarte, da der Zugriff nicht X sekunden wartet, sondern sofort triggert...

Zurzeit sieht das wie folgt aus:

                tcpClient = new TcpClient(Server, Port);
                ns = tcpClient.GetStream();
                writer = new System.IO.StreamWriter(ns);
                reader = new System.IO.StreamReader(ns);

Im Reader mache ich dann einfache

reader.ReadLine();

Dieses ReadLine moechte ich gerne mit Timeout machen.
Was wuerdest Du denn vorschlagen?

Read Exception:System.IO.IOException: Von der Übertragungsverbindung können kein
e Daten gelesen werden: Ein nicht blockierender Socketvorgang konnte nicht sofor
t ausgeführt werden. ---> System.Net.Sockets.SocketException: Ein nicht blockier
ender Socketvorgang konnte nicht sofort ausgeführt werden
   bei System.Net.Sockets.Socket.Receive(Byte[] buffer, Int32 offset, Int32 size
, SocketFlags socketFlags)
   bei System.Net.Sockets.NetworkStream.Read(Byte[] buffer, Int32 offset, Int32
size)
   --- Ende der internen Ausnahmestapelüberwachung ---
   bei System.Net.Sockets.NetworkStream.Read(Byte[] buffer, Int32 offset, Int32
size)
   bei System.IO.StreamReader.ReadBuffer()
   bei System.IO.StreamReader.ReadLine()
   bei XXX.ReaderThread() in C:\Dokumente und Einstellungen\Matthias\Eigen
e Dateien\Visual Studio 2008\Projects\XXX.cs:Zeile 201.

Er liest ein paar Daten anstandslos, wenn ich den ReadTimeout entferne, dann funktioniert alles tadellos - er wartet halt dann, bis Daten kommen...

Ich moechte gerne fuer einen StreamReader einen Timeout setzen.
Probiert habe ich es mit.

            reader.BaseStream.ReadTimeout = 1000;

Das fuehrt leider zu IOExceptions, wenn es keine Daten zum Lesen gibt.
Muss ich jetzt alles auf einen anderen Reader umstellen und dann Byte in String selber umwandeln oder habt Ihr andere Vorschlaege?

Ist es moeglich, dass ich einen Konstruktor mit anderen Parametern wiederaufrufe?
Oder muss ich alles in eine eigene Methode auslagern?

Hauptfrage ist, ob es ein echter C-String ist (endet mit "\n") oder eine Referenz auf ein char[] mit fester Groesse ist.
Echter String geht sowohl mit String als auch Stringbuilder
Char[] mit

[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
                public string x;

Rekursion ist wegen der Stackverwaltung auch sehr teuer, was die Performance anbetrifft...Dein Programm sollte spuerbar schneller werden, wenn Du eine Schleife statt Rekursion verwendest.

Ich bin auf der Suche nach einer performanteren Methode, um C/Perl localtime in C# zu implementieren - ich bekomme die Sekunden seit dem 1.1.1900 und moechte Sie als Sekunden und Minuten anzeigen.
Ich habe im Forum schon DateTime.ToOADate gefunden, aber dann muesste ich die Sekunden zunaechst in Tage umrechnen, was mir nicht so gut gefaellt...

Wahrscheinlich musst Du in Visual Studio noch eine Referenz auf die DLL einfuegen...(Projects....Add reference).

Ich habe das Problem mitlerweile geloest - es lag an dem beliebten Fehler, dass der delegate fuer einen unmanaged Callback durch den Garbage Collector geloescht wurde. Da der Fehler in dem Assembly und nicht in dem Modul selber auftrat, war die Fehlermeldung irrefuehrend - ich habe in der DLL jetzt noch eine statische Referenz auf den Delegate fuer den unamanged Abschnitt hinzugefuegt und alles laeuft prima.
Adam Nathan hat schon recht in seinem Blog:

"The Collected Delegate Probe
The most common mistake made when passing a delegate to unmanaged code (marshaled as a function pointer) is to allow the delegate to be garbage collected before unmanaged code is finished using it. This can happen because unmanaged code is invisible to the CLR garbage collector; it has no way to know when a delegate might still be in use by unmanaged clients. Once the delegate is not being referenced by any managed code, it could be collected at any time, causing the function pointer to become invalid."

Ich habe Probleme mit einer Speicherverletzung, die nur unter bestimmten Umstaenden auftritt.
Ich greife auf eine unmanaged DLL ueber ein selbst geschriebenes .Net Assembly zu. Dabei habe ich Call Backs als Delegate implementiert. Die Delegates greifen auf Pointer zu, die ich in Structs marshale.
Wenn ich jetzt zum Beispiel nur Console.WriteLine auf die Struktur mache, dann laeuft alles prima - wenn ich zum Beispiel mittels Struct ein Objekt erstelle und das Objekt in eine Queue stelle, dann bekomme ich Probleme.
Ich koennte mir vorstellen, dass das Problem durch einen Stack-Ueberlauf kommt, weil ich nicht schnell genug die Callbacks aufrufe - wie kann ich das verifizieren?
Wie wuerdet Ihr ein solches Problem analysieren?

Ohne es ausprobiert zu haben und ohne Gewaehr fuer die Performance, aber warum wandelst Du nicht in einen uint um und nimmst dann die Reste zu den jeweiligen Basen.
Dann wuerdest Du Sekunden als Rest zu 64 (2 hoch 6) usw nehmen, minuten sind dann Rest zu 2 Hoch 12 minus sekunden Hast Du das mal ausprobiert?

Wenn Du nur eine Datenbank und nur SQL im Backend hast - dann vielleicht.
LINQ ist zwar elegant - aber SQL/Linq ist doch nur ein kleiner Teil der Logik - oder denkst Du, dass Du die Business Logic alleine mit Constraints und Stored Procedures abdecken kannst.
Außerdem hilft es unheimlich, wenn Du genau weißt, in welchem Layer Du nachschauen musst, wenn Du fremden Code anfassen mußt.

Wie ich in einem anderen Thread gesehen habe, geht es besser mit

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst=10)]
            public string a;

Komischerweise werden beim Schluesselwort fixed chars mit 2 byte angelegt.
Die Records bekomme ich dann mit folgendem Loop

header= (Header)Marshal.PtrToStructure(data, typeof(Header));
                                for (int i=0; i < Header.NumRecs ;i++  )
                                {
                                    IntPtr currentPrt = new IntPtr(header.Records.ToInt32() + i * 144);//size of 144 for structure
                                    Record record = (Record)Marshal.PtrToStructure(currentPrt, typeof(Record));
                                }

Ich scheitere schon frueher als ich dachte:
Die C-Struktur

typedef struct{
	char a[10];
	char b[10];
	int c;         
        unsigned char d;                
	int e;		                
}CType;

habe ich in folgenden Struct umgewandelt.

unsafe struct CType
        {
            public fixed char a[10];
            public fixed char b[10];
            int c;                   
            byte d;                
            int e;
        }

Das Marshalling mache ich dann mit:

CType cType = (cType)Marshal.PtrToStructure(data, typeof(CType));

Aber irgendwie sieht das Ergebnis falsch aus...Die Char[] sind nicht null terminiert - ergo kann ich kein String/StringBuilder nehmen...

Ich muss eine komplizierte C-Struktur aus einer DLL nach C# Managed umwandeln.
Die Struktur sieht ungefaehr so aus

typedef struct{
	Header Header;
    Records *Data;
}chain;

Die Header-Struktur enthaelt in einem Unterfeld die Anzahl der Records
Die Records sind dabei eine Struktur mit ca.15 bis 20 Feldern.
An sich haette ich gerne mit fixed in der Strukturdefinition in C# gearbeitet und eine maximale Anzahl festgelegt- aber leider unterstuetzt fixed nur primitive Typen und nicht eine Struktur.
Zurzeit tendiere ich dazu Records ald Byte Array zu definieren und dann mit einem Offset auf das Array Marshalling zu betreiben (. Gibt es dazu eine Alternative oder etwas einfacheres?

Bitte poste auch die C-Definitionen.
Ich wuerden den Safe Code nehmen - wahrscheinlich musst Du einfach ein ref davor setzen, aber mit dem, was Du bisher hier gepostet hast, ist es nicht ganz nachvollziehbar.
Wenn Du weisst, wie die Struktur fuer pflagdata aussieht, dann wuerde ich direkt auf die Managed Struktur geben und nicht den Umweg ueber den Pointer gehen.

Ich wuerde neben dem Profiler die diversen .NET Leistngsindikatoren im Perfmon anschauen - hat mir sehr geholfen, da man dort die Schlangenlaengen vor den Threads anschauen kann - bei mir war ein Thread zu langsam und ich konnte schoen sehen, wie die Schlange immer laenger und laenger wurde...
Ich denke, dass der Perform weniger detailliert ist, aber auch weniger Einfluss auf das Laufzeitverhalten hat.

Ich moechte gerne in meinen Application-Settings eine Liste mit CBConnection-Parametern ablegen, so dass das Programm flexibel bei der Anzahl der DB-Connections ist.
Ich wuerde das gerne mit den Standard-Settings machen oder wuerdet Ihr empfehlen aus einem File die Connections auszulesen?

zu 2.)
Du solltest auch ohne das unsafe Flag auskommen - dann wird zum Beispiel aus void *
IntPtr. Siehe Punkt 3.
Zu 3.)Fuer die verschiedenen Typen wuerde ich Dir folgenden Link empfehlen:
Datentypen fuer den Platform-Aufruf(MSDN)
Beim Marshalling gehe ich zurzeit so vor:
Generieren eines Structs anhand der Typ-Tabelle. Dann Marshal.PtrToStructure.

Allgemein ist es wichtig sehr genau auf die Konventionen bei der DLL zu achten - DLL ist nicht unbedingt DLL, wenn Leute low level Multi-Platfom C Bibliotheken zur Verfuegung stellen, wie mir das passiert diese Woche passiert ist. Zum Beispiel die CallConvention kann zu schnellen und ueberraschenden Abstuerzen fuehren...

Das Problem war, dass der Callback _cdecl entsprechen muss.
Nachdem ich vor dem Delegate

[UnmanagedFunctionPointer(CallingConvention.Cdecl)]

hinzugefuegt habe, funktioniert alles.

Ich habe den Delegate nach dem erwaehnten MSDN-Artikel angepasst.
Das Fehlerverhalten hat sich nicht veaendert - wann erscheinen denn Werte Rot im Debugger?

Wo traegt man das genau ein?
Ich habe mitlerweile den Code deshalb wie folgt geaendert:

unsafe delegate int callback(Int32 mainMsg, Int32 SubMsg, UInt32 SymbolID, String Symbol, UInt32 SymCount, IntPtr data, Char DocID);

Das Ergebnis ist leider dasgleiche. Es liegt wohl nicht an 32 vs 64 Bit...
(Auf die idee bin ich durch folgenden Link gekommen🙂

Ich moechte unmanaged Code aus meinem Programm aufrufen.
Dabei muss ich Parameter setzen und dann eine Callback-Funktion aufrufen.
Die Definition der Callback-Funktion lautet:

DLLIMPORT void SetCallback(int (*CallbackFunction)(int,int,unsigned int,char*,unsigned int,void*,unsigned char));

Diesen Callback habe ich uebersetzt nach:

unsafe delegate int callback(int a, int b, uint c, string s, uint d, void * data, byte e;

Der Code ruft dann auch zweimal brav das Delegate auf, beim 3. Aufruf stuerzt das Programm dann ab.
Im Debugger faellt mir auf, dass nach dem zweiten Aufruf b rot angezeigt wird.
Ausserdem koennte es vielleicht eine Rolle spielen, dass ich eine 64 Bit-Workstation (Opteron) benuzte und die DLL 32-bit ist?
Welche Moeglichkeit gibt es die Signatur der DLL anzuschauen, da vielleicht doch eventuell etwas in dem Header nicht stimmt...

Ich habe vor einigen Jahren mit solchen Tools wie Loadrunner gearbeitet.
HP hat durch die Uebernahme von Mercury einige Produkte in dem Bereich. Die Produkte sind zwar sehr gut, aber auch sehr teuer.
Wenn Du Dich wirklich dafuer interessiert und viel Geld investieren willst, wirst Du schnell eine Testinstallation bekommen und kannst ausprobieren, ob es passt.
Auto-It benuzte ich heute - es laeuft gut - ist aber halt rein Windows - ausserdem weiss ich nicht genau, wie schnell es ist - ich habe nie auf die Geschwindigkeit geachtet.

Lag wohl doch an einem Bug in der fremden DLL und nicht an der Art und Weise, wie das Programm gestartet wird.

Ich habe folgendes Problem:
Ich habe eine Anwendung erstellt, die auf mehrere DLLs zurueckgreift, die zum Teil nicht von mir stammen, wo ich aber nur die DLLs und sonst nix habe.
Ich habe jetzt die DLLs referenziert und mit in das bin Verzeichnis kopiert.
Wenn ich jetzt versuche die Anwendung direkt mittels der exe Datei zu starten, dann geht etwas schief, aber ich empfange keine Fehlermeldung - das Programm haengt nur.
Wenn ich das Programm mittels Visual Studio - Start mit oder ohne Debug aufrufe, dann funktioniert alles. Wie kann ich nun den benoetigten Task aufsetzen, damit das Programm zu einer festen Uhrzeit jeden Tag beginnt?

Ich habe nochmal bei Richter nachgeschaut - Ich weise den Wert mittels Interlocked.Exchange zu.
Ich polle nur alle X-Sekunden, ob ich etwas zu bearbeiten habe - im Regelfall geht es so schnell, dass ohnehin immer etwas zu schreiben sein wird.

Lock braucht man nur, wenn mehrere Threads die gleichen Daten veraendern.
Da die run methode nur einmal laeuft und nur den eigenen Index veraendert (den ich sogar nur lokal fuer die Methode definieren koennte, braucht man meines Erachtens keinen lock.
Ich finde polling nicht so schlimm, wenn es nicht mehrfach pro Sekunde passiert...aber das ist Geschmacksache...
Ich denke, dass der Haenger mit der Garbage Collection zusammenhaengt - aber ganz sicher bin ich mir nicht...

    class Logger
    {
        private String[] buffer;
        private int indexWrite;//this index indicates at which place a new message is added (used in the log function)
        private int indexRead;//this is the index 
        object locker=new Object();//locking object to ensure that two threads do not mess around
        private StreamWriter writer;
        private int bufferSize=10000;
        private int timeOutPeriod = 500;

        public Logger(String fileName)
        {
            buffer=new String[bufferSize];
            writer=new StreamWriter(fileName, false);
            this.start();
        }

        public void start(){
            Thread thread = new Thread(new ThreadStart(this.run));
            thread.Start();      
        }

        private void run(){
            while(true) {
                if (indexWrite != indexRead)
                {
                    int tmpWrite=indexWrite;//used to avoid races with the index moving from bigger to smaller
                    if (tmpWrite>indexRead)
                    {
                        while (indexRead<tmpWrite)
                        {
                            writer.WriteLine(buffer[indexRead++]);
                        }   
                    }
                    else
                    {
                        while(indexRead<bufferSize)
                        {
                            writer.WriteLine(buffer[indexRead++]);
                        }
                        indexRead=0;
                        while(indexRead<tmpWrite)
                        {
                            writer.WriteLine(buffer[indexRead++]);
                        }   
                     }
                     writer.Flush();
                } else {
                     Thread.Sleep(timeOutPeriod);                 
                }
            }
        }
        
        public void log(String line)
        {
            lock (locker)
            {
                buffer[indexWrite++]=line;
                if (indexWrite == bufferSize)
                {
                    indexWrite = 0;
                }
            }
        }
    }
}

An sich sollte ich noch mit pulse arbeiten und auch einen Ueberlauf des Buffers abfangen, aber das kommt vielleicht spaeter mal...
Ueber Feedback wuerde ich mich freuen, da ich noch nicht soviel mit C# gemacht habe...

Ich habe jetzt schnell selber etwas gebaut - einziges (kleines) Manko, ist, dass der Main-Thread haengt, wenn ich aus dem Main-Thread heraus logge...
Die Performance liegt ohne Probleme bei mehr als 5.000 Zeilen pro Sekunde...

Wie wuerdet Ihr ein performantes Logging realisieren?
Ich moechte mit niedriger Prioritaet Daten aus mehreren Threads loggen - dabei sind es in Spitzen mehr als 1000 Zeilen pro Sekunde.
Wuerdet Ihr ein eigenen Thread erstellen und dann synchron mit einem TextWriter schreiben oder auf das asynchrone Modell mit BeginWrite zurueckgreifen?
Ich befuerchte, dass so etwas wie Log4Net viel zu langsam ist, da wahrscheinlich nach jeder Zeile ein Flush passiert...Ich kann verschmerzen, wenn ich bei einem Crash des Programmes ein paar Zeilen verliere...

Ich wuerde am liebsten ein Remote-CommandShell bekommen und mich dann durchnavigieren...So muss ich immer noch an den Rechner, wenn das Programm stehen bleibt...

Danke fuer die Antwort - ich wuerde den Rechner gerne wie einen Unix-Linuxrechner behandeln - gibt es da nix von Microsoft?

Ich habe vor kurzem ein C# Programm entwickelt, dass auf einem anderen Rechner als meinem Arbeitsplatz laufen muss.
Das Programm muss remote laufen, das das Programm in einer DMZ laufen muss und da es sehr viel Ressourcen zieht. (Es werden 1000-2000 Nachrichten pro Sekunde verarbeitet).
Wie wuerdet Ihr das Programm administrieren, damit ich von einem anderen Rechner schauen kann, wie das Programm laeuft?
Ich habe daran gedacht, entweder einen SSH-Dienst zu installieren oder VNC mittels SSL zu benutzen.
Beide Rechner laufen unter Windows XP.
Ich habe in den FAQ und unter Adminstration nachgeschaut und nichts bisher gefunden.

Welches Control wuerdet Ihr mir fuer einen Text-Ticker empfehlen.
Der Ticker wird sehr haeufig (manchmal mehr als 10-20 pro Sekunden aktualisiert) und sollte nur Druecken eines Stop-Buttons angehalten werden...
Die Laufrichtung in der bestehenden 3-rd Party Applikation ist von oben.
Was bietet sich da am besten an?

Danke fuer den Tip - stand auf dem Schlauch...funktioniert alles!
Ich caste beim Erhalten des Challenge sbyte in byte und caste nach dem Digest wieder von byte in sbyte in String.
Vielen Dank!