genau 🙂

Fragen:

1. Wozu brauchst Du den Index?
2. Warum reicht keine Referenz auf die TabPage?

Wenn's nicht anders geht:

lock( tabControl1 ){
    // hinzufügen und Index holen
}

Damit verhinderst Du ein Anfügen während der Index (==Count) abgefragt wird.

Sorry, hatte Deinen Code nicht richtig gelesen!

Da gibt es noch mehr in StartInfo zu beachten.
CaptureStandardOutput = true oder so ähnlich.

Versuch's mal mit dem StandardError.
Mache Programme schreiben (warum auch immer) lieber dort rein 😉

Würde ich so machen (und hab ich auch schon 1000mal):

string hex = "0791947122723033040C...".ToUpper();
string res = "";
char c1,c2;

for(int i = 0; i<hex.Length; i++){
    
    switch( hex[i] ){
        case '0':case '1':case '2':case '3':case '4':
        case '5':case '6':case '7':case '8':case '9':
            c1 = hex[i] - '0';
            break;
        default:
            c1 = hex[i] - 'A';
            break;
    }
    if( i % 2 == 0 ){
        c2 = c1 * 0x10;
    }else{
        c2 += c1;
        res += c2;
    }
}

return res;

Ist natürlich ungetestet 🙂
Und die eine oder andere Fehlerabfrage fehlt noch...z.B.:
Sind Zeichen ausser '0'...'F' im Input-String?
Ist die Input-String-Länge gerade?

greetz
DaSchroeter

Ha...diesmal war ich schneller 🙂

Ähm....Fehlermeldung?
Fehlerbeschreibung?
Irgendwas?

Tja, vielleicht schon, aber dazu müsstest Du mal ein bischen direkter beschreiben, was Du eigentlich machen willst.
Also nicht mit Klasse A soll und B in C, sonder z.B.:
Ich möchte ein PlugIn schreiben für Programm X und das soll Dies und Das können.
Probleme gibt es dann beim Aufruf von Blub.
Codeschnipsel wären hilfreich!

Vielleicht liegt ja ein grundsätzlicher Denkfehler (vielleicht ja auch bei mir) vor.

Naja, deshalb gibt es ja für PlugIns immer Interfaces.
Was die bietet geht, sonst nix.

Also wenn Du keinen Code des Formulars hast, was genau machst Du denn da eigentlich? Nur per Referenz und DLL einbinden?

Ich denke das Forumal startet Deinen Worker?!

ch brauche also ein Event in dem Gui-Thread, welches ich aus der asynchronen Methode aufrufen kann...

GUI == Form -> Kein Zugriff -> Geht nicht

Im Großen und Ganzen kann man sagen: HÄ?

Ich glaube Du solltest dich nochmal genauer schlaumachen.

Die beiden Routinen, die ich gepostet habe, befinden soch im Code vom Formular.
Du gibst doch der TcpListener Klasse an, wo sie sich zurückmelden soll.
Und das ist eben wieder im Formular. Nur wird der Code dann in einem anderen Thread-Kontext ausgeführt. Deshalb das Invoke.

Edit:

class Form1 : Form {
    
    private void Bla() {

        TcpListener tcp = new TcpListener(1234);
        tcp.BeginAcceptTcpClient(new AsyncCallback(AcceptClientCallback), null);
    }

    private void AcceptClientCallback(IAsyncResult state) {

        if( InvokeRequired ) {
            Invoke(new AsyncCallback(AcceptClientCallback), new object[] { state });
        } else {
            //mach was
        }
    }
}

Nur mal um zu sehen, ob ich jetzt alles geblickt hab:

private void Bla() {

    TcpListener tcp = new TcpListener(1234);
    tcp.BeginAcceptTcpClient(new AsyncCallback(AcceptClientCallback), null);
}

private void AcceptClientCallback(IAsyncResult state) {

    if( InvokeRequired ) {
        Invoke(new AsyncCallback(AcceptClientCallback), new object[] { state });
    } else {
        //mach was
    }
}

So?

Du gibst doch der TcpListener.BeginAcceptTcpClient eine Callback-Routine mit, oder?

Das ist eine Methode mit der Signatur AsyncCallback.

Also dort drinnen einfach mit InvokeRequired prüfen und evtl. eben eins machen (Selbstaufruf).

string strZahl = (String)floZahl;

Das funktioniert nicht.

string strZahl = floZahl.ToString();

So muss es, und das ist 'eine formatierte Ausgabe'.

Wie gesagt: Es kann, muss aber keine Fehler geben...hängt vom System (Sprache,...) ab.

Bei größeren floats aber aufgepasst:
Eventuell wir ein '.' (Punkt) als Tausendertrennzeichen verwendet!

Generell sollte bei solchen Konvertierungen der Kram aus CurrentCulture und Co Verwendung finden.

Nur um mal klarzustellen, was passieren soll:

1. Deine Main Routine startet Deine GUI (Form)
2. Dein Form startet einen Thread
3. Dein Thread terminiert und soll vorher die GUI benachrichtigen

Ist das richtig?
Oder:

1. Deine Main Routine startet einen Thread
2. Deine Main Routine startet Deine GUI (Form)
3. Dein Thread terminiert und soll vorher die GUI benachrichtigen

Isses das?

Ansonsten poste mal bitte Code (Pseudo reicht).

Typischerweise nimmt man für sowas Events.
In den Handler-Routinen(in der GUI) kannst Du dann mit InvokeRequired prüfen, ob
Du direkt Änderungen machen kannst, oder ob Du ein Invoke einsetzen musst.

Hi!

Grundsätzlich sind das zwei verschiedene Ansätze:

1. Relationale Datenbank
2. Objektorientierte Datenstruktur

Du musst also die Daten aus der Datenbank rausholen und zu Objekten zusammenbauen (Object-Relational-Mapping). Beim Sichern halt umgekehrt.

Oder Du nutzt eine Objektorientierte Datenbank.
Oder Du nutzt keine Datenbank sondern serialisierst Deine Objekte in Dateien.

greetz
DaSchroeter

zu 2.: Im Konstruktor Deines Formulares die string-Valiable auf "" setzen.

Hi!

Ich würde anders vorgehen.
Nimm die BitConverter Klasse.
z.B.:

UInt16 shortUIntValue = BitConverter.ToUInt16(buf,0);

und dann mit ner for:

char[] charAr = new char[buf.Length-2];
for(int i=2; i<buf.Length; i++)
    charAr[i-2] = (char)buf[i];

Das erste geht natürlich nur, wenn die Bytes richtig im Array liegen (->MSDN->BitConverter).

Hab's aufgegeben, danach zu suchen.
Ist ein Bug, soviel steht fest, aber woher der kommt weiss wohl niemand 🙂

Menu->Window->Close All Documents
Menu->Build->Batch Build...->Select All->Rebuild

Dann sollte es wieder funktionieren.

Versuch mal sowas:
String.Split("\r\n");

Original von Dr.Cool
Wie kann eine Maschine aus leblosem Plastik und Metall dieses innere ich entwickeln, von dem man nicht genau weiß, was es ist.

Einfach toll!
Kann ich mir das ausborgen? 🙂
Das kann man gar nicht besser ausdrücken!

Seht Ihr, geht schon los, das 'drüber streiten, ob sie nötig sind' 🙂

Original von no1gizmo
....
So kann auch unser Gehirn sich mit der Zeit erschaffen haben, leistungsfähigere haben sich ggf. durchgesetzt, leistungsschwächere sind wahrscheinlich verschwunden.

Aber das sind nur körperliche Ausprägungen, welches uns nun das Denken wie es ist ermöglichen. Das hat mit unserer eigenen Ideenfindung, z.B. bei der C# Programmierung, nichts zu tun.

Naja, aber es geht ja um die Frage, ob wir alle inklusive Umwelt komplett simuliert sein könnten, d.h. ob es prinzipiell möglich wäre.

Und dazu gehört auch die Evolution, also der Zufall, also 'echte' Zufallszahlen.

Original von no1gizmo
Ich glaube nicht, dass Zufallszahlen eine Rolle spielen.

Ich denke schon, da sonst keine 'Entwicklung' des Programmes möglich ist.
-> Evolution ist nunmal zufallsgesteuert.

Aber für die eigentliche Verarbeitung kann man darüber streiten, ob sie nötig sind 😉

greetz
DaSchroeter

Original von Traumzauberbaum
Ich weiß auch garnicht warum man sich hier so zurückhaltend gibt und die Position für heutige Rechner schon aufgibt. Da ist noch garnichts gezeigt, noch nichts argumentiert außer "das kann doch nicht sein". Da kann ich genauso sagen "klar kann das". Was jetzt? Diskussion beendet? Ich finde das doch etwas dürftig. Bringt mal bitte ein paar Argumente, davon ist irgendwie noch nichts zu sehen. Das macht es irgendwie schwer darüber zu diskutieren.

Neuronale Netze sind eine Datenstruktur. Die sind auf heutigen Rechnern leicht umsetzbar und keine Erfindung von Startrek.
Es gibt verschiedenste evolutionäre und "genetische" Algorithmen, die auf intuitive Weise eine Lösung hernehmen und die immer weiter durch Variation verbessern zu versuchen. Genauso wie wir an irgendeinem Problem tüfteln und "kreativ" sind.

Das ist mir durchaus bewusst. Ich meinte auch nicht, dass ein Neuronales Netz den Rechner bildet, sondern dass sich die Konzepte und Ideen, die hier Eingang finden gut zur Lösung Aufgabenstellung eignen. Dazu gehören sicherlich auch die von Dir genannten 'genetischen' Algorithmen.

Ich denke aber auch, dass das Potential, dass in diesen Konzepten steckt auf heutiger Hardware lange nicht ausgeschöpft werden kann.

Daran, dass sie auch auf heutigen Rechnern funktionieren besteht wohl kein Zweifel.

greetz
DaSchroeter

Hi Dr.Cool,

grundsätzlich redest Du hier von einem 'herkömmlichen' Computer.
Also von solchen mit einer Von-Neumann-Architektur oder Vergleichbarem.

Es gibt aber durchaus auch andere Kozepte, wie z.B. Neuronale Netze.
Nie war hier von aktueller Hardware die Rede und das meinte zumindest ich auch nie.

Um 'Leben' zu 'erschaffen' muss meiner Ansicht nach ein massiv Parrallel verarbeitendes System her.

Sowas ist durchaus zu realisieren und was dann an 'Software' drauf läuft bleibt abzuwarten.

greetz
DaSchroeter

Original von gespannter_Bogen
Es gibt eine ganz einfache Methode, 'uns nachzubauen':

      Kinder kriegen.  

Vor allem aber, dabei mithelfen, sie großzuziehen. Wenn man das macht, bzw. gemacht hat, wird man unschwer feststellen, welch fundamentaler Unterschied zwischen Mensch und Maschine besteht. Der wichtigste: Kinder haben einen eigenen Kopf. Sie sind Subjekte, die vielleicht ein bischen Hilfestellung brauchen, im Prinzip aber selbst wissen, was für sie gut ist und wie sie vorankommen.
Auch ist das Hirn keine festgelegte Hardware, sondern selbst in seiner Substanz im übrigen auch im Alter noch höchst wandelbar und lernfähig.

Das hat überhaupt nichts mit der Aussage von mir zu tun, die Du hier zitiert hast.

Im Grunde genommen sind wir uns aber einig:

Dies ist teilweise evolutionär entstanden und teilweise anerzogen/trainiert.

greetz
DaSchroeter

Hehehe...hört sich an wie mein Chef:

• Da gibt's doch schon was!
• Das kann doch nicht so kompliziert sein!
• Andere machen das doch auch!

Im Ernst: Fremdsoftware korrekt Einbinden ohne Doku ist nicht drin!
Und manche Sachen sind einfach nicht trivial, obwohl die Ergebnisse nicht viel hermachen.
Einfach mal eben ne SMS raushauen...hört sich so einfach an, aber hängt viel dran 🙂

Meine Empfehlung: Recherche bei Motorola.
Haben die ein Developer Center oder sowas?
-> Website

greetz
DaSchroeter

Hmmm...ich glaube die musst Du einzeln zeichnen.
Aber es gibt irgendeine Methode, um eine String-Breite auszumessen.
MeasureString oder so (weiss nicht mehr, ob das C# war 🙂 ).
Dann das Zeichnen in einer Methode kapseln und fertig.
So etwa:

public void DrawMenuItem(int x, int y, string text){
    // hier den ersten Buchstaben malen und die Breite ausmessen
    // dann den Rest hintendran tun ;)
}

@herbivore: hast ja recht, aber mir ist grad langweilig 😉
Und manchmal hilft ein Stückchen Code mehr als 1000 Stichworte...ist ja nix Komplettes 😉

okay...also:

TestReader tr = File.OpenText("..\\..\\Schublade\\Test.txt");
string res = "", line;

line = tr.ReadLine();
string pw = ""; // hier das Passwort aus der ersten Zeile lösen (Stichwort: Split());
string rndStr = ""; // hier die Zufallszahl aus der ersten Zeile löschen (s.o.)
int rnd;
if( !int.TryParse(sndStr,out rnd) ){
    tr.Close();
    throw new Exception("Falsche Zufallszahl");
}

while( (line=tr.ReadLine()) != null ){
    for( int i=0; i<line.Length; i+=3 ){
        res += line[i];
    }
    res += "\r\n";
}
tr.Close();
return res;

Ist aber nicht getestet, sondern einfach nur hier reingetippt.
Liefert die Einträge lesbar zeilenweise.

greetz
D

P.S.: Ich hoffe ich helfe nicht beim Mogeln 😉

Frage: Wieso willst Du sowas machen?
Sieht für mich relativ sinnlos aus 😉

Moin!

Also ich stimme herbivore grundsätzlich zu.

Ich denke das Grundproblem leigt darin, dass sich keiner ein so kompliziertes 'Programm' wie einen Menschen vorstellen kann.

Ein Mensch hat für alle 'Eingaben' ein Reaktionsmuster eingebaut. Dies ist teilweise evolutionär entstanden und teilweise anerzogen/trainiert.
Beispiel: Schmerz als Indikator 'Nicht-Gut'(evolutionär) -> Reaktion: Schmerz vermeiden
Aber 'Schmerz' heisst ja nicht einfach nur Schmerz, sodern 'Schmerz im linken, kleinen Finger'. Also alles in allem ZIEMLICH VIEL Input.

Da das Gehirn auch noch massiv parrallel arbeitet, ist von einem 'Programm' eigentlich nichts zu erkennen.

Es gibt heutzutage keine Hardware, auf der ein vergleichbares, von Menschen erschaffenes Programm laufen könnte.
Es spricht aber meiner Ansicht nach Nichts dagegen - eher sogar Einiges dafür - dass solche Hardware entwickelt werden wird.

Aber Sicherlich nicht in den nächsten paar Jahren 🙂

Und mal ganz allgemein: Warum ist es eigentlich 'schlecht', wenn wir uns nachbauen können?
Perfekt ist der Mensch ja nun wirklich nicht, also warum nicht mal eine V2.0 erstellen 🙂
Und wenn wir das schaffen: Dann war die V1.0 ja doch nicht so blöde 🙂

greetz
DaSchroeter

Sicher, dass die Linien auch im sichbaren Koordinatenbereich liegen?
x = e.Graphics.Width (oder Ähnlich) liegt da z.B. nicht mehr drin, weil der Bereich
von 0-(Width-1) geht.

Das kann aber Probleme geben wenn z.B. folgende Verzeichnisse existieren:
c:\dummes ding 1\hallo.welt
c:\dummes ding 2\hallo.ihr

Schau mal hier nach:
http://www.pinvoke.net/default.aspx/kernel32.GetShortPathName

Aber zu beachten: Das geht NUR für existierende Dateien!
Für Verzeichnisse müsstest Du ne Dummy-Datei anlegen.

Gibt es da (sinngemäß) StayOnTop?

Edit: TopMost? Hiess das so? Steh grad auf'm Schlauch 😉

Zu Registry: Du kannst im Setup-Projekt angeben, welche Schlüssel geschrieben werden sollen (und auch wo). Es gibt da auch 'Variable' wie '[Manufacturer]' und so.

Zu Code: Hab ich zwar noch nicht gemacht, aber es gibt 'Events', bei denen Du Code ausführen kannst. -> MSDN

Zu Schnell: Bin ich immer 🙂

Du kannst doch mit dem Installer in die Registry schreiben.
Und darauf hinterher mit Deiner Anwendung zuzugreifen ist auch kein Problem.

Evtl. kann der Installer ja auch Änderungen an den AppSettings machen?

@herbivore: Mist....wieder zu spät...Du bist aber auch was schnell 🙂

Ich würde permanent prüfen, welches Fenster aktiv ist, und, solange es nicht Dein eigenes ist, es mir als 'Current' merken.

Dahin kannst Du dann die Tasten schicken.

Login myObject = new Login();
XmlSerializer mySerializer = new XmlSerializer(typeof(Login));
Stream myStream;
mySerializer.Serialize(myStream, myObject);

byte[] bytesToSend = // Wie muss ich hier wandeln???(myStream);
this._SendStream.Write(bytesToSend, 0, bytesToSend.Length);

Was genau ist denn _SendStream?
Ist das nicht ein Stream?

Warum serialisierst Du nicht direkt da rein?

Probier mal das hier:

ListViewItem item = listView1.Items.Add("<key>");
item.SubItems.Add("<value>");

Hmm...warum wirfst Du denn kein 2-dimensionales Array vom Typ Eintrag in Deine rekursive Funktion?
Dazu noch Parameter x und y für den zu bearbeitenden Eintrag und fertig.

Dann brauchst Du nicht klonen und die Parameter x und y als int werden eh By-Value übergeben.

greetz
D

Ups, da war mal wieder jemand (wer wohl 🙂 ) schneller!

Hab zwar den Anwendungsfall nicht ganz kapiert, aber TextBox hat ein Ereignis EnabledChanged.
Da kannste Dich dranhängen.

greetz
D

Du könntest auch 'einfach' im ListViewItem.Tag den Treenode hinterlegen, der diesem Eintrag entspricht.

Sieh mal nach, welcher Zeilentrenner bei der Serial Komponente angegeben ist.
ReadLine() verursacht glaube ich nen Fehler, wenn der Trenner nicht innerhalb einer bestimmten Zeit kommt. Gibt gestimmt auch eine TimeOut Eigenschaft für sowas.