Bei Änderung von Variablenwerten einen Event auslösen

Hier erfahren Sie, wie Sie ein Ereignis auslösen können, wenn eine einfache Variable z.B. vom Typ Integer oder String, einen anderen Wert erhält.

Für Objekte im .NET können Sie bei der Deklaration das Attribut „withEvents“ mitgeben, dann haben Sie alle Ereignisse (Events) des Objekts zur Verfügung und können das mitnutzen:

private withEvents myItem as myControl

Alle Events, die dann in myControl mit public deklariert sind (und die ererbten) stehen Ihnen damit zur Nutzung bereit.
Anders sieht es bei einfachen Variablen aus.

private withEvents myInteger as Integer

wird scheitern, da „Integer“ in diesem Sinne keine Events kennt. Ein kleiner Trick kann Abhilfe schaffen.
Definieren Sie einen eigenen Event und lösen Sie ihn durch Ummanteln der Variable in einem Property aus!

Zunächst die Eventdeklaration:

Public Event MyVariableIntegerChanged

Deklarieren Sie die Property:

Property ThisInteger as Integer
Get
  Return myInteger
End Get
Set (ByVal value as Integer)
 myInteger = value
 RaiseEvent MyVariableIntegerChanged
End Set

Jetzt achten Sie darauf, die Variable nicht direkt sondern über das Property zu ändern, schon haben Sie das gewünschte Ergebnis:

Public Sub New()
    ThisInteger = 1 'belegt den Wert der Variablen myInteger mit 1 und löst den Event MyVariableIntegerChanged aus
End Sub

Das ganze in einer Klasse:

Public Class VariablenEventTest
 Dim myInteger as Integer
Public Event MyVariableIntegerChanged
Property ThisInteger as Integer
Get
  Return myInteger
End Get
Set (ByVal value as Integer)
 myInteger = value
 RaiseEvent MyVariableIntegerChanged
End Set
Public Sub New()
    ThisInteger = 1 'belegt den Wert der Variablen myInteger mit 1 und löst den Event MyVariableIntegerChanged aus
End Sub
End Class

Ich kann nun auf den Event wie gewohnt reagieren, z.B. innerhalb der Klasse

Private Sub MyHandle() handles MyVariableIntegerChanged
 Messagebox.Show("Die Variable myInteger wurde geändert")
End Sub

Da ich hier den Event mit Public deklariert habe, steht er auch andernorts bei der Nutzung der Klasse zur Verfügung:

Public Class Irgendwo
Private withEvents meineKlasse as VariablenEventTest
Public Sub New()
meineKlasse = New VariablenEventTest()
End Sub

Private Sub MyHandle() handles meineKlasse.MyVariableIntegerChanged
 Messagebox.Show("Die Variable myInteger wurde geändert")
End Sub
End Class
Advertisements

NET-Framework 2.0: Läuft meine Anwendung aktuell in einem 64-Bit-Betriebssystem?

Windows gibt es seit der Version XP auch als 64-Bit-Version. Richtig durchgesetzt hat sich das aber erst seit dem grandiosen Start von Windows 7. Nahezu 50der Rechner laufen hier unter der superschnellen 64-Spuren-Stadtautobahn, Tendenz steigend.

Da 32-Bit- und 64-Bit-Betriebssysteme sich auch in ihrer Reaktion unterscheiden und teilweise verschiedene Verfahren für Berechtigungen haben, ist es manchmal innerhalb einer .NET-Anwendung notwendig zu wissen, auf welcher Version die Anwendung gerade läuft. Dummerweise war zur Einführung von .NET Framework 2.0 noch nicht bekannt, dass es einmal Win7-64 geben wird, und so kann man auch nicht einfach auf einen Namespace zugreifen, der einem das sagt.

Aber es gibt auch in .NET Framework 2.0 eine Möglichkeit, mit Hilfe der Kernel.dll herauszufinden, auf wieviel Bit-Spuren man unterwegs ist. Hier mein Vorschlag:

' Namespace InteropServices wird benoetigt
Imports System.Runtime.InteropServices

    ''' <summary>Globales Modul ob OS 64-Bit ist</summary>
    Module Check64BitOS

        ''' <summary>
        ''' Die public-Funktion kann aufgerufen werden, um ein 64-Bit-Betriebssystem zu entdecken
        ''' </summary>
        ''' <returns>True wenn 64-Bit-System</returns>
        Public Function Is64BitOperatingSystem() As Boolean
            If ( IntPtr.Size = 8 ) Then  ' Nur 64-bit kann mit dieser Size arbeiten (32-Bit = 4)
                Return True
            Else  ' 32-bit Programme koennen auch im 64-Bit Modus laufen, daher ist der Prozess zu pruefen
                Dim flag As Boolean
                Return ((DoesWin32MethodExist("kernel32.dll", "IsWow64Process") _
                         AndAlso IsWow64Process(GetCurrentProcess, flag)) AndAlso flag)
            End If
        End Function

        ''' <summary>Diese kleine Funktion prüft, ob
        '''          a) eine Bibliothek existiert und
        '''          b) eine Methode innerhalb dieser Methode existiert
        ''' </summary>
        ''' <param name="moduleName">zu untersuchender Modulname</param>
        ''' <param name="methodName">zu suchende Methode</param>
        ''' <returns>True wenn Modul und Methode existieren</returns>
        Function DoesWin32MethodExist(ByVal moduleName As String, ByVal methodName As String) As Boolean
            Dim moduleHandle As IntPtr = GetModuleHandle(moduleName)
            If (moduleHandle = IntPtr.Zero) Then
                Return False
            End If
            Return (GetProcAddress(moduleHandle, methodName) <> IntPtr.Zero)
        End Function

        <DllImport("kernel32.dll")> _
        Function GetCurrentProcess() As IntPtr
        End Function

        <DllImport("kernel32.dll", CharSet:=CharSet.Auto)> _
        Function GetModuleHandle(ByVal moduleName As String) As IntPtr
        End Function

        <DllImport("kernel32", CharSet:=CharSet.Auto, SetLastError:=True)> _
        Function GetProcAddress(ByVal hModule As IntPtr, _
                                <MarshalAs(UnmanagedType.LPStr)> _
                                ByVal procName As String) _
                                As IntPtr
        End Function

        <DllImport("kernel32.dll", CharSet:=CharSet.Auto, SetLastError:=True)> _
        Function IsWow64Process(ByVal hProcess As IntPtr, _
                                <Out()> ByRef wow64Process As Boolean) _
                                As <MarshalAs(UnmanagedType.Bool)> Boolean
        End Function
End Module

Hier müssen Sie lediglich die Methode Is64BitOperatingSystem aufrufen um zu erkennen, ob Sie in einem 64-Bit-System gelandet sind.

 


%d Bloggern gefällt das: