Beim BackgroundWorker:

bool ReportsProgress { get; set; }
void ReportProgress(int progressPercentage[, object userState])
ProgressChangedEventHandler ProgressChanged(object sender, ProgressChangedEventArgs e)

Ach und nenn die Labels anders, nach einer Woche weißt du doch selbst nicht mehr, was "label5" ist.

Grüße, JasonDelife.

Ich habe das mal mit System.Core.dll gemacht und es lief (Compile-Fx: 3.5; Runtime-Fx: 2.0). Die CLR-Version hat sich ja seit 2.0 nicht mehr geändert.
Also müsste es gehen, wenn du bei den Refrenz-Eigenschaften "Ins Ausgabeverzeichnis kopieren" einstellst.

Grüße, JasonDelife.

Du müsstest eine List<Form> in der MainForm haben, in der du jede Form einfügst.
Dann kannst du mit foreach die Forms alle schließen.
Oder du werkelst mit Application.OpenForms herum, aber da ist ja auch die Hauptform dabei.

Grüße, JasonDelife.

WIDTH und HEIGHT korrekt initialisieren?

Grüße, JasonDelife.

Schau mal hier (Google hilft): MSDN: Threading in WPF

Grüße, JasonDelife.

Wieso setzt du stepsize nicht bevor du den Thread startest?

double stepsize;

void btn_Click(...) {
 stepsize = // Something
 // Threading-Zeug
}

void StartListening() {
 // Variablen
 // stepsize muss nicht mehr aus Textbox geholt werden
 // Rest der Methode
}

Grüße, JasonDelife.

Generell sollte man es vermeiden außerhalb von Paint zu zeichnen.
Wenn du es in pictureBox1_Paint(...) packst, dann wird es ja auch beim laden der form gezeichnet. Wenn es nach einer bestimmten Zeit oder bei einer bestimmten Aktion verschwinden soll, kannst du ja ein boolsches Falg benutzen.

private void pictureBox1_Paint(object sender, PaintEventArgs e)
{
 if(drawMyThings) {
  Graphics neu = e.Graphics;
  // pictureBox1.Refresh(); // ist hier total unnötig (auch in Shown oder Load)
  Pen bla = new Pen(Color.Black);
  neu.DrawLine(bla, 100, 100, 200, 200);
  // Hier kein Dispose(), da ja in Paint, aber
  // AUSSERHALB VON PAINT MUSST DU DISPOSE AUFRUFEN!!!
 }
}

Grüße, JasonDelife.

Probiere mal das, müsste die Performance verbessern:

        private string getString(byte[] b)
        {
            returnstring = "";
            int i = 0;
            StringBuilder sb = new StringBuilder();
            int percent = 0;
            foreach (byte bb in b)
            {
                percent = i / (b.Length / 100);
                if(pbBar.Value != percent) pbBar.Value = percent;
                sb.Append(Convert.ToString(bb, 16));
                i++;
            }
            returnstring = sb.ToString();
            returnstring = returnstring.ToUpper();
            pbBar.Value = 0;
            return returnstring;
        }

Für das Problem mit dem String weiß ich leider nichts.

Grüße, JasonDelife.

Ja, dann ist in deinem Programm die falsche Kodierung eingestellt. Sorry, hab mich undeutlich ausgedrückt. Die .NET-I/O-Klassen versuchen die kodierung rauszufinden oder verwenden eine Standard-Kodierung. Es kann sein, dass diese aber nicht die der datei ist und dann kommt sowas raus. Evtl. änderst du die Datei-Kodierung in Unicode (UTF-16 oder so), das müsste .NET eig. handeln können.

Grüße, JasonDelife.

Das liegt an der falschen Kodierung.
Da musst du schauen, welche der Server unterstützt und welche die Datei hat.

Grüße, JasonDelife.

Zugriffsmethoden gibt es unter Java, aber unter C# sind sie tabu.

Was ist damit?

object obj = new object();
int hash = obj.GetHashCode();
Type t = obj.GetType();
// Eigentlich sind das doch typische Get-Only-Properties, oder?

Grundsätzlich stimme ich herbivore zu, ich wollte nur mal wissen, wieso hier doch Methoden verwendet werden.

Grüße, JasonDelife.

Beim Upload kommt doch keine Antwort, oder nicht?
Was will dir der Server auch antworten?
Es werden doch nur Daten gesendet.

Grüße, JasonDelife.

Doppelposts sind gar nicht gerne gesehen!
Hier hast du extakt das gleiche gepostet: http://forum.chip.de/c-net/client-zugriff-webseite-passwort-1185858.html
EDIT:
Hier auch: http://www.ms-office-forum.net/forum/showthread.php?p=1229260

EDIT 2: Moderator informiert.

Grüße, JasonDelife.

Dann implementierst du Equals eben so. Und/Oder IComparable<T> und Compare.
Oder du gefinierst eine Klasse die IEqualityComparer<T> (Siehe MSDN) implementiert, die Objekte nach Name vergleicht und übergibst eine Instanz als zweites Argument an Except.

Grüße, JasonDelife.

Ein Blick in die MSDN, und schon hat man es:
MSDN: Enumerable.Except-Methode

double[] numbers1 = { 2.0, 2.1, 2.2, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };

IEnumerable<double> onlyInFirstSet = numbers1.Except(numbers2);

foreach (double number in onlyInFirstSet)
    Console.WriteLine(number);

/*
 This code produces the following output:

 2
 2.1
 2.3
 2.4
 2.5
\*/

Grüße, JasonDelife.

Vor allem, da du doch nicht auf WM_PAINT in WndProc hören musst. Es gibt doch virtual void OnPaint(PaintEventArgs e)!

public class MyTextBox : TextBox // Klassen groß!
    {
        bool drawTriangle;
        
        protected override void OnValidating(CancelEventArgs e)
        {

            string sText = "";

            base.OnValidating(e);

            if (_IsPflichtFeld == true) // ISPflichtFeld deutet schon Zwei-Zustands-Logik an
                                                 // --> Daher bool!
            {

                sText = this.Text;

                //Leerzeichen löschen
                string nsText = Regex.Replace(sText," ","");

                if((nsText.Length <= 0) || (nsText == ""))
                {
                    drawTriangle = true;

                    this.Select();
                } else drawTriangle = false;
                this.Invalidate();
            }
        }

        protected override void OnEnter(EventArgs e)
        {
            drawTriangle = true;
            this.Invalidate();
            base.OnEnter(e); // !
        }

         protected override void OnLeave(EventArgs e)
        {
            drawTriangle = false;
            this.Invalidate();
            base.OnLeave(e); // !
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.onPaint(e);
            if(drawTriangle) {
               Graphics f = e.Graphics;
               PointF[] points = {
                                 new Point(this.Width - 8, 0),
                                 new Point(this.Width - 2, 0),
                                 new Point(this.Width - 7, 1),
                                 new Point(this.Width - 2, 1),
                                 new Point(this.Width - 6, 2),
                                 new Point(this.Width - 2, 2),
                                 new Point(this.Width - 5, 3),
                                 new Point(this.Width - 2, 3)
                             };

                f.DrawLines(new Pen(Color.Purple, 1), points);
            }
            // Bei CreateGraphics müsste hier übrigens noch ein f.Dispse(); hin!
        }
    }

Grüße, JasonDelife.

Soweit ich weiß nutzt der WebBrowser den Internet Explorer. Der hat auch irgendwo eine Option "Skriptfehler anzeigen" oder so.

Hoffe, es hilft.
Grüße, JasonDelife.

Das geht auch mit der WebRequest-Klasse.

Grüße, JasonDelife.

Wenn du mit zwei Instanzen arbeiten willst/musst:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Test {
    class Program {
        static void Main(string[] args) {
            Random rnd = new Random();
            Würfel w1 = new Würfel(rnd);
            Würfel w2 = new Würfel(rnd);

            for (int i = 0; i < 10; ++i) {
                Console.WriteLine(w1.Würfeln() + "; " + w2.Würfeln());
            }
        }
    }
    class Würfel {
        private Random rnd;

        public Würfel(Random r) { rnd = r; }
        
        public int Würfeln() {
            return rnd.Next(1, 7);
        }
    }
}

PS: Nur private Member werden klein geschrieben, alles andere groß.

Grüße, JasonDelife.

Ob es da in WPF speziell was gibt, weiß ich nicht.
Aber für die Office-Formate kannst du Office-Interop/PIA verwenden.
Und für PDF sowas wie iTextSharp.

Google hilft 😉.

Grüße, JasonDelife.

Um den Zähl-Thread automatisch mit dem Programm zu beenden, muss man ihn nur als Hintergrund-Thread erzeugen:

Thread t = new Thread(new ThreadStart(method));
// Configure Thread...
t.IsBackground = true;
t.Start();

Mal ganz davon abgesehen, dass der Timer - wie ErfinderDesRades sagte - hier die optimale Lösung ist.

PS: Nur private / lokale Member werden klein geschrieben.

Grüße, JasonDelife.

Wenn mann this.Close() aufruft, wird FormClosing glaube ich nicht aufgerufen.
Also - frei aus dem Kopf - ungefähr so:

private void minimize() {
    this.Hide();
    this.WindowState = FormWindowState.Minimized;
}

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    if (this.WindowState == FormWindowState.Normal)
    {
        e.Cancel = true; // das Schließen des Fensters abbrechen
        minimize();
    }
}

private void button1_Click(object sender, EventArgs e) {
    minimize();
}

Grüße, JasonDelife.

Wenn du eine Unterform hast, die wahrscheinlich jedesmal und oft aufgerufen wird, dann ist das sogar performanter, als die Form jedesmal neu zu erzeugen. Natürlich dauert der Start der Applikation ein bisschen länger.
Das einzige NoGo ist, dass die Form "Form2" heißt 😉.

Grüße, JasonDelife.

Du erzeugst jedesmal ein neues Fenster, dann wird das neue Fenster versteckt.
Muss so sein:

SettingsForm s;
void Einstellungen() {
 if(s == null) s = new SettingsForm();
 if(settingsToolStripMenuItem.Checked) s.Show();
 else s.Hide();
}

Grüße, JasonDelife.

Spiele arbeiten meist mit DirectInput, da kann man mit ein paar "popeligen" Window-Messages nix erreichen. Aber du kannst ja mal googeln.

Grüße, JasonDelife.

Hier ein kleines Bspl für SendKeys:
In VS: Form mit Button und TextBox.
PS: Kannst ja nen Timer für den Test benutzen, damit nicht beim Send dein App die im Vordergrund ist.

using System;
using System.Windows.Forms;

namespace X {
    class MyForm: Form {
        public MyForm() {
            InitializeComponent();
        }
        
        private void button1_Click(object sender, EventArgs e) {
            SendKeys.Send(textBox1.Text); // Sendet Text an aktive Anwendung
        }
    }
}

Grüße, JasonDelife.

Schau dir mal das an: K_Updater

Siehe: MSDN: SendKeys-Klasse

Sicher, dass das Event registriert ist?

Den Dialog als Klassenvariable im Hauptfenster und im KeyUp auf null prüfen.
Dabei Dispose nicht vergessen!

class Hauptfenster : Form {
    private MyDialogForm dlg;
    
    private void listView_KeyUp(...) {
        if(dlg == null) {
            // Starte Programm
        }
    }
 
    private void methodWhereDialogIsShown(...) {
        dlg = new MyDialogForm();
        dlg.ShowDialog();
        dlg.Dispose();
        dlg = null;
    }
}

Grüße, JasonDelife.

Ergänzend zum BackgroundWorker:
Dieser bietet:

• DoWork (Hier asynchrone Operationen)
• ProgressChanged (Hier Fortschritt in GUI darstellen [nur falls nötig])
• RunWorkerCompleted (Hier Ende in GUI darstellen [nur falls nötig])

Siehe: MSDN: Der BackgroundWorker

Grüße, JasonDelife.

Hierfür ist das .NET Konfigurationsmodell gedacht.
Siehe: [Tutorial] Das neue Konfigurationsmodell im .NET Framework 2.0

Grüße, JasonDelife.

Du kannst in der Factory-Klasse eine Methode zum Registrieren der Klassen bereitstellen.

Wenn die Factory-Klasse für eine ID immer das selbe Objekt zurückliefern soll:
-> Dictionary<string, IConverter>
-> AddClass(string id, IConverter instance)

Wenn die Factory-Klasse jedesmal ein neues Objekt zurückliefern soll:
-> Reflection benutzen
-> Dictionary<string, Type>
-> AddClass(string id, Type classType) (Prüfen, ob classType IConverter implementiert)
-> Dann kann mithilfe der Type-Instanz ein neues Objekt erzeugt werden

Das vllt. noch als Ergänzung.

Grüße, JasonDelife.

Wenn du den MemoryStream beschrieben hast:

• Das alte Bitmap disposen
• Der Variablen mit Bitmap.FromStream(myMemoryStream) das neue Bitmap-Objekt zuweisen.
• Dem object-Parameter übergeben

Allerdings hast du dann den doppelten Aufwand (2x serialisieren).
Alternativ könntest du den MemoryStream nicht in ein Bitmap sondern in ein byte[] lesen und diesen verschicken. byte[] wird ja beim serialisieren einfach so genommen und verschickt, oder? Beim Empfänger kannst du aus dem byte[] dann wieder ein Bitmap machen.

Grüße, JasonDelife.

Mit der reinen Ableitung von MarshalByRefObject ist es nicht getan.
Siehe: MSDN: .NET Remoting Technology
Dass die Events so funktionieren lässt sich damit machen.

Wenn du eine Klasse als Kopie des Originals verschicken willst, musst du sie als Serializable kennzeichnen.

Grüße, JasonDelife.

Vllt. hilft dir der UserActivityHook von CodeProject (Processing Global Mouse and Keyboard Hooks in C#).
Je nach Spiel kann es aber sein, dass er nicht funktioniert.

Grüße, JasonDelife.

Du solltest die Methode tcp_in() sowie die Felder nicht als static deklarieren.
Auf eine IP-Port-Kombination kann ja immer nur ein Programm/Listener hören.
Wenn du also auf mehrere Ports hören willst, musst du mit Instanzen arbeiten.

Desweiteren solltest du die Namenskonventionen einhalten.
Also: Server, TcpIn(), strIpAdresse, ipAdresse, strIpPort, transactionData (Wenn "transactiondata" eine Klasse ist, dann: TransactionData), Process(), InMessage, Log und DatenZuruecksetzten().

Grüße, JasonDelife.

Bei der Ableitung von MarshalByRefObject wird die Klasse als Verwies (MBR) zwischen Anwendungen übertragen. Ähnlich dem übergeben einer Klasse an den Parameter einer Methode. Wenn von Anwendung A Felder geändert werden, so hat das auch auf Anwendung B auswirkungen.

Grüße, JasonDelife.

if (CurrentSiteChange != null)
{
     // CurrentSiteChange ist nicht null --> Feure Event
     CurrentSiteChange(this, new CurrentSiteChangeEventArgs(value));
}
else
{
    // CurrentSiteChange ist null --> Feure Event
    CurrentSiteChange(this, new CurrentSiteChangeEventArgs(null));
}

Aber wenn CurrentSiteChange null ist, dann schlägt das feuern des Events mit einer NullReferenceException fehl.

Zweitens:

public class CurrentSiteChangeEventArgs
{
    public CurrentSiteChangeEventArgs(LayoutSite currentSite) { CurrentSite = currentSite; }
    public LayoutSite CurrentSite { get; set; } // readonly
    // readonly??? Es ist public get und public set!!!
}

Grüße, JasonDelife.

Stichwort: Serialisierung

Grüße, JasonDelife.

Du darfst nicht e nach object[] casten, sondern e.Argument.

Grüße, JasonDelife.

Du musst e.Argument nach object[] casten.

EDIT Erklärung:
e.Argument ist vom Typ object, sodass man alles zuweisen kann.
Du weißt ein object[] zu und willst auch wieder ein object[].
Also musst du nach object[] casten.

Allerdings wäre hier eine Klasse für die daten sinvoller (wie Peter Bucher schon sagte).

Grüße, JasonDelife.

Klar ist das möglich!
Einfach wenn sich der ausgewählte Punkt ändert:

• Im Anzeige-Panel alle Controls entfernen (evtl. disposen)
• Neue hinzufügen
  Dabei kannst du dann pro Menüpunkt ein UserControl erstellen und dort anzeigen.

Grüße, JasonDelife.

Kante needed = _kanten.Find(k => k.Grenze == 100000);

Sollte man wissen.
Aber hier wäre doch ein Dictionary<int, Kante> besser, wenn du Grenze als Index haben möchtest. Dann kannst du

Kante k = new Kante(dictKnoten["ABC"], dictKnoten["XYZ"], 4.5, 100000);
_dictKanten.Add(k.Grenze, k);
// ...
Kante needed = _dictKanten[100000];

schreiben.
Grüße, JasonDelife.

Wenn die Byte-Arrays auf null sind, dann starte manuell den Garbage Collector.
Das müsste den Speicher der Arrays freigeben.

GC.Collect();

Grüße, JasonDelife.

Oder die CpuUsage-Klasse von Mentalis.org benutzen:
Mentalis.org / Useful Classes / CpuUsage
Sehr einfach zu handhaben, nutzt die WinAPI. Mentalis.org ist übrigens immer mal einen Blick Wert.

Grüße, JasonDelife.

Weil dann die GUI direkt auf die DAL zugreifen kann! Und umgekehrt.
Das soll aber nicht sein und widerspricht der Schichten-Architektur.

Grüße, JasonDelife.

Du musst die verschiedenen Click/CheckedChanged/TextChanged-Ereignisse der Steuerelemente abonnieren und dort dann das entsprechende setzten.
Also für die 3 Rotations-RadioButtons 1 CheckedChanged.
Für jede CheckBox eines. Und für jede TextBox (Höhe, Breite) eines.
Momentan wird alles im Click-Ereignis der PictureBox ausgeführt!
Außerdem reicht es, das Bild zu laden, wenn im OpenFileDialog ein Bild ausgewählt wurde. Des weiteren könntest du - zur besseren lesbarkeit (für dich und uns) - die Steuerelemente besser bennen ("rotate90RadioBtn" oder so, statt "radioButton2").

Skalierung funktioniert, wie JAck30lena schon sagte, mit GDI+.

Grüße, JasonDelife.

Marshallen bedeutet, dass über ein Netzwerk (.NET-)Objekte ausgetauscht werden können, also die Methodenaufrufe nicht beim "Halter" des Objekts (Client) sondern beim Bereitsteller (Server) ablaufen. So ist es z.B. möglich einen Singleton zu erstellen, der über eine URL von überall angesprochen werden kann (server-activated singleton). Oder man kann ein Objekt aus einem Server bereitstellen von dem jeder Client eines hat (client-activated object), wie ein normales Objekt, aber die Methoden werden auf dem Server ausgeführt.
Das ist die .NET Remoting Technology, eine Alternative zu den Web Services.

Der Proxy eines Remote-Objekts ist eine Instanz einer speziellen Klasse, die dafür sorgt, dass die Methodenaufrufe bei Bedarf an den Server geschickt und ausgeführt werden. Außerdem wird auf das korrekte Übertragen der Parameter/Rückgabetyp/Aufruf-Infos geachtet.

Hoffe es ist etwas klarer.
Grüße, jasonDelife.

Nein.
Das Gleichheitszeichen ist SHIFT+ZERO (HOCHSTELL+NULL).
Also ungefähr so (weiß die Namen nicht auswendig):

// e vom Typ KeyEventArgs
if(e.Shift && e.KeyValue == Keys.D0) { /* Gleichheitszeichen */ }

Grüße, JasonDelife.