Feedback

C# - Invoke Beispiel mittels Erweiterungs Methoden.

Veröffentlicht von am 20.08.2008
(1 Bewertungen)
Wer kennt es nicht ..
Das lästige ausführen eines Delegaten bestimmten Typs um Daten aus einem anderen thread auf einem Windows.Form anzeigen zu können, ohne mit einer Ausnahme beworfen zu werden.
Das .NET Framework ab Version 3 bietet sogenannte extension methods an, die sich für so eine Aufgabe geradezu anbieten.
Im Prinzip liesse sich diese Klasse auf jeden erdenklichen Datentyp erweitern.
Ich habe drei Beispieltypen verwendet um das Prinzip darzustellen.
(Es wird natürlich immer ein Verweis auf das Windows.Form gebraucht um das Invoke entsprechend auszuführen.)
Dies ist mein Beitrag zum Snippet Contest.
Grüsse Patrick
GFU-Schulungen  [Anzeige]

VB.NET 2017/2015/2013 Komplett

Ziel des Seminars ist der flexible Umgang mit VB.NET, wie z.B. die damit verbundene eigenständige Entwicklung von Programmen oder das Verwenden von Datenbanken.

C# 2017/2015/2013 Aufbau

In dieser Schulung lernen Sie fortgeschrittene Techniken im Bereich .Net C#. Dabei stehen neben den eigentlichen Techniken auch architektonische Aspekte im Mittelpunkt.

using System;
using System.Windows.Forms;

namespace FX3Goodies.ExtensionMethods
{
    public static class Extensions
    {

        /// <summary>
        /// Delegate um strings zu invoken.
        /// </summary>
        public delegate string StringInvoker(string toInvoke, Form Invoker);
        /// <summary>
        /// Delegate um Integer Werte zu invoken.
        /// </summary>
        public delegate int  IntegerInvoker(int toInvoke, Form Invoker);
        /// <summary>
        /// Delegate um Double Werte zu invoken.
        /// </summary>
        public delegate double DoubleInvoker(double toInvoke, Form Invoker);

        
        /// <summary>
        /// Invokes the this string. Extension-method with params.
        /// </summary>
        /// <param name="stringToInvoke">The string to invoke.</param>
        /// <param name="theInvokingForm">The invoking form.</param>
        /// <returns></returns>
        /// Documented at : 20.08.2008 ,  10:56
        /// done by : Noodles
        /// on workstation : UNI-2
        /// compiled for processor architecture : x86
        /// processor id : x86 Family 15 Model 79 Stepping 2, AuthenticAMD
        /// number of processors : 1
        /// operating system : Windows_NT
        /// (C) 2008 Sperneder Patrick , Gert H. Burgstaller
        /// http://www.psi-labs.at/development/noodles
        public static string InvokeThisString(this string stringToInvoke, Form theInvokingForm)
        {
            if (theInvokingForm.InvokeRequired)
            {
                theInvokingForm.Invoke(new StringInvoker(InvokeThisString), new Object[] { stringToInvoke, theInvokingForm });
            }

            return stringToInvoke;
        }

        /// <summary>
        /// Invokes the this integer. Extension-method with params.
        /// </summary>
        /// <param name="integerToInvoke">The integer to invoke.</param>
        /// <param name="theInvokingForm">The invoking form.</param>
        /// <returns></returns>
        /// Documented at : 20.08.2008 ,  10:56
        /// done by : Noodles
        /// on workstation : UNI-2
        /// compiled for processor architecture : x86
        /// processor id : x86 Family 15 Model 79 Stepping 2, AuthenticAMD
        /// number of processors : 1
        /// operating system : Windows_NT
        /// (C) 2008 Sperneder Patrick , Gert H. Burgstaller
        /// http://www.psi-labs.at/development/noodles
        public static int InvokeThisInteger(this int integerToInvoke, Form theInvokingForm)
        {
            if (theInvokingForm.InvokeRequired)
            {
                theInvokingForm.Invoke(new IntegerInvoker(InvokeThisInteger), new Object[] { integerToInvoke , theInvokingForm });
            }

            return integerToInvoke ;
        }

        /// <summary>
        /// Invokes this double. Extension-method with params.
        /// </summary>
        /// <param name="doubleToInvoke">The double to invoke.</param>
        /// <param name="theInvokingForm">The invoking form.</param>
        /// <returns></returns>
        /// Documented at : 20.08.2008 ,  11:00
        /// done by : Noodles
        /// on workstation : UNI-2
        /// compiled for processor architecture : x86
        /// processor id : x86 Family 15 Model 79 Stepping 2, AuthenticAMD
        /// number of processors : 1
        /// operating system : Windows_NT
        /// (C) 2008 Sperneder Patrick , Gert H. Burgstaller
        /// http://www.psi-labs.at/development/noodles
        public static double InvokeThisDouble(this double doubleToInvoke, Form theInvokingForm)
        {
            if (theInvokingForm.InvokeRequired)
            {
                theInvokingForm.Invoke(new DoubleInvoker(InvokeThisDouble), new Object[] { doubleToInvoke, theInvokingForm });
            }
            return doubleToInvoke;
        }
    
    }
}
Abgelegt unter thread, invoke, multi threading, extension.

2 Kommentare zum Snippet

Jens Schneeweiß schrieb am 21.01.2009:
Bitte mal ein Beispiel angeben, wie man damit am besten umgehen soll?
Rainer Hilmer schrieb am 21.01.2009:
Wie immer, wenn es um dieses Thema geht, verweise ich auf mein Lieblings-Snippet (ist nicht von mir):
http://dotnet-snippets.de/dns/threadsicheres-zuweisen-von-control-eigenschaften-SID829.aspx
 

Logge dich ein, um hier zu kommentieren!