Ja, die "Plugins" sind Klassen, die per Reflektion geladen und Instanziert werden. Diese Klassen sollen die Steuerung der Spielfiguren übnernehmen. Am Ende solls sone art Robocode werden.

Was soll die Rechteeinschänkung denn bringen?
Das der Code der injected wird, nicht volle Rechte hat?

ja:

1. Schutz gegen Schummeln,
2. Schutz gegen Schadcode

Bitte gib mal mehr Details preis. Bspw. welche Art des Schummeln du verhindern willst.

Ich will verhindern, dass man auf interne member zugreift und sowas macht wie:

• Sich selbst oder andere Spielfiguren teleportieren (Geht bei z.B. bei Antme hervorragend)
• Andere Teammitglieder oder feinde steuern

Mit PermissionSet.PermitOnly kann man erfolgreich die Rechte des Nachfolgenden Codes einschränken. Das Problem dabei ist: man kann im eingeschränkten bereich Objekte erzeugen, deren Finalizer wiederum im nicht eingeschränkten bereich aufgeführt werden.

public class SecurityTests
    {
        public SecurityTests()
        {
            Console.WriteLine("contructor:");
            Test();
        }

        [STAThread()]
        public static void Main()
        {
            PermissionSet set = new PermissionSet(System.Security.Permissions.PermissionState.None);
            set.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
            Create(set);
            GC.Collect();
            Console.ReadLine();
        }

        private static void Create(PermissionSet set)
        {
            set.PermitOnly();
            SecurityTests tests = new SecurityTests();
            Console.WriteLine("test:");
            tests.Test();
        }

        ~SecurityTests()
        {
            Console.WriteLine("finalizer:");
            Test();
        }

        private void Test()
        {
            try
            {
                FieldInfo field= typeof(System.DateTime).GetField("dateData", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.SetField);
                object obj = DateTime.Now;
                field.SetValue(obj, (ulong)0);
                Console.WriteLine(obj.ToString());
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.GetType().ToString()+":"+ex.Message);
            }
        }
    }

contructor:
System.FieldAccessException:System.DateTime.dateData
test:
System.FieldAccessException:System.DateTime.dateData
finalizer:
01.01.0001 00:00:00

Ich möchte die Sicherheitsbeschränkungen nutzen, um Schummeln bei einem Spiel zu verhindern. Dabei wird es wohl den meisten ned auffallen, außerdem hab ich noch ne andere Gemeinheit gegen Reflection eingebaut.
Trotzdem wüsste ich gerne, wie man es verhindern kann.

Backgroundworker=Klasse die einen thread erstellt und verschidene nützliche events anbietet.

Sowat gibt es schon in c# (open source): http://easyhook.codeplex.com/
Soweit ich weiß werden aber nur nach dem starten vom Prozess verwendete oder geöffnete Dateihandles gelistet.

So, hab beides behoben.
Dass mir die alt-Gr spezialität dazwischengefunkt hat liegt daran, dass ALt-gr strg+alt entspricht und ich allles mit strg zusammen durchgelassen hab.
Bleiben nurnoch neue Betriebssystemversionen und dass einige regionale Spezialitäten, die nur mit strg eingegeben werden nicht funktionieren (falls es sowas überhaupt gibt) als Fehlerquellen. Aber du hast wohl recht, dass man nie ganz sicher sein kann mit der Methode.

Beschreibung:

Ein Enum, das so ziemlich alle Windowsmeldungen beinhaltet.

public enum Wm:int
        {
            WM_NULL = 0,
            WM_CREATE = 1,
            WM_DESTROY = 2,
            WM_MOVE = 3,
            WM_SIZE = 5,
            WM_ACTIVATE = 6,
            WM_SETFOCUS = 7,
            WM_KILLFOCUS = 8,
            WM_ENABLE = 10,
            WM_SETREDRAW = 11,
            WM_SETTEXT = 12,
            WM_GETTEXT = 13,
            WM_GETTEXTLENGTH = 14,
            WM_PAINT = 15,
            WM_CLOSE = 16,
            WM_QUERYENDSESSION = 17,
            WM_QUIT = 18,
            WM_QUERYOPEN = 19,
            WM_ERASEBKGND = 20,
            WM_SYSCOLORCHANGE = 21,
            WM_ENDSESSION = 22,
            WM_SHOWWINDOW = 24,
            WM_CTLCOLOR = 25,
            WM_WININICHANGE = 26,
            WM_DEVMODECHANGE = 27,
            WM_ACTIVATEAPP = 28,
            WM_FONTCHANGE = 29,
            WM_TIMECHANGE = 30,
            WM_CANCELMODE = 31,
            WM_SETCURSOR = 32,
            WM_MOUSEACTIVATE = 33,
            WM_CHILDACTIVATE = 34,
            WM_QUEUESYNC = 35,
            WM_GETMINMAXINFO = 36,
            WM_PAINTICON = 38,
            WM_ICONERASEBKGND = 39,
            WM_NEXTDLGCTL = 40,
            WM_SPOOLERSTATUS = 42,
            WM_DRAWITEM = 43,
            WM_MEASUREITEM = 44,
            WM_DELETEITEM = 45,
            WM_VKEYTOITEM = 46,
            WM_CHARTOITEM = 47,
            WM_SETFONT = 48,
            WM_GETFONT = 49,
            WM_SETHOTKEY = 50,
            WM_GETHOTKEY = 51,
            WM_QUERYDRAGICON = 55,
            WM_COMPAREITEM = 57,
            WM_GETOBJECT = 61,
            WM_COMPACTING = 65,
            WM_COMMNOTIFY = 68,
            WM_WINDOWPOSCHANGING = 70,
            WM_WINDOWPOSCHANGED = 71,
            WM_POWER = 72,
            WM_COPYDATA = 74,
            WM_CANCELJOURNAL = 75,
            WM_NOTIFY = 78,
            WM_INPUTLANGCHANGEREQUEST = 80,
            WM_INPUTLANGCHANGE = 81,
            WM_TCARD = 82,
            WM_HELP = 83,
            WM_USERCHANGED = 84,
            WM_NOTIFYFORMAT = 85,
            WM_CONTEXTMENU = 123,
            WM_STYLECHANGING = 124,
            WM_STYLECHANGED = 125,
            WM_DISPLAYCHANGE = 126,
            WM_GETICON = 127,
            WM_SETICON = 128,
            WM_NCCREATE = 129,
            WM_NCDESTROY = 130,
            WM_NCCALCSIZE = 131,
            WM_NCHITTEST = 132,
            WM_NCPAINT = 133,
            WM_NCACTIVATE = 134,
            WM_GETDLGCODE = 135,
            WM_SYNCPAINT = 136,
            WM_NCMOUSEMOVE = 160,
            WM_NCLBUTTONDOWN = 161,
            WM_NCLBUTTONUP = 162,
            WM_NCLBUTTONDBLCLK = 163,
            WM_NCRBUTTONDOWN = 164,
            WM_NCRBUTTONUP = 165,
            WM_NCRBUTTONDBLCLK = 166,
            WM_NCMBUTTONDOWN = 167,
            WM_NCMBUTTONUP = 168,
            WM_NCMBUTTONDBLCLK = 169,
            WM_NCXBUTTONDOWN = 171,
            WM_NCXBUTTONUP = 172,
            WM_NCXBUTTONDBLCLK = 173,
            WM_INPUT = 255,
            WM_KEYDOWN = 256,
            WM_KEYFIRST = 256,
            WM_KEYUP = 257,
            WM_CHAR = 258,
            WM_DEADCHAR = 259,
            WM_SYSKEYDOWN = 260,
            WM_SYSKEYUP = 261,
            WM_SYSCHAR = 262,
            WM_SYSDEADCHAR = 263,
            WM_KEYLAST = 264,
            WM_WNT_CONVERTREQUESTEX = 265,
            WM_CONVERTREQUEST = 266,
            WM_CONVERTRESULT = 267,
            WM_INTERIM = 268,
            WM_IME_STARTCOMPOSITION = 269,
            WM_IME_ENDCOMPOSITION = 270,
            WM_IME_COMPOSITION = 271,
            WM_IME_KEYLAST = 271,
            WM_INITDIALOG = 272,
            WM_COMMAND = 273,
            WM_SYSCOMMAND = 274,
            WM_TIMER = 275,
            WM_HSCROLL = 276,
            WM_VSCROLL = 277,
            WM_INITMENU = 278,
            WM_INITMENUPOPUP = 279,
            WM_MENUSELECT = 287,
            WM_MENUCHAR = 288,
            WM_ENTERIDLE = 289,
            WM_MENURBUTTONUP = 290,
            WM_MENUDRAG = 291,
            WM_MENUGETOBJECT = 292,
            WM_UNINITMENUPOPUP = 293,
            WM_MENUCOMMAND = 294,
            WM_CHANGEUISTATE = 295,
            WM_UPDATEUISTATE = 296,
            WM_QUERYUISTATE = 297,
            WM_CTLCOLORMSGBOX = 306,
            WM_CTLCOLOREDIT = 307,
            WM_CTLCOLORLISTBOX = 308,
            WM_CTLCOLORBTN = 309,
            WM_CTLCOLORDLG = 310,
            WM_CTLCOLORSCROLLBAR = 311,
            WM_CTLCOLORSTATIC = 312,
            WM_MOUSEFIRST = 512,
            WM_MOUSEMOVE = 512,
            WM_LBUTTONDOWN = 513,
            WM_LBUTTONUP = 514,
            WM_LBUTTONDBLCLK = 515,
            WM_RBUTTONDOWN = 516,
            WM_RBUTTONUP = 517,
            WM_RBUTTONDBLCLK = 518,
            WM_MBUTTONDOWN = 519,
            WM_MBUTTONUP = 520,
            WM_MBUTTONDBLCLK = 521,
            WM_MOUSELAST = 521,
            WM_MOUSEWHEEL = 522,
            WM_XBUTTONDOWN = 523,
            WM_XBUTTONUP = 524,
            WM_XBUTTONDBLCLK = 525,
            WM_PARENTNOTIFY = 528,
            WM_ENTERMENULOOP = 529,
            WM_EXITMENULOOP = 530,
            WM_NEXTMENU = 531,
            WM_SIZING = 532,
            WM_CAPTURECHANGED = 533,
            WM_MOVING = 534,
            WM_POWERBROADCAST = 536,
            WM_DEVICECHANGE = 537,
            WM_MDICREATE = 544,
            WM_MDIDESTROY = 545,
            WM_MDIACTIVATE = 546,
            WM_MDIRESTORE = 547,
            WM_MDINEXT = 548,
            WM_MDIMAXIMIZE = 549,
            WM_MDITILE = 550,
            WM_MDICASCADE = 551,
            WM_MDIICONARRANGE = 552,
            WM_MDIGETACTIVE = 553,
            WM_MDISETMENU = 560,
            WM_ENTERSIZEMOVE = 561,
            WM_EXITSIZEMOVE = 562,
            WM_DROPFILES = 563,
            WM_MDIREFRESHMENU = 564,
            WM_IME_REPORT = 640,
            WM_IME_SETCONTEXT = 641,
            WM_IME_NOTIFY = 642,
            WM_IME_CONTROL = 643,
            WM_IME_COMPOSITIONFULL = 644,
            WM_IME_SELECT = 645,
            WM_IME_CHAR = 646,
            WM_IME_REQUEST = 648,
            WM_IMEKEYDOWN = 656,
            WM_IME_KEYDOWN = 656,
            WM_IMEKEYUP = 657,
            WM_IME_KEYUP = 657,
            WM_NCMOUSEHOVER = 672,
            WM_MOUSEHOVER = 673,
            WM_NCMOUSELEAVE = 674,
            WM_MOUSELEAVE = 675,
            WM_CUT = 768,
            WM_COPY = 769,
            WM_PASTE = 770,
            WM_CLEAR = 771,
            WM_UNDO = 772,
            WM_RENDERFORMAT = 773,
            WM_RENDERALLFORMATS = 774,
            WM_DESTROYCLIPBOARD = 775,
            WM_DRAWCLIPBOARD = 776,
            WM_PAINTCLIPBOARD = 777,
            WM_VSCROLLCLIPBOARD = 778,
            WM_SIZECLIPBOARD = 779,
            WM_ASKCBFORMATNAME = 780,
            WM_CHANGECBCHAIN = 781,
            WM_HSCROLLCLIPBOARD = 782,
            WM_QUERYNEWPALETTE = 783,
            WM_PALETTEISCHANGING = 784,
            WM_PALETTECHANGED = 785,
            WM_HOTKEY = 786,
            WM_PRINT = 791,
            WM_PRINTCLIENT = 792,
            WM_APPCOMMAND = 793,
            WM_HANDHELDFIRST = 856,
            WM_HANDHELDLAST = 863,
            WM_AFXFIRST = 864,
            WM_AFXLAST = 895,
            WM_PENWINFIRST = 896,
            WM_RCRESULT = 897,
            WM_HOOKRCRESULT = 898,
            WM_GLOBALRCCHANGE = 899,
            WM_PENMISCINFO = 899,
            WM_SKB = 900,
            WM_HEDITCTL = 901,
            WM_PENCTL = 901,
            WM_PENMISC = 902,
            WM_CTLINIT = 903,
            WM_PENEVENT = 904,
            WM_PENWINLAST = 911,
            DDM_SETFMT = 1024,
            DM_GETDEFID = 1024,
            NIN_SELECT = 1024,
            TBM_GETPOS = 1024,
            WM_PSD_PAGESETUPDLG = 1024,
            WM_USER = 1024,
            CBEM_INSERTITEMA = 1025,
            DDM_DRAW = 1025,
            DM_SETDEFID = 1025,
            HKM_SETHOTKEY = 1025,
            PBM_SETRANGE = 1025,
            RB_INSERTBANDA = 1025,
            SB_SETTEXTA = 1025,
            TB_ENABLEBUTTON = 1025,
            TBM_GETRANGEMIN = 1025,
            TTM_ACTIVATE = 1025,
            WM_CHOOSEFONT_GETLOGFONT = 1025,
            WM_PSD_FULLPAGERECT = 1025,
            CBEM_SETIMAGELIST = 1026,
            DDM_CLOSE = 1026,
            DM_REPOSITION = 1026,
            HKM_GETHOTKEY = 1026,
            PBM_SETPOS = 1026,
            RB_DELETEBAND = 1026,
            SB_GETTEXTA = 1026,
            TB_CHECKBUTTON = 1026,
            TBM_GETRANGEMAX = 1026,
            WM_PSD_MINMARGINRECT = 1026,
            CBEM_GETIMAGELIST = 1027,
            DDM_BEGIN = 1027,
            HKM_SETRULES = 1027,
            PBM_DELTAPOS = 1027,
            RB_GETBARINFO = 1027,
            SB_GETTEXTLENGTHA = 1027,
            TBM_GETTIC = 1027,
            TB_PRESSBUTTON = 1027,
            TTM_SETDELAYTIME = 1027,
            WM_PSD_MARGINRECT = 1027,
            CBEM_GETITEMA = 1028,
            DDM_END = 1028,
            PBM_SETSTEP = 1028,
            RB_SETBARINFO = 1028,
            SB_SETPARTS = 1028,
            TB_HIDEBUTTON = 1028,
            TBM_SETTIC = 1028,
            TTM_ADDTOOLA = 1028,
            WM_PSD_GREEKTEXTRECT = 1028,
            CBEM_SETITEMA = 1029,
            PBM_STEPIT = 1029,
            TB_INDETERMINATE = 1029,
            TBM_SETPOS = 1029,
            TTM_DELTOOLA = 1029,
            WM_PSD_ENVSTAMPRECT = 1029,
            CBEM_GETCOMBOCONTROL = 1030,
            PBM_SETRANGE32 = 1030,
            RB_SETBANDINFOA = 1030,
            SB_GETPARTS = 1030,
            TB_MARKBUTTON = 1030,
            TBM_SETRANGE = 1030,
            TTM_NEWTOOLRECTA = 1030,
            WM_PSD_YAFULLPAGERECT = 1030,
            CBEM_GETEDITCONTROL = 1031,
            PBM_GETRANGE = 1031,
            RB_SETPARENT = 1031,
            SB_GETBORDERS = 1031,
            TBM_SETRANGEMIN = 1031,
            TTM_RELAYEVENT = 1031,
            CBEM_SETEXSTYLE = 1032,
            PBM_GETPOS = 1032,
            RB_HITTEST = 1032,
            SB_SETMINHEIGHT = 1032,
            TBM_SETRANGEMAX = 1032,
            TTM_GETTOOLINFOA = 1032,
            CBEM_GETEXSTYLE = 1033,
            CBEM_GETEXTENDEDSTYLE = 1033,
            PBM_SETBARCOLOR = 1033,
            RB_GETRECT = 1033,
            SB_SIMPLE = 1033,
            TB_ISBUTTONENABLED = 1033,
            TBM_CLEARTICS = 1033,
            TTM_SETTOOLINFOA = 1033,
            CBEM_HASEDITCHANGED = 1034,
            RB_INSERTBANDW = 1034,
            SB_GETRECT = 1034,
            TB_ISBUTTONCHECKED = 1034,
            TBM_SETSEL = 1034,
            TTM_HITTESTA = 1034,
            WIZ_QUERYNUMPAGES = 1034,
            CBEM_INSERTITEMW = 1035,
            RB_SETBANDINFOW = 1035,
            SB_SETTEXTW = 1035,
            TB_ISBUTTONPRESSED = 1035,
            TBM_SETSELSTART = 1035,
            TTM_GETTEXTA = 1035,
            WIZ_NEXT = 1035,
            CBEM_SETITEMW = 1036,
            RB_GETBANDCOUNT = 1036,
            SB_GETTEXTLENGTHW = 1036,
            TB_ISBUTTONHIDDEN = 1036,
            TBM_SETSELEND = 1036,
            TTM_UPDATETIPTEXTA = 1036,
            WIZ_PREV = 1036,
            CBEM_GETITEMW = 1037,
            RB_GETROWCOUNT = 1037,
            SB_GETTEXTW = 1037,
            TB_ISBUTTONINDETERMINATE = 1037,
            TTM_GETTOOLCOUNT = 1037,
            CBEM_SETEXTENDEDSTYLE = 1038,
            RB_GETROWHEIGHT = 1038,
            SB_ISSIMPLE = 1038,
            TB_ISBUTTONHIGHLIGHTED = 1038,
            TBM_GETPTICS = 1038,
            TTM_ENUMTOOLSA = 1038,
            SB_SETICON = 1039,
            TBM_GETTICPOS = 1039,
            TTM_GETCURRENTTOOLA = 1039,
            RB_IDTOINDEX = 1040,
            SB_SETTIPTEXTA = 1040,
            TBM_GETNUMTICS = 1040,
            TTM_WINDOWFROMPOINT = 1040,
            RB_GETTOOLTIPS = 1041,
            SB_SETTIPTEXTW = 1041,
            TBM_GETSELSTART = 1041,
            TB_SETSTATE = 1041,
            TTM_TRACKACTIVATE = 1041,
            RB_SETTOOLTIPS = 1042,
            SB_GETTIPTEXTA = 1042,
            TB_GETSTATE = 1042,
            TBM_GETSELEND = 1042,
            TTM_TRACKPOSITION = 1042,
            RB_SETBKCOLOR = 1043,
            SB_GETTIPTEXTW = 1043,
            TB_ADDBITMAP = 1043,
            TBM_CLEARSEL = 1043,
            TTM_SETTIPBKCOLOR = 1043,
            RB_GETBKCOLOR = 1044,
            SB_GETICON = 1044,
            TB_ADDBUTTONSA = 1044,
            TBM_SETTICFREQ = 1044,
            TTM_SETTIPTEXTCOLOR = 1044,
            RB_SETTEXTCOLOR = 1045,
            TB_INSERTBUTTONA = 1045,
            TBM_SETPAGESIZE = 1045,
            TTM_GETDELAYTIME = 1045,
            RB_GETTEXTCOLOR = 1046,
            TB_DELETEBUTTON = 1046,
            TBM_GETPAGESIZE = 1046,
            TTM_GETTIPBKCOLOR = 1046,
            RB_SIZETORECT = 1047,
            TB_GETBUTTON = 1047,
            TBM_SETLINESIZE = 1047,
            TTM_GETTIPTEXTCOLOR = 1047,
            RB_BEGINDRAG = 1048,
            TB_BUTTONCOUNT = 1048,
            TBM_GETLINESIZE = 1048,
            TTM_SETMAXTIPWIDTH = 1048,
            RB_ENDDRAG = 1049,
            TB_COMMANDTOINDEX = 1049,
            TBM_GETTHUMBRECT = 1049,
            TTM_GETMAXTIPWIDTH = 1049,
            RB_DRAGMOVE = 1050,
            TBM_GETCHANNELRECT = 1050,
            TB_SAVERESTOREA = 1050,
            TTM_SETMARGIN = 1050,
            RB_GETBARHEIGHT = 1051,
            TB_CUSTOMIZE = 1051,
            TBM_SETTHUMBLENGTH = 1051,
            TTM_GETMARGIN = 1051,
            RB_GETBANDINFOW = 1052,
            TB_ADDSTRINGA = 1052,
            TBM_GETTHUMBLENGTH = 1052,
            TTM_POP = 1052,
            RB_GETBANDINFOA = 1053,
            TB_GETITEMRECT = 1053,
            TBM_SETTOOLTIPS = 1053,
            TTM_UPDATE = 1053,
            RB_MINIMIZEBAND = 1054,
            TB_BUTTONSTRUCTSIZE = 1054,
            TBM_GETTOOLTIPS = 1054,
            TTM_GETBUBBLESIZE = 1054,
            RB_MAXIMIZEBAND = 1055,
            TBM_SETTIPSIDE = 1055,
            TB_SETBUTTONSIZE = 1055,
            TTM_ADJUSTRECT = 1055,
            TBM_SETBUDDY = 1056,
            TB_SETBITMAPSIZE = 1056,
            TTM_SETTITLEA = 1056,
            MSG_FTS_JUMP_VA = 1057,
            TB_AUTOSIZE = 1057,
            TBM_GETBUDDY = 1057,
            TTM_SETTITLEW = 1057,
            RB_GETBANDBORDERS = 1058,
            MSG_FTS_JUMP_QWORD = 1059,
            RB_SHOWBAND = 1059,
            TB_GETTOOLTIPS = 1059,
            MSG_REINDEX_REQUEST = 1060,
            TB_SETTOOLTIPS = 1060,
            MSG_FTS_WHERE_IS_IT = 1061,
            RB_SETPALETTE = 1061,
            TB_SETPARENT = 1061,
            RB_GETPALETTE = 1062,
            RB_MOVEBAND = 1063,
            TB_SETROWS = 1063,
            TB_GETROWS = 1064,
            TB_GETBITMAPFLAGS = 1065,
            TB_SETCMDID = 1066,
            RB_PUSHCHEVRON = 1067,
            TB_CHANGEBITMAP = 1067,
            TB_GETBITMAP = 1068,
            MSG_GET_DEFFONT = 1069,
            TB_GETBUTTONTEXTA = 1069,
            TB_REPLACEBITMAP = 1070,
            TB_SETINDENT = 1071,
            TB_SETIMAGELIST = 1072,
            TB_GETIMAGELIST = 1073,
            TB_LOADIMAGES = 1074,
            TTM_ADDTOOLW = 1074,
            TB_GETRECT = 1075,
            TTM_DELTOOLW = 1075,
            TB_SETHOTIMAGELIST = 1076,
            TTM_NEWTOOLRECTW = 1076,
            TB_GETHOTIMAGELIST = 1077,
            TTM_GETTOOLINFOW = 1077,
            TB_SETDISABLEDIMAGELIST = 1078,
            TTM_SETTOOLINFOW = 1078,
            TB_GETDISABLEDIMAGELIST = 1079,
            TTM_HITTESTW = 1079,
            TB_SETSTYLE = 1080,
            TTM_GETTEXTW = 1080,
            TB_GETSTYLE = 1081,
            TTM_UPDATETIPTEXTW = 1081,
            TB_GETBUTTONSIZE = 1082,
            TTM_ENUMTOOLSW = 1082,
            TB_SETBUTTONWIDTH = 1083,
            TTM_GETCURRENTTOOLW = 1083,
            TB_SETMAXTEXTROWS = 1084,
            TB_GETTEXTROWS = 1085,
            TB_GETOBJECT = 1086,
            TB_GETBUTTONINFOW = 1087,
            TB_SETBUTTONINFOW = 1088,
            TB_GETBUTTONINFOA = 1089,
            TB_SETBUTTONINFOA = 1090,
            TB_INSERTBUTTONW = 1091,
            TB_ADDBUTTONSW = 1092,
            TB_HITTEST = 1093,
            TB_SETDRAWTEXTFLAGS = 1094,
            TB_GETHOTITEM = 1095,
            TB_SETHOTITEM = 1096,
            TB_SETANCHORHIGHLIGHT = 1097,
            TB_GETANCHORHIGHLIGHT = 1098,
            TB_GETBUTTONTEXTW = 1099,
            TB_SAVERESTOREW = 1100,
            TB_ADDSTRINGW = 1101,
            TB_MAPACCELERATORA = 1102,
            TB_GETINSERTMARK = 1103,
            TB_SETINSERTMARK = 1104,
            TB_INSERTMARKHITTEST = 1105,
            TB_MOVEBUTTON = 1106,
            TB_GETMAXSIZE = 1107,
            TB_SETEXTENDEDSTYLE = 1108,
            TB_GETEXTENDEDSTYLE = 1109,
            TB_GETPADDING = 1110,
            TB_SETPADDING = 1111,
            TB_SETINSERTMARKCOLOR = 1112,
            TB_GETINSERTMARKCOLOR = 1113,
            TB_MAPACCELERATORW = 1114,
            TB_GETSTRINGW = 1115,
            TB_GETSTRINGA = 1116,
            TAPI_REPLY = 1123,
            ACM_OPENA = 1124,
            BFFM_SETSTATUSTEXTA = 1124,
            CDM_FIRST = 1124,
            CDM_GETSPEC = 1124,
            IPM_CLEARADDRESS = 1124,
            WM_CAP_UNICODE_START = 1124,
            ACM_PLAY = 1125,
            BFFM_ENABLEOK = 1125,
            CDM_GETFILEPATH = 1125,
            IPM_SETADDRESS = 1125,
            PSM_SETCURSEL = 1125,
            UDM_SETRANGE = 1125,
            WM_CHOOSEFONT_SETLOGFONT = 1125,
            ACM_STOP = 1126,
            BFFM_SETSELECTIONA = 1126,
            CDM_GETFOLDERPATH = 1126,
            IPM_GETADDRESS = 1126,
            PSM_REMOVEPAGE = 1126,
            UDM_GETRANGE = 1126,
            WM_CAP_SET_CALLBACK_ERRORW = 1126,
            WM_CHOOSEFONT_SETFLAGS = 1126,
            ACM_OPENW = 1127,
            BFFM_SETSELECTIONW = 1127,
            CDM_GETFOLDERIDLIST = 1127,
            IPM_SETRANGE = 1127,
            PSM_ADDPAGE = 1127,
            UDM_SETPOS = 1127,
            WM_CAP_SET_CALLBACK_STATUSW = 1127,
            BFFM_SETSTATUSTEXTW = 1128,
            CDM_SETCONTROLTEXT = 1128,
            IPM_SETFOCUS = 1128,
            PSM_CHANGED = 1128,
            UDM_GETPOS = 1128,
            CDM_HIDECONTROL = 1129,
            IPM_ISBLANK = 1129,
            PSM_RESTARTWINDOWS = 1129,
            UDM_SETBUDDY = 1129,
            CDM_SETDEFEXT = 1130,
            PSM_REBOOTSYSTEM = 1130,
            UDM_GETBUDDY = 1130,
            PSM_CANCELTOCLOSE = 1131,
            UDM_SETACCEL = 1131,
            EM_CONVPOSITION = 1132,
            PSM_QUERYSIBLINGS = 1132,
            UDM_GETACCEL = 1132,
            MCIWNDM_GETZOOM = 1133,
            PSM_UNCHANGED = 1133,
            UDM_SETBASE = 1133,
            PSM_APPLY = 1134,
            UDM_GETBASE = 1134,
            PSM_SETTITLEA = 1135,
            UDM_SETRANGE32 = 1135,
            PSM_SETWIZBUTTONS = 1136,
            UDM_GETRANGE32 = 1136,
            WM_CAP_DRIVER_GET_NAMEW = 1136,
            PSM_PRESSBUTTON = 1137,
            UDM_SETPOS32 = 1137,
            WM_CAP_DRIVER_GET_VERSIONW = 1137,
            PSM_SETCURSELID = 1138,
            UDM_GETPOS32 = 1138,
            PSM_SETFINISHTEXTA = 1139,
            PSM_GETTABCONTROL = 1140,
            PSM_ISDIALOGMESSAGE = 1141,
            MCIWNDM_REALIZE = 1142,
            PSM_GETCURRENTPAGEHWND = 1142,
            MCIWNDM_SETTIMEFORMATA = 1143,
            PSM_INSERTPAGE = 1143,
            MCIWNDM_GETTIMEFORMATA = 1144,
            PSM_SETTITLEW = 1144,
            WM_CAP_FILE_SET_CAPTURE_FILEW = 1144,
            MCIWNDM_VALIDATEMEDIA = 1145,
            PSM_SETFINISHTEXTW = 1145,
            WM_CAP_FILE_GET_CAPTURE_FILEW = 1145,
            MCIWNDM_PLAYTO = 1147,
            WM_CAP_FILE_SAVEASW = 1147,
            MCIWNDM_GETFILENAMEA = 1148,
            MCIWNDM_GETDEVICEA = 1149,
            PSM_SETHEADERTITLEA = 1149,
            WM_CAP_FILE_SAVEDIBW = 1149,
            MCIWNDM_GETPALETTE = 1150,
            PSM_SETHEADERTITLEW = 1150,
            MCIWNDM_SETPALETTE = 1151,
            PSM_SETHEADERSUBTITLEA = 1151,
            MCIWNDM_GETERRORA = 1152,
            PSM_SETHEADERSUBTITLEW = 1152,
            PSM_HWNDTOINDEX = 1153,
            PSM_INDEXTOHWND = 1154,
            MCIWNDM_SETINACTIVETIMER = 1155,
            PSM_PAGETOINDEX = 1155,
            PSM_INDEXTOPAGE = 1156,
            DL_BEGINDRAG = 1157,
            MCIWNDM_GETINACTIVETIMER = 1157,
            PSM_IDTOINDEX = 1157,
            DL_DRAGGING = 1158,
            PSM_INDEXTOID = 1158,
            DL_DROPPED = 1159,
            PSM_GETRESULT = 1159,
            DL_CANCELDRAG = 1160,
            PSM_RECALCPAGESIZES = 1160,
            MCIWNDM_GET_SOURCE = 1164,
            MCIWNDM_PUT_SOURCE = 1165,
            MCIWNDM_GET_DEST = 1166,
            MCIWNDM_PUT_DEST = 1167,
            MCIWNDM_CAN_PLAY = 1168,
            MCIWNDM_CAN_WINDOW = 1169,
            MCIWNDM_CAN_RECORD = 1170,
            MCIWNDM_CAN_SAVE = 1171,
            MCIWNDM_CAN_EJECT = 1172,
            MCIWNDM_CAN_CONFIG = 1173,
            IE_GETINK = 1174,
            IE_MSGFIRST = 1174,
            MCIWNDM_PALETTEKICK = 1174,
            IE_SETINK = 1175,
            IE_GETPENTIP = 1176,
            IE_SETPENTIP = 1177,
            IE_GETERASERTIP = 1178,
            IE_SETERASERTIP = 1179,
            IE_GETBKGND = 1180,
            IE_SETBKGND = 1181,
            IE_GETGRIDORIGIN = 1182,
            IE_SETGRIDORIGIN = 1183,
            IE_GETGRIDPEN = 1184,
            IE_SETGRIDPEN = 1185,
            IE_GETGRIDSIZE = 1186,
            IE_SETGRIDSIZE = 1187,
            IE_GETMODE = 1188,
            IE_SETMODE = 1189,
            IE_GETINKRECT = 1190,
            WM_CAP_SET_MCI_DEVICEW = 1190,
            WM_CAP_GET_MCI_DEVICEW = 1191,
            WM_CAP_PAL_OPENW = 1204,
            WM_CAP_PAL_SAVEW = 1205,
            IE_GETAPPDATA = 1208,
            IE_SETAPPDATA = 1209,
            IE_GETDRAWOPTS = 1210,
            IE_SETDRAWOPTS = 1211,
            IE_GETFORMAT = 1212,
            IE_SETFORMAT = 1213,
            IE_GETINKINPUT = 1214,
            IE_SETINKINPUT = 1215,
            IE_GETNOTIFY = 1216,
            IE_SETNOTIFY = 1217,
            IE_GETRECOG = 1218,
            IE_SETRECOG = 1219,
            IE_GETSECURITY = 1220,
            IE_SETSECURITY = 1221,
            IE_GETSEL = 1222,
            IE_SETSEL = 1223,
            CDM_LAST = 1224,
            IE_DOCOMMAND = 1224,
            MCIWNDM_NOTIFYMODE = 1224,
            IE_GETCOMMAND = 1225,
            IE_GETCOUNT = 1226,
            IE_GETGESTURE = 1227,
            MCIWNDM_NOTIFYMEDIA = 1227,
            IE_GETMENU = 1228,
            IE_GETPAINTDC = 1229,
            MCIWNDM_NOTIFYERROR = 1229,
            IE_GETPDEVENT = 1230,
            IE_GETSELCOUNT = 1231,
            IE_GETSELITEMS = 1232,
            IE_GETSTYLE = 1233,
            MCIWNDM_SETTIMEFORMATW = 1243,
            EM_OUTLINE = 1244,
            MCIWNDM_GETTIMEFORMATW = 1244,
            EM_GETSCROLLPOS = 1245,
            EM_SETSCROLLPOS = 1246,
            EM_SETFONTSIZE = 1247,
            MCIWNDM_GETFILENAMEW = 1248,
            MCIWNDM_GETDEVICEW = 1249,
            MCIWNDM_GETERRORW = 1252,
            FM_GETFOCUS = 1536,
            FM_GETDRIVEINFOA = 1537,
            FM_GETSELCOUNT = 1538,
            FM_GETSELCOUNTLFN = 1539,
            FM_GETFILESELA = 1540,
            FM_GETFILESELLFNA = 1541,
            FM_REFRESH_WINDOWS = 1542,
            FM_RELOAD_EXTENSIONS = 1543,
            FM_GETDRIVEINFOW = 1553,
            FM_GETFILESELW = 1556,
            FM_GETFILESELLFNW = 1557,
            WLX_WM_SAS = 1625,
            SM_GETSELCOUNT = 2024,
            UM_GETSELCOUNT = 2024,
            WM_CPL_LAUNCH = 2024,
            SM_GETSERVERSELA = 2025,
            UM_GETUSERSELA = 2025,
            WM_CPL_LAUNCHED = 2025,
            SM_GETSERVERSELW = 2026,
            UM_GETUSERSELW = 2026,
            SM_GETCURFOCUSA = 2027,
            UM_GETGROUPSELA = 2027,
            SM_GETCURFOCUSW = 2028,
            UM_GETGROUPSELW = 2028,
            SM_GETOPTIONS = 2029,
            UM_GETCURFOCUSA = 2029,
            UM_GETCURFOCUSW = 2030,
            UM_GETOPTIONS = 2031,
            UM_GETOPTIONS2 = 2032,
            OCMBASE = 8192,
            OCM_CTLCOLOR = 8217,
            OCM_DRAWITEM = 8235,
            OCM_MEASUREITEM = 8236,
            OCM_DELETEITEM = 8237,
            OCM_VKEYTOITEM = 8238,
            OCM_CHARTOITEM = 8239,
            OCM_COMPAREITEM = 8249,
            OCM_NOTIFY = 8270,
            OCM_COMMAND = 8465,
            OCM_HSCROLL = 8468,
            OCM_VSCROLL = 8469,
            OCM_CTLCOLORMSGBOX = 8498,
            OCM_CTLCOLOREDIT = 8499,
            OCM_CTLCOLORLISTBOX = 8500,
            OCM_CTLCOLORBTN = 8501,
            OCM_CTLCOLORDLG = 8502,
            OCM_CTLCOLORSCROLLBAR = 8503,
            OCM_CTLCOLORSTATIC = 8504,
            OCM_PARENTNOTIFY = 8720,
            WM_APP = 32768,
            WM_RASDIALEVENT = 52429,
        } //enum Wm

Mit folgendem Code gehts bei mir (man kann nur Großbuchstaben und Zeilenumbrüche eingeben, wobei Kleinbuchstaben in Großbuchstaben umgewandelt werden)
Ich mache dabei nichts rückgängig und zeichne nichts auf.

-Einfügen aus der Zwischenablage wird gefiltert.
-Eingeben von Zeichen wird gefiltert (auch alt+...)
-Es wird nicht jedesmal der gesamte Text gefiltert, sondern nur die Eingaben.

Für daS Wm-enum siehe hier.

public class CustomTextbox : TextBox
    {
        protected override void WndProc(ref Message m)
        {
            switch ((Wm)m.Msg)
            {
                case Wm.WM_CHAR:
                    {
                        if (OnChar((char)m.WParam))
                        {
                            base.WndProc(ref m);
                        }
                    }
                    break;
                case Wm.WM_PASTE:
                    {
                        OnPaste();
                    }
                    break;
                default:
                    base.WndProc(ref m);
                    break;
            }
        }

        private void OnPaste()
        {
            Insert(FilterString(GetPasteText()));
        }

        private string FilterString(string text)
        {
            char[] chars = new char[text.Length];
            int i = 0;
            foreach (char c in text)
            {
                char newChar = c;
                if (FilterChar(ref newChar))
                {
                    chars[i] = newChar;
                    i++;
                }
            }
            return new string(chars, 0, i);
        }

        public void Insert(string newText)
        {
            int oldStart = SelectionStart;
            int oldLength = SelectionLength;
            string oldText = Text;
            Text = oldText.Substring(0, oldStart) + newText + oldText.Substring(oldStart + oldLength);
            SelectionStart = oldStart+newText.Length;
        }

        private static string GetPasteText()
        {
            IDataObject obj = Clipboard.GetDataObject();
            if (obj.GetDataPresent(DataFormats.UnicodeText))
            {
                return obj.GetData(DataFormats.UnicodeText).ToString();
            }
            if (obj.GetDataPresent(DataFormats.Text))
            {
                return obj.GetData(DataFormats.Text).ToString();
            }
            return "";
        }

        private bool OnChar(char p)
        {
            
            if ((Control.ModifierKeys & ~Keys.Shift) == Keys.Control)
            {
                switch ((int)p)
                {
                    case 1:
                        SelectAll();
                        break;
                    case 24:
                        Cut();
                        break;
                    case 3:
                        Copy();
                        break;
                    case 22:
                        OnPaste();
                        break;
                }
                return false;
            }
            if (p == '\b'||p=='\r') return true;
            if (FilterChar(ref p))
                Insert(p.ToString());
            return false;
        }

        protected virtual bool FilterChar(ref char p)
        {
            if (p == '\r' || p == '\n') return Multiline;
            if (p <= 'Z' && p >= 'A') return true;
            if (p <= 'z' && p >= 'a') { p = (char)((int)p + (int)'A' - (int)'a'); return true; }
            return false;
        }
    }

Ich denke dieser Code gewinnt zwar den Kampf mit der Windmühle, ob es sinnvoll ist eingabeseitig zu prüfen muss wohl jeder selbst beurteilen.

Sonst überschreib doch einfach wndproc: wm_char (wParam nach char casten), überprüfe die Eingaben und änder den Text selbst (Selectionstart ist die Position des carets, auf '\b' prüfen), wm_paste auch abfangen

Wenn man in einen bestimmten Prozess eine c#-Assebmbly einschleusen will, ohne gleich einen systemeiten hook zu setzen geht es mir der Bibliothek auch. (Die Assembly muss auch eine Klasse namens Hook enthalten, die hookproc wird allerdings nie aufgerufen, sondern nur "init" und "run"):

        unsafe private static void InjectCore(uint processId)
        {
            IntPtr hKernel32 = Kernel32.LoadLibrary("kernel32.dll");
            IntPtr loadLibraryProc = Kernel32.GetProcAddress(hKernel32, "LoadLibraryW");
            IntPtr hprocess = Kernel32.OpenProcess(Kernel32.ProcessAccessFlags.CreateThread | Kernel32.ProcessAccessFlags.Synchronize |
                Kernel32.ProcessAccessFlags.VMWrite | Kernel32.ProcessAccessFlags.VMOperation | Kernel32.ProcessAccessFlags.VMRead
            , false, processId);

            IntPtr foreigenMemory = IntPtr.Zero;
            {
                string paramstr = Program.GetLocalPath() + "LoaderDll.dll\0";
                byte[] bytes = Encoding.Unicode.GetBytes(paramstr);
                foreigenMemory = Kernel32.VirtualAllocEx(hprocess, IntPtr.Zero, (uint)bytes.Length,
                    Kernel32.AllocationType.RESERVE | Kernel32.AllocationType.COMMIT, Kernel32.MemoryProtection.EXECUTE_READWRITE);
                int written = 0;
                Kernel32.WriteProcessMemory(hprocess, foreigenMemory, bytes, (uint)bytes.Length, out written);
            }
            uint id = 0;
            Kernel32.CreateRemoteThread(hprocess, IntPtr.Zero, 0, loadLibraryProc, foreigenMemory, 0, &id);
            Kernel32.CloseHandle(hprocess);
        }

public class Kernel32
    {
        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle,
           uint dwProcessId);

        [Flags]
        public enum ProcessAccessFlags : uint
        {
            All = 0x001F0FFF,
            Terminate = 0x00000001,
            CreateThread = 0x00000002,
            VMOperation = 0x00000008,
            VMRead = 0x00000010,
            VMWrite = 0x00000020,
            DupHandle = 0x00000040,
            SetInformation = 0x00000200,
            QueryInformation = 0x00000400,
            Synchronize = 0x00100000
        }

        [DllImport("kernel32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool CloseHandle(IntPtr hObject);

        [DllImport("kernel32.dll")]
        public static extern IntPtr GetCurrentProcess();

        [DllImport("kernel32.dll")]
        public static extern IntPtr OpenThread(ThreadAccess dwDesiredAccess, bool bInheritHandle,
           uint dwThreadId);

        [DllImport("kernel32.dll")]
        public static extern bool TerminateThread(IntPtr hThread, uint dwExitCode);

        [Flags]
        public enum ThreadAccess : int
        {
            TERMINATE = (0x0001),
            SUSPEND_RESUME = (0x0002),
            GET_CONTEXT = (0x0008),
            SET_CONTEXT = (0x0010),
            SET_INFORMATION = (0x0020),
            QUERY_INFORMATION = (0x0040),
            SET_THREAD_TOKEN = (0x0080),
            IMPERSONATE = (0x0100),
            DIRECT_IMPERSONATION = (0x0200)
        }

        [DllImport("kernel32.dll")]
        public static extern uint SuspendThread(IntPtr hThread);

        [DllImport("kernel32.dll")]
        public static extern uint ResumeThread(IntPtr hThread);

        [DllImport("kernel32.dll")]
        public static unsafe extern IntPtr CreateRemoteThread(IntPtr hProcess,
           IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, uint* lpThreadId);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress,
           byte[] lpBuffer, uint nSize, out int lpNumberOfBytesWritten);


        [Flags()]
        public enum AllocationType : uint
        {
            COMMIT = 0x1000,
            RESERVE = 0x2000,
            RESET = 0x80000,
            LARGE_PAGES = 0x20000000,
            PHYSICAL = 0x400000,
            TOP_DOWN = 0x100000,
            WRITE_WATCH = 0x200000
        }

        [Flags()]
        public enum MemoryProtection : uint
        {
            EXECUTE = 0x10,
            EXECUTE_READ = 0x20,
            EXECUTE_READWRITE = 0x40,
            EXECUTE_WRITECOPY = 0x80,
            NOACCESS = 0x01,
            READONLY = 0x02,
            READWRITE = 0x04,
            WRITECOPY = 0x08,
            GUARD_Modifierflag = 0x100,
            NOCACHE_Modifierflag = 0x200,
            WRITECOMBINE_Modifierflag = 0x400
        }

        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
        public static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress,
           uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect);

        [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
        public static extern IntPtr LoadLibrary(String InPath);

        [DllImport("kernel32.dll", CharSet = CharSet.Ansi)]
        public static extern IntPtr GetProcAddress(IntPtr InModule, String InProcName);
    }

Guckste Easyhook oder Sharppcap.
Sharppcap basiert wie Wireshark auf Winpcap
Mit Easyhook kann man c#-Assemblys in gemanagte und nicht gemanagte Prozesse einschleusen und gemanagte Hookhandler für nicht gemanagte Apifunktionen schreiben.
Wer nur einschleusen und nicht apihooken will kann sich auch hier bedinen.

Ich hab folgendes ausgegraben:

[StructLayout(LayoutKind.Sequential)]
private struct ICONINFO
{
     public bool IsIcon;
     public int xHotspot;
     public int yHotspot;
     public IntPtr MaskBitmap;
     public IntPtr ColorBitmap;
};

[DllImport("user32.dll")]
private static extern IntPtr CreateIconIndirect([In] ref ICONINFO iconInfo);

[DllImport("gdi32.dll")]
public static extern bool DeleteObject(IntPtr hObject);

private static void CreateIcon(Bitmap bmp)
{
     ICONINFO ii = new ICONINFO();
     ii.IsIcon = true;
     IntPtr imgHandle = bmp.GetHbitmap();
     try
     {
     ii.MaskBitmap = imgHandle;
     ii.ColorBitmap = imgHandle;
     IntPtr handle = CreateIconIndirect(ref ii);
     _formIcon = Icon.FromHandle(handle);
     }
     finally
     {
     DeleteObject(imgHandle);
     }
}

Weiß aber ned, obs besser is.

Ehmm:

1. Das Programm ist von mir. Könntest du bitte dazu sagen, dass es von mir ist und auf den eigentlichen thread verweisen, anstatt es einfach so umzubenennen und anzuhängen?!!
   PC Fernsteuerung

2. Der Code ist gerßteils von mir (alles, was nicht von mir ist findet man auf http://www.pinvoke.net/) und wirklich c#, aber ich bin nicht gewillt, den zu veröffentlichen. Grundsätzlich könnte man die gui aber weglassen und die Addresse hardcoden.

Ich finde, bis jetzt ist es
a)Die schönste Komponente
b)Die umfangreichtse

Wo wir schon bei absichtlichem horror sind: Coderätsel: Was macht dieses Programm?

Als ich ein Control mal über den halben Bildschirm gezogen hab, has bei mir auch angefangen zu flackern.
Hab bereits einen fix versucht. Probier einfach mal den aktuellen code. Bin mir aber nicht sicher, obs wirklich viel bringt.

Wenn ich die Prograssbar auf normaler größe hab, flackert es bei mir auch so nicht.

Ich hab es nun sdelber mal getestet.
Ergebnis ist, dass es funktioniert, solange das Fenster, das den Button enthält den fokus hat.

Wollt ihr jetzt Pursuit Racer (Grafiker gesucht) nachbauen?

Titel ist immerhin: PursuitDrift (2D-Autorennspiel)

Die Methode onEnter funktioniert auch aber wird dann überzeichnet glaube ich,

Normalerweise schon, aber ausgerechnet bei der textbox hält sich microsoft selbst nicht dran, weshalb man den Textbereich einer textbox auchnicht selber zeichnen kann. (von apihooks einmal abgesehen)

Ja, aber onPaint wird nie aufgerufen!
Deshalb funktioniert es auch nicht.

Das framework ruft normalerweise entwerder die Originalmethode aus oder OnPaint. Wenn man beides aufgerufen haben will, hilft normalerweise folgendes: Darstellung von windowseigenen Controls ändern
Das Problem dabei ist aber, dass es nur aufgerufen wird, wenn normal in wm_paint gezeichnet wird. Da M$ aber bei der Textbox den Textbereich außerhalb von wm_paint zeichnet, kannst du in WM_paint höchstens den Ramen ändern.

Wenn es wichtige daten sind, sollte man sie nicht unbedingt im firefox speichern, weil man bloß 2 dateien kopieren braucht, um die Passwörter (z.B. auf einen anderen Rechner) zu übertragen und auszulesen.

Wenn du einen mausklick simulieren willst, obwohl das Fenster nicht zusehen ist:

1. ist es dein eigenes Fenster oder nicht?
   eigen:
   Onclick aufrufen
   fremd:
   0x0200=512=WM_MOUSEMOVE
   0x0201=513=WM_LBUTTONDOWN
   0x0202=514=WM_LBUTTONUP
   in der Reigenfolge senden. (google)
   Nimm dazu am besten PostMessage

Du musst aber darauf achten, dass du das handle zum richtigen unterfenster hast:ChildWindowFromPointEx

Wenn du ein fenster simulieren wills, das garned da is, nimm nen globalen getmessagehook und prüf jede mausmessage, ob sie für das fenster bestimmt is.

Versuch mal das:

[StructLayout(LayoutKind.Sequential, Size=512),Serializeable(),UnsafeValueType()]
struct DMXStep
{
//leer
}

Zugriff auf die Unterelemente:

DMXStep value;
byte* pValue=(byte*)&value;
byte element=pValue[index];

Stellt sich nurnoch die Frage, ob der Serializer das Kapiert.

Falls nicht, musst du wohl versuchen, selber zu serialisieren.

Ich brauche eine sichere Möglichkeit, einem bestimmten Prozess Daten zu übergeben:

struct Parameters
{
    int id;
    IntPtr handle;
}

Ich kenne lediglich die prozessId und die threadId. Die Nachricht muss auf jeden Fall ankommen, egal ob der Thread schon läuft oder noch "suspended" ist.

Tcp o.Ä. kommt auf keinen Fall in Frage, ich kann die Nachricht auchnicht über Kommandozeile oder standardInput (Console) übergeben.

Wofür ist die Api gut?

        [DllImport("user32.dll")]
        static extern bool GetKeyboardState([Out(), MarshalAs(UnmanagedType.LPArray)]byte[] lpKeyState);

        [DllImport("user32.dll")]
        static extern int ToUnicode(int wVirtKey, uint wScanCode, byte[] lpKeyState,[Out(), MarshalAs(UnmanagedType.LPArray)]char[] result, int cchBuff,uint wFlags);

Siehe dazu auch: msdn

Eine Combibox besteht intern aus mehreren Controls. (u.A. einer textbox,die genau da ist, wo dein text verschwindet).
Diese Controls haben aber keinen gemanagten Wrapper und sind deshalb nur über winapi erreichbar. Du müsstest also wenn überhaupt die WndProc der Textrbox ableiten.
Mal abgesehen davon abgesehen ist es extrem schwierig, das Aussehen einer Textbox zu ändern, weil der Textbereich außerhalb WM_PAINT neu gezeichnet wird. (mit lokalem apihook gehts natrürlich).

Wird in deinem Fall auchnichts nützen, aber wenn ich deinen code so sehe, solltest du dir mal "setStyle(resizeredraw|userdrawing,true)" und Darstellung von windowseigenen Controls ändern angucken.

Hallo Floste,
ich weiß ja nicht welchen Reflector du meinst oder welche Version du benutzt, aber bei mir gibts im Reflector (Lutz Röder) unter File den Menupunkt Open Cache der genau das tut was du suchst, hat sogar eine Suchfunktion.

Die aktruellste, updates sind an

Open Cache da sind (bei mir) nur die Frameworkassemblies drin. Slimdx und XNA z.B. sind bei mir in der Liste nicht enthalten, obwohl beides installiert ist.

Edit: Da bin ich anscheinend nicht der Einzige.

Wer einmal eine Anwendung, die XNA, Slimdx oder ähnliche Frameworks verwendet im .net Reflector betrachten wollte, dem wird angezeigt worden sein, dass die Assembies nicht gefunden werden konnten und man sie manuell suchen soll. Aber wo sind die hin?

Antwort: Sie sind in einem Unterordner von "%SYSTEMROOT%\assembly".
(Wenn man den Ordner über Start->Ausführen aufruft, wird das %SYSTEMROOT% durch den Systemordner, meist "C:\Windows" ersetzt)

Wer den Ordner aber direkt zu öffnen versucht, wird keine gewöhnliche Ordneransicht vorfinden. Wie soll man da die Assemblies mit dem Reflektor öffnen?

Dafür gibt es 3 Möglichkeiten:

1. Man schreibe seinen eigenen Explorer oder nutze cmd 😉
2. Man gibt "%SYSTEMROOT%\assembly\gac" in Ausführen ein und wechselt in den übergeordneten Ordner, denn dadurch kann man anscheinend die künstliche Ansicht umgehen.
3. Xp bis Vista: Man kann den Ordner als Laufwerk einbinden: in cmd "subst X: %SYSTEMROOT%\assembly", wobei das "X" durch den gewünschten Laufwerksbuchstaben ersetzt werden kann. Wieder los wird man das Laufwerk mit "subst X: /d".

so müssts gehen. (bool durch int ersetzt)

Ich hatte vor kurzem ein ähnliches Problem. Ich habe es mit halbwegs akteptabler Performance gelöst (Threadsicher):

        LockFreeQueue<string> toWrite=new LockFreeQueue<string>();//nicht einfach Queue<T> nehmen, weil nicht Threadsicher
        int invoking=0;
        StringBuilder sbCmdOut = new StringBuilder(1048576);
        void rec_Receaved(object sender, General.GEA<string> e)
        {
            toWrite.Enqueue(e);
            if (Interlocked.Exchange(ref invoking,1)==0)//wenn nicht schon Verarbeitung in Auftrag gegeben wurde
            {
                BeginInvoke((MethodInvoker)(() =>
                    {
                        invoking=0;
                        string toAppend;
                        while (toWrite.Dequeue(out toAppend))
                        {
                            sbCmdOut.Append(toAppend);
                        }
                            textBoxCmd.Text = sbCmdOut.ToString();
                            textBoxCmd.SelectionStart = textBoxCmd.Text.Length;
                            textBoxCmd.ScrollToCaret();
                    }));
            }
        }

Was ich damit sagen wollte: sobald ein anderes Programm den Speicher brauchtwid in der Regel welcher freigegeben.

Immer wenn irgendwo als Argument ein irgendwas* gefordert wird, kannst du void* oder IntPtr (ohne sternchen) übergeben, oder einen Zeiger auf einen primitiven Typ bzw. einen Zeiger auf ein struct als Typ angeben.

Du bekommst für belibige (auch selbstdefinierte) c#-delegaten mithilfe einer statischen Funktion der Klasse Marshal ein IntPtr.

Was jeweils am meiten Sinn macht, ist die andere Frage.

Was kann / muss ich machen, um den Ram wieder auf die Ausgansgröße von etwa 15MB runterzukriegen?

Starte ein anderes programm, das sehr viel Speicher braucht.

Ja, es fehlte eine Abfrage, ob das Array leer ist. Ich hab mal eine dazugehackt.

Ersteinmal möchte ich mich für den Code bedanken. Die Klasse ist sehr hilfreich.

Danke. Für was nimmst du sie denn?

([Edit] die binarys sind jetzt in den Unterordnern .\Release\ und .\Injecter\bin\Release){orange}

Beschreibung:

Eine Bootstrapper-dll, die eine c#-dll nachlädt und die Hookproc-Aufrufe daran weiterleitet.

Die zu ladende Dll muss eine Klasse namens "Hook", die in keinem namespace ist und die Funktionen "public static int Init(string empty)","public static int GetHookProc(string empty)" und "public static int Run(string empty)" enthält enthalten:

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Runtime.InteropServices;

public class Hook
{
    [STAThread]
    public static int Init(string empty)
    {
        return 0;
    }

    public delegate int HookProcDelegate(int code, IntPtr wParam, IntPtr lParam);

    [STAThread]
    public static int GetHookProc(string empty)
    {
        HookProcDelegate del = new HookProcDelegate(HookProc);
        
        GCHandle.Alloc(del, GCHandleType.Normal);//Edit

        IntPtr result = Marshal.GetFunctionPointerForDelegate(del);
        return (int)result;
    }

    [DllImport("user32.dll")]
    static extern int CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);

    static unsafe int HookProc(int code, IntPtr wParam, IntPtr lParam)
    {
        MSG* pmsg = (MSG*)lParam;
        //Hook-Code
        return CallNextHookEx(IntPtr.Zero, code, wParam, lParam);
    }

    public static int Run(string empty)
    {
        return 0;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct MSG
    {
        public IntPtr hwnd;
        public UInt32 message;
        public IntPtr wParam;
        public IntPtr lParam;
        public UInt32 time;
        public POINT pt;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct POINT
    {
        public int X;
        public int Y;

        public POINT(int x, int y)
        {
            this.X = x;
            this.Y = y;
        }

        public static implicit operator System.Drawing.Point(POINT p)
        {
            return new System.Drawing.Point(p.X, p.Y);
        }

        public static implicit operator POINT(System.Drawing.Point p)
        {
            return new POINT(p.X, p.Y);
        }
    }
}

Hook erstellen (die c#dll "inject.dll" mit der Hook-klasse und die loaderDll.dll müssen sich im gleichen Ordner befinden):

[DllImport("kernel32.dll",EntryPoint="LoadLibraryW")]
        static extern IntPtr LoadLibrary([MarshalAs(UnmanagedType.LPWStr)]string str);

        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, ExactSpelling = true)]
        public static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

        [DllImport("user32.dll", SetLastError = true)]
        static extern IntPtr SetWindowsHookEx(HookType hook, IntPtr callback,
        IntPtr hMod, int dwThreadId);

        [DllImport("user32.dll")]
        static extern bool UnhookWindowsHookEx(IntPtr hhk);

        public enum HookType : int
        {
            WH_JOURNALRECORD = 0,
            WH_JOURNALPLAYBACK = 1,
            WH_KEYBOARD = 2,
            WH_GETMESSAGE = 3,
            WH_CALLWNDPROC = 4,
            WH_CBT = 5,
            WH_SYSMSGFILTER = 6,
            WH_MOUSE = 7,
            WH_HARDWARE = 8,
            WH_DEBUG = 9,
            WH_SHELL = 10,
            WH_FOREGROUNDIDLE = 11,
            WH_CALLWNDPROCRET = 12,
            WH_KEYBOARD_LL = 13,
            WH_MOUSE_LL = 14
        }

       
        IntPtr hHook=IntPtr.Zero;
        IntPtr hDll = LoadLibrary("LoaderDll.dll");
        if(hDll==IntPtr.Zero)throw new Exception("LoaderDll.dll nicht gefunden");
        IntPtr hookProc = GetProcAddress(hDll, "?Proc@@YGJHIJ@Z");
        hHook = SetWindowsHookEx(HookType.WH_GETMESSAGE, hookProc, hDll, 0);
        ...
        //zurückkehern zu Application.Run()
        ....
        UnhookWindowsHookEx(hHook);
        

Schlagwörter: Globaler Hook Hoocproc Keyboard

-Bugfix für Markus Fehler versucht. Es kann allerdings sein, dass die Texturen der Controls komplett weiß werden. (zweimal das jeweils mitlerste Control zum Starten klicken)

Die controls kann man trotzdem bedienen. Dur die Darstellung geht ned. (Directx kannn anscheinend keine bitmaps laden, und ich kenn kein anderes so einfaches Format)

Die mittleren weißen teile sind buttons zum klicken (unterer weißer Streifen im ersten Bild)

Neue Version:
-Editor ist jetzt mit im Paket
-Shader verbessert
-Man kann jetzt Startpositionen der Autos im Editor festlegen
-Anzeige von Geschwindigkeit, restlicher Strecke und Platzierung
-Nach 2 Runden ist das Spiel zuende (Abkürzen ist zwar möglich,die zurückgelegte Strecke wird aber solange nicht gewertet, bis man zu der Position, wo man vom kurs Abgewichen ist zurückgefahren ist)

**Ich suche jemanden, der gut mit Blender o.ä umgehen kann, ein wenig Ahnung hat und für das Projekt ein paar schöne Modelle herstellt. **(Einfach ne Pn an mich , am besten mit Skypenamen, senden.)

Die dll gehört zum Betriebssystem und es kann verschidene Versionen geben:
-Sicherheitspatches werden nur auf die Version im Systemordner angewandt
-Es kann Unterschide/Optimierungen zwischen Betriebssystemversionen geben
-Deine Kopie kann inkompatibel zum Betriebssystem/der Version sein.

Du hast all diese probleme nicht, wenn du die dll aus dem Systemordner verwendest.

Wenn khalid Recht hat mit der Reihenfolge, ist es aber schlichtweg egal, weil deine kopie ignoriert wird.

Erstell einfach ein Panel und abbonier das Paint-Event (doppelklick im Designer). In die erstellte Methode Packst du deinen Zeichencode. Ein Graphics wird für dich automatisch erstellt: e.Graphics.

Wenn du das machst, dann wird dein Code immer aufgerufen, wenn Windows merkt, dass ein Teil deiner Zeichnungen verschwunden ist und neu gezeichnet werden muss.

Wenn du deinen Zeichencode selber aufrufen willst, weil sich die Werte deiner Anzeige geändert haben, schreib anstelle deines Zeichencodes control.Invalidate(), das ruft dann deinen Zeichencode auf.

Ich kann aber nur empfehlen, [Tutorial] Zeichnen in Windows-Programmen (Paint/OnPaint, PictureBox) einmal gründlich und mit Bemühen um Vertändnis durchzuarbeiten.

Globale Hotkeys?

Man kann ihn aber seeehhr leicht entlarven: drück mal die "Dachtaste" (^)

Meine Tests ergaben, dass lzma deutlich langsamer ist, aber teilweise ein paar kB besser komprimiert.

Bei beinahe verlustfreier komprimierung (Verlust nur durch ycbcr Umwandlung) habe ich ca. 2/3 der Dateigröße von pngs erreicht.

Allerdings hinterlässt die Reduzierung der Differenzstufen an Kanten und Bereichen maximaler Helligkeit bunte Störpixel. Meine Resultate hatten bei leicht schlechterer Qualität ca. die doppelte Dateigröße von jpeg.

Irgendwie ist das Verarbeiten auch recht langsam. Ich muss wohl noch dran Arbeiten, aber für mein erstes Bildformat bin ich zufrieden.

Ansonsten mein Tip: Prog dir das PNG Format nach, bzw. bau die Prefilter nach und Pack das ganze mit nem BZIP Stream.

Sowas ähnliches mach ich grade:

1. YCbCr
2. Filter, der dem Png Vorfilter sehr ähnlich ist, aber die möglichen Differenzstufen reduziert
   (3. evl. Huffman oder sowas)
3. LZMA

Mal gucken, was draus wird
Ich wäre schon mit 5 FPS sehr zufrieden.

Ich verwende bereits ein eigenes Double Buffering und da ich das Standardverhalten umgehe, wird das Property "DoubleBuffered" ignoriert.

Das Flackern ist mir bisher nicht aufgefallen.

uund mdx ist nicht eingeschalfen?

slimdx unterstützt directx 10.
xna nicht.

Ich habs jetzt so gelöst, dass ich für jeden Block ein bit mitsende, ob er transparent sein soll.

Warum benutzt Du nicht DivX oder MP4, denn die sind ja extra für soetwas gedacht.

1. kennst du eine halbwegs bequeme api
2. Was ich mache ist quasi livestreaming. Sind die Codecs+api für sowas geeignet?

Fuer Window XP Homer Benutzer wahrscheinlich eine gute alternative.

Nichtnur für die, sondern, wenn einer seinen Router nicht konfigurierebn kann/will, geht es bei meinem trotzdem in beide Richtungen. Außerdem kommt meine Fernsteuerung mit einer eibnzigen Verbindung über tcp aus.

Die Remoteunterstützung funktioniert nur bei vollständiger Netzwerkverbindung zwischen dem Computer des erfahrenen Benutzers und dem Computer des unerfahrenen Benutzers über folgende Netzwerkanschlüsse:

* TCP-Port 135  
* TCP-Port 3389  
* Alle TCP-Ports oberhalb von 1024  

Wenn für einen dieser Anschlüsse zwischen den beiden Computern eine Portfilterung vorliegt, funktioniert die Remoteunterstützung nicht.

Setzte das ganze fuer Windows Mobile um und du hast einen neuen user fuer dein Tool 😃

Ich habe nochnie etwas für windows mobile gemacht.

Was müsste ich denn alles ändern?
1.Compact Framework verwenden
2. Windowsnachrichten statt Sendinput
3. ???

Bleibt der Netzwerkkrams gleich?

Reicht es, wenn ich den Clienten protiere?

Ich würde es sehr nervig finden, 2 Projekte mit fast identischem Code zu haben und immer beide zu aktualisieren, sobald ich etwas ändere.

@seequark (jojo) bitte benutz deinen Aufrufzählererhöher woanders. Der verursacht bloß unnützen Datenverkehr.

Slimdx ist zwar etwas komplizierter als xna, ist mdx aber deutlich ähnlicher.

HINWEIS: Das folgende Programm wurde für windows xp konzipiert und man muss UAC vollständig deaktivieren, um es auf Vista und nachfolgern zu benutzen!

Im Anhang ist eine "PC Fernsteuerung", mit der man, sofern der Client es erlaubt:
-Bildschirmfotos anfordern (beinahe Video)
-Maus benutzen
-Schreiben
-Dateien senden
-Meldungsfenster anzeigen
-Beligige Programme starten (Cmd, man sieht die Ausgabe)

Die Features können vom Fernzuzusteuernden einzeln deaktiviert werden.
Ein Demovideo gibts auch: http://www.youtube.com/watch?v=4E3IkN1B13M