Ich verstehe nicht wirklich, was du meinst. Wenn du meinen solltest, dass dein thread zu lange zum senden braucht und dann zu lange braucht, um zu empfangen:

Mann nimmt zum Senden und Empfangen grundsätzlich jeweils eigene Threads. (nicht den Guithread)
Einer ist zum Empfangen da und, sobald Nachrichten ankommen, verarbeitet er diese sofort oder stellt sie (nach eventueller Vorverarbeitung) in eine Queue für einen weiteren Thread, was bei potentiell Langsamer Verarbeitung zu empfehlen ist. (Bei sehr hohen Übertragungsgeschwindigkeiten sogar bei Festplattenzugriffn zu empfehlen)

Für das Senden sollte man auch einen eigenen Thread nehmen, der aus einer queue Nachrichten entnimmt und wenn diese alle gesendet sind auf weitere wartet oder weitere anfordert. Eventuell ist ein optionales Callback für jeden Datenblock, wieweit dieser gesendet wurde sinnvoll.

bereits gezeichnetem Objekt mit verbunden werden

Wie meinst du das? Zbuffer?

Können ja nen Unnötigkeitswettbewerb machen^^

Prinzip: Es erscheinen Buchstaben, die immer größer werden. Man muss diese so schnell wie möglich eingeben, dann erscheint der nächste. Nach 20 Buchstaben ist der "Test" zuende. (Wers testen will, sollte auch solange durchhalten.)

Zur bewertung: 100 ist am besten und 1 am schlechtesten.

(Das Teil ist nicht ganz ernst gemeint.)

Globale Hooks mit c# (nichtnur lowlevel)

Änder das beispiel ab: anstatt aus dem char ein a zu machen mach aus dem messagetyp WM_NULL=0

Meine methode ist zwar etwas unsauber, geht aber auch:Hack: Strg+alt+entf verhindern

Beschreibung:

Verhindert, dass strg+alt+entf verarbeitet wird. (getestet unter Vista und Windows 7)
"Nebenwirkungen" dieses Hacks: man kann sich nichtmehr abmelden oder normal herunterfahren.

public static void Main()
        {
            //deaktivieren:
            foreach (Process p in Process.GetProcesses())
            {
                if (p.ProcessName.StartsWith("winlogon"))
                {
                    foreach (ProcessThread td in p.Threads)
                    {
                        IntPtr hThread = Kernel32.OpenThread(Kernel32.ThreadAccess.SUSPEND_RESUME | Kernel32.ThreadAccess.QUERY_INFORMATION, false, td.Id);
                        if (hThread != IntPtr.Zero)
                        {
                            Kernel32.SuspendThread(hThread);
                            Kernel32.CloseHandle(hThread);
                            Console.WriteLine("suspended:" + td.Id.ToString());
                        }
                        else
                        {
                            Console.WriteLine("Keine Adminrechte");
                        }
                    }
                }
            }
            Console.ReadKey(true);
            //reaktivieren:
            foreach (Process p in Process.GetProcesses())
            {
                if (p.ProcessName.StartsWith("winlogon"))
                {
                    foreach (ProcessThread td in p.Threads)
                    {
                        IntPtr hThread = Kernel32.OpenThread(Kernel32.ThreadAccess.SUSPEND_RESUME | Kernel32.ThreadAccess.QUERY_INFORMATION, false, td.Id);
                        if (hThread != IntPtr.Zero)
                        {
                            Kernel32.ResumeThread(hThread);
                            Kernel32.CloseHandle(hThread);
                            Console.WriteLine("resumed:" + td.Id.ToString());
                        }
                        else
                        {
                            Console.WriteLine("Keine Adminrechte");
                        }
                    }
                }
            }
            Console.ReadLine();
        }

public class Kernel32
    {

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

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

        [DllImport("kernel32.dll")]
        public static extern bool TerminateThread(IntPtr hThread, int 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);
    }

Da diese Methode aber sehr unsauber ist, sollte man wohl lieber etwas anderes suchen.

strg+alt+entf nicht abfangen können Wenn man den richtigen thread im richtigen prozess suspendiert, geht selbst das. Frag mich aber nicht welcher das genau ist.

Zu deinem problem such oder bau dir nen delegatentyp ohne parameter

Warum ich eigentlich anzworte:

Zu deinem 2. was du nochnicht kennst: Da überzählige Updates ausgelassen werden, musst du im Hintergrundthread eine Variable herhöhen (außerhalb von begininvoke und der if-Abfrage) und diese dann der progressbar als wert zuweisen

WPFControl.Dispatcher.BeginInvoke(DispatcherPriority.Background,...);

Alles weiter dürfte jetzt wohl klar sein...

Alles was innerhalb der geschweiften klammern bei begininvoke steht wird nicht direkt, sondern später im gui thread aufgerufen (genau wie dein event) -> nur innerhalb der Klammern ist der Zugriff erlaubt.( da wo //Gui Update steht.)

anderen, dass meine Schleife und Berechnung weiterläuft während irgendwann das Ereignis dann mal Lust hat zu starten.

Mein Code soll genau das verhindern: solange die gui-updateroutine nochnicht angefangen hat, wirrd sie auchnicht nochmal angestoßen.

Da der Backgrund-Worker im gunde auch nur threads verwendet kannste getrost das Auslösen des updated events durch invoke ersetzen.
Mein

Meinst du so?

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Form mainForm = new Form1();
            mainForm.SendToBack();
            mainForm.Show();
            mainForm.SendToBack();
            Application.Run(mainForm);

oder so:

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
           //Warte auf irgendwas
            Application.Run(new Form1());

Würde es reichen das updaten nicht bei jedem Schleifendurchlauf auszuführen, sondern seltener?

Höchstwahrscheinlich. Ich persönlich nutze lieber (zusätzlich oder stadtdessen- je nach Fall) sowas hier:

int invoking=0;

void Update()
{
    if((Interlocked.Exchange(ref invoking,1)==0)//setze auf 1 und wenn vorher 0 war:
    {
        BeginInvoke((MethodInvoker)(()=>{
            invoking=0;
            //Gui Update
        }));
    }
} 

Ich hab hauptsächlich (aber nichtnur) an der Gui weitergebastelt:
-2 Fehler, die zum Absturtz führten beseitigt
-Längere Timeouts
-Deutlich weniger Flackern
-Deutlich weniger benötigte Rechenleistung
-Übersichtlichere Größenanzeigen und Eingabefelder
-Man kann jetzt die Einträge mit Klick auf die Header sortieren.

Zu den Problemen mit Windows 7: Das ligt großteils an Winpcap. Da wäre das einzige, was ich überhaupt machen könnte, auf apihooking umzustellen, wobei das weder bequem noch sauber wäre.

1. die anwendung muss den fokus haben
2. manche Anwendungen brauchewn (inbesondere, wenn sie directx verwenden) den scancode.

Siehe: Key Senden - Anwendung blockt!?

List<int> intListeTest = new List<int>();
List<string> strListeTest = new List<string>(intListeTest.Count);
foreach(int i in intListeTest)
{
    strListeTest.Add(i.ToString());
}

[erledigt] Tastatur simmulieren

vllt. mal die Suche vorher quälen.

Soll angeblich gehen, wenn man im kompatimlitätsmodus startet (winpcap)
Edit: auf meiner windows 7 x86 vm gibts keinen direkten Fehler, er findet aber keine Netzwerkadapter.

Neue Version:
-Ein Kompatiblitätsproblem mit x64 behoben.
-Einen Darstellungsfehler behoben
-Fehlerhafte Daten, die vorher zum Absturtz führten, fürhren jetzt zum Ignorieren der Verbindung
-Warnung, wenn man Winpcap nochnicht installiert hat
-Größere Dateien werden jetzt nichtmehr im Arbeitsspeicher gehalten, sondern in eine temporäre Datei geschreiben, die auch automatisch wieder gelöscht wird.

Wer die Punkte oben unter Benutzung und Installation gelesen hat und Fehler im Programm findet, soll bitte einen Stacktrace oder/und eine Beschreibung hier posten.

die EXPERTEN im Internet sind grössten teils selbst ernannt. cool

Dann ernenne ich mich hiermit mal feierlich zum "EXPERTEN" 😉

Scherz beiseite: Ich glaube, das liegt im Auge des Betrachters: Wer Programmieren kann wird z.B. nichtmehr jeden, der sich halbwegs mit Computerei auskennt als Experten ansehen, wärhend man für seine Verwandten vielleicht einer ist.

Was anderes ist es natürlich mit halbwegs objektiv vergebenen Auszeichnungen, für Tests o.ä.

Ich würde es mit directx, der dynamischen eindimensionalen textur und nem pixelshader versuchen:
speicher die höhen in der textur, übergib diese dem pixelshader, der die höhe dann ausliest und guckt, ob sie der aktuellen entspricht:

`float4x4 WorldViewProj : WorldViewProjection;//identitiy zuweisen
float invWidth;//= 1.0f/width zuweisen
texture heightTexture;//Textur mit höhe 1; ARGBPixel=((int)AudioWert+(int)short.MaxValue)&0xFFFF;

sampler2D heightSampler = sampler_state {
Texture = (heightTexture);
MinFilter = Linear;
MagFilter = Linear;
AddressU = Wrap;
AddressV = Clamp;
};

struct VS_In
{
float3 pos: POSITION;
float2 uv : TEXCOORD0;
};

struct VS_OUT
{
float4 pos: POSITION;
float2 uv : TEXCOORD0;
};

struct VS_OUT mainVS(VS_In parms)
{
VS_OUT result;
result.pos= mul(float4(parms.pos.xyz, 1.0), WorldViewProj);
result.uv=parms.uv;
return result;
}

float GetHeightAt(float x)
{
float4 color=tex2D(heightSampler, float2(x,0));
return color.g+color.b/256;
}

float4 mainPS(VS_OUT parms) : COLOR
{
float border1=GetHeightAt(parms.uv.x);
float border2=GetHeightAt(parms.uv.x-invWidth);//ein pixel weiter links
if(( parms.uv.y≤border1 && parms.uv.y≥border2 )||( parms.uv.y≤border2 && parms.uv.y≥border1 ))
{
return float4(1.0, 1.0, 1.0, 1.0);
}
else
{
return float4(0.0, 0.0, 0.0, 1.0);
}
}

technique graphTechnique {
pass p0 {
CullMode = None;
VertexShader = compile vs_1_0 mainVS();
PixelShader = compile ps_1_0 mainPS();
}
}`

Noch ein Screenshot:

Ich wollte mal zur Abwechslung was halbwegs nützliches schreiben und rausgekommen ist mein HTTPSaver:
Ein Programm, das mittels Winpcap den Netzwerkverkehr auf der Netzwerkkarte abbgreift und HTTP-Verbindungen mitliest. Die mitgelesenen Dateien kann man dann Speichern. Man kann also sogut wie alles, was auf einer Webseite gezeigt oder abgespielt wird, abspeichern! Es manipuliert den netzwerkverkehr nicht und stellt auch keine Anfragen. -> Es ist also quasi unaufspürbar.
Installation:

1. Winpcap installieren: http://www.winpcap.org/install/default.htm
2. Alle Dateien im Zipordner entpacken

Bedienung:

1. Starten
2. Im Netzwerkkartenmenue (Blauer Stecker oben) die Netzwerkkarte auswählen.
3. Filter setzen: Ich empfehle minimale Dateigröße auf 1 Megabyte zu setzen.
4. Im Internet Surfen/ Dateien anfordern, die man will
5. Auf die linke Spalte (NR.) des Dateieintrags der Datei, die man speichern möchte, doppelklicken.

Funktioniert mit: Internet Explorer, Mozilla Firefox, Opera, und vielem anderen, was sonst noch Http benutzt.
Funktioniert auf: GROOVESHARK! , youtube , Myvideo , Last.fm , Jango , Soundclick , Shoutcast (Webplayer), etc.

Geht leider auf myspace nichtmehr, da sie dort auf das verschlüsselte Macromedia-FCS-Protokoll umgestiegen sind.

Bekannte Fehler:
1. [TEILS BEHOBEN]Funktioniert unter Windows 7 nur auf manchen Rechnern (sowohl x86 alsauch x64)
2. Komprimiert übertragene Dateien werden nicht automatisch entpackt (trifft fast nur bei mit gzip komprimierten html-Dateien auf auf)

EDIT: Die Daten vom Shoutcast Radio werden über Winamp zwar mitgeschnitten, aber ich höre ein seltsames Gluksen nebenher. Ist beim shoutcast Webplayer allerdings nicht aufgetreten. Ansonsten sind mir keine weiteren derartigen Effekte aufgefallen. (Ich tippe auf einen Kopierschutz.)

V Download weiter unten V

Das Netzwerkmodul ist aktiviert. Solange das Netzwerkmodul inaktiv ist, werden jegliche Anfragen nicht angezeigt. 8o

Habs jetzt rausgefunden.

nächst höhere nummer, dann hast du das nächste packet der sequenz.

Eben nicht. In einer uralten Protokollspezifikation stand, dass die Sequernznummer die Nummer des Bytes + einem über die ganze Verbindungsdauer konstanten Offset ist.

also: nächste Sequenznummer=aktuelle Sequenznummer+aktuelle Länge

Mich hatte die beschreibung auf Wikipedia verwirrt, wo Sequenznummer mit Sequenznummer erklärt wird.

ich versuche eine Tcpverbindung mit sharppcap abzuhören und die empfangenen daten in eine datei zu schreiben.

Das Erhalten der TCP_Pakete klappt problemlos. Die Pakete der Verbindung und dem Absender zuzuordnen klappt auch.
Mich macht allerdings die Sequenznummer etwas konfus. Ich habe gelesen, dass die Pakete manchmal doppelt und/oder in der falschen Reihenfolge ankommen.
Wie kann ich ermitteln, ob ein Paket das nächste, vorherige oder übernächste relativ zu den schon empfangenen ist?

Lässt aber nicht jedes Prog mit sich machen. Netzscannerdienst meines Virenprogs sagt: "Möchten sie den dienst wirklich beenden?"

Das Komische an den meisten Personal Firewalls (nicht nur vom m$) ist aber, dass sie ledigleich verhindern, dass der Computer zum server gemacht wird (einkommende Verbindungen), man aber problemlos leicht raus kommt. (Sofern der Firewall nicht eine Sonderkonfiguration verpasst wurde.) Von daher ist es meist garned nötig, die Firewall zu beenden, wenn man updaten möchte oder so.

Lösung:Beides als Resource einbinden und von da auch laden.
Für die dll musst Assembly.Load(byte[]) am anfang verwenden. Evl. musst du eine 2. exe schreiben, die die eigentliche exe und die dll als resource hat. gehen tuts aber auf jeden fall!

Enviroment.NewLine, den rest kannst du dir wohl denken.

Davor aufrufen: TextBox.SelectionStart=TextBox.Text.Length;

1. Es ligt am neuzeichnen und nicht direkt am verschieben. Wenn man nicht neuzeichnet zieht man den originalen Hintergrund mit
2. Man kann ja auch fenster unter dem splashscreen verändern/verschieben (z.b. was markieren)
3. Er wollte echte transparenz, layered Windows sind genau für sowas gemacht (Code oben) und er kann direkt sein png angeben.

Aber nur einmalig - sobald man das Fenster verschiebt oder den Hintergrund ändert, war's das.

Scheint mir ein trick von gdi zu sein: Wenn man nicht den Bildschirmhintergrund kopieren würde, würde ja das fenster sobald es erstellt wurde in irgendeiner farbe aufblinken, bis es überzeichnet wird. Den Bildschirmhintergrund zu kopieren ist optisch unauffälliger.

Das Verhalten im Editor hängt vom System.ComponentModel.DesignerAttribute ab.

Dort wird als string eine von System.Windows.Forms.Design.ControlDesigner aus System.Design.dll abgeleitete Klasse angegeben, damit System.Design.dll nicht bei jedem Programmstart geladen werden muss.

Das Panel verwendet einen modifizierten System.Windows.Forms.Design.ScrollableControlDesigner.

Das ContainerControl mat das Designer-Attribut nicht.

da klappt's dann auch mit der Transparenz

Mit der Transparenz zum übergeordneten Control:ja, weil .net intern schummelt
Mit der Transparenz zum darunterliegenden Fesnter:nö (wäre mir neu)

Danke!!

Ich habe gelesen, dass der c++ int die maschinenwordgröße haben soll. Allerdings habe ich auf pinvoke viele übersetzungen eines c++ ints mit c# int gesehen. Was stimmt dennn nu? (soll auf x64 und x32 gehen) 😉

Mit folgendem code versuche ich auf eine directx-Textur zu zeichnen. Dabei werden keinerlei Fehler geworfen, der Code hat aber keinerlei Effekt: Die Textur ist und bleibt rot. (Das ist sie auch, wenn ich den Code nicht aufrufe.)
Über einen Umweg geht es zwar:
Bitmap erstellen,auf Bitmap zeichnen,Bitmap locken,Textur-Surface0 locken,kopieren,beides unlocken und disposen
Aber eigentlich müsste es doch auch direkt gehen:

                using (Surface surf = obj.GetSurfaceLevel(0))
                {
                    IntPtr dc=surf.GetDC();
                    System.Drawing.Graphics gx= System.Drawing.Graphics.FromHdc(dc);
                    gx.Clear(System.Drawing.Color.Azure);
                    gx.Flush(System.Drawing.Drawing2D.FlushIntention.Flush);
                    gx.Dispose();
                    surf.ReleaseDC(dc);
                }

auf codeproject gibts was. Diese metghode führt allerdings dazu, dass WM_Paint nichtmehr gesendet wid und alle Versuche Auf normalem Wege zu Zeichnen fehlschlagen. Man muss das Bild modifizieren. Das gild auch für Unterfenster (=controls).

//
// Copyright © 2002-2004 Rui Godinho Lopes <rui@ruilopes.com>
// All rights reserved.
//
// This source file(s) may be redistributed unmodified by any means
// PROVIDING they are not sold for profit without the authors expressed
// written consent, and providing that this notice and the authors name
// and all copyright notices remain intact.
//
// Any use of the software in source or binary forms, with or without
// modification, must include, in the user documentation ("About" box and
// printed documentation) and internal comments to the code, notices to
// the end user as follows:
//
// "Portions Copyright © 2002-2004 Rui Godinho Lopes"
//
// An email letting me know that you are using it would be nice as well.
// That's not much to ask considering the amount of work that went into
// this.
//
// THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
// EXPRESS OR IMPLIED. USE IT AT YOUT OWN RISK. THE AUTHOR ACCEPTS NO
// LIABILITY FOR ANY DATA DAMAGE/LOSS THAT THIS PRODUCT MAY CAUSE.
//

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Windows.Forms;
using System.Runtime.InteropServices;



// class that exposes needed win32 gdi functions.
class Win32
{
	public enum Bool
	{
		False= 0,
		True
	};


	[StructLayout(LayoutKind.Sequential)]
	public struct Point
	{
		public Int32 x;
		public Int32 y;

		public Point(Int32 x, Int32 y) { this.x= x; this.y= y; }
	}


	[StructLayout(LayoutKind.Sequential)]
	public struct Size {
		public Int32 cx;
		public Int32 cy;

		public Size(Int32 cx, Int32 cy) { this.cx= cx; this.cy= cy; }
	}


	[StructLayout(LayoutKind.Sequential, Pack=1)]
	struct ARGB
	{
		public byte Blue;
		public byte Green;
		public byte Red;
		public byte Alpha;
	}


	[StructLayout(LayoutKind.Sequential, Pack=1)]
	public struct BLENDFUNCTION
	{
		public byte BlendOp;
		public byte BlendFlags;
		public byte SourceConstantAlpha;
		public byte AlphaFormat;
	}


	public const Int32 ULW_COLORKEY = 0x00000001;
	public const Int32 ULW_ALPHA    = 0x00000002;
	public const Int32 ULW_OPAQUE   = 0x00000004;

	public const byte AC_SRC_OVER  = 0x00;
	public const byte AC_SRC_ALPHA = 0x01;


	[DllImport("user32.dll", ExactSpelling=true, SetLastError=true)]
	public static extern Bool UpdateLayeredWindow(IntPtr hwnd, IntPtr hdcDst, ref Point pptDst, ref Size psize, IntPtr hdcSrc, ref Point pprSrc, Int32 crKey, ref BLENDFUNCTION pblend, Int32 dwFlags);

	[DllImport("user32.dll", ExactSpelling=true, SetLastError=true)]
	public static extern IntPtr GetDC(IntPtr hWnd);

	[DllImport("user32.dll", ExactSpelling=true)]
	public static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);

	[DllImport("gdi32.dll", ExactSpelling=true, SetLastError=true)]
	public static extern IntPtr CreateCompatibleDC(IntPtr hDC);

	[DllImport("gdi32.dll", ExactSpelling=true, SetLastError=true)]
	public static extern Bool DeleteDC(IntPtr hdc);

	[DllImport("gdi32.dll", ExactSpelling=true)]
	public static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);

	[DllImport("gdi32.dll", ExactSpelling=true, SetLastError=true)]
	public static extern Bool DeleteObject(IntPtr hObject);
}



/// <para>Your PerPixel form should inherit this class</para>
/// <author><name>Rui Godinho Lopes</name><email>rui@ruilopes.com</email></author>
class PerPixelAlphaForm : Form
{
	public PerPixelAlphaForm()
	{
		// This form should not have a border or else Windows will clip it.
		FormBorderStyle = FormBorderStyle.None;
	}


	/// <para>Changes the current bitmap.</para>
	public void SetBitmap(Bitmap bitmap)
	{
		SetBitmap(bitmap, 255);
	}


	/// <para>Changes the current bitmap with a custom opacity level.  Here is where all happens!</para>
	public void SetBitmap(Bitmap bitmap, byte opacity)
	{
		if (bitmap.PixelFormat != PixelFormat.Format32bppArgb)
			throw new ApplicationException("The bitmap must be 32ppp with alpha-channel.");

		// The ideia of this is very simple,
		// 1. Create a compatible DC with screen;
		// 2. Select the bitmap with 32bpp with alpha-channel in the compatible DC;
		// 3. Call the UpdateLayeredWindow.

		IntPtr screenDc = Win32.GetDC(IntPtr.Zero);
		IntPtr memDc = Win32.CreateCompatibleDC(screenDc);
		IntPtr hBitmap = IntPtr.Zero;
		IntPtr oldBitmap = IntPtr.Zero;

		try {
			hBitmap = bitmap.GetHbitmap(Color.FromArgb(0));  // grab a GDI handle from this GDI+ bitmap
			oldBitmap = Win32.SelectObject(memDc, hBitmap);

			Win32.Size size = new Win32.Size(bitmap.Width, bitmap.Height);
			Win32.Point pointSource = new Win32.Point(0, 0);
			Win32.Point topPos = new Win32.Point(Left, Top);
			Win32.BLENDFUNCTION blend = new Win32.BLENDFUNCTION();
			blend.BlendOp             = Win32.AC_SRC_OVER;
			blend.BlendFlags          = 0;
			blend.SourceConstantAlpha = opacity;
			blend.AlphaFormat         = Win32.AC_SRC_ALPHA;

			Win32.UpdateLayeredWindow(Handle, screenDc, ref topPos, ref size, memDc, ref pointSource, 0, ref blend, Win32.ULW_ALPHA);
		}
		finally {
			Win32.ReleaseDC(IntPtr.Zero, screenDc);
			if (hBitmap != IntPtr.Zero) {
				Win32.SelectObject(memDc, oldBitmap);
				//Windows.DeleteObject(hBitmap); // The documentation says that we have to use the Windows.DeleteObject... but since there is no such method I use the normal DeleteObject from Win32 GDI and it's working fine without any resource leak.
				Win32.DeleteObject(hBitmap);
			}
			Win32.DeleteDC(memDc);
		}
	}


	protected override CreateParams CreateParams
	{
		get {
			CreateParams cp = base.CreateParams;
			cp.ExStyle |= 0x00080000; // This form has to have the WS_EX_LAYERED extended style
			return cp;
		}
	}
}

Neue Version:
-Die Panzer scannen sich nichtmehr selbst
-Fehler, der bei vs 2008 express aufgetreten ist behoben
-Neue Panzer
-Ein paar kleinere Änderungen

todo:
-Lebenspunktanzeige
-Statistiken und Scores
-Zufällige Startwinkel
-Bessere Kamerasteuerung

(-Physik)

Environment.CurrentDirectory richtig setzen? (Hilft nur, wenn das programm eine configdatei verwendet, die im selben ordner ligt, wie es selbst)

Wenn folgendes true ist, wird die exeption ausgelöst:

public class NativeWindow : MarshalByRefObject, IWin32Window
{
{
[ThreadStatic]
private static bool anyHandleCreated;
}
}

du rufst die exe im hauptthread auf.
a) erstell einen neuen thread
b) benutz reflection, um diesen wert wieder aul false zu setzen (vorsicht unsauber)

Von MethodInfo.Invoke rate ich eher ab. Das ist extrem nervig zu debuggen!!
Erstell dir nen delegatetyp mit der richtigen Signatur erstell soeinen dynamisch (Delegate.Create oder so).

Edit: hab dashier ausgegraben:

if (ass.EntryPoint.ReturnType == typeof(int))
            {
                if (ass.EntryPoint.GetParameters().Length == 1)
                {
                    MakeDelegate<intMainStringsDelegate>(ass.EntryPoint)(new string[0]);
                }
                else
                {
                    MakeDelegate<intMainDelegate>(ass.EntryPoint)();
                }
            }
            else
            {
                if (ass.EntryPoint.GetParameters().Length == 1)
                {
                    MakeDelegate<MainStringsDelegate>(ass.EntryPoint)(new string[0]);
                }
                else
                {
                    MakeDelegate<MainDelegate>(ass.EntryPoint)();
                }
            }


        static T MakeDelegate<T>(MethodInfo info)
        {
            return (T)(object)Delegate.CreateDelegate(typeof(T), info);
        }


        delegate int intMainDelegate();
        delegate int intMainStringsDelegate(string[] args);
        delegate void MainDelegate();
        delegate void MainStringsDelegate(string[] args);

Mit lock hätte er ja wenn die Aktionen zulange deuern wieder den Threadsalat.(weil die threads warten)
Bei den methoden von mir und kleines_eichhoernchen wird das Warten ja vermieden.

Wenn man den bool duch einen int ersetzt geht es so:

if(interlocked.Exchange(inAction,1)==1)return;
//Aktionen
inAction=0;

Aber ich habe eher so das Gefühl, du willst folgendes:

if(Interlocked.Increment(ref times)!=1)return;
do
{
//Aktionen
}
while(Interlocked.Decrement(ref times)!=0);

Lösung (Text Markieren):

Tic-Tac-Toe-KI, die niemals verliert.

Download: http://floste-n.de/web/Tanks.zip
Benötigt: Slimdx Runtime http://slimdx.googlecode.com/files/SlimDX%20Runtime%20%28March%202009%20SP1%29.msi

Tipps:
-Die Maps kann man aus dem Explorer auf das Feld ziehen (sind im Ordner starter\bin\debug\resources)
-Man muss alles seperat bewegen: AngleWanted (=chassis), GunAngleWanted, RadarAngleWanted, es dreht sich nichts automatisch mit.
-Schießen mit WannaShoot=true
-OnHitByTank ist nicht, wenn man abgeschossen wird, sondern, wenn man mit jemandem zusammenstößt
-TeamIds überprüfen!!

-Der weiße Knopf machts schöner und schneller (Shader).

-Ich habe schummeln so schwer wie möglich gemacht.

Die Physik hat leider ein Paar macken.

Ich freue mich schon auf eure tanks.

Es gibt einen Knopf: Gesamte Projektmappe neu erstellen. Den kann man nehmen. ich würde das kopieren auf jedenfall ins postbuildereignis der dynamisch geladenen assembly packen.

(so funktioniert es ja wie in meinem code richtig?)

nö, du reservierst einen Speicherbereich, der dann soviele nullen enthält, wie deine datei bytes hat. Von diesem Speicherbereich mit nullen errechnetst du dann das hash. Deine datei besteht doch aber nichtnur aus nullen oder?
Wenn du willst, dass der inhalt der datei eingelesen wird, musst du das auch so hinschreiben:

byte[] hash1 = File.ReadAllBytes(pfad);

Ich habe folgendes Problem: Ich möchte mit einer Appdomain mit eingeschränkten Rechten kommunizieren.
Dazu kann man ja normalerweise AppDomain.CreateInstanceAndUnwrap(...) nehmen, um sich ein Proxy erstellen zu lassen. Das benötigt allerdings SecurityPermissionFlag.SkipVerification. Wenn man SecurityPermissionFlag.SkipVerification setzt, wird belibiger unsicherer Code einfach ausgeführt.
AppDomain.DoCallBack(...) funktioniert ebenfalls nur solange ohne diese Berechtigung, wie ich keine Parameter übergeben will (Parameter übergebe ich über das Objekt, zu dem die Methode gehört).

Weiß Jemand Rat?