Forenbeiträge von maxE Ingesamt 456 Beiträge
Ja, die Dienste heißen bei mir z.B.: Prozessor, Netzwerkschittstelle, Logischer Datenträger, Druckerwarteschlange, usw. ...
Etwas blöd gelöst finde ich. Englisch ist mir da doch lieber 😉
Hab dann aber mal etwas rumgespielt und mir ist aufgefallen das man auch englische Kategorienamen wählen kann, obwohl sie nicht in der Leistungsverwaltung angezeigt werden. Seltsam!?
Ich schau mir das mal mit WMI an. Kann man sich eigentlich alle Namensräume, Klassen, Pfade mit nem Programm anzeigen lassen?
Danke erst mal.
Ein Problem hab ich allerdings noch mit dem PerformanceCounter:
Die Namen der Kategorien sind bei der deutschen Windowsversion nun mal in deutsch (wie bei der Leistungsverwaltung von Win). Das bedeutet letztendlich, dass meine Anwendung nur auf der deutschen Windowsversion laufen wird. Gibt es irgendwelche generischen englischen Namen für die Kategorien?
Hi,
gibt es ne Möglichkeit den lokalen Netzwerkverkehr zu überwachen.
Ich möchte gern protokollieren wie viel Daten ich sende bzw. empfange wenn ich im Internet surfe. Daraus will ich dann ein paar Statistiken erstellen.
Geht so was von .NET u. C# aus?
Danke im Vorraus
Original von Tankian
Läuft CsGL also nicht auf Mono ?
Ne, CsGL läuft nur auf Windows. Hat mit den unterschiedlichen OpenGL Libs und Aufrufkonventionen der Plattformen zu tun.
Ich schreibe zur Zeit an einem eigenen OpenGL-.NET Bridge Generator. Der gl.h und glext.h parst und daraus .Net Klassen-Methoden erzeugt.
Allerdings mit dem kleinen Unterschied das goße Teile nicht in C# sondern in MSIL erzeugt werden. Das hat den Vorteil das man keinen C++ Code wie bei CsGL mitschleppt, oder wie bei Tao mit Funktionspointern hantieren muss.
CsGL ist durchaus brauchbar.
Aber wenn du OpenGL in C# verwenden willst, dann nimm lieber das Tao-Framework.
Ist wesentlich moderner, CLS und Linux fähig. Leider ist die URL zur Zeit down:
http://www.taoframework.com
Der spielt lieber Doom3 als seinen Server zu akualisieren 😉
Aber im Mono CVS ist das Tao-Framework auch drinn wenn du es brauchst.
Ob OpenGL oder Direct3D ist wohl wieder so ne Typische Glaubensfrage. Ich bin eher ein OpenGL Fan. Aber probier beides aus und entscheide dann was du für dein Projekt verwenden willst. Die Vor- und Nachteile wurden schon mehr als einmal diskutiert.
Hier mal ein Beispiel wie ein einfaches PlugIn-System aussieht:
Du hast einmal eine Hostanwendung die Plugins laden kann.
In dieser Hostanwendung gibt es eine Klasse, den PlugIn-Manger
und eine Schnittstelle IPlugin.
Dein PlugIn Interface kann z.B. so aussehen:
public interface IPlugIn
{
int Init();
int ExecCommand(int cmdID...);
int Shutdown();
}
und der PlugInManager so:
public class PlugInManager
{
int Load(string plugin) {...}
int ExecPlugInCommand( sztring plugInName, int cmdID, params ...) {...}
}
Dein PlugIn hat nun ne Referenz auf deine Hostanwendung, denn sie muss die Schnittstelle IPlugIn implementieren damit dein Programm auf eine einheitliche Schnittstelle zugreifen kann.
Dein PluginManger sucht nun im PlugIn-Verzeichnis alle Asssemblys ab, die Klassen enthalten, welche die IPlugIn Schnittstelle implementieren und Läd diese mit Hilfe der Reflection Klassen aus dem Framework in einen Cache. Könnte z.B. mit ner Hashtabelle realisiert werden.
Da das PlugIn eine Referenz auf dein Programm hat, kann es beispielsweise auf alle Klassen zugreifen die als public deklariert sind. Internal Klassen sind zB. für das PlugIn nicht zugänglich.
Normalerweise wird bei einer FileNotFoundException der Dateiname mit angegeben der fehlt. Schau dir mal den Stacktrace an. Eigendlich müsste da stehen welche Datei genau nicht gefunden wird bzw. von welchen Methoden die Ausnahme gewurfen wurde. Notfalls dein ganzes Prog in einen try-catch Block schreiben der alle Ausnahmen fängt und dann denn Stacktrace anschauen.
Probiers mal so:
// Create image.
Image imageFile = Image.FromFile("SampImag.jpg");
// Create graphics object for alteration.
Graphics newGraphics = Graphics.FromImage(imageFile);
// Alter image.
newGraphics.FillRectangle(new SolidBrush(Color.Black), 100, 50, 100, 100);
// Draw image to screen.
e.Graphics.DrawImage(imageFile, new PointF(0.0F, 0.0F));
//save image
imageFile.Save("test.jpeg");
// Release graphics object.
newGraphics.Dispose();
He, danke erst mal.
Aufwendige statistische Verfahren oder neuronale Netze sind wohl eher nicht dafür notwendig. Lief ja schließlich auch auf nem uralt Rechner.
Bach ordnete ja Noten nach bestimmten Zahlenverhältnissen an. Wenn man solche generiert und leicht varieirt, dann könnte man ja theoretisch einfache Fugen zusammenbauen.
Mal sehen ob ich noch alten Basiccode dazu auftreiben kann😉 Vielleicht lässt sich damit was anfangen.
Hier mal ne recht ungewöhnliche Frage:
Ich hab mal von Programmen gehört die Fugen und andere Musikstücke im Stil von Johann Sebastian Bach automatisch berechnen können.
Die Musik von Bach folgt ja bestimmten formalen Regeln und mathemaischen Modellen. So lassen sich zum Beispiel viele Bachstücke auch rückwärts wiedergeben.
Ich hab so was mal vor langer Zeit auf nem uralten Robotronrechner gesehen (bzw. gehört). Der spuckte nach bestimmten Regeln Bach-artige Musik aus.
Kennt jemand von euch Möglichkeiten wie man so was machen kann oder hat so was selbst schon mal umgesetzt?
von C# direkt geht es glaube ich nicht.
Aber du kannst per PInvoke Funktionen aus der Video for Windows Library (ist fester Bestandteil von Windows) importieren.
In der MS Platform SDK sollte das alles beschrieben sein.
Damit solltest du ne menge Daten über dein Video erhalten: Wie Größe, Frames Formate usw.
Fortran wurde für das Lösen mathematischer Probleme entworfen.
Ein Kupel von mir studiert Mathematik und dei denen ist das praktisch Standard.
Intel entwickelt nicht umsonst neben seinem C++ Compiler einen hochoptimierenden Fortran Compiler.
Fortran wirst du sicher nicht an normalen Desktoprechnern finden, sondern eher auf wissenschaftlichen Großrechnern wo unmengen an arithmetschen Operationen ausgeführt werden müssen. (Matrizenberechnungen)
An meiner UNI hat uns mal ein Prof. ein Benchmark vorgeführt. Da würden riesige Matritzen mit zig tausend Elementen multipliziert. Einmal in C geschrieben und einmal in Fortran. Fortran-code war hier übrigens deutlich performanter als C-code, da er optimierte Methoden zur Matrizenberechnung nuzt. Scherzhaft fügte er noch hinzu, dass man so was lieber nicht mit Java machen sollte 😉
Stimmt, Lisp ist neben Prolog die Standardprogrammiersprache in der KI und Logik.
hmm, recht interessant.
Witzig finde ich, dass es ein Dinosaurier wie Fortran (von Anfang an dabei) bis in unsere heutige Zeit geschafft hat und sich immer noch größer Beliebtheit erfreut.
Das Framework selbst bietet keine möglichkeiten Bilder zu bearbeiten.
Du musst dir selbst einen Algo zum Schärfung schreiben.
Vielleicht hilft das weiter:
Beim parsen, filtern von irgendwelchen Textdokumenten sag ich nur:
Regular expressions (System.Text.RegularExpressions)
Das ist die beste und eleganteste Methode so was zu tun.
string regexPattern = "Monitore";
Regex r = new Regex( regexPattern );
MatchCollection mc = r.Matches(textString);
foreach( Match m in mc )
{
Console.WriteLine( m.Value );
}
textString ist deine Datei als String.
regexPattern ist der Text nach dem gesucht wird. Es gibt da noch diverse Steuerzeichen. Für Wiederholungen, Platzhalter, Gruppierungen usw...
\d match auf Zahlen
\s match auf leerzeichen
\w auf buchtaben
. beliebiges Zeichen
- eine oder keine wiederholung
* beliebig haufige wiederholung
und und und ....
"<!--.*?-->" für regexPattern sucht zb. alle html kommentare.
Alle Sonderzeichen zu erklären sprengt wohl den Rahmen.
Such mal nach Tutorials zu Perl 5 Regular expressions.
Hab erst deinen vorletzten Artikel gelesen und geglaubt es hätte sich erledigt 😉
Aber als ich weiter scrollte sah ich das es doch noch nicht so ganz klappt.
Zuerst mal ist es schon wichtig die zugrunde liegende Mathematik zu verstehen und mit etwas Gedult zu erarbeiten. Die fertigen Funktionen zu verwenden ist zwar schön und gut bringt aber nicht immer was, vor allem wenn man nicht richtig versteht was sie genau machen. Also schön lineare Algebra lernen 😉
den tempOrtho Vector hast du ja praktisch beliebig gewählt.
Wenn die Vektoren senkrecht aufeinender stehen brauchst du nicht viel mit Winkeln ausrechen.
Für einen senkrechten Vektor braucht man ja nichts weiter als zwei vektoren auf denen er steht.
Der erste ist ja dein up Vektor, dann nimmst du den tempOrtho Vektor und bildest das Kreuzprodukt aus ihm und dem up Vector. Das ist jetzt unsere Binormale. Up und Binormale stehen jetzt auf alle Fälle senkrecht aufeinender. Bildest du jetzt nochmal das Kreuzprodukt aus up und Binormale hast du jetzt den Tangentialvektor zur Kugeloberfläche(Die Binormale verläuft natürlich ebenfalls tangential zur Oberfläche)
So kannst du Vektoren erzeugen die senkrecht zum Up Vektor liegen. Diese kannst du wie gehabt für die oben beschriebene Matrix zur Transformation benutzen bzw. für die Kamera, um sie auszurichen.
Vielleicht kann dir das jetzt weiterhelfen.
Viel Erfolg noch beim deinem Raketenabschussprogramm 😉
Übrigens: Was soll das heißen: Texanische Grüße. Schreibst du etwa aus dem Ammi-Land 😉
Ich geb jetzt auch mal meinen Senf dazu 😉
Da UML ein recht wichtiges Werkzeug in der Softwareentwicklung geworden ist, finde ich das ein gutes freies UML Tool fehlt, welches in C# geschrieben ist.
Die meisten dieser Werkzeuge sind entweder sau teuer oder nur primär für Java zu gebrauchen. Für C# gibts da noch recht wenig brauchbares. Das einzigste das ich kenne ist zwar Freeware aber Closed Source: Jumli.
Leider hat es recht viele Schwächen und ist weniger für produktive Dinge, sondern mehr für Schulungen geeignet.
Deswegen mach ich den Vorschlag mal ein freies Programm für UML Diagramme zu entwickeln. Natürlich mit generierung von C# Code aus den Klassendiagrammen.
Der Code sieht ja soweit richtig aus.
Wenn man die (Up,lookAt) noch normalisiert und einen Left vektor aus up und Lookat erzeugt, kann man eigendlich die Matrix korrekt erzeugen.
Also wenn du ihn gedreht hast musst du ihn mit der angegebenen Matrix eigendlich in den Worldspace transformieren können.
Ferndiagnose ist bei so was immer recht schwiering 😉 Hast du das schon mal selbst von Hand durchgerechnet?
Was passiert denn eigendlich ungewöhnliches wenn du es so machst wie jetzt ?
Da schreibt man mal was zu MSIL und schon geht die Diskussion los 😉
NoOneKnows hat recht. MSIL hat sicherlich nichts mit einem normalem Assembler zu tun. Er ist ja wie schon gesagt objektorientiert und auf nem recht hohem abstraktionslevel im gegensatz zu einem normalem Maschienen Code wie x86-Assembler. Jeder der das schon mal gemacht hat weiß das genau 😉
MSIL bietet viele interessante Möglichkeiten.
Auch einen Compiler zu schreiben ist mit MSIL sicher nur halb so schwer (selbst das ist eigentlich noch übertrieben) wie mit einem "normalem" Assembler, da man vom .Net Framework kräftig unterstützt wird (System.Reflection.Emit - Die SDK Beispiele dort zeigen das auch gut). Die Codeerzeugung geht da fast automatisch 😉 Außerdem ist IL Stack basierend und man muss sich nicht mit lästiger Registerverwaltung rumärgern.
IL ist sicherlich kein Spielzeug für "Fetischisten" die an die guten alten Zeiten denken 😉 Dafür ist IL schon fast zu komfortabel. Man kann halt ne menge Dinge machen die mit "normalem" C# unmöglich sind. Automatische generierung von Assemblies zur Laufzeit, selbst geschriebene Skriptsprachen für Programme, polymorpher Code, und und ....
Ist objPhy.m_physics.velocity im Worldspace oder im "Tangentspace". Also relativ zum Oberflächenstartpunkt?
Ich hatte auch schon mal ne frage zu Funktionspointern hier gestellt und wie man sie von c# aufrufen kann. Das geht aber leider nur von MSIL aus. Danke ebenfalls noch mal für den Link NoOneKnows.
Zu erwähnen wäre vielleicht noch das der calli Befehl nicht auf dem Compact Framework läuft und Leute die auf Linux arbeiten cdecl als Aufrufkonvention verwenden sollten und nicht stdcall.
MSIL ist sicher interessant, da man einige Dinge nur von hier aus machen kann (Funktionspointer).
Vielleicht will ja jemand mal einen MSIL Compiler für eine Programmiersprache schreiben. Ein SharpProlog, SharpHaskel oder ähnliches fehlt ja noch 8)
Im SDK is ja glaube ich sogar ein CommonLisp Compiler drin ( mit Quellcode ) der MSIL erzeugt.
Es gibt aber leider recht wenige gute Tutorials zu IL.
Hier aber ein bissl Stoff den ich noch so gefunden hab:
http://www.codeproject.com/dotnet/#MSIL
http://www.codeguru.com/Csharp/.NET/net_general/il/article.php/c4635/
http://csharpcomputing.com/Tutorials/Lesson2.htm
Es bringt doch eigendlich nichts den Vektor vom World space in den eye space zu transformieren. Du willst es doch eher umgekehtrt machen. Hast einen Vektor rockedDirUser der vom Benutzer angegeben wird. Also wie bei dir (0,10,0) für einen senkrechten Aufstieg der Rakete.
[ Binormal.X Binormal.Y Binormal.Z 0 ]
rocketDirUser * [ Tangent.X Tangent.Y Tangent.Z 0 ] = rockedDirWorldSpace
[ Normal.X Normal.Y Normal.Z 0 ]
[ Pos.X Pos.Y Pos.Z 1 ]
Wobei hier die Teilvektoren der Matrix nochmal folgendes bedeuten:
Normal ... Oberflächennormale der Kugel
Binormal ... Vektor der senkrecht zu Normal ist
Tangent ... Vektor der senkrecht zu den beiden anderen ist (orthonormalisiert)
Die Berechnung sollte hoffentlich klar sein.
Du spannst also so was ähnliches wie einen TangentSpace für jeden Oberflächenpunkt auf der Kugel auf.
rockedDirWorldSpace ist dann der Vektor relativ zur Oberfläche der Kugel.
Du kannst das mal auf einen 2D Sachverhalt reduzieren und mal den Vektor mit Bleistift und Papier "transformieren" dann sollte das deutlicher werden.
Also eine 2D Matrix die einen 2D Raum auf dem Papier aufspannt und einen Raketen-Richtungsvektor (0,10). Transformiere ihn und schau dir mal an wo der sich im neu aufgespannten 2D Raum befindet. Mach das ruhig mal zeichnerisch, oft werden Dinge damit klarer.
Auch wenn ich mich jetzt unbeliebt mache 😉
Da ja immer wieder über neue Forenecken diskutiert wird, möchte ich noch einen Vorschlag für eine Forenkategorie machen:
Was halted ihr von einem Unterforum das sich mit den Internas von .Net und C# beschäftigt:
Also Fragen zum CLI, CLR, CTS, GAC, den Metadaten, Portierbarkeit, wie funktioniert Garbage Collection, Security, Signierung und vor allem MSIL ( was für Opcodes gibt es, was machen sie, usw ...)
Also keine Dinge wie: "Ich möchte das und das programmieren, wie mach ich das?", sondern mehr: Was macht das .Net System eigendlich wenn es meinen Code ausführt und wie greift das alles ineinander.
Also quasi ein "Inside .Net" für teschnisch Interessierte 8)
Du willst also ein Kamerakoordinatensystem erstellen mit dem du praktisch tangential über die Kugel blickst.
Wichtig ist jedenfalls immer, dass alle 3 Vektoren die deinen Raum aufspannen senkrecht aufeinander stehen.
Das erreich man mit dem Kreuzprodukt:
Rigth = Up x irgendeinVektor;
lookAt = Up x Rigth
Warum willst du eigendlich mit der lookAt Methode einen Vektor transformieren?
Das ist ja im Endeffekt nichts anderes als ihn vom Worldspace in den Eyespace zu transformieren. Also den Vektor relativ zur Kamera berechnet. Was möchtest du genau machen?
Ich finde die Idee auch gut. Die meisten Programmier-Foren sind ja leider recht eindimensional.
Wenn man auch noch allgemeinere Dinge zur professionelleren Softwareentwicklung mit reinpackt würde, wär das das ziemlich gut.
Vor allem für die Erfahrungsberichte und Patterns wäre doch so was wie ein myC# Wiki net schlecht.
Hehe!
Danke das Tao Framework liegt tatsächlich im Mono CVS.
Im offiziell downloadbarem Mono Release ist es aber leider noch nicht enthalten.
Hi Leute,
weiß jemand wo ich noch das Tao-Framework herunterladen kann.
Der Server von Randy Ridge ist ja schon ne weile Down.
Oder hat irgend jemand die Assemblys(+ Source) und kann sie mir schicken.
Danke
Natürlich musst du den Up-Vektor mit transformieren, genau so wie den Left-Vektor.
Ich verwiese einfach mal auf ne URL wo das alles recht gut erklärt wird:
Ist zwar nur C Code sollte aber dein Problem mit der Camera Klasse lösen:
maxE, ist ne verkürzte Version von "maximal entropy".
Die Entropie hat in den Naturwissenschaften die unterschiedlichsten Bedeutungen.
Es kann Chaos, Unordnung, Zufall bedeuten. Ist aber auch ein Maß für die
Information einer Quelle oder der Energie eines Systems.
Ich weiß, etwas abstrakt 😉
Hmm,
ich hoffe mal dich jetzt richtig zu verstehen.
Was funktioniert an deinem letzten Code Abschnitt nicht?
Werte?
Kann es sein das du noch irgendwelche Transformationen vorgenommen hast und in der Transformationsmethode, bei der ja ein homogener 4-Komponenten Vektor zurück gegeben wird, die w-Koordinate ungleich 1 ist?
Wenn ja, dann teile mal die x, y, z Komponenten des Vektors durch die w-Koordinate.
Hi,
hab mal folgende Frage:
Ich hab eine C Funktion in einer DLL die mir einen Zeiger auf eine Funktion liefert.
Wie kann ich solche Funktionszeiger von C# aus nutzen.
Man kann ja mit DllImport externe C Funktionen importieren. Die Parameter werden ja durch das Marshalling angepasst:
[DllImport("mydll.dll")]
public static extern IntPtr GetFunctionPointer(int funcID);
Gibt es eine Möglichkeit den zurückgegebenen Funktions-Pointer von C# aus als Methode aufzurufen? Kann man den IntPtr auf einen Delegaten casten oder irgendwas ähnliches machen ?(
Versuch es doch mal mit neuronalen Netzen zur Mustererkennung 😉
Mal ernsthaft:
Was für ein Kreuz meinst du, hat das immer eine bestimmte Form, Ausdehnung, Farbe ?
Ich hoffe wir werden in Zukunft noch mehr kommerzielle Spiele sehen die auf .NET besieren.
Die Vorteile sind ja offensichtlich. Viele Konzepte die in C++ recht schwer bzw. nur mit "dirty hacks" lösbar waren, sind mit C# recht einfach umsetzbar.
Schreibt z.B. mal ein Plattformunabhängiges PlugIn System für eine Game Engine in C++. Da hat man ne menge Arbeit und trifft auf viele programmiertechnische Wiederstände. In C# ist so was (frustfrei) an einem Nachmittag gelöst 😉
Und bei den stetig komplexer werdenden Spielen ist ja auch die Wartbarkeit des Codes ein gutes Argument für die Verwendung von .Net
Spätestens bei Longhorn kommt man dann kaum noch dran vorbei.
Glaubt mir, in zwei, drei Jahren schreiben alle Komerziellen ihre Spiele in C# 😉
Wenn du mehr Flexibilität brauchst und es dich interessieren sollte wie die du eine solche Matrix manuell aufbauen kannts dann schreibe einfach folgende Werte rein:
[ Right.X Right.Y Right.Z 0 ]
[ Up.X Up.Y Up.Z 0 ]
[ Dir.X Dir.Y Dir.Z 0 ]
[ Pos.X Pos.Y Pos.Z 1 ]
Right, Up und Dir sind die orthonormalisierten Kameravektoren (alle stehen senkrecht aufeinander und haben die Länge 1). "Dir" ist die Richtung auf die die Kamera blickt und "Up" ist der Vektor der nach oben von der Kamera aus zeigt.
Right kannst du mit dem Kreuzprodukt ausrechnen. "Pos" ist der Ursprungspunkt der Kamera.
Lad dir doch mal das DirectX SDK runter. Da gibt es eine unmenge an Beispielen wie du Direct Draw/3D initialisierst, Anzeigen machst und Tastenereignisse abfragst.
Oder schau doch mal hier wenn es ein Tutorial sein soll:
http://www.kuhnstall.de/tutorials.html
Probiers mal mit GC.Collect().
Leider sind .NET Anwendungen sehr Speicherhungrig. Hatte auch schon mal Speicherprobleme. Ist wohl der Fluch der gemanagten Sprachen, den man in kauf nehmen muss.
Edit:
Ach ja, sei mit GC.Collect() vorsichtig. Es lastet die CPU sehr aus da es einen kompletten garbage collect ausführt. Also Collect() nur selten benutzen.
Ich geh mal davon aus das du mit animieren vor allem das abspielen mehrer Bilder hintereinander meinst. So wie in Trickfilmen.
Du könntest für jede Animationssequenz eine Textur erzeugen, die du bei jedem Rendern wechselst. ISt aber nicht so optimal, da Grafikkarten bei häufigen Texturswitches ziemlich ausgebremst werden. Versuch mal alle deine Animationsseqenzen in eine Textur zu speichern und dann durch Veränderung der Texturkoordinaten einen anderen Bildausschnitt anzuzeigen.
Im DirectX Framework gibt es übrigens ne Klasse die speziell für Sprites konzipiert ist und vieles einfacher macht.
Es geht mir auch weniger um das abrufen/laden von Icons aus Resourcen oder sonst wo her. Ich hab ein Programm das Bilddateien konvertiert. Als Ziel sollen auch Icons möglich sein. Nur leider klappt des nicht richtig (siehe oben). Irgendwie seltsam das PNGs erzeugt werden und keien Icons, obwohl ich das explizit angegeben habe. Notfalls muss ich das Speichern manuell erledigen und nicht über das Framework. Wer weiß was sich Microsoft da wieder gedacht hat 😜
Hallo Leute,
ich hab mal ne Frage. Wie kann man eigentlich Icons richtig abspeichern?
Icon.Save(...) speichert merkwürdigerweise scheinbar nur 16 Farben Icons ab, obwohl es sich um ein True-Color Icon handelt. (Konvertiert aus einem Bitmap mit Bitmap.GetHicon())
Auch Image.Save( fileName, ImageFormat.Icon ) funktioniert nicht richtig.
Das speichert kein Icon ab, sondern ein PNG ???? Warum eigentlich das, ein Bug im Framework?
Danke schon mal für eure Antworten im Vorraus.
Hmm, ganz spontan würd ich sagen, dass ne Manager Klasse all deine Steuerelemente verwalten könnte.
Deine Steuerelemente könntest du von einer abstrakten klasse ableiten.
Diese Managerklasse prüft dann für alle Steuerelemente ob der Mauszeiger drin und die ne taste getrückt ist. Wenn ja kannst du ein ereignis auslösen( Siehe events in deiner c# referenz ) Die Mausposition könntest du z.B. mit DirectInput auslesen.
Um das noch zu optimieren würde ich nicht immer alle Elemente durchsuchen, sondern nur prüfen ob du dich immer noch inner halb deines GUI Elements befindest. Wenn ja entfällt die weiter Prüfung. Wenn nein, dann musst du nach einem Steuerelement suchen das den Mauszeiger enthält. Es gibt sicher noch weitere möglichkeiten das zu optimieren.
Wollte ja nur ein paar Alternativen aufzeigen und das die Welt nicht nur aus Microsoft Installern besteht 😉 Take it easy 😉
So was macht man am besten mit Regular Expressions (System.Text.RegularExpressions). Die Klasse RegEx liefert alles was du für erweiterte Stringbearbeitung brauchst. Allergings ist etwas einarbeitung nötig. Schau dir am besten mal Perl Tutorials zum Thema RegularExpressions an.
Die Reg.-Ex. von .NET sin Perl 5 kompatibel und äußerst mächtig. Alles was mit Strings zu tun hat ( splitten, erstzen, suchen, ...) kannst du damit machen.
Sucht mal im Netz nach einem Tool namens Inno Setup oder der dem NullSoft Install System (NSIS). Damit kannst du Installationsroutinen scripten und Setups erstellen. Inno Setup ist etwas einfacher zu handhaben als NSIS. Was du davon aber letztlich benutzt ist aber geschmackssache.
Nehme auch gleich mal die gelegenheit war mich vorzustellen.
Ich bin 21 und studiere im 4. Semester Medieninformatik und werde vielleicht reguläre Informatik im Hauptstudium weiter studieren.
Beschäftige mich schon seit ewigkeiten mit Computern. Alles hat bei mir mit einem damals in der DDR (Ja ich bin ein Ossi😉 )gefertigtem Rechner angefangen: Dem KC 85/4 (über C64 Nutzer konnte ich nur lachen😉
Geiles Teil mit Basic Interpreter im Rom und einem Betriebssystem mit dem viel sagendem Namen: CHAOS.
Später hab ich dann mit nem PC angefangen. Erst Pascal, dann C und C++ und a bissl x86 asm. Vor kurzem auch recht interessiert C# und Java.
Und desweiterem ist man ja vom studium durch noch ein paar andere Sprachen vorgeschädigt: Haskell, Prolog z.B. Wobei letzteres ne wirklich feine Programmierspache ist um mal den eingenen Gehirnschmalz etwas zu trainieren. Eine die nur auf rekursive Definitionen setzt, ist schon was feines 😉
@Anke: Auch glückwunsch von mir
Bei mir läuft es. Aber extrem langsam.
Dummerweise bleibt ich immer an einer Stelle im Spiel stecken. Da ist ein Bug in der Collision Detection und man bleibt an einer Säule hängen.
Bei der seltsamen Grafik am Anfang hab ich auch gedacht es sein ein Treiberfehler aber es ist schon so gewollt.
Na ja, trotzdem. Schon Wahnsinn was man mit geschickter programmierung auf 94KB unterbringen kann.
Die Demogruppe die das gemacht hat (Farbrausch) hat auch noch ne menge sehr guter anderer Demos entwickelt. Alle sehr sehenswert. Einfach mal bei scene.org nach farbrausch gucken. Viel Spaß.
Schaut mal hier:
http://www.theprodukkt.com/
Eine weitere möglichkeit wäre eventuell noch eine bidirektionale Hashtabelle.
Du speicherst einmal das Key -> Value Paar in der Hashtabelle und in einer 2. Hashtabelle ein Value -> Key Paar. Würde aber nur funktionieren wenn es keine Kollision zwischen gleichen Werten gibt und die Zuordnung eineindeutig ist.