Forenbeiträge von Borg Ingesamt 1.529 Beiträge
Habe obigen Code mal ausprobiert und angepasst.
Die aktuelle Version:
private static double GetPasswordSecurityIndex( string pwd )
{
double pwdlog = Math.Log( pwd.Length + 1);
double pwdlen = (double)pwd.Length;
double value = pwd.Length;
for (int i = 0; i < pwd.Length; i++)
for (int j = i + 1; j < pwd.Length; j++)
value += Math.Pow( Math.Abs((int)pwd[i]-(int)pwd[j]) / pwdlen, pwdlog );
return (value > 0.0) ? Math.Log( value ) : 0;
}
Hier mal ein paar Beispiele:
Borg 5,02650877675571
Borg1234 7,02423089434529
Borg was here. 7,95082622741682
No Borg here anymore, even not a single 1. 7,90570469080243
mycsharp 4,33975705524902
mycsharp.de 6,68671924145669
www.mycsharp.de 7,36601719119733
http://www.mycsharp.de 7,76037497025754
Das ist nur ein absolut sinnfreier Teststring, der nur zeigen soll, was bei extrem langen Passwörtern passiert. 6,97574345705376
hIug^H$&&%8_ihugü# 9,7687777314195
Ich finde, dass das schon relativ vielversprechend aussieht...
Du könntest auch das geometrische Mittel der gegenseitigen Differenzen aller UNICode-Werte des Strings bestimmen und als Maß nutzen. Dann brauchst du nichts bewerten oder ähnliches sondern ziehst als Kriterium bloß die Unterschiedlichkeit der Zeichen heran.
Im Code:
private double GetPasswordSecurityIndex( string password )
{
double value = 1;
for (int i = 0; i < password.Length; i++ )
for (int j = i + 1; j < password.Length; j++ )
value *= Math.Abs( (int)password[i] - (int)password[j] ) + ( j - i );
return password.Length * Math.( value, 1 / password.Length );
}
Vermutlich muss man diese Berechnung noch deutlich anpassen, allerdings liefert sie dann relativ schnell und eindeutig eine numerische Bewertung eines Passworts.
So empfinde ich die Nutzung eines SortedDictionary (@dr4g0n76: du hast versehentlich SortedList geschrieben), nur um doppelte Zeichen zu ermitteln, für arg umständlich. Desweiteren werden aufeinanderfolgende Zeichen nicht geprüft.
So sind die beiden Passwörter "abcdefgh" und "quejspod" gleichwertig, was sie jedoch mit Sicherheit nicht sind.
Falls du mehr Infos als nur die Namen brauchst: DirectoryInfo( myDirectory ).GetFiles().
- Ersetze while-do durch do-while
// aus
serialBTPort.Read(Buffer, 0, 1);
i = Convert.ToInt32(Buffer[0]);
while ((i & 192) != 0)
{
serialBTPort.Read(Buffer, 0, 1);
i = Convert.ToInt32(Buffer[0]);
}
// wird
do
{
serialBTPort.Read(Buffer, 0, 1);
i = Buffer[0];
} while( (i & 192) != 0)
- Ich würde die komplette Struktur ändern. Eine eigene Klasse beinhaltet den SerialPort und lässt sich von diesem per DataReceived benachrichtigen, sobald ein Byte eingetroffen ist (ReceivedBytesThreshold).
Ist diese ein Startbyte, wandert es in einen Puffer, der mit den folgenden drei Bytes aufgefüllt wird. Sobald der Puffer voll ist, löst die Klasse wiederum ein Event aus und gibt die Daten weiter.
Sei dir dennoch bewusst, dass es zwischen den beiden Varianten einen Unterschied gibt.
Bei public single i1, i2, i3, i4; liegen vier Singles direkt hintereinander im Struct und benötigen damit 16 Bytes.
Bei public single[] i; wird nur die Referenz auf ein Array, also vier Bytes, abgelegt. Das Array selbst wird auf dem Heap angelegt (mittels new).
Um dieses Problem zu umgehen, könntest du dir für die zusammengehörenden Werte index und weight einen eigenen Typ als Struct definieren und diesen nutzen.
PS.: Verwendet man den Begriff Heap unter .NET eigentlich noch? Und wenn nicht: welcher wäre besser?
In Vista wurde das alles und noch mehr verwendet.
Scheinbar jedoch nicht gründlich genug. Jedenfalls enthält Vista den Fehler auch.
@sarabande: Bevor du jetzt mit Windows Messages ankommst:
Lies doch bitte mal einen Thread durch, bevor du postest. megamacy möchte einen (mit Steuerung behafteten) Mausklick auf eine bestimmte Koordinate in einem DirectX-Spiel simulieren. Also vermutlich in irgendeinem Spiel cheaten.
Und das funktioniert nicht so wie gedacht.
EDIT: Und nachdem du wegen bunt und fett und groß (vermutlich) eine Verwarnung bekommen hast, arbeitest du jetzt mit Asterik und Gänsefüßchen und der gleichen Aggressivität.
Vielleicht funktioniert es besser, wenn du SerialPort.BaseStream.ReadByte() verwendest?
Wie benutze ich den saveFileDialog 1.Klickst du Ordner 1.Tippst du Name 1.Klickst du speichern
Mit den Compilermeldungen nicht klar zu kommen ist leicht wenn man den code größtenteils nicht versteht ^^
Da ist doch kaum Code. Ein paar Structs, ein paar Konstruktoren und Erzeugung und Füllen eines Arrays. Wenn du das nicht verstehst, solltest du eventuell noch mal an den Grundlagen feilen.
das tasten drücken greift garnicht
Möglicherweise muss man beim Mausklicken auch noch die aktuellen Koordinaten in dx und dy mitliefern. Um diese zu erhalten, kannst du GetCursorPos benutzen.
EDIT: Code angepasst.
beim ausführen werden die maustasten lahm gelegt
Das bedeutet was?
Nein, ich habe den Code nicht getestet.
Ich habe den direkt hier rein getippt. Weil ich dir nämlich auch bloß helfen wollte.
Da wusste ich aber noch nicht, dass du nicht mit ein paar Compilerfehlermeldungen klar kommst.
Code wiederum angepasst.
Ein solch kleines Problemchen solltest du aber durchaus alleine lösen können...
Daher: Syntaxfehler selbst lösen (Compilerfehlermeldungen)
Code oben angepasst.
Und hör mal bitte auf deine Beiträge zu editieren. Beziehungsweise - so wie ich - nur um Fehler zu verbessern. Aber nicht um Fragen hinzuzufügen oder zu entfernen. Lies dir doch mal deine Posts durch und dann meine jetzt plötzlich völlig zusammenhanglosen Antworten...
Das ist hier ein Forum, kein Chat...
Habe das fehlende "d" ergänzt.
Ansonsten ist die Verwendung durch die Konstruktoren doch sehr einfach...
Ebenfalls System.Runtime.InteropServices. Müsstest du doch aber schon drin haben!?
Muss ja auch hin. Habe das oben verpeilt. Ist jetzt aber geändert.
Probier einfach nur uint.
Das Problem ist, dass du zwei unterschiedliche Funktionen nutzt. Mittels SendInput kannst du alle deine Aktionen atomar ausführen.
[DllImport("user32.dll", SetLastError = true)]
private static extern int SendInput(int nInputs, ref INPUT[] pInputs, int cbSize);
[DllImport("user32.dll", SetLastError = true)]
private static extern bool GetCursorPos( ref POINT coord );
[StructLayout(LayoutKind.Sequential, Pack = 1)]
private struct POINT
{
public Int32 x;
public Int32 y;
}
[Flags()]
private enum MOUSEEVENTF
{
MOVE = 0x0001,
LEFTDOWN = 0x0002, LEFTUP = 0x0004,
RIGHTDOWN = 0x0008, RIGHTUP = 0x0010,
MIDDLEDOWN = 0x0020, MIDDLEUP = 0x0040,
XDOWN = 0x0080, XUP = 0x0100,
WHEEL = 0x0800,
VIRTUALDESK = 0x4000,
ABSOLUTE = 0x8000,
none = 0x0;
}
[Flags()]
private enum KEYEVENTF
{
EXTENDEDKEY = 0x0001,
KEYDOWN = 0x0, KEYUP = 0x0002,
UNICODE = 0x0004, SCANCODE = 0x0008,
none = 0x0
}
[StructLayout(LayoutKind.Sequential, Pack = 1)]
private struct MOUSEINPUT
{
public Int32 dx;
public Int32 dy;
public UInt32 mouseData;
public UInt32 dwFlags;
public UInt32 time;
public IntPtr dwExtraInfo;
public MOUSEINPUT( Int32 x, Int32 y, UInt32 mD, MOUSEEVENTF dwF, UInt32 t, IntPtr dwEI )
{
dx = x; dy = y; mouseData = mD; dwFlags = (UInt32)dwF; time = t; dwExtraInfo = dwEI;
}
}
[StructLayout(LayoutKind.Sequential, Pack = 1)]
private struct KEYBDINPUT
{
public UInt16 wVk;
public UInt16 wScan;
public UInt32 dwFlags;
public UInt32 time;
public IntPtr dwExtraInfo;
public KEYBDINPUT( UInt16 wV, UInt16 wS, KEYEVENTF dwF, UInt32 t, IntPtr dwEI )
{
wVK = wV; wScan = wS, dwFlags = (UInt32)dwF; time = t; dwExtraInfo = dwEI;
}
}
[StructLayout(LayoutKind.Explicit)]
private struct INPUT
{
[FieldOffset(0)]
public UInt32 type;
[FieldOffset(4)]
public MOUSEINPUT mi;
[FieldOffset(4)]
public KEYBDINPUT ki;
public INPUT( MOUSEINPUT mouse )
{
type = INPUT_MOUSE;
ki = new KEYBDINPUT( 0, 0, KEYEVENTF.none, 0, IntPtr.Zero );
mi = mouse;
}
public INPUT( KEYBDINPUT keybd )
{
type = INPUT_KEYBD;
mi = new MOUSEINPUT( 0, 0, 0, MOUSEEVENTF.none, 0, IntPtr.Zero );
ki = keybd;
}
private const UInt32 INPUT_MOUSE = 0;
private const UInt32 INPUT_KEYBD = 1;
private const UInt32 INPUT_HARDWARE = 2;
}
// ....
private const UInt16 VK_CONTROL = 0x11;
public void DoSomeAction()
{
// Mauskoordinaten holen
POINT coord;
GetCursorPos( coord );
// Strg runter, Maus links runter, Maus links hoch, Strg hoch
INPUT[] inputs = new INPUT[4];
inputs[0] = new INPUT(new KEYBDINPUT(VK_CONTROL,0,KEYEVENTF.KEYDOWN,0,IntPtr.Zero));
inputs[1] = new INPUT(new MOUSEINPUT(coord.x,coord.y,0,MOUSEEVENTF.LEFTDOWN,0,IntPtr.Zero));
inputs[2] = new INPUT(new MOUSEINPUT(coord.x,coord.y,0,MOUSEEVENTF.LEFTUP,0,IntPtr.Zero));
inputs[3] = new INPUT(new KEYBDINPUT(VK_CONTROL,0,KEYEVENTF.KEYUP,0,IntPtr.Zero));
int result = SendInput( inputs.Length, ref inputs, Marshal.SizeOf( typeof(INPUT) ) );
// ...
}
Nur leider ist Logging und Fragmentierung der falsche Ansatz.
Gerade wenn die Festplatte fragmentiert ist, sinkt die Prozessorauslastung, da die Prozesse länger auf die Festplatte warten müssen...
Ich fürchte, es liegt an etwas anderem. Auf jeden Fall ist es ein Mythos, dass die Fragmentierung der Festplatte irgendetwas mit einem langsamen Rechner zu tun hätte...
Erstellt in der Software doch mal ein mit Zeitstempeln versehenes DebugLog, in dem alle Aktionen verzeichnet sind. Dann findet ihr vielleicht heraus, womit die Software beschäftigt ist.
Ist doch logisch. Die Funktion erwartet immer die angegebene Reihenfolge. Änderst du diese, liest die Funktion sinnlose Daten. So könnte beispielsweise eine Frequenz von 60kHz verlangt werden. Kein Wunder, dass das false zurückkommt.
Irgendwie versteh ich das nicht. Werden die MouseClicks asynchron ausgelöst? Wie können denn Funktionsaufrufe nach dem MouseClick diesen verändern? Kann man bei MouseClick nicht irgenwie gedrückte Tasten mitliefern?
Was ist damit:
keybd_event((int)Keys.ControlKey, 0, KEYEVENTF_EXTENDEDKEY, 0);
MausClick("ld");
MausClick("lu");
keybd_event((int)Keys.ControlKey, 0, KEYEVENTF_KEYUP, 0);
keybd_event((int)Keys.ControlKey, 0, KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
Und wieder ein Buffer Overrun.
Klar das so etwas in einem riesigen Softwareprojekt wie Windows passiert. Allerdings könnte Microsoft - gerade angesichts der Beteuerung mehr für die Code- und Laufzeitsicherheit tun zu wollen - ein Tool entwickeln, welches C- und C++-Code auf typische Fehler, wie zum Beispiel dem Verwenden nicht größengetesteter Puffer beim Kopieren, untersucht. Und das wichtigste: dieses Tool muss dann auch auf jeden Fetzen Code im Hause losgelassen werden.
Die Milliarden von Her(t)zen moderner Prozessoren sind im Checken aller Parameter und Datenstrukturen vor dem Damit-Arbeiten besser angelegt als in neuem graphischen Schnickschnack...
Ich vermute eher, dass die Funktion den Struct nicht wirklich auf den Stapel packt (unüblich), sondern nur die Referenz. Also musst du ihn auch per Referenz übergeben.
[StructLayout(LayoutKind.Sequential, Pack = 1)]
private struct DAC
{
byte WaveShape;
UInt16 Amplitude;
UInt16 Frequency;
UInt16 Offset;
}
[DllImport("gUSBamp.DLL")]
private static extern bool GT_SetDAC(IntPtr hDevice, ref DAC AnalogOut);
Falls es so auch nicht geht, kannst du es ja doch wieder ohne ref probieren.
Das ist doch aber keine Binär- sondern nur eine Strichuhr...
Ich vermute mal, da ist NetUserGetInfo kürzer, einfacher und performanter.
Ich kombiniere deine obigen Versionen mal zu:
keybd_event((int)Keys.ControlKey, 0, KEYEVENTF_EXTENDEDKEY, 0);
MausClick("ld");
MausClick("lu");
keybd_event((int)Keys.ControlKey, 0, KEYEVENTF_KEYUP, 0);
@nin: Nur leider war dieser Name nie gesucht. Es geht um den vollständigen Benutzernamen, den man in der Computerverwaltung zusätzlich zum Benutzernamen (= Login-Name) angeben kann. Der Explorer zeigt diesen, wenn er vorhanden ist, im Startmenü an.
System.Security.Principal.WindowsIdentity.GetCurrent().Name liefert aber - glaube ich - auch nur den Login-Namen.
Ansonsten musst du die WinAPI-Funktion NetUserGetInfo benutzen.
Siehe: Programm beenden erzwingen
Ungefähr genauso, wie a, b und c bei allgemeinen Parametern in der Analysis, x, y und z für die drei Koordinaten eines kartesischen Koordinatensystems, r, s, t als Parameter in der analytischen Geometrie oder f, g, h als Funktionen.
Oder mit griechischen Buchstaben.
Der gemeine Mathematiker sucht sich einen Buchstaben für einen bestimmte Größe aus und bezeichnet gleiche Größen mit den nachfolgenden Buchstaben. Andere Größen bekommen einen anderen Startbuchstaben und daher eine andere Folge.
Wieso so kompliziert?
Mittels DirectoryInfo.GetFiles bekommst du direkt ein FileInfo[]. Dort brauchst du dann bloß noch die Zeit abfragen. Das ganze über Strings laufen zu lassen ist sehr kompliziert.
Desweiteren solltest du statt new DateTime(2001,1,1) einfach DateTime.MinValue benutzen.
Allse in allem also so:
public string GetNewestFilesName( string DirectoryName, string FileMask )
{
DateTime newestDate = DateTime.MinValue;
int newestIndex = 0;
FileInfo[] Files = (new DirectoryInfo( DirectoryName )).GetFiles( FileMask );
for ( int i = 0; i < Files.Length; i+ )
{
if (newestDate < Files[i].LastWriteTime)
{
newestDate = Files[i].LastWriteTime;
newestIndex = i;
}
}
return (Files.Length > 0) ? Files[newestIndex].FullName : null;
}
in .NET 2.0 gehts auch leicht inkl. Unterordner: SearchOption.AllDirectories
Sollte man trotzdem nicht verwenden, da die Funktion mit einer Exception aussteigt, wenn ein Unterordner nicht geöffnet werden kann.
public int GetFileSize( string filename )
{
string[] lines = File.ReadAllLines( filename );
int charcount = 0;
foreach( string line in lines )
charcount += line.Length;
retunr charcount;
}
Ich möchte dich allerdings noch darauf hinweisen, dass die Methode nicht die Dateigröße liefert, sondern die Anzahl der Zeichen exklusive dem Zeilenendezeichen. Das ist nicht das gleiche (war es auch in Delphi nicht). Um die Dateigröße zu ermitteln, nimmst du (new FileInfo( filename )).Length.
Die Netzwerkkarten kannst du über WMI herausfinden, Klassen Win32_NetworkAdapter und eventuell alle mit Win32_PnP*. Such mal hier nach WMI Code Creator".
Trotzdem bleibe ich bei meiner Meinung, dass du eigentlich die Kameras identifizieren willst und das auch tun solltest. Du könntest ja die Seriennummern aller Kameras in der Software speichern und bei jeder eintragen, ob sie als Kamera 1 oder 2 dient und entsprechend den Aufkleber anbringen.
falls du umlaute meidest
Was allerdings technisch gesehen nicht nötig ist, da .NET auf Unicode basiert.
Nur wenn du deine Klassen an anderssprachige (bzw. anderstastaturlayoutige) weitergibst, sollten alle öffentlichen Klassen, Methoden und Felder in lateinischen Buchstaben geschrieben sein.
Die technischen Elemente einer Anwendung darfst du nachbauen, so lange wie du keinen Code kopierst, die Anwendung dekompilierst oder ähnlich. Also nur reines Reverse Engineering. Davon leben einige Open-Source-Projekte (bspw. Samba).
Die graphische Gestaltung kann hingegen, wenn eine gewisse Schöpfungshöhe erreicht ist, als ein originäres Werk eines Designers betrachtet werden und unterliegt damit auch Schutzansprüchen.
Eine "gewisse Schöpfungshöhe" erreicht man aber mit Sicherheit nicht, wenn man einfach nur normale Menüs und Buttons benutzt. Als Beispiel müsste dieses der Oberfläche von Word bis zur Version 2003 abgesprochen werden. Erst in der 2007er Version ist durch das Ribbon wieder ein gewisser schöpferischer Akt erkennbar.
Solange du dich nur inspirieren lässt und deine Oberfläche an einer bestehenden Anwendung orientierst, ist der Hersteller machtlos.
Nur Kopieren und Quellcode anschauen (auch Dekompilat) ist strikt verboten.
Ansonsten wären Microsoft, Apple, jeder Linux-Distributor und die meisten anderen Softwarehäuser schon längst pleite, da sie ständig wegen irgend einem graphischen Detail, das irgendeiner der Millionen Programmierer bereits vor ihnen hatte, verklagt würden.
Ich fürchte, ich habe den Unterschied zwischen public event myEventType myEvent; und public Event<myEventType> myEvent; nicht ganz verstanden...
Erst gacutil, dann ngen.
Und ansonsten - wie herbivore schrieb - einfach die Zahl der Starts auf einen pro Rechnerneustart reduzieren...
Mein Schreibtisch sieht nicht mal so aus, nachdem ich aufgeräumt habe...
Das möchte ich euch wirklich nicht antun.
Zur Darstellung einfach LinearGradientBrush.
Ansonsten gibt es verschieden Möglichkeiten einen solchen Farbverlauf darzustellen.
Du könntest im dreidimensionalen linearen RGB-Farbraum einfach die Gerade zwischen den beiden Farben linear darstellen, so wie norman_timo es vorgeschlagen hat. Anstelle einer Gerade sind aber auch noch viele andere Funktionen denkbar. Du könntest auch den Farbraum logarithmisch darstellen.
Du kannst natürlich auch in einen anderen Farbraum umrechnen. Gerade der von herbivore angesprochene HSL Farbraum ermöglicht es, den Farbverlauf in einer für Menschen sehr harmonisch wirkenden Weise zu berechnen.
Allerdings gibt es auch hier wieder mehrere Möglichkeiten von einem Punkt des Farbraums zu einem anderen zu kommen.
Prinzipiell möglich, jedoch ist dann das ganze nur mehr Mono
Wie kommst du denn darauf? Ich habe auch so ein Teil: vorne 3,5mm-Stereo-Klinke-Stecker, hinten zweimal 3,5mm-Stereo-Klinke-Buchse.
Sieht ungefähr so aus: Y
Zur Klärung:
Windows verteilt Prozessorzeit mittels preemptiven Multitaskings. Das bedeutet, jeder Thread bekommt einen Zeitrahmen (Standard: 50ms), ist dieser beendet, wird der Thread angehalten und der nächste wiederaufgenommen.
Ein Thread kann drei schedulerrelevante Status haben: Running, Ready To Run oder Waiting.
Es gibt pro Prozessor nur einen Thread mit dem Status "Running". Dies ist der gerade ausgeführte. Wenn der nächste zum Zuge kommen soll, sucht der Scheduler nach Threads mit dem Status "Ready To Run" und führt denjenigen mit der höchsten Priorität aus (Status wird zu "Running"). Ist der Zeitrahmen vorbei (bzw. wird beendet), wird dieser Thread auf den Status "Ready To Run" gestellt und ein Flag gesetzt, dass er in diesem Durchlauf bereits lief.
Gibt es mehrere Threads mit gleicher Priorität wird derjenige ausgeführt, der noch kein gesetztes Flag hat. Gibt es einen solchen nicht, wird das Flag bei allen wieder entfernt.
Der Status "Waiting" wird durch bestimmte Systemfunktionen vergeben, die größtenteils ein Wait im Namen tragen. Oder auch durch Control.Invoke. Er besagt, dass der Thread zwar noch läuft, momentan jedoch nicht ausgeführt werden braucht, da er auf den Abschluß einer Aktion wartet.
Damit ist klar, warum so eine scheinbar merkwürdige Reihenfolge herauskommt.
Alle Threads beenden ihren Zeitrahmen beim Aufruf von Control.Invoke. Da sie die gleiche Priorität haben, werden sie reihum ausgeführt.
Haben sie jetzt unterschiedliche Prioritäten, so kommen die niedriger priorisierten nur dann zum Zuge, wenn alle höheren nichts zu tun haben.
Allerdings kann das Laufzeitverhalten jetzt nicht mehr vorhergesagt werden, da ja nicht genau bekannt ist, wann die per Control.Invoke in einem anderen Thread gestartetet Methode beendet ist und der Thread wieder zu "Ready To Run" zurückkehrt. In genau diesen Zeiten kommt ein niedriger priorisierter Thread zum Zug, auch er bleibt beim Control.Invoke hängen und macht "Platz" für den nächsten.
Da es jetzt aber noch ganz viele andere Threads anderer Prozesse auf dem System gibt, ist das wirkliche Verhalten noch viel komplexer.
Ich bin verwirrt.
da da wirklich enorme Datenmengen zustande kommen, wenn man 1600x1200 RGB-Pixel bei ca. 30Hz transportiert.
1600x1200x3x30 => 165 MB/s.
Selbst wenn die Bilder JPEG-komprimiert (auf 10%) kommen, ergibt das 16,5 MB/s.
Falls du Fast Ethernet (100Mbps) benutzt, wovon ich ausgehe, wenn du von PCI redest, hast du eine theoretische maximale Transferleistung von rund 12MB/s. Also zu wenig.
Solltest du Gigabit Ethernet benutzen, wird das wiederum am PCI-Bus scheitern, da der in der normalen (32Bit, 33MHz) Form nur 133MB/s transferieren kann. Und das müssen sich alle Geräte teilen.
Ich vermute eher, dass die Kameras die Bilder MPEG kodieren und dann so zwischen 5 und 10 Mb/s verschicken.
Ansonsten: es kann doch deiner Software egal sein, an welcher NIC eine Kamera hängt und welche IP-Adresse sie hat. Da du die Kamera identifizieren willst, solltest du das auch tun. Wer schützt dich denn davor, dass jemand (versehentlich) Kamera 1 an NIC 2 stöpselt (und umgekehrt)? Wenn deine Software die Kamera nur über den NIC identifizieren will, öffnet das der Fehlbedienung Tür und Tor.
Falls du das dennoch willst, hast du ja schon eine geeignete Idee beschrieben.
Gibt es eine Möglichkeit das NotifyIcon immer sichtbar (also nicht inaktiv) zu schalten???
Gibt es: Rechtsklick auf Taskleiste\Eigenschaften\Taskleiste\Infobereich\Inaktive Symbole ausblenden\Anpassen.
Dort kann man für jedes Icon festlegen, ob es ausgeblendet werden darf.
Und wenn der Explorer das speichert, kann man sicherlich auch herausfinden, wo und wie er das tut und dies entsprechend programmatisch anpassen.
Nichtsdestotrotz gilt, was herbivore oben gesagt hat: immer den Benutzer entscheiden lassen, wenn die Voreinstellungen von Windows/Explorer geändert werden sollen.
Prinzipiell ist das möglich, indem du einen Treiber schreibst, der eine virtuelle Soundkarte ins System einbindet und die Kanäle verteilt.
Allerdings (erstens) verlässt du damit den Bereich von .NET deutlich und (zweitens) wird das derart kompliziert, dass es billiger ist, in ein Programm zu investieren, welches von Haus aus mehrere Soundkarten unterstützt.
Der oben verlinkte Code ist ja schrecklich!
Aber auch dort steht, dass das ganze Geheimnis in der einfachen Zeile myForm.StartPosition = FormStartPosition.Manual; besteht.
Ich möchte halb widersprechen.
Mir klang der erste Post nicht so, als ob eine Bitfolge gesucht würde. Wenn das der Fall sein sollte, hast du, talla, natürlich Recht.
Allerdings werden bei den meisten binären Dateien Werte wirklich byteweise geschrieben, so dass man auch nur byteweise suchen braucht. Dadurch würde der Code deutlich einfacher. Allerdings wird der bremsende Faktor eh die Festplatte sein, so dass es aus Performancegesichtspunkten keinen Unterschied macht.
Ein bitweises Suchen ergibt meist nur bei Bitstreams Sinn, wie zum Beispiel alle MPEG-Dialekte oder andere Audio- und Videoformate.