Laden...
Avatar #avatar-2376.jpg
Benutzerbeschreibung
Mag unkonventionelle Lösungen, am liebsten wenn sie garnicht gehen dürften.

Forenbeiträge von Floste Ingesamt 1.130 Beiträge

20.10.2009 - 15:36 Uhr

1.Wenn man ein Programm mit dem Debugger startet, wird es mit anderen Benutzerrechten ausgeführt, als normale Programme. Deshalb funktioniert der Code nicht, solange man mit dem Debugger startet. Uac kann ebenfalls ein Problem darstellen, sofern das Programm mit geringeren Rechten als andere des selben Benutzers gestartet wird.

  1. Die Bootstrapperdll ist nicht für x64 geeignet. Deshalb muss man seine c#-Exe für x86 compilieren. Die direkte dll-injektion von x86 in x64-Prozesse (und umgekehrt) scheitert. Globale hooks funktionieren auf x64 aus irgebndeinem Grund nicht. Wahrscheinlich wurden sie aus Sicherheitsgründen vom m$ deaktiviert..

Wenn jemand Inetresse an einer x64-dll hat, kann er sich bei mir melden. Es muss aber um beide Systeme zu unterstützen ein Prozess pro System gestartet werden. Also müssten ein Prozess für x64 und einer für x86 parallel laufen.

  1. Ich habe die Runtimeversion des 2.0er Frameworks hardcoded einprogrammiert. Injezierte dlls dürfen also nur die Frameworkversionen von 2.0 bis 3.x verwenden, da diese auf der selben Runtimeversion beruhen. Um das zu umgehen kann man selbstverständlich die Runtimeversion im Code ändern und die c++ -Dll neu Compilieren.

  2. Nicht die alte ver verwenden

  3. Bestimmte Programme mögen es nicht besonders, wenn man dlls injeziert: In seltensten Fällen Av-Software b.z.w firewalls (Das sie anschlagen ist aber die absolute Ausnahme, solange man nur Programme des lokalen Benutzers und keine Systemdienste manipuliert) und bestimmte Onlinespiele (Insbesondere gewisse MMORPGS) haben was dagegen.

18.10.2009 - 21:17 Uhr

Ich würde es folgendermaßen machen: Rechts ein multipage Control. Den treeview manuell füllen und jedem Node als tag eine page zuweisen.
Dann noch treeview.SelectionChanged abbonieren und darin die aktuelle seite des multipage controls auf den tag des treeviews setzen (casten).

Quelle des Controls:http://www.codeproject.com/KB/miscctrl/multipane_control.aspx
(Verbreitung ist gestattet, sofern man es nicht unter gpl o.ä stellt und die Copyrighthinweise belässt.)

18.10.2009 - 11:28 Uhr

es ist eine native dll das geht nicht!
Mach doch einfach ne resource und erstell beim Start die Dll, sofern die nochnicht vorhanden ist.

Ansonsten gibts noch Loading a DLL from memory, das du allerdings nach c# übersetzen müsstest. Ich traue dir das aber ehrlichgesagt nicht zu.

17.10.2009 - 10:29 Uhr

Ich würde generell selber mit gdi oder directx auf ein eigenes Control zeichnen. nichts anderes macht die Picturebox ja schließlich auch intern. Dann erübrigt sich auch das Problem mitm anderen Bild.
Man kann an gdi auch direkt eine Matrix übergeben.

16.10.2009 - 15:47 Uhr

Möglichkeit1: Speichere die aktuelle Rotation und rotiere die neue translation, bevor du sie dazuaddierst.
Möglichkeit2: Lass das ganze von ner Matrixklasse erledigen. Das ist zwar eigentlich bequemer und übersichtlicher, man muss sich aber etwas auskennen.

15.10.2009 - 18:34 Uhr

Ich kenne mich etwas mit dirctx aus, aber ned so mit opengl und dein code ist außerdem noch von mir hehe 😁

color4 nimmt in directx wetrte von 0 bis 1.

Also vermute ich mal so:

Color4 TeperaturZuFarbe(double data, double min, double max)
        {
            data = clip(data, min, max);

            double middle = (min + max) / 2;
            if (data > middle)
            {
                float cv = (float)clamp(data, middle, max, 0, 1);
                Color4f(cv, 1 - cv, 0,1);
            }
            else
            {
                float cv = (float)clamp(data, min, middle, 0, 1);
                Color4f(0, cv, 1 - cv,1);
            }
        }
        internal double clip(double value, double min, double max)
        {
            if (value > max) return max;
            if (value < min) return min;
            return value;
        }
        internal double clamp(double value, double oldMin, double oldMax, double newMin, double newMax)
        {
            double factor = (newMax - newMin) / (oldMax - oldMin);
            return (value - oldMin) * factor + newMin;
        }
15.10.2009 - 18:10 Uhr

Von daher, nein, da wird nichts anders behandelt.

String wird intern anders behandelt, als andere klassen, davon bekommt man aber nur selten was mit: Intern ist er wie folgt aufgebaut:


class String
{
    int size;
    int array_size;//kp warum doppelte Angabe
    char chars_0;
    char chars_1;
    char chars_2;
    char chars_3;
    ....
    char chars_n;
}


Ein Array im c-stil mit Variabler Elementzahl hat sonst keine andere Klasse.

15.10.2009 - 17:41 Uhr

Was ist dann der Grund für das krasse flackern?

Das spiel greift über directx oder opengl direkt auf die grafikkarte zuz und nimmt dabei keinerlei Rücksicht auf bereiche, die eigentlich anderen Programmen zustehen. Dadurch kann die leistung deutlich gesteigert werden.

Die einzige Möglichkeuit das zu verhindern ist, dass man dem Spiel nachträglich "beibringt", Bereiche für andere Programme zur Verfügung zu stellen. Alternativ kann man es auch dem Grafiktreiber "beibringen".

Dieses Beibringen geht, indem man eigenen Code einschleust. Damit dieser Code im Richtigen moment aufgerufen wird manipuliert man bestimmte Tabellen, in denen die Addressen der Funktionen stehen und ersetzt sie durch die eigenen, die dann die originalen aufrufen. Das nennt man hooking. Man muss die Funktionen Swapbuffer (opengl) und devive->Present (directx) hooken und einbauen, dass eigene Sachen gezeichnet werden.
Da man mit ähnlichen Techniken auch cheaten und cracken kann, mögen es manche Spiele nicht besonders (insbesondere wow & co ned). Deshalb sollte man lieber mit nem Treiber hooken, weils ned so Auffällig is. Treiber kann man in c# nicht schreiben.

15.10.2009 - 11:07 Uhr

O(1) sondern O(n)

vorher war ja schließlich n=1

Es wird nicht ein Bucket pro Key angelegt, sondern am Anfang eine bestimmte Anzahl (z.B. 16). Um ein Element einzufügen wird erst der Hashcode berechnet und dieser durch die Anzahl der Buckets geteilt. Der Rest dieser Division ist die Nummer des Buckets. Da hashcodes unterscheidlicher Elemente im Idealfall zufällig verteilt sein sollten, werden die Elemente also erstmal gleichmäßig aufgeteilt.
Innerhalb der buckets wird eine lineare Suche durchgeführt, bei der zuerst der Hash verglichen wird.
Insgesamt ist die Efiziens also normalerweise O(n/buckets) und im schlechtesten Fall O(n)

[jetzt wirds vage... ist schon länger her...]

Ich hab nochmal nachgeguckt, aber herbivore war schneller 🙂

14.10.2009 - 18:35 Uhr

Das erste wirklich eigene was ich gemacht hab war ein Zahlenraten in Pascal.
So ziemlich das erste, was ich in c# gemacht hab war ein bildschirm blocker, der einen screenshot machte und als hintergrundbild der eigenen Form ohne Rahmen setzte. (nur leider konnte man den mitm taskmanager ausmachen, was aber auch gut so war, weil ich grade den autostart entdeckt hatte... 😄)
Danach hab ich was mit primzahlen gemacht.

14.10.2009 - 18:27 Uhr

Die einzige methode (die mir bekannt ist), mit der man das flackerfrei bekommt ist apihooking (swapbuffers und device->Present). Dafür muss man sich aber mit directx und opengl ziemlich gut auskennen. Außerdem mögen es einige Spiele nicht sonderlich, wenn man irgendwelchen eigenen Code einschleust (Insbesondere Wow soll besonders schlimm sein). Deshalb müsste man sich dafür eigentlich einen eigenen Treiber schreiben, der im kernel hookt.

Also ist es wie jack beschreiben hat: nicht sonderlich einfach

12.10.2009 - 23:48 Uhr

bei Dateien die mir suspekt sind frag ich immer Google

Ich allerdings auch: die zeichenfolge war kryptisch und war nicht auffindbar (0 treffer)

Wenn du dir unsicher bist, würde ich mal eine vollständige Prüfung deines Systems mit einem Virenscanner machen.

Mein virenscanner macht einen virentest, sobald ne datei geschrieben, als dll/exe geladen oder übers netzwerk geschickt wird -> extrem unwahrscheinlich, das das was bringt. Mal abgesehen, davon, dass die ersten Einträge von 2008 sind. Viel wahrscheinlicher ist, dass es entweder eine nicht detektierte malware oder garkeine malware ist. (beides gibts haufenweise)

12.10.2009 - 21:58 Uhr

Ich habe heute nachmittag beschlossen, mal ein wenig auf meiner festplatte aufzuräumen. Ich hab ganz banal nach dateien>50MB gesucht und alles gelöscht, was ich nicht brauche.

Dabei ist mir eine Datei mit kryptischem Namen ohne Endung im Windowsordner aufgefallen, die über 500 mb groß war. Drin standen in chronologischer Reihenfolge lauter Datumsangaben, Ordnerangaben, Dateinamen und Ordnernamen des letzten jahres. (meist unterornder von "anwendungsdaten" und diverse Verknüpfungen)

Das war mir suspekt und ich hab das Teil gelöscht. Geschadet hats nicht.

Meine Frage: Wei kommt das ding dahin?! Ist das Spyware? Sollte ich vielleicht in nächster Zeit das System neu aufsetzen?

11.10.2009 - 16:32 Uhr

typeof(Ienumerable<wasweißich>).IsAssignabelFrom(typeof(IList<wasweißich>))

Nicht getestet, aber müsste gehen.

11.10.2009 - 15:22 Uhr

Mein code macht aber eigentlich einen Übergang: blau-grün-rot

Aber bei allen Varianten gibt es bei einer bestimmten Temperatur einen Sprung von Rot auf Blau.

Kann es sein, dass du nur die Endpunkte deiner Anzeige berechnest? Mach doch einfach nen shader draus, der das für jeden Punkt macht. dann ists gleichzeitig schneller und hat nen besseren Übergang.

11.10.2009 - 12:33 Uhr

Nen regenbogen zeichnen willste?

public color TeperaturZuFarbe(double temperatur,double min, double max)
{
    temperatur=clip(temperatur,min,max);
    
    double middle=(min+max)/2;
    if(temperatur>middle)
    {
        int cv=(int)clamp(temperatur,middle,max,0,255);
        return Color.FromArgb(255,cv,255-cv,0);
    }
    else
    {
        int cv=(int)clamp(temperatur,min,middle,0,255);
        return Color.FromArgb(255,0,cv,255-cv);
    }
}

public double clip(double value,double min, double max)
{
    if(value>max)return max;
    if(value<min)return min;
    return value;
}

public double clamp(double value,double oldMin,double oldMax,double newMin,double newMax)
{
    double factor=(newMax-newMin)/(oldMax-oldMin);
    return (value-oldMin)*factor+newMin;
}
10.10.2009 - 20:46 Uhr

        public enum KeyEventF:uint
        {
            EXTENDEDKEY   = 0x0001,
            KEYUP     = 0x0002,
            UNICODE       = 0x0004,
            SCANCODE      = 0x0008
        }

Einfach jeweils das gleiche nochmal mit keyup senden:


        INPUT[] input = new INPUT[message.Length*2];
        for (int i = 0; i <= message.Length - 1; i++)
        {
            int off=i*2;
            input[off].type = 1;
            input[off].ki.dwFlags = KeyEventF.SCANCODE;
            input[off].ki.wScan = (short)message[i];
            off++;
            input[off].type = 1;
            input[off].ki.dwFlags = KeyEventF.SCANCODE|KeyEventF.KEYUP;
            input[off].ki.wScan = (short)message[i];
        }
        uint sent = SendInput((uint)input.Length, input, Marshal.SizeOf(input[0]));
10.10.2009 - 20:34 Uhr

eine MessageBox hält deine Nachrichtenschleife an.

Naja, so ganz einverstanden bin ich damit nicht, denn:
Eine Messagebox hat eine eigene Nachrichtenschleife, die die Nachrichtenverarbeitung für alle Fenster des aktuellen Threads übernimmt. Man kann auch während eine Messagebox was ausführen. Probier mal Folgendes (gänzlich ohne multithreading):


for(int i=10;i!=0;i--)
{
    BeginInvoke((Action)(()=>{
        MessageBox.Show("Messagebox",i.ToString());
    }));
}

10.10.2009 - 20:23 Uhr

könnte es zufällig sein, dass du vergessen hast, die keyup-befehle zwischenzupacken: keydown-keyup-keydown-keyup....... 😉?

10.10.2009 - 13:33 Uhr

Irgendwie habe ich das gefühl, dass du meine vorschläge nicht so ganz verstanden hat.

Wenn ja, dann hättest du gemerkt, dass ein einzelner Punkt der Auflistung jeweils ausreicht, um die Prüfung vorzunehmen. (alles gleichzeitig ist also ziemlich sinnlos)

nicht nur vom Interface sondern auch gleichzeitig vom Button ableiten, oder? das ist auch bei intrfaces keinerlei Problem.

So hab ich eingestellt, dass mein eigener Editor verwendet wird.


        IList<IAbility> abilitys;

        [Editor(typeof(AbilityCollectionEditor),typeof(UITypeEditor))]
        public IList<IAbility> Abilitys
        {
            get { return abilitys; }
        }

Du implementierst also einen solchen Editor und zeigst dann nur die Properties von deinem AbilityChooser an, oder?

Ahm nö: mein AbilityChooser ist nur ein Form (das linke auf dem Bild) und das gibt einfach nur zurück, welcher Typ ausgewählt wurde. Man kann natürlich ach gleich das neue Objekt ansich zurückgeben.
In die Liste aufgenommen wird auch nicht das Auswahlfenster, sondern das eigentliche Objekt. Deshalb werden auch keine Propertys vom Auswahlfenster angezeigt. (Wie kommst du überhaupt drauf?)

09.10.2009 - 18:56 Uhr

Topmost ist gut. Außerdem Brauchste WS_EX_NOACTIVATE (createPraramsex überschreiben mit return base.createPraramsex|WS_EX_NOACTIVATE; )

Hooks allgemein sind zwar ein brauchbarer Ansatz, jedoch nicht die, für die du den code gefunden hast. Du hast WH_KEYBOARD_LL gefunden. Dieser hooktyp ist aber nicht zu gebrauchen, um die Weiterverarbeitung zu verhindern oder Daten zu manipulieren.Man kann nur bei einer einzigen Hookart verhindern, dass die eingaben weitergereicht und normal verarbeitet werden: WH_getmessage!

geht das denn auch unter Win 7 hooks gelten nur für den aktuellen benutzer, egal welches bs. Es kann also zu Problemen mit UAC kommen, weil dein prog nicht als admin läuft und andere schon oder umgekehrt.

09.10.2009 - 15:00 Uhr

Vielleicht hilfr dir meine implementation (ich habs mir einfach gemacht):


    class AbilityCollectionEditor : CollectionEditor
    {
        public AbilityCollectionEditor()
            : base(typeof(List<IAbilityType>))
        {
        }

        protected override Type CreateCollectionItemType()
        {
            return typeof(AbilityType);
        }

        protected override bool CanRemoveInstance(object value)
        {
            return true;
        }

        protected override bool CanSelectMultipleInstances()
        {
            return true;
        }

        protected override object CreateInstance(Type itemType)
        {
            IAbilityInfoFactory fac = AbilityChooser.Choose();
            if (fac == null) return null;
            return fac.GetInfo();
        }
    }

genutzt mit [EditorAttribute(typeof(AbilityCollectionEditor),typeof(UITypeEditor))]

Zu deiner zweiten frage:

  1. registrier deine prüfung im addingNew-event der buindingList und schmeiß ne exeption
  2. erstell deine eigene klasse
  3. leite alle zugelassenen Controls vin nem interface ab und gib das als t der liste an. Vorteil: erweiterbar nachteil: bestehende controls können nicht direkt genutzt werden (wenn man eigeneAbleitungen von denen erstellt, die das Interface implementieren, dann schon)
08.10.2009 - 18:51 Uhr

Musst deinen eigenen collectiondesigner bauen. wenn du es so wie im bild haben willst, musst du die methode createForm überschreiben und dein eigenes form zurückgeben. dieses form muss von ner bestimmten klasse erben, die man aber nur ableiten kann, wenn man die abgeletiete als private klasse von Collectiondesigner erstellt.

Deutlich einfaches ist es aber CreateInstance zu überschreiben und einen dialog anzuzeigen. ÄWenn die methode null zurückgibt wird nix hinzugefügt.

07.10.2009 - 10:56 Uhr

Dann sammeln sich doch immernoch WeakReference-Leichen in meinem index.

07.10.2009 - 10:44 Uhr

Ich muss von objekten mehrere kopien, die gleichzeitig existieren anfertigen. Änderungen an einer der kopien sollen auf das original Anwendbar sein.
Problem dabei:
Wie finde ich das Original?
Da hab ich mir gedacht, ich nummerier einfach mal alle Objekte durch und leg einen Index an. Problem dabei: Das sorgt dafür, dass die garbage collection nichtmehr richtig funzt, weil der index ja auf jedes objekt verweist. Wie werde ich die objekte jemals wieder los?

07.10.2009 - 09:48 Uhr

Ich wünsche mir auch

Die Möglichkeit eine Property als PropertyInfo oder ähnliches zu übergeben.

oder zumindest, dass man delegates auf die getter und setter von properties setzen kann (sind schließlich auch nur Methoden)

07.10.2009 - 09:38 Uhr

Ich habe mal was in 3d und gdi+ gemacht.
Man muss sich dazu allerdings etwas mit matrizen auskennen.

Die grundlagen sind if folgender seite Ganz gut erklärt, finde ich:
http://www.mathematik.uni-leipzig.de/pool/tuts/SelfDXD/DirectXGraphics/theorie/dg_mat.html


_11 _12 _13 _14
_21 _22 _23 _24
_31 _32 _33 _34
_41 _42 _43 _44

Die Namen kann man sich folgendermaßen merken: die erste ziffer ist die ursprungskoordinate, die zweite ziffer ist die zielkoordinate. _43 heißt also ursprüngliches w mit _43 multipliziert wird zu neuem z hinzuaddiert.

dass eine w-Koordinate vorhanden ist, ist vielleicht erstmal komisch, man setzt aber w einfach für jeden Ausgangspunkt auf 1, um verschiebungen hinzubekommen.

Folgendes kannste als Projktionsmatrix nehmen (damit's perspektivisch aussieht) nehmen:


1 0 0 0
0 1 0 0
0 0 1 1
0 0 0 1

_44 bestimmt, wie groß Objekte sind, die direkt vor der kamera liegen (z=0). Je größer _44, desdo kleiner ist alles.
ge größer _34 desdo schneller wird alles nach hinten hin kleiner.

Vor der Darstellung mach einfach mit jedem Punkt folgendes:


    Matrix matrix=view*projection;

    //für jeden punkt einzeln:
    Vector4 transformiert=new Vector4(punkt.X, punkt.Y, punkt.Z, 1.0);//w=1 hinzufügen
    matrix.Transform(ref transformiert);//transformieren
    if(transformiert.Z>=0)
    {
        transformiert /= transformiert.W;
        //zeichnen
    }
    else
    {
        //Objekt hinter kamera
    }

Directx macht das ganze automatisch und auf der Grafikkarte. Dafür darf man sich mit viel verwaltungsgedöns herumschlagen, sofern es einem die api nicht schon abnimmt (xna, wpf machen das)

05.10.2009 - 19:34 Uhr

irgendwie wird dein inhalt nicht richtig als code serialisiert. Guck dir mal den vom designer generierten code an und poste den (oder auch nicht, falls da nix is)

05.10.2009 - 18:19 Uhr

.net minimaler aufwand ist, sowas zu erstellen.

Der Netzwerkzugriff ansich ist wirklich ziemlich einfach. Man muss sich aber noch um Threading und Protokoll und so selber kümmern.
Ich hab mir meine Wrapper geschrieben, die das Threading, Handshake, Paketaufteilung und so übernehmen. Die könntest du dir vielleicht mal angucken. Ich habe die aber eigentlich nicht für kommerzielle Projekte geschrieben (PC Fernsteuerung). Halbwegs stablil läuft das Teil trotzdem. Anpassbar ists sehr gut. Für 3mb-Dateien habe ich die lib schon gebraucht. Eine Doku gibts allerdings ned.
Netzwerkbibliothek (Sourcecode ist dabei)
Um 20mb-Dateien in einem Rutsch zu übertragen müsstest du eventuell die ArrayQueue (Packetpatcher) optimieren ,dass die in größeren Schritten vergrößert wird, sonst ist es nicht besonders performant bei der ersten Datei. (Bei Nachfolgenden aber schon.)
Ich empfehle aber eher, die datei Stückweise einzulesen, was du selber implementieren müsstest (mit callback).

05.10.2009 - 17:49 Uhr

Ich habe festgestellt, dass man die Dateiendungen von Bildern belibig vertauschen kann:
bmp, gif, png, jpg, ico, ...
Kein Programm stört sich ernsthaft dran.
Wenn man die Bitmap.Save(string)-Methode verwendet wird sogar manchmal im falschen Format gespeichert.

Außerdem habe ich mal in meinen httpsaver geguckt, wo das Format nicht der Endung entsprach (der hat auch ne Erkennung eingebaut): Ich habe unter gif, png und jpg jede Kombination von Endung und tatsächlichem Format mindestens einmal gefunden. 😁

Vielleicht sollte man mal die Endung .img einführen und alle anderen Endungen ablösen ^^.

04.10.2009 - 20:07 Uhr
  1. Einen thread nach dem anderen zu starten ist ned nötig.
  2. niemals in mehreren threads die selbe liste verwenden. Wenn das noch nögig sein sollte: a) lock(liste) oder b) einen threadsichere liste nehmen
  3. die ersten 20 threads werden doppelt gestartet bei deiner version
  4. exceptions sind für absolute ausnahmen. Dass eine liste irgendwann leer ist, wenn man sie leer macht, ist eher die Regel als die Ausnahme.
    Mein Vorschlag:

foreach(Proxy p in proxys)
{
    TesteProxy(p);
}

...
private void TesteProxy(Proxy p)
{
    new Thread(()=>
    {

        /*
        Hier wird der Proxy getestet, damit habe ich keine Probleme
        */
    }).Start();
}

Wer jetzt bei meinem code denkt, dass man die TesteProxy-Methode direkt in die Schleife schreiben könnte, der irrt sich.

03.10.2009 - 14:20 Uhr

Wirf mal n blick aufs FAQ: [FAQ] TcpClient einfaches Beispiel
Ich hab schon ein paar Netzwerkprogramme mit tcp geschrieben und den netzwerkteil (mit Quellcode) online gestellt: Netzwerkbibliothek

Da is zwar schon ein eigenes protokoll, handshake und so dabei, das kann man aber recht einfach gegen ein eigenes Protokoll austauschen. (Einfach von IPipelineElement ableiten. Was eigenes zu bauen setzt allerdings vorraus, dass man sich halbwegs mit Threading auskennt.)

30.09.2009 - 16:01 Uhr

LOL! Das googeln lohnt sich in jedem Fall.

26.09.2009 - 11:27 Uhr

Wie dem auch sei. Der Weg wird sein, in dem PropertyGrid ein eigenes PropertyTab zu definieren, in der PropertyTab.GetProperties so definiert ist, dass es die passenden PropertyDescriptors liefert, bei denen die PropertyDescriptor.Converter auf den gewünschten TypeConverter gesetzt sind.

Klappt. Man muss allerdings auch eine unterklasse von Propertygrid erstellen und DefaultTabType überschreiben. Außerdem muss man in seinem Tab selber prüfen, ob ein typeconverter mit subproperties gesetzt ist und diesen manuell bedienen.

25.09.2009 - 23:21 Uhr

Wie kann ich Typenconverter und andere Designer fürs Propertygrid festlegen, ohne dafür ein Attribut zu verwenden?
Es geht darum, dass ich ne dll habe, in der ein enum und eine Klasse Definiert sind, die eine Sonderbehandlung im Propertygrid bekommen sollen. Diese Dll soll aber keinerlei Ahnung davon haben , dass es Winforms überhaupt gibt!

Wie sage ich dem propertygrid ohne attribut, welchen typenconverter/designer es nehmen soll?

24.09.2009 - 15:37 Uhr

Hallo,
So ein Problem darf das mit TCP wirklich nicht sein.
Ich glaube eher, dass du vergessen hast zu flushen.

Flushen taugt nicht, um Packete zu richtig zusammenzusetzen oder das Stückeln zu verhindern. Deshalb ist diese Aussage zumindest irreführend.

Man darf nicht vergessen, dass TCP relativ große Paketgrößen zulässt.

Man darf auchnicht vergessen, dass Ethernet, über das die Tcp-Pakete versendet werden dies nicht tut. Außerdem werden, wenn Pakete schnell hintereinander ankommen, diese erst teilweise zusammengesetzt. Ich habe versehentlich mal in ner Endlosschleife 17 byte-Pakete versendet und ein einzelnes 14Kbyte-Paket empfangen ⚠

Hat für mich noch immer den Anschein gemacht, als würde die Funktion von TCP nicht ganz klar Fragt sich jetzt nur bei wem 😁

"Nachrichtenformat"

richtig, mit einem passenden Nachrichtenformat kann man das Problem lösen. Ich habe einfach folgendes Format genutzt: Man schreibe die Länge der zu erwartenden Daten vorweg.
Um das richtig umzusetzen braucht man aber einen Speicherplatz/queue, wo man die Pakete wieder zusammensetzt und voneinander trennt. Dieser muss auch größer als 64kbyte werden können. Deshalb der Ringbuffer.

Natürlich kann man sich leicht ein anderes Format basteln. Z.b. Nachrichten enden immer mit einem Nullbyte. Das mit der Länge habe ich nur genommen, weil man darüber belibige Daten versenden kann und es seghr simpel ist.

23.09.2009 - 18:14 Uhr

Jup: gib mal eine exe, dann kann man das auch bewerten. Wenn jeder, der die exe hat den text lesen kann, hast du (bewusst?) was falsch gemacht.

23.09.2009 - 18:11 Uhr

-Named pipes (systemweiter stream, lässt sich u.a. mit der windows dateiapi ansprechen)
-Benannte Waithandles, mutexes....
-Sockets (deine Netzwerkkommunikation)
-(shared Memory)
-(dateien)

22.09.2009 - 16:31 Uhr

Das typische M$ Motto: bevor die zur Konkurrenz gehen, verschenken wir unsere Produkte lieber. (bzw. lassen sie "klauen" => China)

21.09.2009 - 19:33 Uhr

(Für mich) am einfachsten ist:


BitmapData data=meinBild.LockRectangle(... ,Format.32bbpargb);
//setpixel und getPixel hier ausführen
meinBild.UnlockRectangle(data);

unsafe int GetPixl(BitmapData data,int x, int y)
{
    byte* ptr= ((byte*)data.Scan0) + y*data.Stride + 4*x;
    return *((int*)ptr);
}

unsafe void SetPixl(BitmapData data,int x, int y, int argb)
{
    byte* ptr= ((byte*)data.Scan0) + y*data.Stride + 4*x;
    *((int*)ptr)=argb;
}

In deinem Fall vllt auch sowas:


byte* ptr= ((byte*)data.Scan0) + y*data.Stride;
for(int x=0;x<data.Width;x++)
{
    *ptr=*ptr+50;//blau
    ptr++;
    *ptr=*ptr+50;//grün
    ptr++;
    *ptr=*ptr+50;//rot
    ptr++;
    //undurchsichtigkeit nicht verändern
    ptr++;
}

Du musst aber noch auf Überläufe prüfen!! (bei bytes ergibt 130+130=4)

Aber es gibt auch was vorgefertigtes:
GetPixel und SetPixel um Längen geschlagen. 800 mal schneller

Um die helligkeit zu verändern musst du einfach einen Wert addieren oder subtrahieren. Wenn du den Kontrast verändern willst, musst du multiplizieren.

20.09.2009 - 17:13 Uhr

Nachdem ich einen gewissen Webcast von Golo Roden gesehen habe, in dem Lock für threadsichere Events benutzt wurde, habe ich mir sofort gedacht: das ist doch ein klarer Fall für Interlocked.CompareExchange! Das erspart einem auch sämtliche Lockobjekte.

Damit man nicht jedes Mal soviel Schreibaufwand hat, habe ich mir erstmal eine Methode geschrieben, die threadsichere Modifikationen ohne lock erlaubt, solange das Ursprungsobjekt dabei nicht verändert, sondern durch eine ein Neues ausgetaust wird. Also besonders geeignet für: Werttypen, Strings, Delegaten und alle anderen immutablen Referenztypen.


        //Für alle Referenztypen
        public static T InterlockedModify<T>(ref T value, Func<T, T> action) where T : class
        {
            T oldValue;
            T newValue;
            do
            {
                oldValue = value;
                newValue = action(oldValue);
            }
            while (Interlocked.CompareExchange(ref value, newValue, oldValue) != oldValue);
            return newValue;
        }

        //Für Werttyp int. Wer andere Werttypen will, muss sich eine eigene Überladung machen.
        public static int InterlockedModify(ref int value, Func<int, int> action)
        {
            int oldValue;
            int newValue;
            do
            {
                oldValue = value;
                newValue = action(oldValue);
            }
            while (Interlocked.CompareExchange(ref value, newValue, oldValue) != oldValue);
            return newValue;
        }

Man kann mit dieser Methode z.B. Threadsicher
-Mathematische Operationen ausführen:

InterlockedModify(ref wert, (v)=> v*3 );

-Strings oder Delegaten Verketten:

InterlockedModify(ref wert, (v)=> v+" hallo" );

Wichtig ist, dass keine Eigenschaften von Referenztypen geändert werden (jedenfalls nicht die vom Original) und die übergebene Methode (der 2. Parameter) mehrmals ausgeführt werden kann, wobei alle Ergebnisse bis auf das des letzten Aufrufs verworfen werden.

Hier also der Code für Threadsichere Events ohne lock:


        private EventHandler myEvent;

        public event EventHandler MyEvent
        {
            add
            {
                InterlockedModify(ref myEvent, ((v) => v + value));
            }
            remove
            {
                InterlockedModify(ref myEvent, ((v) => v - value));
            }
        }

        protected virtual void OnMyEvent()
        {
            EventHandler handler=myEvent;
            if (handler != null)
            {
                handler(this, null);
            }
        }

Die Compilergenerierten Events benutzen ([MethodImpl(MethodImplOptions.Synchronized)]

was einem lock(this){....} entspricht

Siehe auch:
Lockfreie threadsichere Queue
Lockfreier threadsicherer Stack

Schlagwörter:

20.09.2009 - 15:37 Uhr

vielleicht solltest du es mit Surface.lockRectangle versuchen?

20.09.2009 - 14:51 Uhr

eher langsamer, da du einen frame zusätzlich rendern müsstest. Versuch doch erstmal nen lockable backbuffer.

20.09.2009 - 14:23 Uhr

Du brauchst: Lockable backbuffer (Beim Erstellen des Devices angeben)

Aber du kannst auch komplett gdi nehmen (copyfromscreen)

wenn du einen wirklich eleganten weg haben willst, solltest du eine textur als rendertarget erstellen

19.09.2009 - 19:43 Uhr

Beschreibung:

Da es immer wieder einige Anfragen zum Thema gibt, habe ich eine Bibliothek geschrieben, die einem einiges davon abnimmt:

-Socket auslesen+Threading
-Handshake mit Versionsübertragung (Es soll sich ja nicht jeder x-belibige Browser verbinden)
-Pakete vor der Weiterverarbeitung an zusammensetzen und voneinander trennen
-Man kann kommandos unterschidlich handler zuordnen.
-Optionales callback, wenn Packet gesendet wurde (Nützlich z.B. bei Dateiübertragungen, um Stückweise einzulesen)
-Wenn gewünscht kann ich Verschlüsselung noch hinzufügen

Man muss die einzelnen Verarbeitungsschritte nurnoch zusammensetzen:


            Connection conn = new Connection(tcpClient);

            Handshake handshake = new Handshake("Protokollname", 1);
            handshake.Fail += (sender,ea) => { conn.Close(); };

            PacketPatcher patcher = new PacketPatcher();

            CommandParser parser = new CommandParser();
            //Kommanos hier registrieren
            ....

            conn.Next = handshake;
            handshake.Next = patcher;
            patcher.Next = parser;
            ....

            conn.Start();

Um auf Verbindungen zu warten gibts denConnectionWaiter.

Wer irgendwelche Events abboniert oder Callbacks angibt muss man damit rechnen, dass diese in anderen Threads ausgeführt werden. Deshalb sollte man BeginInvoke benutzen!
Wenn man Invoke statt begininvoke nimmt, senkt das die Performance.
(Da guiElemente auch geschlossen/zerstört werden können, sollte man begininvoke mit try-catch verwenden.)

Ein Beispielprogramm liegt bei: ein kleiner Chat

Schlagwörter: tcp socket sockets

18.09.2009 - 15:00 Uhr

Guck dir mal an, was der Treeview selvber so anbietet. da gibts doch bestimmt labeleditcompleted oder sowas, in dem man den node dann informieren kann. (vermute ich einfach mal)

16.09.2009 - 17:12 Uhr
  1. Eine Collection sollte mehrere ienumeratoren gleichzeuitig zulassen, da unter andem verschachtelte Schleifen sonst nicht funktionieren.
public bool Remove(T item)
        {
            return Elements.Remove(item);
        }

Gibt natürlich ein Problem, wenn der Leseindex größer wie der index des zu entfernenden items ist.
3.


public bool MoveNext()
        {
            if (CurrentReadPointer >= MaxLength)
            {
                CurrentReadPointer = 0;
                return false;
            }

            CurrentReadPointer++;
            return true;
        }

Ist es gewollt, dass hinterher CurrentReadPointer gleich MaxLength sein kann, wobei true zurückgegeben wird?
4.

public T Current
        {
            get
            {
                if (CurrentReadPointer >= MaxLength || CurrentReadPointer >= Elements.Count)
                {
                    CurrentReadPointer = 0;
                }

                int index = CurrentReadPointer;
                CurrentReadPointer++;
                return Elements[index];
            }
        }

Getter von Properties sollten normalerweise nichts verändern. Mach ne Methode draus.

15.09.2009 - 20:01 Uhr

Höchstwahrscheinlich willst du garkein mausevent erzwingen, sondern nur deinen eigenen Code von woanders aus nochmal aufrufen. Dazu brauchst du ihn nur ein eine möglichst mit sinvollem namen versehene Methode packen und diese im eventhandler und wo du den Code sonstnoch brauchst die methode aufrufen:


buttonX_Click(object sender, MouseEventArgs e)
{
    Machwas();
}

void Machwas()
{
//hier kommt dein code hin
}

Da, wo du dein event erzwingen willst, schreibst du statdessen einfach


    Machwas();

EDIT:){red}für fernsteuern anderer programme: [erledigt] Tastatur simmulieren mit vorherigem cursor.Position=....

14.09.2009 - 20:22 Uhr

alle anderen Threads anhalten.

Ähm wenns geht eher nicht. (jedenfalls ned länger als ca. 0,02 secs)

Entweder mit nem Zugriff auf die erste Adresse (und try-catch um die Zugriffsverletzungen abzufangen) oder vielleicht auf die weniger brachiale Art mit VirtualQuery.

Vielleicht beides: den eleganten Weg vorweg und falls die page während des lesens gesperrt wird noch try-catch?
Aber kann man Zugriffsverletzungen überhaupt abfangen?

Allerdings bietet Windows selbst auch schönere Methoden um an relevante Memory-Dumps zu kommen.

Hört sich irgendwie langsam und unpassend an.

Danke schonmal! Ich werd mich bald ransetzen.

14.09.2009 - 18:07 Uhr

Wie kann ich am besten den kompletten (unmanaged+managed) arbeitsspeicher des eigenen, greade arbeitenden Prozesses auslesen?

Mit Zeigern bekomme ich ja zwangsweise Zugriffsverletzungen. (Selbst wenn ich weiß, dass ein bereich grade genutzt wird, kann er ja während des Auslesens freigegeben werden.)
Wie kann ich überhaupt auslesen, welche Bereiche genutzt werden?