Hallo dr4g0n76,

da mich das jetzt zu interessieren angefangen hat, habe ich heute mal angefangen eine native DLL zu implementieren (die ich dann aus .NET raus anspreche) mit der ich mich als Globaler Systemhook in's System reinhängen kann.

Mal schauen ob man damit was erreichen kann. Bis jetzt hab ich allerdings noch keinen (offiziell Dokumentierten) Hook gefunden der GDI Operationen abfangen kann.

Grüsse,
Egon

Hallo,

ich bin mir ziemlich sicher, dass dir da der Grafiktreiber mitspielen muss und die Funktionalität zum abfangen der entsprechenden Zeichenfunktionen ein muss bei OSX Treibern ist.

Anders kann ichs mir nicht vorstellen, da du im Prinzip jeden gezeichneten Pixel invertieren musst bevor er tatsächlich in den Bildschirmspeicher geschaufelt wird.

Grüsse,
Egon

/edit:

Eventuell möglich wäre vielleicht auch noch dass du dich in Systemcalls reinhängst (Hooking) und damit was zusammen bekommst.

Hallo,

JetBrains hat soeben die Version 3.1 seines vielleicht einigen bekannten Tools "ReSharper" veröffentlicht.

Link

Grüsse,
Egon

Hallo,

und noch was schönes von Microsoft. Trifft uns zwar nicht direkt, aber wer schon immer mal seine Nase in VB.NET stecken wollte:

Microsoft Visual Basic 2005 - Das Entwicklerbuch

... gibts jetzt als Download kostenlos.

Grüsse,
Egon

Hallo,

soweit ich im Source zu deiner benutzten Library gesehen habe, gibt es eine Decrypt ToBytes Methode welche als Eingabeparameter ein Byte-Array möchte, und dir das entschlüsselte ebenso als Byte-Array zurückgibt:

    /// <summary>
    /// Decrypts a base64-encoded cipher text value and generates a byte array
    /// of plain text data.
    /// </summary>
    /// <param name="cipherTextBytes">
    /// Byte array containing encrypted data.
    /// </param>
    /// <returns>
    /// Byte array containing decrypted value.
    /// </returns>
    public byte[] DecryptToBytes(byte[] cipherTextBytes)
    {
    .
    .
    .
    }

Grüsse,
Egon

/edit: Ach ja, es gibt auch eine überladung, welche als Eingabe einen String möchte und ein Byte-Array zurückliefert. Ich glaube die suchst du.

Hallo,

du wirst nicht herum kommen, die nativen Windows Funktionen zu bemühen. Microsoft hat dazu einen schönen Artikel im MSDN veröffentlicht:

http://msdn2.microsoft.com/en-us/library/bb384608.aspx

Ist zwar für C++ aber das sollte ja nicht das Problem sein.

Grüsse,
Egon

Hallo,

wie der Vorposter schon sagte, kannst Du für eine Form TopMost setzen. Das geht allerdings nur so lange wie Du dich am Desktop befindest. Sobald Du eine Vollbild DirectX oder OpenGL Applikation startest funktioniert diese Methode nicht mehr.

Ich denke Du willst es beispielsweise so machen wie Fraps, welches am oberen Bildschirmrand einen Framecounter anzeigt. Wie dass programmatisch genau aussieht weiss ich nicht da ich es noch nie gebraucht habe. Stichwörter hierfür sind: DirectX Overlay DLL Injection

(z.B. http://forums.xna.com/thread/27853.aspx)

Grüsse,
Egon

Byte + Byte = Integer. Und den willst du nem Byte zuweisen und da erwartet er natürlich nen expliziten Cast. Du musst also sowas

zahl = (byte)(zahl + Convert.ToByte(3));  
  

schreiben.

Warum dass so ist (ich finds persönlich etwas eigenartig von C# dass es keine reine Bytearithmetik gibt) kann man nachlesen unter:

http://blogs.msdn.com/ericgu/archive/2004/02/02/66345.aspx

Grüsse,
Egon

Hallo,

ich muss gleich vorweg sagen dass ich Log4Net noch nie benutzt habe. Aber ein kurzer blick in die Wundergoogle (cooles Wort, is mir grad eingefallen) verriet mir dass es anscheinend etwas damit zu tun hat, dass man in der app.config den vollständigen Namen, Version und Key der Log4Net.dll angeben muss:

<section name="log4net"
type="log4net.Config.Log4NetConfigurationSectionHandler,log4net,
Version=1.2.9.0, Culture=neutral, PublicKeyToken=b32731d11ce58905" />

Google: Could not find schema information log4net

Grüsse,
Egon

Hallo,

Microsoft gibt weitere Weihnachtsgeschenke in Form von e-Books heraus:* Introducing Microsoft ASP.NET Ajax Link

• Introducing Microsoft Silverlight Link

Viel spass beim lesen und Grüsse,
Egon

/edit: Gefunden in http://blogs.msdn.com/swiss_dpe_team/archive/2007/12/20/at-microsoft-press-is-christmas-time-get-e-books-on-silverlight-linq-and-asp-net-for-free.aspx

Bitoperatoren in C#

Üblicherweise arbeitet man während der Entwicklung mit C# mit dem Byte als kleinste logische Einheit. Ab und an ist es aber nötig auf einer noch kleineren Ebene arbeiten zu können, beispielsweise wenn man mittels P/Invoke auf nativen Code zugreift und vom diesen Daten zurückbekommt die Informationen auf Bitebene enthalten.

Genau hier kommen die Bit Operatoren ins Spiel. Untenstehend eine übersicht über diese:*OR *AND *NOT *XOR *Shifting

Der Artikel beinhaltet folgende Bereiche:*Übersicht und beschreibung der einzelnen Operatoren *Anwendungsfälle *Endianess von Systemen

OR

Der OR Operator verknüpft zwei Werte, bei denen das Ergebnis nur dann 1 ist wenn wenn einer der beiden (oder aber beide) Werte 1 ist. Andernfalls ist das Ergebnis 0. Grafische darstellung:

In C# ist der entsprechende Operator das Pipe ("|"). Codebeispiel:

using System;

public class Test
{
    public static void Main( string[] args )
    {
        byte b1 = 0xCD; // 0xCD = 205                   = 11001101
        byte b2 = 0x6A; // 0x6A = 106                   = 01101010

        byte erg1 = ( byte ) ( b1 | b2 ); // 0xEF = 239 = 11101111
        Console.Out.WriteLine( "{0:X2}", erg1 );

        int i1 = 37841; // 0x93D1                           = 00000000000000001001001111010001
        byte b3 = b2; // 0x6A = 106                         = 00000000000000000000000001101010
        int erg2 = ( int ) ( i1 | b3 ); // 0x93FB = 37883   = 00000000000000001001001111111011
        Console.Out.WriteLine( "{0:X}", erg2 );
    }
}

AND

Der AND Operator verknüpft zwei Werte, bei denen das Ergebnis dann 1 ist, wenn beide Eingangswerte 1 sind. Andernfalls ist das Ergebnis 0. Grafische darstellung:

In C# ist der entsprechende Operator das Ampersand ("&"). Codebeispiel:

using System;

public class Test
{
    public static void Main( string[] args )
    {
        byte b1 = 0xCD; // 0xCD = 205                   = 11001101
        byte b2 = 0x6A; // 0x6A = 106                   = 01101010

        byte erg1 = ( byte ) ( b1 & b2 ); // 0x48 = 72  = 01001000
        Console.Out.WriteLine( "{0:X2}", erg1 );

        int i1 = 37841; // 0x93D1                           = 00000000000000001001001111010001
        byte b3 = b2; // 0x6A = 106                         = 00000000000000000000000001101010
        int erg2 = ( int ) ( i1 & b3 ); // 0x40 = 64        = 00000000000000000000000001000000
        Console.Out.WriteLine( "{0:X}", erg2 );
    }
}

NOT

Der NOT Bitoperator ist der einzige, welcher nur den Quellwert für seine Arbeit benötigt (Unärer Operator). Er "dreht" im Prinzip alle Bits genau auf den Gegenwert um (aus 0 wird 1 und umgekehrt). Grafische Darstellung:

In C# ist der entsprechende Operator die Tilde ("~"). Codebeispiel:

using System;

public class Test
{
    public static void Main( string[] args )
    {
        byte b1 = 0xCD; // 0xCD = 205                   = 11001101
        byte b2 = 0x6A; // 0x6A = 106                   = 01101010

        Console.Out.WriteLine( "{0:X8}", b1 );  // 0x000000CD = 00000000000000000000000011001101
        Console.Out.WriteLine( "{0:X8}", b2 );  // 0x0000006A = 00000000000000000000000001101010

        Console.Out.WriteLine( "{0:X8}", ~b1 ); // 0xFFFFFF32 = 11111111111111111111111100110010
        Console.Out.WriteLine( "{0:X8}", ~b2 ); // 0xFFFFFF95 = 11111111111111111111111110010101
    }
}

Aus diesem Beispiel heraus erfährt man wieder ein kleines Detail:*Bitoperationen werden immer als Int32 (oder Int64; je nachdem wie gross der Ausgangsdatentyp ist) ausgeführt, dementsprechend ist auch das Ergebnis der Operation wie man an der Ausgabe des obigen Codes sehen kann.

Manch einer mag sich jetzt vielleicht fragen: Ist der NOT Bitoperator wirklich der einzige Unäre Bitoperator? (Wie oben ausgesagt)
Darüber lässt sich nun streiten. So wie die Tilde das Einerkomplement berechnet, so berechnet das Minus das Zweierkomplement. Es ist allerdings die Frage ob man das Minus als Bitoperation oder als Arithmetische Operation ansieht. Ich würde das Minus als Zwitter zwischen diesen beiden sehen.

XOR

Was aber nun, wenn man zwei Werte so miteinander verknüpfen möchte, dass das Ergebnis nur dann 1 ist wenn entweder die Quelle oder das Pattern 1 ist, nicht aber beider oder gar keines? Grafisch dargestellt also:

In der boolschen Algebra gibt es kein Exklusives Oder (XOR) man muss sich daher folgenden Konstruktes bemühen:

ERGEBNIS = NOT(( A AND B ) OR (( NOT A ) AND ( NOT B )))

In C# geschrieben sieht dass dan so aus:

using System;

public class Test
{
    public static void Main( string[] args )
    {
        byte b1 = 0xCD; // 0xCD = 205            = 11001101
        byte b2 = 0x6A; // 0x6A = 106            = 01101010

        byte b3 = ( byte ) ~(( b1 & b2 ) | (( ~b1 ) & ( ~b2 )));
        Console.Out.WriteLine( "{0:X}", b3 );
    }
}

Wie man sehen kann, ein relativ umständlicher Weg. Als Lösung springt hier der XOR Operator, welcher in C# durch das Karet ("^") dargestellt wird ein. Mit diesem vereinfacht sich das ganze auf:

using System;

public class Test
{
    public static void Main( string[] args )
    {
        byte b1 = 0xCD; // 0xCD = 205            = 11001101
        byte b2 = 0x6A; // 0x6A = 106            = 01101010

        byte b3 = ( byte ) ( b1 ^ b2 );
        Console.Out.WriteLine( "{0:X}", b3 );
    }
}

Untenstehend noch ein komplettes Codebeispiel, welches auch noch einige andere Dinge zeigt die danach gleich besprochen werden:

using System;

public class Test
{
    public static void Main( string[] args )
    {
        byte b1 = 0xCD; // 0xCD = 205                   = 11001101
        byte b2 = 0x6A; // 0x6A = 106                   = 01101010

        byte erg1 = ( byte ) ( b1 ^ b2 ); // 0xA7 = 167 = 10100111
        int  erg2 = ( b1 ^ b2 );          // 0xA7 = 167 = 000000000000000000000010100111
        Console.Out.WriteLine( "{0:X2}", erg1 );

        int i1 = 37841; // 0x93D1                           = 00000000000000001001001111010001
        byte b3 = b2; // 0x6A = 106                         = 00000000000000000000000001101010
        int erg3 = ( int ) ( i1 ^ b3 ); // 0x93BB = 37819   = 00000000000000001001001110111011
        Console.Out.WriteLine( "{0:X}", erg3 );
    }
}

Im obigen Beispiel kann man einige grundlegende Dinge von Bitoperationen sehen:*Es ist nicht zwingend notwendig dass die beiden zu verknüpfenden Daten vom selben Typ sind. Wenn man wie oben beispielsweise einen int (32 Bit breit; Wird zu System.Int32 im CIL) mit einem byte (8 Bit breit; Wird zu System.Byte im CIL) verknüpft, so werden die nicht benutzten stellen mit 0 aufgefüllt. *Das Ergebnis einer Bitoperation ist immer ein int. Man muss also bei zuweisungen casten, sofern kein Operatorüberladung für den entsprechenden, impliziten cast existiert.

Vielleicht fragt sich der eine oder andere nun, warum die Repräsentation der Bytes so ist wie sie ist und nicht andersrum: Das hat etwas mit der sg. Endianess eines Systems zu tun. Weiter unten findet sich ein entsprechender Teil welcher erklärt was dies ist und warum es für uns wichtig ist.

SHIFTING

Beim Shifting wird die Bitreihenfolge des Eingangswerts entweder nach links ("<<") oder nach rechts (">>") um einen angegebenen Wert verschoben. Die resultierende Lücke wird dabei mit 0 aufgefüllt. Grafische darstellung:

Wenn man also nun z.b. einen Shift um 8 nach rechts durchführt so ist bei einem Byte das Ergebnis immer 0. Analog dazu wenn der Shift nach links durchgeführt wurde, da dann an der rechten Seite eine 0 eingefügt wird.

In C# ist der Operator für das Shifting das doppelte Größer- oder Kleinerzeichen (">>", "<<") gefolgt von einer Nummer die die Anzahl des Shifts festlegt. Codebeispiel:

using System;

public class Test
{
    public static void Main( string[] args )
    {
        byte b1 = 0xCD; // 0xCD = 205       = 11001101
        byte b2, b3, b4, b5;

        b2 = ( byte ) ( b1 << 1 );  // 0x9A = 10011010
        b3 = ( byte ) ( b1 << 2 );  // 0x34 = 00110100
        b4 = ( byte ) ( b1 << 3 );  // 0x68 = 01101000
        b5 = ( byte ) ( b1 << 8 );  // 0x00 = 00000000

        Console.Out.WriteLine( "{0:X2} {1:X2} {2:X2} {3:X2}", b2, b3, b4, b5 );

        b2 = ( byte ) ( b1 >> 1 ); // 0x66 = 01100110
        b3 = ( byte ) ( b1 >> 2 ); // 0x33 = 00110011
        b4 = ( byte ) ( b1 >> 3 ); // 0x19 = 00011001
        b5 = ( byte ) ( b1 >> 8 ); // 0x00 = 00000000

        Console.Out.WriteLine( "{0:X2} {1:X2} {2:X2} {3:X2}", b2, b3, b4, b5 );
    }
}

Das Shifting kann auf jeden Werttyp angewandt werden, welcher Ganzzahlen speichert. Strukturen (welche ja auch Wertetypen sind) und Fließkommazahlen (Decimal, Float, Double) können nicht geshiftet werden. Der Grund liegt darin:*Bei Strukturen würde es grundsätzlich keinen Sinn machen. *Fließkommazahlen sind auf Bitebene im IEE754 Format gespeichert. Ein Shifting würde zu sinnlosen Werten führen, dementsprechend wird es unterbunden.

Anwendungsbeispiele

Für was kann man das ganze nun denn gebrauchen? Beispielsweise kommt es manchmal vor, dass eine native Applikation welche mittels P/Invoke aufgerufen wird ein sg. "Bit-Feld" zurückgibt, welches die einzelnen Bits als True und False Flags benutzt (da es unter C/C++ mittels eines Sprachkonstruktes leicht möglich ist eine Stuktur zu definieren deren einzelne Felder Bitpositionen darstellen). Stellen wir uns folgendes Bitfeld vor:

Diese bekommen wir von der nativen Methode zurückgeliefert und wollen nun feststellen ob "Flag 1" gesetzt ist oder nicht. Dazu können wir beispielsweise folgendes Konstrukt verwenden:

using System;

public class Test
{
    private static byte FLAG_1 = 0x04; // 00000100
    private static byte FLAG_3 = 0x01; // 00000001

    public static void Main( string[] args )
    {
        byte bitfield = 0x05; // 00000101

        if(( bitfield & FLAG_1 ) == FLAG_1 )
            Console.Out.WriteLine( "Flag 1 gesetzt!" );

        if(( bitfield & ( FLAG_1 | FLAG_3 )) == ( FLAG_1 | FLAG_3 ))
            Console.Out.WriteLine( "Flag 1 und 3 sind gesetzt!" );
    }
}

Auch wenn der Code auf den ersten Blick etwas verwirrend wirkt, so werden wir die Logik dahinter doch gleich feststellen wenn wir diesen im Kopf durchgehen und die einzelnen Operationen durchrechnen. Wenn wir einer nativen Methode ein Bitfeld übergeben müssen, können wir auch dies mit unseren Bit-Operationen erstellen. Wir wollen beispielsweise ein Bitfeld übergeben bei dem "Flag 1" und "Flag 2" gesetzt sind:

using System;

public class Test
{
    private static byte FLAG_1 = 0x04; // 00000100
    private static byte FLAG_2 = 0x01; // 00000001

    public static void Main( string[] args )
    {
        byte bitfield = 0x00;

        bitfield |= FLAG_1;
        bitfield |= FLAG_2;

        Console.Out.WriteLine( "{0:X2}", bitfield );

        // Alternativ: Beide gleichzeitig setzen
        bitfield = 0x00;
        bitfield |= ( byte ) ( FLAG_1 | FLAG_2 );
        Console.Out.WriteLine( "{0:X2}", bitfield );
    }
}

Ausser dem oben genannten beispiel gibt es noch einige andere Bereich der Anwendung. So kann man mittels eines Bitshiftings relativ schnell multiplizieren, wenn der Multiplikator ein Wert aus dem Bereich 2^n ist. Beispiel:

using System;

public class Test
{
    public static void Main( string[] args )
    {
        int val = 7384;

        for( int i = 1; i < sizeof( int ) * 8; i ++ )
        {
            Console.Out.WriteLine( "{0} x {1} = {2}",
                val,
                1 << i,
                val << i );
        }
    }
}

Ob das ganze nun auch wirklich schneller ist kann heutzutage nicht mehr klar beantwortet werden. In C/C++ Zeiten und mit noch nicht so ausgereiften Compilern konnte das ganze klar mit einem Ja beantwortet werden, da ein SHL (Shift Left für Multiplikation) bzw. ein SHR (Shift Right für Division) schneller ausgeführt wurde als ein MUL oder DIV. Heutige Compiler optimieren extremst und es ist nicht auszuschliessen dass eine Multiplikation oder Division bei der der Multiplikator oder Divisor im Bereich von 2^n liegt nicht auf diese Weise umgesetzt wird.

Interessierte können sich mittels Bitoperatoren auch die Struktur von Werttypen (alle welche Zahlen speichern, also keine Strukturen) anzeigen lassen:

using System;

public class Test
{
    public static void Main( string[] args )
    {
        int val = -8;

        DumpValue( val );
    }

    private static void DumpValue( int val )
    {
        int bits = System.Runtime.InteropServices.Marshal.SizeOf( val ) * 8;

        Console.Out.WriteLine( "Type      : {0}", val.GetType().ToString() );
        Console.Out.WriteLine( "Bit width : {0}", bits );

        uint bitTest = 0x80000000;
        for( int index = 0; index < bits; index ++ )
        {
            if(( val & bitTest ) == bitTest )
                Console.Out.Write( "1" );
            else
                Console.Out.Write( "0" );

            bitTest = bitTest >> 1;
        }
        Console.Out.WriteLine();
    }
}

Endianess von Systemen

Auch wenn es nicht direkt etwas mit Bitoperationen zu tun hat, so soll nun doch auch noch eine Kleinigkeit aus den tiefen des Systems beleuchtet werden: Die Endianess

Diese sagt aus, in welcher Binärform ein Wert dargestellt wird: Das niederwertigste Byte zuerst (Little Endian) oder das höchstwertigste Byte zuerst (Big Endian). Eine kleine Grafik veranschaulicht dies:

Vermutlich wird uns Big Endian vertrauter sein, da dies auch unserem natürlichem Umgang mit Zahlen entspricht. Ein Problem in welches wir aber tapsen können ist, wenn wir Daten aus einem System erhalten welches nicht unserer Endianess entspricht. Die .NET CLR verwendet standardmässig immer Little Endian auf allen Platformen (ausgenommen dem XNA Framework auf der XBox360, da haben wir Big Endian...).

Es ist zu beachten, dass es sich bei der Endianess nur um die Position der Bytes innerhalb eines Datenwerts handelt, die Position der einzelnen Bits innerhalb des Bytes sind bei beiden gleich:

Wenn wir also beispielsweise einen Int32 als Binärwert in ein File schreiben lassen und dann im XNA Framework auch wieder Binär auslesen und in einen Int32 konvertieren so erhalten wir einen falschen Wert für diesen (Falsch eigentlich nicht, nur passen eben die Bytepositionen nicht). Wir müssen uns daher einen entsprechenden Konverter schreiben, damit wir diese Bytes wieder in Ihre richtige Position rücken. Eine Hilfsklasse dafür ist "System.BitConverter", welcher ein byte Array entgegennimmt und dieses in einen anderen Werttype verwandelt. Der umgekehrte Weg (von Werttypen nach Byte Array) geht natürlich mit der Klasse ebenso.

Am schluss möchte ich noch folgenden Personen für das Korrekturlesen und das geben von Anregungen danken (in alphabetischer Reihenfolge):*hauptmann *herbivore *norman_timo *Peter Bucher *Programmierhans *SimonKnight6600 *svenson *talla

strings vergleicht man am besten mit equal() oder CompareTo(), da du mit == und != speicheradressen vergleichst.

Bei String nicht, da hier die Operatoren != und == überladen sind.

Grüsse,
Egon

Hallo,

MonoDevelop wurde in der Beta3 veröffentlicht. Es wurden wie immer Kiloweise Bugs beseitigt und ein Feature eingefügt welches ich schon so lange vermisse:

Das ordentliche minimieren von Toolboxfenstern. Siehe Screenshot.

MonoDevelop Projektseite

Grüsse,
Egon

Hallo,

http://www.sqlite.org/
http://www.python.org/

... oder was wolltest du wissen? 😉

Grüsse,
Egon

Hallo,

ich tippe mal drauf dass in der Methode InitializeComponent() (Welche vom VS generiert wird) irgendwo der Hund begraben liegt. Poste den Code von der Methode mal.

Grüsse,
Egon

Hallo,

ich kann dir nur das Buch "Programming Windows Forms and Custom Controls" aus dem APress Verlag empfehlen. Ist zwar nicht rein über GDI+ sondern über Windows Forms programmierung generell, hat aber einen grossen Abschnitt über GDI+, der eigentlich alle wesentlichen Thematiken abhandelt.

Link

Grüsse,
Egon

Hallo,

grundsätzlich sollte es (theoretisch) schon möglich sein Mono irgendwann mal am iPhone zum laufen zu kriegen.

Für das stationäre OSX gibt es eine Mono Version, ebenso ist die Unterstützung für die CPU des iPhones (ARM) auch schon im JIT implementiert. Technisch steht einem Port also nichts im wege ... ausser Apple selbst.

Eine offizielle Version wird es meines erachtens allerdings nicht geben, da Apple ja ziemliche Restriktionen auferlegt was Homebrew Software am iPhone angeht und beinahe jeden Hack mit einem Firmwareupgrade kontert.

Grüsse,
Egon

Hallo,

ich habe gerade eine interessante Seite gefunden die ich euch nicht vorenthalten möchte:

http://www.it-recht-kanzlei.de/index.php?id=eBooks

es handelt sich dabei um eine Sammlung von kurzen e-Books welche diverse Rechtssituationen im Internet beleuchten. Geschrieben wurde das ganze von einer Anwaltskanzlei welche sich mit der Thematik beschäftigt, die dargelegten Informationen dürften also mit ziemlicher Sicherheit dem aktuellen Recht entsprechen.

Viel Spass beim lesen!

Grüsse,
Egon

Hallo,

die neuen PowerToys für das .NET CF 3.5 wurden veröffentlicht:

Link

Grüsse,
Egon

Ja. Du kannst aber auch mit VS 2008 .NET 2.0 Programme schreiben.

Kann man dann die Programme(.net 2.0), die mit VS 2008 erstellt wurden, mit VS 2005 öffnen?

Nein das geht nicht, da sich das Fileformat der Solution geändert hat.

Grüsse,
Egon

Hallo,

wenn du etwas nach dem einlegen eines Mediums automatisch von diesem ausführen lassen willst so erstelle dir eine autorun.inf datei (Link)

Es muss aber Autorun aktiv sein (standardmässig ist es aktiv).

Grüsse,
Egon

Hallo,

die Informationen die dir Top, Ps und ähnliche Tools anzeigen werden aus informationen im /proc Filesystem gelesen.

So zeigt /proc/meminfo den aktuellen Speicherverbrauch des Systems. Du könntest Dir einfach mal die sourcen zu obigen Tools ansehen und die Werte auf die gleiche Weise direkt auslesen. Somit entfällt die abhängigkeit zu externen Tools.

Grüsse,
Egon

Hallo,

wenns was kostenpflichtiges sein darf: NetOp von Danware. Haben wir in der Firma als Remoteassistance Software im einsatz und funktioniert auch mit Vista bestens.

Grüsse,
Egon

Original von Feroc
die guten alten Zeiten mit meinem Amiga 500... als ich noch die ersten PCler ausgelacht hab, weil sie in ihrem komischen DOS rumtippen, während ich eine grafische Oberfläche hatte. 🙂

Das kenn ich nur zu gut. Doch leider änderte sich das Bild ein paar Jahre später, da wurde ich dann ausgelacht - hatte bis 1996 nen Amiga (3000). Auf Windows95 respektive MacOS war ich damals schon etwas neidisch muss ich zugeben.

Grüsse,
Egon

Hallo,

da sich bis jetzt noch niemand gemeldet hat nehme ich mal an, dass Du etwas genauer formulieren sollst um was es geht.

Ich für meinen Teil habe nicht verstanden was Du eigentlich machen möchtest 😉

Grüsse,
Egon

Hallo,

ich habe so etwas ähnliches vor einigen Jahren für die Erkennung von Message-Stürmen in unserem Alarmserver (Alarmierung für Bereitschaft) implementiert. Damals habe ich auf den Jaro-Winkler algorithmus zurückgegriffen der einen Wert zwischen 0 und 1 liefert (0=Keine übereinstimmung, 1=Volle übereinstimmung).

Die genaue Vorgehensweise des Algorithmusses habe ich mir nicht angesehen, aber er tut in dieser Form seit Jahren bei uns seinen Dienst und hat uns noch nie im Stich gelassen.

Als Library verwende ich dafür SimMetrics: http://www.dcs.shef.ac.uk/~sam/simmetrics.html

Grüsse,
Egon

Hallo,

lang, lang ists her. Und ich hab ihn immer noch: Den Amstrad CPC6128 welchen ich im Jahre 1987 von meinem Vater bekommen habe. Mit sagenhaften 128KB RAM, einem 3" (ja 3" nicht 3.5") Diskettenlaufwerk einem Grünmonitor und CP/M als Betriebssystem.

Das war auch das Gerät auf dem ich den ersten Kontakt zum Programmieren hatte. Zuerst mittels des eingebauten BASIC Interpreters, später - kurz bevor ich dann auf einen Amiga 500 umgestiegen bin - habe ich dann meine ersten Schritte in Z80 Assembler gewagt. War schon eine spassige Geschichte damals.

Von dem Gerät war ich damals so angetan (und bin es auch heute noch) dass ich ihn immer wieder mal anwerfe um zu sehen ob das gute Ding eh noch seinen Dienst verrichtet.

Für alle die Ihn nicht kennen und noch kennenlernen wollen: http://de.wikipedia.org/wiki/Schneider_CPC

Grüsse,
Egon

Hallo,

wenn Du alles ohne externe Abhängigkeiten machen willst, wirst du nicht rum kommen dich mit dem ISO9660 Filesystem zu beschäftigen - und anschliessend die entsprechenden Strukturen selbst zu erstellen.

http://en.wikipedia.org/wiki/ISO_9660

Von dort aus gibts dann Links zur Spezifikation.

Grüsse,
Egon

Hallo Programmierhans,

ich glaube unter http://www.codeproject.com/KB/macros/versioningcontrolledbuild.aspx ist alles beschrieben was du dafür wissen musst. (Hoffe ich zumindest, hab den Artikel nur kurz überflogen da er doch etwas länger ist 😉

Grüsse,
Egon

Hallo dr4g0n76,

ich hab mich vor einiger Zeit mal mit dem Fileformat von Windows Executables (PE) befasst. Damals habe ich so etwas ähnliches versucht, herausgekommen ist folgendes:

using System;
using System.IO;
using System.Runtime.InteropServices;

namespace egrath.tools
{
    public class CheckNet
    {
        private static long OFFSET_PEHEADEROFFSET = 0x0000003C;

        private FileStream m_Stream;
        private int m_PeHeaderOffset;
        private int m_PeClrHeaderOffset;
        private PeType m_Type;

        public static void Main( string[] args )
        {
            if( args.Length < 1 )
            {
                Console.Out.WriteLine( "please specify a file" );
                return;
            }

            new CheckNet( args[0] );
        }

        public CheckNet( string fileName )
        {
            m_Stream = new FileStream( fileName, FileMode.Open, FileAccess.Read, FileShare.Read );
            if( ! IsValidPeFile() )
            {
                Console.Out.WriteLine( "Not a valid PE File" );
                return;
            }
            else
            {
                Console.Out.WriteLine( "Good, we have a PE File here" );
            }

            GetPeType();
            Console.Out.WriteLine( "PE Type is: {0}", m_Type.ToString() );

            if( IsClrExecutable() )
                Console.Out.WriteLine( "Is executable by the CLR" );
            else
                Console.Out.WriteLine( "Not executable by the CLR" );

            m_Stream.Close();
        }

        private bool IsClrExecutable()
        {
            m_Stream.Seek((long) m_PeClrHeaderOffset, SeekOrigin.Begin );
            byte[] clrhdr = new byte[8];
            m_Stream.Read( clrhdr, 0, 8 );
            foreach( byte b in clrhdr )
            {
                if( b != 0x00 )
                    return true;
            }

            return false;
        }

        private void GetPeType()
        {
            m_Stream.Seek(( long ) m_PeHeaderOffset +25, SeekOrigin.Begin );
            if( m_Stream.ReadByte() == 0x01 ) // PE; PE+ has 0x02
            {
                m_Type = PeType.PE;
                m_PeClrHeaderOffset = m_PeHeaderOffset + 25 + 208;
            }
            else
            {
                m_Type = PeType.PEPlus;
                m_PeClrHeaderOffset = m_PeHeaderOffset + 25 + 224;
            }
        }

        private bool IsValidPeFile()
        {
            GetPeHeaderOffset();
            m_Stream.Seek(( long ) m_PeHeaderOffset, SeekOrigin.Begin );
            byte[] hdr = new byte[4];
            m_Stream.Read( hdr, 0, 4 );
            if( hdr[0] != 0x50 || hdr[1] != 0x45 || hdr[2] != 0x00 || hdr[3] != 0x00 )
                return false;
            else
                return true;
        }

        private void GetPeHeaderOffset()
        {
            m_Stream.Seek( OFFSET_PEHEADEROFFSET, SeekOrigin.Begin );
            byte[] offset = new byte[2];
            m_Stream.Read( offset, 0, 2 );

            Int16Conv cnv = new Int16Conv( offset );
            m_PeHeaderOffset = cnv.Value;
        }

        [StructLayout( LayoutKind.Explicit )]
        private struct Int16Conv
        {
            public Int16Conv( byte[] arr )
            {
                Value = 0;
                Byte0 = arr[0];
                Byte1 = arr[1];
            }

            [FieldOffset( 0 )] public Int16 Value;
            [FieldOffset( 0 )] public byte Byte0;
            [FieldOffset( 1 )] public byte Byte1;
        }

        private enum PeType
        {
            PE,
            PEPlus
        }
    }
}

Habe ich mit relativ vielen nativen und CLR Executables getestet und ist bis jetzt immer recht gelegen.

Vielleicht hilft es dir ja was.

Grüsse,
Egon

Hallo,

die zuweisung "auslesen = NameLine" und das anschliessende "NameLine = auslesen" ist redundant, da du ja in NameLine sowieso schon die aktuell gelesene Zeile drinnen hast.

Wenn Du in deinem File also mehrere Zeilen hast, dann steht in NameLine immer die letzte gelesene Zeile. Hat dein File am Ende einen Zeilenumbruch, so enthält NameLine eine leere Zeile.

Grüsse,
Egon

Hallo,

so etwas ist normalerweise nur über die native Win32 API durchzuführen. Eine möglichkeit wäre, an den entsprechenden Handle des Controls die WM_GETTEXT Message zu senden.

Habe ich allerdings noch nicht ausprobiert, aber mit folgenden Stichworten müsstest Du schon weiter kommen:* SendMessage

• WM_GETTEXT
• EnumWindows und EnumWindowsProc

Spy++ aus der Visual Studio installation ist auch dein Freund.

Grüsse,
Egon

Original von norman_timo
Und jetzt: HULDIGT MIR 😁

Du oh grosser norman_timo, chuck norris der C# entwicklung, wir huldigen dir!

Hallo,

eine neue Version (4.12) ist fertig:* Unterstützung für das Dekompilieren von Interfaces, Feldern, Strukturen und Enum's

• Unterstützung für Inner Classes und Inner Structs
• Anzeige der Methoden Signatur, Classen/Interface/Struct/Enum Header in einer Titelzeile

Grüsse,
Egon

/edit: Nochmal ne neue Version für heute. Neu hinzugekommen:* Resourcen anzeig- und extrahierbar

Hallo,

ich habe mich noch nie intensiver mit der CRC32 Funktion beschäftigt, aber bei mir kommt mit einer Bytefolge von 0x010100000000 eine Prüfsumme von 0xD4326D90 heraus. Das gleiche ergebnis wie mit der Referenzimplementierung auf wikipedia. Habe auch noch etliche andere Prüfsummen für andere Eingabedaten versucht und die Ergebnisse stimmen überein....

Eventuell passt am Referenzcode was nicht?

Grüsse,
Egon

... und der Source. Version vom 4.12.2007

Hallo,

gerade eben habe ich den ersten Prototypen meines CIL Disassemblers fertiggestellt. Es gehen noch nicht alle Dinge (z.b. werden Enum's und Struct's noch als Klassen ausgewiesen und die Initialisierung von Feldern wird noch nicht angezeigt). Aber er zeigt schon mal wohin sich das Projekt bewegen wird.

Das ganze ist für Mono (Mono.Cecil und GTK#) gedacht, läuft aber bei entsprechender Installation der GTK# Libraries auch unter Windows.

Grüsse,
Egon

Hallo,

falls es der OP noch nicht hinbekommen hat, hier eine Conversion des auf Wikipedia zu findenden Algorithmusses für die Berechnung eines CRC32 für ein Byte-Array:

using System;

namespace egrath.test.crc32
{
	public class Crc32Test
	{
		private static UInt32 CalculateCrc32( byte[] data )
		{
			UInt32 polynom = 0x04C11DB7;
			UInt32 crc32 = 0;

			for( int index = 0; index < data.Length; index ++ )
			{
				int hbit = 0;
	
				hbit = (( crc32 & 0x80000000 ) == 0x80000000 ) ? 1 : 0;
				if( hbit != data[index] )
				{
					crc32 = ( crc32 << 1 ) ^ polynom;
				}
				else
				{
					crc32 = crc32 << 1;
				}
			}

			return crc32;
		}

		public static void Main( string[] args )
		{
			Console.Out.WriteLine( "0x{0:X}", CalculateCrc32( new byte[] { 1, 0, 0, 0, 1, 1, 0, 0 } ));
		}
	}
}

Grüsse,
Egon

Original von Peter Bucher
Hallo Egon

Original von egrath
btw. wer wissen möchte was noch kommt: Einfach mal schauen wie das Vorschaubild des Buches heisst - und dann probieren 😉
Öhm, wie? 🙂

Gruss Peter

Hallo Peter,

das Bild für das Buch von heute (2.12) heisst:

http://entwickler-press.de/ep/img/cover/02.jpg

Wenn Du nun anstelle von 02 03-24 eingibts, siehst Du die kommenden Titel.

Grüsse,
Egon

Hallo,

btw. wer wissen möchte was noch kommt: Einfach mal schauen wie das Vorschaubild des Buches heisst - und dann probieren 😉

Grüsse,
Egon

Hallo,

auf entwickler-press.de bekommt man zwischen dem 1.12 und 24.12 jeden Tag ein aktuelles e-Book geschenkt.

Geht nur mit dem Internet Explorer.

Viel spass mit den Büchern 😉

Grüsse,Egon

Original von Dizzy.w3
Wie kann ich was löschen / abändern (brauche beides ...)

Hallo,

indem Du die originaldatei einliest, schliesst und inklusive der änderungen (dazu gehört beim löschen dann einfach das auslassen) wieder in das originalfile reinschreibst.

Ein ganz einfaches (und nicht sehr performantes) Beispiel für eine CSV Datei:

1.) Das ganze File in einen Memory Stream lesen und die originaldatei schliessen
2.) Das File von (1) schreibend öffnen.
3.) Vom Memory Stream Zeile für Zeile lesen und in das File schreiben. Dabei allerdings die nicht gewünschten Zeilen auslassen.

Grüsse,
Egon

Hallo,

hbit = (( crc32 & 0x80000000 ) == crc32 ) ? 1 : 0;

Grüsse,
Egon

Hallo,

das kannst Du nicht verhindern, sondern nur erschweren. Stichwort "Obfuscation".

Grüsse,
Egon

Hallo,

welches Betriebssystem benutzt Du (unter Windows Vista gibts Probleme mit dem Snippet)? Verwendest Du irgendeine Theming Engine (z.B. WindowBlinds)?

Grüsse,
Egon

Hallo,

ich habe vor einiger Zeit so etwas mal für Java geschrieben - ein umwurschteln auf C# sollte aber kein Problem sein.

Mit dem Ding kannst Du mathematische Ausdrücke (beinahe) beliebiger Komplexität lösen:

http://www.geocities.com/egon_rath/java/expressionsolver.html

Grüsse,
Egon

Hallo dr4g0n76,

zur Zeit befindet sich das ganze in einem sehr frühren Stadium. Es ist zur Zeit möglich Assemblies zu laden und deren Struktur in einem TreeView darzustellen. Durch selektieren eines Nodes wird der entsprechende IL Code für das Element (Field, Type, Method, Constructor, ...) dargestellt (allerdings nicht wie beim ILDasm in einem eigenen, sondern wie beim Reflector).

Zur disassemblierung verwende ich allerdings nichts selbstgestricktes, sondern die Mono.Cecil Library, da diese relativ ausgereift ist und auch in vielen anderen Mono Projekten (z.b. Debugger, Linker, etc.) verwendet wird - läuft natürlich auch unter Windows, da der Entwickler der Library alles nur rein managed ohne native Interop gemacht hat.

Die Idee mit der Ausgabe der Methode finde ich grundsätzlich nicht schlecht, damit kann man im Fehlerfall sicherlich einiges analysieren. Für den versierten Benutzer einer mit einer solchen Methodik ausgestatteten Applikation sicherlich sinnvoll.

Grüsse,
Egon

Hallo dr4g0n76,

als ich deinen Beitrag las, musste ich schmunzeln. Arbeite momentan genau an einem gleichen Projekt 😉

Bei mir soll es in späterer Folge ein Clone des Microsoft eigenen ILDasm's für das Mono Projekt werden, da ein entsprechendes GUI Tool bei denen noch fehlt.

Grüsse,
Egon

Hallo Herbivore,

danke für den Link, ich werd mir das mal durchschauen und eventuell daraus was basteln.

Zur zeit hab ich es jetzt so gelöst, dass ich mittels einer regulären For-Schleife iteriere und mittels der Inkrementor-Variable mein Problem löse.

Grüsse,
Egon