• Du befindest Dich hier:
• Community
• »
• Mitglieder
• »
• Borg
• »
• Beiträge von Borg

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...

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 );
   }
}

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;
}

Die gedachte Verwendung dieser Methoden ist, sie den Cursor beim Eintritt auszublenden und beim Austritt wieder anzuzeigen. Deshalb werden die Aufrufe auch bilanziert.
Im Mausklick machst du doch bestimmt noch irgendwas anderes. Dann blendest du den Cursor beim Start aus und beim Beenden wieder ein. Das Control, bei dem er sichtbar sein soll, sollte beim Enter die alte Cursorform speichern, das Kreuz einstellen und den Cursor sichtbar schalten. Beim Leave entsprechend wieder ausschalten und den alten Cursor setzen.
Du verschränkst hier die Aufrufe der Methoden und bekommst daher Probleme.

Trotzdem frage ich mich, wozu du den Cursor bei einem Klick ausschalten willst.

Du kannst auch die BigInteger-Klasse von J# verwenden. Die ist bei jedem Framework dabei.

Zumindest im WinAPI war es so, dass der Cursor nur angezeigt wird, wenn genauso oft Show wie Hide aufgerufen wurde. Ich vermute, dass dieses Verhalten sich daher auch im Framework zeigt.

@herbivore: LOL

Ich würde beim Vergleich sämtliche alphanumerischen Zeichen entfernen. Auf ein solches Zeichen folgende Nullen werden auch entfernt. dadurch erhältst du die reine Nummer. Das einzige, was dann noch Probleme bereitet, sind gleiche Telefonnummern, die sich nur in der Angabe der Vorwahl unterscheiden (beispielsweise +49(030)12345678 zu 03012345678). Dieses Problem kann man ohne Liste der gültigen Vorwahlen kaum umgehen.

public string ConvertToComparablePhoneNumber( string PhoneNumber )
{
   StringBuilder Converted = new StringBuilder( PhoneNumber.Length );
   bool RemoveZero = true;
   for( int i = 0; i < PhoneNumber.Length; i++ )
   {
      if ( Char.IsDigit( PhoneNumber, i ) )
      {
         if (PhoneNumber[i] == '0')
         {
            if (!RemoveZero)
            {
               Converted.Add( PhoneNumber[i] );
            }
         }
         else
         {
            Converted.Add( PhoneNumber[i] );
            RemoveZero = false;
         }
      }
      else
      {
         RemoveZero = true;
      }
   }
   return Converted.ToString();
}

Ahhh, der fiese Weg-Editier-Teufel...

Da "Test" ein Wort ist, das auch einfach so im Text stehen kann, würde ich den Text von Hand splitten. Es wäre trotzdem empfehlenswert, ein anderes Trennzeichen zu verwenden.