Die Antwort von .NET heisst ClickOnce. Das Prinzip dahinter ist grundsätzlich genau gleich. So können Applikationen direkt auf einem Webserver veröffentlicht werden. Die Veröffentlichung von ClickOnce-Applikationen ist dabei spielend einfach. Im Eigenschaften Fenster des Projekts müssten im Reiter “Publish” einfach der Exportpfad sowie der entgültige Pfad auf dem Webserver eingegeben werden. Der Entwickler hat dier noch mehrere Einstellmöglichkeiten welche sich hinter dem “Options” Button verbergen. Wurde der gesamte Export auf den Webserver geladen, kann die Applikation auf 2 Arten gestartet werden:

• Mit einem direkten Start über die “.application” Datei (funktioniert mit dem IE Einwandfrei, während Firefox dazu evtl. das Addon Microsoft .NET Framework Assistant benötigt)
• Mit einem vorherigen Download eines Setups, welches prüft ob die vorausgesetzten Software Packages installiert sind (Framework, Windows Installer, etc.).

Als kleines Beispiel habe ich eine Hello World-Applikation gemacht, welche ganz einfach über einen Browser aufrufbar ist.

Starte die ClickOnce-Demo (leitet dich auf eine Seite weiter, welche von Visual Studio generiert wurde und beide obengenannten Startmöglichkeiten verlinkt hat)

Control.CheckForIllegalCrossThreadCalls

Diese ist in C# von Beginn weg auf True gestellt. Es gibt nun zwei verschiedene Möglichkeiten wie man von anderen Threads trotzdem die GUI Komponenten aufrufen kann:

• Man stellt die obengenannte Eigenschaft auf  false, womit keine Prüfung mehr erfolgt ob es ein threadübergreifender Vorgang ist
• Man benutzt die InvokeRequired-Methode welche prüft ob ein threadübergreifender Vorgang vorliegt und Methode nochmals vom GUI-Thread aufgerufen werden soll.

Da die erste Möglichkeit mit einer Codezeile erledigt wird, möchten wir uns die zweite Methode genauer anschauen. Dabei kommen Delegates zum Einsatz. Wie der Name schon sagt werden dabei Methodenaufrufe delegiert.  Der Methodenaufruf wird dabei an den den GUI-Thread übergeben, welche die Methode von sich aus aufruft. Damit haben wir das Problem des threadübergreifenden Zugriffs elegant gelöst!

Als kleines Beispiel habe ich ein Projekt erstellt welche einerseits mit der BeginInvoke-Methode arbeitet und andererseits keine Prüfung beinhaltet (also eine Exception wirft). Um die Abläufe der Aufrufe am besten zu verfolgen wird empfohlen das Projekt im Debugging-Modus auszuführen. So ist klar ersichtlich welche Aufrufe wann passieren und es ist leichter nachvollziehbar. Der zentrale Code mit den Delegates lautet folgendermassen:

delegate void ChangeLabelSizeCallback(float newSize);
private void ChangeLabelSize(float newSize)
{
    if (lblTarget.InvokeRequired)
    {
        ChangeLabelSizeCallback lsc = new ChangeLabelSizeCallback(ChangeLabelSize);
        lblTarget.Invoke(lsc, new Object[] { newSize });
    }
    else
    {
        lblTarget.Font = new Font(lblTarget.Font.FontFamily, newSize);
        lblTarget.Text = "FontSize: " + newSize.ToString();
    }
}

Anbei steht das gesamte Beispiel noch zum Download bereit:

Um kurz zu zeigen wie einfach es ist seinen eigenen Service zu schreiben, habe ich wie immer ein kleines Beispiel hochgeladen. Das Beispiel beinhaltet dabei 2 Projekte. Ein Server (also der Dienserbringer) und einen Client (der Dienstnutzer). In unserem Beispiel bietet der Server einen Service an, welche alle empfangenen Strings in umgekehrter Buchstabenfolge zurücksenden. Sendet der Client also “Hallo Welt” an den Server, so erhält er als Antwort “tleW ollaH”

Dazu müssen beide Applikationen den Namespace “System.ServiceModel” referenzieren, welcher die entsprechenden WCF-Klassen bereitstellt.

Hinweise zum Server:
Da der Server eine bestimmte Service-URL reservieren und auf einen bestimmten Port horchen muss, müssen diese beiden Angaben eingerichtet werden. Um die URL zu reservieren gibt man in der Konsole folgendes ein (benötigt Administratorenrechte!):

• Windows Server 2003, XP:
  httpcfg.exe set urlacl /u http://myhost:8000/ /a “O:AOG:DAD:(A;;RPWPCCDCLCSWRCWDWOGA;;;S-1-0-0)”
• Windows Vista:
  netsh http add urlacl url=http://+:80/MyUri user=DOMAIN\user

Danach muss man den Port noch als Ausnahme bei der Windows Firewall hinzufügen:

• Windows Server 2003, XP:
  httpcfg.exe set iplisten -i 0.0.0.0:8000
• Windows Vista:
  netsh http add iplisten ipaddress=0.0.0.0:8000

Die genauen Angaben über die Befehle findet man auf:

http://msdn.microsoft.com/en-us/library/ms733768.aspx

Wenn die beiden Konsolenanwendungen laufen, sieht das ganze dann so aus:

Client:

Server:

Service- und OperationContract des Servers:

using System;
using System.ServiceModel;

namespace WCF_Example
{
    [ServiceContract]
    public interface IReverseString
    {
        [OperationContract]
        String ReverseString(String strInput);
    }
}

Implementation des Servers:

using System;

namespace WCF_Example
{
    public class StringOperation : IReverseString
    {

        public string ReverseString(string strInput)
        {
            String strOutput = String.Empty;

            Console.WriteLine("\nFolgender String wurde empfangen: " + strInput);
            Console.WriteLine("String wird verarbeitet");
            for (int i = strInput.Length - 1; i >= 0; i--)
            {
                strOutput += strInput.Substring(i, 1);
            }
            Console.WriteLine("Verarbeitung beendet");
            return strOutput;
        }

    }
}

Sourcecode des Clients:

using System;
using System.ServiceModel;
using WCF_Example;

namespace WCF_Client
{
    public class Client
    {
        public String ReverseString(String strInput)
        {
            ChannelFactory<IReverseString> factory = new ChannelFactory<IReverseString>( new WSHttpBinding(), new EndpointAddress("http://localhost:43210/StringOperation"));

            IReverseString revString = factory.CreateChannel();

            return revString.ReverseString(strInput);
        }
    }
}

In C# ist dies wirklich sehr einfach gelöst. Es benötigt nur ein paar Zeilen Code und schon hat man einen eigenen Event erstellt, der von überallher angezapft werden kann. Als kleines Beispiel habe ich ein Konsolenanwendung geschrieben, welche eine boolsche Variable hat, welche regelmässig ihren Wert ändert. Da man aber zum Vornherein nicht genau weis, wann das sein wird, wird ein Event zur Verfügung gestellt welche alle horchenden Objekte benachrichtigt. Bei einer erhaltenen Benachrichtigung wird dies auf dem Konsolenfenster ausgegeben.

Dies ist die Klasse die den Event zur Verfügung stellt und ihn nötigenfalls abfeuert:

using System;
using System.Timers;

namespace EventExample
{
    public delegate void FlagValueChangedEventHandler(bool newValue);

    public class EventSource
    {
        public event FlagValueChangedEventHandler FlagValueChanged;
        private bool m_Flag;
        private Timer m_Timer = new Timer();
        private Random m_Random = new Random();

        /// <summary>
        /// Konstruktor
        /// </summary>
        public EventSource()
        {
            //Event für Timer wird angezapt
            m_Timer.Elapsed += new ElapsedEventHandler(m_Timer_Elapsed);
        }

        /// <summary>
        /// Berechnet den neuen Interval und starten den Timer
        /// </summary>
        public void Start()
        {
            //Zufälliges Intervall zwischen 1 und 10 Sekunden wird ermittelt
            m_Timer.Interval = (m_Random.Next(9) + 1) * 1000;

            //Timer wird gestartet
            m_Timer.Start();
        }

        /// <summary>
        /// Ereignis welches auftritt wenn die Intervalzeit abgelaufen ist
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void m_Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            //Timer wird gestoppt
            m_Timer.Stop();

            //Wert des boolschen Flags wird geändert
            m_Flag = !m_Flag;

            //Wenn jemand auf den Event horcht wird dieser abgefeuert
            if (FlagValueChanged != null)
            {
                FlagValueChanged(m_Flag);
            }

            //Spiel beginnt wieder von neuem
            Start();
        }

    }
}

Als Grundlage dient eine normale Combobox (Stichwort: Vererbung). Dieser Combobox werden einige neue Eigenschaften und Methoden hinzugefügt. Das Herzstück des neuen Controls ist jedoch die Methode “OnDrawItem”, welche die ComboBox in ihrer neuen (farbigen) Form erscheinen lässt. Diese Methode wird implizit aufgerufen, sobald das Control sich neu zeichnen muss. In unserer Variante haben wir die Möglichkeit einen Text und daneben eine beliebige Farbe anzeigen zu lassen. Dies sieht dann etwa so aus:

Der unten aufgeführt Code ist lediglich für die ColorComboBox. Das Demoprogramm welches heruntergeladen werden kann, zeigt wie die ColorComboBox gefüllt werden kann und wie im Design-Modus von Visual Studio daherkommt.

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using System.ComponentModel;

namespace ColorComboBoxDemo
{
    public class ColorComboBox : System.Windows.Forms.ComboBox
    {
        private bool bCustomColor;
        private List<ColorItem> arrColorItems = new List<ColorItem>();
        private ColorItem currentItem;
        private const string strCustom = "Benutzerdefiniert...";

        public ColorComboBox ()
        {
            //Zeichungsmodus wird festgelegt
            this.DrawMode = DrawMode.OwnerDrawFixed;

            //Eventhandler werden hinzugefügt
            this.DrawItem += new DrawItemEventHandler(OnDrawItem);
            this.SelectedIndexChanged += new System.EventHandler(OnSelectedIndexChanged);
            this.DropDown += new System.EventHandler(OnDropDown);
        }

        private void OnDrawItem(object sender, System.Windows.Forms.DrawItemEventArgs e)
        {
            //Ränderabstand wird festgelegt
            int padXl = 20;
            int padXr = 10;
            int padY = 2;

            if (e.Index < 0)
            {
                return;
            }

            //Momenan aktives ColorItem wird ausgelesen
            currentItem = arrColorItems[e.Index];

            if (currentItem.ShowOnlyColor == true)
            {
                padXl = 3;
            }

            //Grafikzeichner wird instanziert
            Graphics grfx = e.Graphics;

            //Pinsel für Farbige Rechtecke werden definiert
            Color brushColor = currentItem.CurrentColor;
            SolidBrush brush = new SolidBrush(brushColor);

            //Zeichnungsbereiche werden definiert
            Rectangle rectFillBackground = new Rectangle(e.Bounds.X, e.Bounds.Y, e.Bounds.Width, e.Bounds.Height);
            Rectangle rectFillColor = new Rectangle(e.Bounds.X + padXl, e.Bounds.Y + padY, e.Bounds.Width - (padXl + padXr), e.Bounds.Height - (2 * padY));
            Rectangle rectText;

            //Hintergrund wird gezeichnet
            grfx.FillRectangle(new SolidBrush(Color.White), rectFillBackground);

            if (currentItem.ShowOnlyText == false)
            {
                //Textbereich wird definiert
                rectText = new Rectangle(e.Bounds.X, e.Bounds.Y, e.Bounds.X + padXl, e.Bounds.Height - (2 * padY));

                //Farbiges Rechteck wird gezeichnet
                grfx.FillRectangle(brush, rectFillColor);

                //LinieOben
                grfx.DrawLine(new Pen(Color.Black, (float)0.1), new Point(e.Bounds.X + padXl, e.Bounds.Y + padY), new Point(e.Bounds.X + padXl + (e.Bounds.Width - padXl - padXr), e.Bounds.Y + padY));
                //LinieRechts
                grfx.DrawLine(new Pen(Color.Black, (float)0.1), new Point(e.Bounds.X + padXl + (e.Bounds.Width - padXl - padXr), e.Bounds.Y + padY), new Point(e.Bounds.X + padXl + (e.Bounds.Width - padXl - padXr), e.Bounds.Y + e.Bounds.Height - (2 * padY) + 1));
                //LinieUnten
                grfx.DrawLine(new Pen(Color.Black, (float)0.1), new Point(e.Bounds.X + padXl, e.Bounds.Y + e.Bounds.Height - (2 * padY) + 1), new Point(e.Bounds.X + padXl + (e.Bounds.Width - padXl - padXr), e.Bounds.Y + e.Bounds.Height - (2 * padY) + 1));
                //LinieLinks
                grfx.DrawLine(new Pen(Color.Black, (float)0.1), new Point(e.Bounds.X + padXl, e.Bounds.Y + padY), new Point(e.Bounds.X + padXl, e.Bounds.Y + e.Bounds.Height - (2 * padY) + 1));
            }
            else
            {
                //Textbereich wird definiert
                rectText = new Rectangle(e.Bounds.X, e.Bounds.Y, e.Bounds.X + e.Bounds.Width, e.Bounds.Height);
            }

            //Text wird gezeichnet
            grfx.DrawString(currentItem.Text, e.Font, new SolidBrush(Color.Black), rectText);

            //Markierung wird gelöscht
            this.SelectionStart = 0;
            this.SelectionLength = 0;

        }

        private void OnSelectedIndexChanged(object sender, System.EventArgs e)
        {
            //Ausgewähltes Element wird ausgelesen
            currentItem = arrColorItems[this.SelectedIndex];

            //Wenn es das Benutzerdefinierte Item ist, wird der Farben Dialog angezeigt
            if (currentItem.ShowOnlyText == true)
            {
                ColorDialog dlgColor = new ColorDialog();

                if (dlgColor.ShowDialog(this) == DialogResult.OK)
                {
                    //Item mit gewählter Farbe wird eingefügt und selektiert
                    ColorItem col = new ColorItem();
                    col.ShowOnlyColor = true;
                    col.CurrentColor = dlgColor.Color;
                    arrColorItems.Insert(arrColorItems.Count - 1, col);
                    this.Items.Insert(this.Items.Count - 1, col);
                    this.SelectedIndex = this.Items.Count - 2;
                }
            }
        }

        private void OnDropDown(object sender, System.EventArgs e)
        {
            //Ausgewähltes Element wird ausgelesen
            if (this.SelectedIndex > -1)
            {
                currentItem = arrColorItems[this.SelectedIndex];
            }
        }

        public void AddColorItem(Color col, string itemText)
        {
            ColorItem c = new ColorItem();
            c.CurrentColor = col;
            c.Text = itemText;

            if (bCustomColor == true)
            {
                if (this.Items.Count == 0)
                {
                    arrColorItems.Insert(0, c);
                    this.Items.Insert(0, c);
                }
                else
                {
                    arrColorItems.Insert(this.Items.Count - 1, c);
                    this.Items.Insert(this.Items.Count - 1, c);
                }
            }
            else
            {
                arrColorItems.Add(c);
                this.Items.Add(c);
            }
        }

        public bool EnableCustomColor
        {
            get
            {
                return bCustomColor;
            }
            set
            {
                if (bCustomColor == false && value == true)
                {
                    bCustomColor = value;

                    //Benutzerdefiniertes Item wird eingefügt
                    ColorItem c = new ColorItem();
                    c.CurrentColor = Color.White;
                    c.Text = strCustom;
                    c.ShowOnlyText = true;
                    arrColorItems.Add(c);
                    this.Items.Add(c);
                }

                if (bCustomColor == true && value == false)
                {
                    bCustomColor = value;

                    //Benutzerdefiniertes Item wird entfernt
                    for (int i = 0; i <= arrColorItems.Count - 1; i++)
                    {
                        ColorItem c = (ColorItem)arrColorItems[i];
                        if (c.ShowOnlyText == true)
                        {
                            arrColorItems.RemoveAt(i);
                            this.Items.RemoveAt(i);
                        }
                    }
                }

            }
        }

        [Browsable(false)]
        public Color SelectedColor
        {
            get
            {
                return currentItem.CurrentColor;
            }
            set
            {
                //Item mit gewählter Farbe wird eingefügt und selektiert
                ColorItem col = new ColorItem();
                col.CurrentColor = value;
                col.ShowOnlyColor = true;
                arrColorItems.Insert(arrColorItems.Count - 1, col);
                this.Items.Insert(this.Items.Count - 1, col);
                this.SelectedIndex = this.Items.Count - 2;
            }
        }

        [Browsable(false)]
        public new String SelectedText
        {
            get
            {
                return currentItem.Text;
            }
            set
            {
                //Item mit entsprechendem Text wird gesucht und selektiert
                for (int i = 0; i <= arrColorItems.Count - 1; i++)
                {
                    ColorItem col = (ColorItem)arrColorItems[i];
                    if (col.Text == value)
                    {
                        this.SelectedIndex = i;
                        break;
                    }
                }
            }
        }

    }

    //************************************************************************************************
    //------------------------------------------------------------------------------------------------
    //************************************************************************************************

    public class ColorItem
    {
        private Color m_Color;
        private String m_Text = "";
        private bool m_bOnlyText;
        private bool m_bOnlyColor;

        public ColorItem()
        {

        }

        public Color CurrentColor
        {
            get { return this.m_Color; }
            set { this.m_Color = value; }
        }

        public String Text
        {
            get { return this.m_Text; }
            set { this.m_Text = value; }
        }

        public bool ShowOnlyText
        {
            get { return this.m_bOnlyText; }
            set { this.m_bOnlyText = value; }
        }

        public bool ShowOnlyColor
        {
            get { return this.m_bOnlyColor; }
            set { this.m_bOnlyColor = value; }
        }
    }

    //************************************************************************************************
    //------------------------------------------------------------------------------------------------
    //************************************************************************************************
}

using System;
using System.Threading;

namespace MultiThreading
{
    class Program
    {
        static void Main(string[] args)
        {
            ConsoleKeyInfo keyAnswer;

            //Solange Fragen bis entweder Y oder N gedrückt wurde
            do
            {
                Console.Clear();
                Console.WriteLine("Möchten Sie die Applikation im Multithreading Modus starten? (Y/N)");
                keyAnswer = Console.ReadKey(true);
            }
            while (keyAnswer.Key != ConsoleKey.Y && keyAnswer.Key != ConsoleKey.N);

            //Je nach dem was gewählt wurde, die Methoden im entsprechenden Modus ausführen
            switch (keyAnswer.Key)
            {
                case ConsoleKey.Y:
                    //Threading Modus
                    Thread t1 = new Thread(new ThreadStart(ThreadOneOutput));
                    Thread t2 = new Thread(new ThreadStart(ThreadTwoOutput));
                    t1.Start();
                    t2.Start();
                    break;

                case ConsoleKey.N:
                    //Normaler Modus
                    ThreadOneOutput();
                    ThreadTwoOutput();
                    break;
            }

            //Wartet auf irgendeine Eingabe und beendet das Programm danach
            Console.ReadKey(true);

        }

        /// <summary>
        /// Methode welche als erster Thread ausgeführt werden kann
        /// </summary>
        private static void ThreadOneOutput()
        {
            for (int i = 1; i <= 50; i++)
            {
                Console.WriteLine("Thread 1: Output Nr. " + i.ToString());
            }
        }

        /// <summary>
        /// Methode welche als zweiter Thread ausgeführt werden kann
        /// </summary>
        private static void ThreadTwoOutput()
        {
            for (int i = 1; i <= 50; i++)
            {
                Console.WriteLine("Thread 2: Output Nr. " + i.ToString());
            }
        }
    }
}