Einen eigenen TimeOut implementieren.

Such mal hier im Forum nach "WMI Code Creator" und lade den herunter. Der sollte alle weiteren Fragen bezüglich der Verwendung von WMI beantworten.

WMI, Namespace root\CIMV2, Klassen Win32_PnpSignedDriver & Win32_SystemDriver, Methoden StartService & StopService

Klasse für Primzahl- und Integer-Berechnungen

Die Gruppenrichtlinien sind letztendlich auch nichts anderes als Werte in der Registry. Musst also nur rausfinden, welcher Richtlinie sich in welchem Wert verewigt und diesen dann direkt ändern.

Wenn die exe sowieso über eine Batch gestartet wird, kann sie doch genauso gut auch von der Batch wieder gelöscht werden. Mit

start "" /WAIT <<programm>> <<parameter>>

kann man die Batch bis zum Ende des Programms anhalten.

Habe gerade festgestellt, dass er die ersten Gänsefüßchen als Fenster-Titel annimmt.
Daher sollte start "nix" /wait <<programm>> <<parameter>> es eigentlich tun.

1.
Sind denn in der Verbindung Benutzername und Kennwort richtig eingetragen? Wenn es beim Doppelklick auf das Symbol in Netzwerkverbindungen funktioniert, sollte rasdial eigentlich auch funktionieren.

EDIT:
3.
Schau dir doch einfach die Ping-Zeiten an. Alle unter 200ms kann nicht UMTS sein...

Hmmm, vielleicht WMI, Klasse Win32_PrintJob?

Na wenn dann mit Post-Inkrement und ohne Kopieren des MemoryStreams.

byte[] endArray = new byte[ms.Length << 1]; //doppelte größe
int x = 0;
foreach(byte p in ms.GetBuffer())
{
    endArray[x++] = p;
    endArray[x++] = (byte) 1;
}

Probier doch mal eine Batch-Datei mit folgendem Inhalt:

rasdial <<Verbindungsname>>
start /WAIT "Pfad zum Programm" Parameter
rasdial <<Verbindungsname>> /d

Diese stellt die Verbindung her, startet das Programm und schließt die Verbindung nach dem Ende wieder. Eigentlich müsste Windows dann als Default-Route diese Verbindung nutzen. Falls das nicht der Fall ist, kannst du noch extra Routen über diese Schnittstelle festlegen. Meld dich einfach noch mal.

EDIT: Am besten sieht das aus, wenn du die Batch (Extension .cmd) in den Ordner des Programms packst und dann im Startmenü (bzw. auf dem Desktop) eine Verknüpfung auf die Batch erzeugst. Dann in den Eigenschaften der Verknüpfung als Symbol das Spiel auswählen (bzw. das Symbol des Spiels) und bei Ausführen "minimiert" auswählen.

EDIT2: spellcheck

Auch lustig ist die Tatsache, dass strings scheinbar optional sind.

Was vermutlich daran liegt, dass Strings Referenztypen sind und daher auch den Wert "kein Wert" (null) aufnehmen können.

Ok, das mit dem break stimmt. Wenn ich aber eine Abbruchbedingung brauche, vewende ich eh eine while-Schleife.

Ist aber das gleiche, da Contains die zweite Schleife kapselt.

Dann implementiere doch dein eigenes Deep-Clone.

Wenn die Listen sortiert sind, kannst du mit linearen Aufwand das doppelte Element finden.
Die doppelte Schleife hat den Aufwand O(n*k). Bei so wenigen Elementen würde sich das extra Sortieren also nicht lohnen.

Schalte mal auf Detailansicht und "In Gruppen anzeigen", dann erkennst du, woher diese Sortierung kommt.

Process.Threads

Hast du hier im Forum schon mal danach gesucht?

Genau genommen sind es nicht mal Sinus- sondern Rechteck-Schwingungen.

Zu 1.: Du musst die Datei mit geeignetem FileMode, FileAccess und vor allem FileShare öffnen.

Wenn du die Datei speichern willst, nimm WebClient.DownloadFile.

Leider wird es trotzdem nicht so toll klingen, da du mit den Beep-Funktionen keine Hüllkurven modellieren kannst.

Das einzige Problem, dass bei mehreren Threads auftritt, ist der Schreibzugriff auf gemeinsam genutzte Objekte (in dem Fall also statische Klassenmember). Lokale Variablen sind unproblematisch.
Suche => Synchronisation

EDIT: Variablen durch Objekte ersetzt.

Nun, dann brauchst du wohl eine neue Tabelle Arbeitszeit (Datum [PK], Arbeitsbeginn, Arbeitsende).
In dieser schlägst du für jeden involvierten Tag nach und bestimmst die Differenzen.

Berechne die Datumsdifferenz in Tagen, multipliziere sie mit der täglichen Arbeitspause (8h) und subtrahiere dies von der Zeitdifferenz in Stunden.

Um allerdings Feiertage und Wochenende auszuschließen, musst du die Tage zwischen Anfang und Ende des Auftrags daraufhin untersuchen.
Es würde sich daher anbieten, die Zeit beim Beenden eines Auftrags einmalig zu beenden und mit im Auftrag zu speichern.

Bei mir traten keinerlei Probleme auf. Ansonsten vorher einen Systemwiederherstellungspunkt setzen.

Nein.

NTFS Change Journal

In Reaktion auf das Öffenen eines Programms, aber wie? steht, wie es prinzipiell geht.
Wenn du die Benutzeranmeldung mitbekommen möchtest, musst du die Überwachung für erfolgreiche Anmeldeereignisse aktivieren. Die Ereigniscodes sollten mit einem Blick ins Log schnell zu ermitteln sein.

Ja.
WMI.
Namespace _root\CIMV2_, Klassen Win32_IP4RouteTable und Win32_IP4PersistedRouteTable sowie
Namespace _root\snmp\localhost_, Klasse SNMP_RFC1213_MIB_ipRouteTable.

WinAPI-Funktion: BOOL FreeConsole(void);

Zu deinem Problem: deine Berechnungsmethode ist falsch.

Genauer gesagt, kann deine Methode nicht mit mehreren Nullstellen in einem Intervall umgehen. Von daher ist eine periodische Funktion natürlich der denkbar ungünstigste Testfall.

Meine Idee wäre es, zwei Listen zu benutzen.
Eine sortierte Liste mit allen Elementen und eine zweite Liste mit deren Permutation.
Wenn mich meine Überlegungen jetzt nicht in die Irre geführt haben, müsste der Fehlstand dann die Differenz zwischen dem Index des Elements in der Permutation und dem Index in der sortierten Liste sein.
Da binäres Suchen in einer Liste den Aufwand O(log₂ n) hat und du jedes Element in der Permutation in der anderen Liste suchen musst, wäre der Gesamtaufwand O(n*log₂ n).

Wenn du aber die gleiche TreeView in zwei Forms anzeigen willst, wäre es dann nicht besser die Oberfläche in zwei Teile zu teilen? Links der TreeView und rechts entweder TabPages oder Panels, die du je nach Bedarf ein- und ausblendest?

Wenn du alle diese Formate unterstützen möchtest, bist du mit Sicherheit eine Weile beschäftigt.

Falls es dir aber nur um die Textpassagen geht, wäre es wahrscheinlich einfacher einen globalen Maus-Hook zu implementieren.
Zum Beispiel kann der Nutzer in einer beliebigen Anwendung ein Wort markieren. Klickt er dann (beispielsweise) mit gedrückter Strg- und Alt-Taste auf die Markierung, wird dein Programm aktiv, sichert das Clipboard, sendet der fokussierten Anwendung den Tastencode für Kopieren (Strg-C), holt sich die Daten aus dem Clipboard und schreibt den alten Inhalt zurück.
Dies funktioniert dann in so gut wie allen Anwendungen (wenn sie das Kopieren zulassen, was in PDF- und Word-Dokumenten eingeschränkt sein kann).

CAPI ist das Common ISDN Application Programming Interface. Es stellt also nur Funktionen zur Flusssteuerung und Datenübertragung über ISDN zur Verfügung.
Um eine E-Mail zu senden (SMTP) benötigst du aber TCP/IP und das hat erstmal nichts mit ISDN zu tun.
Wenn du eine Mail senden möchtest, brauchst du eine TCP/IP-Route ins Internet, so dass du den Mail-Server kontakten kannst.
Du musst also eine Internetverbindung anlegen (über den Windows-Assistenten "Neue Verbindung anlegen"), die sich über die ISDN-Karte bei einem Provider einwählt. Diese Verbindung kannst du dann bei Bedarf von deinem Programm aufbauen und beenden lassen. Während sie steht kannst du, wie auch immer du willst, mit den Rechnern im Internet kommunizieren, also auch Mails versenden.

Zur Erklärung: Die Klasse Application wird im Namespace System.Windows.Forms definiert. Dieser ist per Default nicht in einem Konsolenprojekt referenziert. Du könntest also entweder den Verweis und das using manuell hinzufügen oder - wie xxxprod schon schrieb - einfach die Main-Methode verlassen. Ein return anstelle von Application.Exit() erledigt das.

Ähh, du beachtest, dass in allen C-Derivaten alle Indize nullbasiert sind?

Natürlich geht das auch mit dem Framework. Schau dir mal den Namespace System.Security.AccessControl an. Allerdings ist es nicht so einfach auf Anhieb zu verstehen, wie das ganze abläuft. Dazu brauchst du schon relativ genaue Einblicke in das Sicherheitsmodell von Windows.

Daher ist es wahrscheinlich einfacher, die Dateien verschlüsselt im IsolatedStorage abzulegen. Dazu kannst du die Klasse ProtectedData aus obigem Namespace benutzen.

EDIT:

Eventuell reicht es dir auch, wenn du einfach folgendes Kommando per Process.Start absetzt: cacls "myfile" /G SYSTEM:F /G Administratoren:F
Danach haben nur das System und Administratoren Vollzugriff, alle anderen keinen.

Das erscheint mir logisch. Da das Programm auf eine Eingabe wartet, schreibt es den Text ohne Zeilenende. Wenn du mit Sicherheit weißt, dass diese Abfrage kommt, kannst du ja einfach ein n senden...

beide Dateien einlesen Byte für Byte und prüfen ob die Checksumme gleich ist.

Wenn man die Datei eh komplett einliest, kann man sich das Bilden des Hash sparen und direkt vergleichen. Diesen zu berechnen ist nur sinnvoll, wenn man den Hash in einer Datenbank o.ä. speichert, um Veränderungen zu bemerken.

Ich würde die Dateigrößen sowie den Modified-Zeitstempel vergleichen. Unterscheiden sich die Dateien in der Dateigröße sind sie definitiv ungleich, unterscheiden sie sich im Zeitstempel sehr wahrscheinlich. Sollten sie sich in keinem von beiden unterscheiden, ist das natürlich keine Garantie dafür, dass die Dateien identisch sind.
Sprich: außer bei Ungleichheit der Größe muss man vergleichen. Dazu braucht man aber keinen Hash.

Alternativ könnte das Programm natürlich beim Übertragen auf den PPC die Checksumme der Datei bilden und ebenfalls mit ablegen. nur dann wäre es sinnvoll, die Hashes zu vergleichen.
Beachte bei den Hashes aber auch, dass Hashes nicht die Originalität sonder nur die Differenz zweier Datenblöcke garantieren.
Soll heißen: unterschiedliche Hashes bedeuten mit Sicherheit unterschiedliche Daten. Gleiche Hashes bedeuten nur höchstwahrscheinlich (aber eben nicht garantiert) gleiche Daten.

Dein Programm kann den String einfach auf der Kommandozeile ausgeben (Console.WriteLine).
Mittels for /f "delims=" %i in ('myCommand.exe') do @set myVar=%j kannst du die Ausgabe zuweisen.

WM_PASTE abfangen?

Möglicherweise erfolgt die Ausgabe über StandardError?

Finde es mit dem .NET Reflector selbst heraus: http://www.aisto.com/roeder/dotnet/

Du musst Ausgabe von Darstellung trennen, d.h., du zeichnest im Hintergrund nur wenn sich etwas ändert in eine Bitmap. Im Paint stellst du einfach diese Bitmap dar.

Wenn du der Genauigkeit wegen mit Brüchen rechnen willst, bringt dir die Umwandlung nichts, da sie eh (meist) ungenau sein wird. In diesem Fall, solltest du konsequent von Eingabe bis Ausgabe mit Brüchen arbeiten. Dazu benötigst du aber eigene Klassen.

Ich habe mal eine auf long-basierende Klasse für Brüche geschrieben. Da diese auf dem von mir hier schon mal geposteten Primzahlengenerator aufsetzt, ist der eigentliche Code für die Brüche sehr kompakt.

Falls es dir etwas hilft, hänge ich den Code mal an.
Da ich ihn für das ursprüngliche Projekt nicht mehr benötige, habe ich auch nicht weiter an den Einschränkungen gearbeitet.

Zeichne im Hintergrund einfach nur dann, wenn sich etwas ändert in zwei Bitmaps. In die eine die komplette Karte (also jeweils die Gelände-Bitmaps), in die andere einfach nur farbige Punkte für die Minimap.
Dazu bietet es sich an, die Datenstruktur komplett zu ändern.

public enum UndergroundTypes
{
   Empty = 0,
   Water = 1,
   Meadow = 2,
   Moor = 3,
   Field = 4,
   Forest = 5,
   Mountain = 6,
}
public struct UndergroundGraphics
{
   public Image MapImage;
   public Pen MinimapPen;
}

// hier die Verknüpfung von GeländeTypen mit den Zeichenobjekten
public Distionary< UndergroundTypes, UndergroundGraphics> UndergroundData = ... ;

public class GameMaps
{
   // der Faktor zwischen Spielkoordinaten und Bildschirmkoordinaten
   public const int TileSize = 16; // Größe 16 * 16

   // hier die Verknüpfung von Spielkoordinaten mit Geländetypen
   private UndergroundTypes[,] Tiles;

   // hier das Spielfeld
   internal Bitmap Map;
   // und die Minimap
   internal Bitmap Minimap;

   // Spielfeld-Graphics
   private Graphics MapGraphics;
   private Graphics MinimapGraphics;

   // erzeugt die Karten mit der maximalen Größe x und y
   public GameMaps( int x, int y)
   {
      Tiles = new UndergroundTypes[ x , y ];
      Map = new Bitmap( x * TileSize, y * TileSize );
      MapGraphics = Graphics.FromImage( Map );
      Minimap = new Bitmap( x, y );
      MinimapGraphics = Graphics.FromImage( Minimap );
   }

   public UndergroundTypes GetUnderground( int x, int y )
   {
      return Tiles[x,y];
   }

   public void SetUnderground( int x, int y, UndergroundTypes undrgrnd )
   {
      Tiles[x,y] = undrgrnd;
      MapGraphics.DrawImageUnscaled( UndergroundData[undrgrnd].MapImage, x * TileSize, y * TileSize );
      MinimapGraphics.DrawRectangle( UndergroundData[undrgrnd].MinimapPen, x, y, 1, 1 );
   }
}

Jetzt wird in die Bitmaps nur gezeichnet, wenn sich etwas ändert. Im Paint brauchst du dann nur noch Map und Minimap mittels Graphics.DrawImage(Image,Rectangle,Rectangle,GraphicsUnit) darstellen.

Wobei man von "Zufallsklassen", die auf int basieren nicht zuviel erwarten sollte. Dazu ist der Zahlenbereich einfach zu klein. Näheres siehe Random von Namen (String).

Unabhängig von LINQ: Es ist nicht sehr sinnvoll, erst alle Elemente zu kopieren (zwei mal) um dann die überflüssigen zu löschen.
Daher:

//class MyList<T> : List<T>
public static MyList<T> operator -(MyList<T> Liste1, MyList<T> Liste2)
{
   MyList<T> tList = new MyList<T>( Liste1.Count );
   foreach( T obj in Liste1 )
   {
      if (!Liste2.Contains( obj ))
      {
         tList.Add( obj );
      }
   }
   return tList;
}