Progressbar aus asynchronem Prozeß steuern

roth am Mittwoch, 8.September 2010 um 21:30

Public Class Form3

Private m_ToolstripProgressClass As ToolstripProgressClassPublic Sub New()‘ Dieser Aufruf ist für den Designer erforderlich.

InitializeComponent()

‘ Fügen Sie Initialisierungen nach dem InitializeComponent()-Aufruf hinzu.

End Sub

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

m_ToolstripProgressClass = New ToolstripProgressClass(ToolStripProgressBar1)

Dim worker As WorkerClass = New WorkerClass

AddHandler m_ToolstripProgressClass.CallbackIsReady, AddressOf Worker_End

m_ToolstripProgressClass.Start(worker, False)

End Sub

Private Sub Worker_End()

MessageBox.Show(“Asynchron-Callback”)

End Sub

Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click

m_ToolstripProgressClass = New ToolstripProgressClass(ToolStripProgressBar1)

Dim worker As WorkerClass = New WorkerClassm_ToolstripProgressClass.Start(worker, True)

m_ToolstripProgressClass.Reset()

MessageBox.Show(“Synchron-Ende”)

End Sub

End Class

Public Class ToolstripProgressClass

Public Delegate Sub AsyncValueChanged(ByVal ProgessValue As Integer)

Public Delegate Sub CallbackIsReadyDelegate(ByRef sender As Object, ByRef p_strdate As String)

Public Delegate Sub AsyncLongrunning()Public Event CallbackIsReady(ByRef sender As Object, ByRef p_date As String)

Private m_AsyncMethod As AsyncLongrunning

Private callback As AsyncCallback

Private WithEvents EndeTimer As Windows.Forms.Timer

Private WithEvents m_ToolstripProgress As System.Windows.Forms.ToolStripProgressBar

Public Sub New(ByRef ToolstripProgress As System.Windows.Forms.ToolStripProgressBar)

m_ToolstripProgress = ToolstripProgress

EndeTimer =

New Windows.Forms.TimerEndeTimer.Interval = 3000

End Sub

Public Sub Start(ByRef LongrunningWorker As IWorkerWithProgressEvent, ByVal Synchron As Boolean)

AddHandler LongrunningWorker.ProgressValueChanged, AddressOf ProgressValueChanged

If Synchron Then

LongrunningWorker.Longrunning()

Else

callback = AddressOf CallbackHandlerm_AsyncMethod = AddressOf LongrunningWorker.Longrunning

Dim asyncResult As IAsyncResult = m_AsyncMethod.BeginInvoke(callback, m_AsyncMethod)

End If

End Sub

Public Sub CallbackHandler(ByVal result As IAsyncResult)

Dim asyncmethod As AsyncLongrunning = CType(result.AsyncState, AsyncLongrunning)m_AsyncMethod.EndInvoke(result)

Dim strText As String = “Fertig”

RaiseEvent CallbackIsReady(Me, strText)

End Sub

Private Sub async_CallbackIsReady(ByRef sender As Object, ByRef p_strTxt As String) Handles Me.CallbackIsReady

If m_ToolstripProgress.Owner.InvokeRequired Then

Dim isReady As CallbackIsReadyDelegate = AddressOf async_CallbackIsReady

Dim param As Object() = New Object() {Me, p_strTxt}m_ToolstripProgress.Owner.Invoke(isReady, param)

Else

Reset()

End If

End Sub

Public Sub Reset()m_ToolstripProgress.Value = 100

EndeTimer.Start()

End Sub

Private Sub ProgressValueChanged(ByVal Value As Integer)

If m_ToolstripProgress.Owner.InvokeRequired Then

Dim ValueChanged As AsyncValueChanged = AddressOf ProgressValueChanged

Dim param As Object() = New Object() {Value}m_ToolstripProgress.Owner.Invoke(ValueChanged, param)

Else

m_ToolstripProgress.Value = Value

End If

End Sub

Private Sub EndeTimer_Tick(ByVal sender As Object, ByVal e As EventArgs) Handles EndeTimer.Tick

EndeTimer.Stop()

m_ToolstripProgress.Value = 0

End Sub

End Class

Public Class WorkerClass : Implements IWorkerWithProgressEvent

Public Event ProgressValueChanged(ByVal Value As Integer) Implements IWorkerWithProgressEvent.ProgressValueChanged

Public Sub LongRunning() Implements IWorkerWithProgressEvent.Longrunning

For i As Integer = 0 To 100System.Threading.Thread.Sleep(20)

RaiseEvent ProgressValueChanged(i)

Next

End Sub

End Class

Public Interface IWorkerWithProgressEvent

Event ProgressValueChanged(ByVal Value As Integer)Sub Longrunning()

End Interface

Application Events

roth am Mittwoch, 8.September 2010 um 21:26

‘ Für MyApplication sind folgende Ereignisse verfügbar:

‘ Startup: Wird beim Starten der Anwendung noch vor dem Erstellen des Startformulars ausgelöst.‘ Shutdown: Wird nach dem Schließen aller Anwendungsformulare ausgelöst. Dieses Ereignis wird nicht ausgelöst, wenn die Anwendung nicht normal beendet wird.

‘ UnhandledException: Wird ausgelöst, wenn in der Anwendung eine unbehandelte Ausnahme auftritt.‘ StartupNextInstance: Wird beim Starten einer Einzelinstanzanwendung ausgelöst, wenn diese bereits aktiv ist.

‘ NetworkAvailabilityChanged: Wird beim Herstellen oder Trennen der Netzwerkverbindung ausgelöst.Partial Friend Class MyApplication

‘'’ ‘'’ Zentrale Fehlerbehandlungsroutine für Fehler, welche nicht per Programmcode

‘'’ behandelt werden‘'’

‘'’

 

‘'’

 

‘'’ Private Sub GeneralErrorHandler(ByVal sender As Object, _ByVal e As System.Threading.ThreadExceptionEventArgs) _Handles MyClass.UnhandledExceptionDim err = New Tools.clsUnhandledErrorUserControls.clsErrorHandler.ToDB(err,

“Unhandled in MyApplication.”)UserControls.clsErrorHandler.ToDialog(err, “Die Anwendung “ + _

“wird geschlossen und muss neu gestartet werden. Das “ + _ “Entwicklerteam wird von diesem Vorgang automatisch benachrichtigt.”)End Sub

PIVOT

roth am Freitag, 26.Februar 2010 um 15:23

select * from (select u.Betrag as Umsatz,v.bezeichnung as Verkäufer,p.bezeichnung as Produkt

from Umsatz u join Produkt p on p.ID=u.IDProdukt

join Verkäufer v on v.ID=u.IDVerkäufer) AS S pivot(sum(Umsatz) for S.Verkäufer in ([Maier],[Schulze],[Müller])) as U

Asynchron und Controls

roth am Mittwoch, 27.Januar 2010 um 14:36

Hier ein Standardbeispiel für das Starten einer asynchronen Aufgabe aus einem Windows-Form und der Verwendung des Ergebisses in einem Control des Forms. Vorausgesetzt wird eine Klasse StringZahl in einem Namespace Zahl.

1. Die Form-Klasse

using System;
using System.Text;
using System.Windows.Forms;

namespace Umrechnung
{
    public partial class Form1 : Form
    {
        ASyncRechnen cThreadClass;
        private delegate void ASyncResultIsReady(Object sender,
                                    Umrechnung.ASyncRechnen.CallbackEventArgs e);
        // Initialisieren der asynchronen Funktionalität
        public Form1()
        {
            InitializeComponent();
            cboBasis.SelectedItem = “10″;
            cThreadClass = new ASyncRechnen();
            cThreadClass.ASyncResultIsReady
                += new ASyncRechnen.ASyncResultIsReadyDelegate(
                            cThreadClass_ASyncResultIsReady);

        }
        // Asynchrones Rechnen starten
        private void button1_Click(object sender, EventArgs e)
        {
            txtString.Text = “Programm rechnet !!!”;
            StringBuilder strVor    =   new StringBuilder(txtVorkomma.Text);
            StringBuilder strNach   =   new StringBuilder(txtNachkomma.Text);
            Int32 nBasis    =   Convert.ToInt32(cboBasis.SelectedItem);
            cThreadClass.AsynchLoad(strVor, strNach, nBasis);
        }
        // Ergebnis des Asynchronen Rechnens in einem Control nutzen
        void cThreadClass_ASyncResultIsReady(Object sender,
                                Umrechnung.ASyncRechnen.CallbackEventArgs e)
        {
            if (txtString.InvokeRequired)
            {
                ASyncResultIsReady cResultIsReady
                    = new ASyncResultIsReady(cThreadClass_ASyncResultIsReady);
                object[] param = new object[] { this, e };
                txtString.Invoke(cResultIsReady, param);
            }
            else
                txtString.Text = e.Result;
        }
        // Anzeige wird ungültig
        private void cboBasis_SelectedValueChanged(object sender, EventArgs e)
        {
            txtString.Text = “Basis hat sich geändert. Wert muss neu errechnet werden.”;
        }
    }
}
2. Asynchrone Funktionalität

using System;
using System.Text;
using Zahl;
using System.Windows.Forms;

namespace Umrechnung
{
    public class ASyncRechnen
    {
        public delegate String WorkerDelegat(StringBuilder p_strVor,
                                            StringBuilder p_strNach,
                                            Int32 p_nBasis);
        public delegate void ASyncResultIsReadyDelegate(Object sender,
                                            CallbackEventArgs e);
        public event ASyncResultIsReadyDelegate ASyncResultIsReady;

        public String WorkerMethod(StringBuilder p_strVor,
                                   StringBuilder p_strNach,
                                   Int32 p_nBasis)
        {
            String strRet   =   “”;
            try
            {
                StringZahl cZahl = new StringZahl(p_strVor, p_strNach, p_nBasis);
                strRet = cZahl.ZahlString.ToString();
            }
            catch (ArgumentException exc)
            {
                MessageBox.Show(exc.Message, “Fehler”);
            }
            return strRet;
        }
        public void AsynchLoad(StringBuilder p_strVor,
                               StringBuilder p_strNach,
                               Int32 p_nBasis)
        {
            WorkerDelegat workerDelegat = new WorkerDelegat(WorkerMethod);
            IAsyncResult asyncResult
                = workerDelegat.BeginInvoke(p_strVor,p_strNach,p_nBasis,
                            new AsyncCallback(CallbackHandler), workerDelegat);
        }
        public void CallbackHandler(IAsyncResult p_cResult)
        {
            WorkerDelegat workerDelegat = (WorkerDelegat)p_cResult.AsyncState;
            String strResult = workerDelegat.EndInvoke(p_cResult);
            CallbackEventArgs arg = new CallbackEventArgs(strResult);
            if (ASyncResultIsReady != null)
                ASyncResultIsReady(this, arg);
        }
        public class CallbackEventArgs : EventArgs
        {
            String strResult;
            public String Result { get { return strResult; } }
            public CallbackEventArgs(String p_strResult)
            {
                strResult = p_strResult;
            }
        }
    }
}

Dynamisches SQL

roth am Mittwoch, 28.Oktober 2009 um 18:20

Um Spalten entsprechend der Berechtigung des verwendeten Login in der Datenbank anzuzeigen bzw. auszublenden ist dynamisches SQL notwendig. Dies könnte in etwa so aussehen:

 

Rekursive CTE’s

roth am Mittwoch, 24.Juni 2009 um 16:34

Beispiel für eine rekursive CTE mit einem Text. Analog kann dazu natürlich auch auf eine Datenbanktabelle rekursiv zugegriffen werden.

SQL-Scripte testen

roth am Samstag, 21.Februar 2009 um 16:32

Um SQL-Scripte auf ihre Syntax und ihre Auswirkungen auf die Daten in der Datenbank zu überprüfen ohne eine Schaden durch eventuelle Fehler zu verursachen können die folgenden Zeilen in das Script eingebaut werden:

– Im Kopf der Scripdatei

IF OBJECT_ID(’tempdb..#err’)<>0 DROP TABLE #err
GO
CREATE TABLE #err (id int IDENTITY, error int)
GO
BEGIN TRAN
GO
====================================================
–Hier stehen die zu testenden SQL-Aktionen, nach welcher jeweils die folgende
–Zeile stehen muss

GO
DECLARE @e int SET @e=@@ERROR IF @@TRANCOUNT=0 BEGIN INSERT #err (error) VALUES (@e) BEGIN TRAN END
GO

===================================================
– Zum Testen ROLLBACK, zum Ausführen COMMIT auskommentieren

IF EXISTS(SELECT * FROM #err)
BEGIN
ROLLBACK
SELECT * FROM #err
END ELSE

– COMMIT
ROLLBACK

Fremdschlüssel aus anderer Datenbank

roth am Samstag, 21.Februar 2009 um 16:32

Habe ich eine Fremdschlüsselbeziehung zu einer anderen Datenbank kann mit dem folgenden Trigger die refrenzielle Integrität gewahrt werden:

CREATE TRIGGER [dbo].[Triggername] ON [dbo].[Tabelle_mit_Fremdschlüssel]
FOR INSERT, UPDATE
AS

SET NOCOUNT ON

IF NOT EXISTS(SELECT * FROM inserted ins
LEFT JOIN Tabelle T ON T.ID=ins.IDFremdschlüssel WHERE T.ID IS NULL)
RETURN

RAISERROR (50000, 11, 1, ‘IDFremdschlüssel ‘, ‘Tabelle’)

ROLLBACK

Einfügen eines vorgegebenen Primärschlüssels

roth am Samstag, 21.Februar 2009 um 16:31

Wenn z.B. aus einer gesicherten Tabelle Daten wieder hergestellt werden sollen aber die Primärschlüsselwerte die gleichen bleiben sollen, folgendes Script verwenden:

set identity_insert Tabelle on
insert into Tabelle (ID, Spalten) select ID, Spalten from sicherung.dbo.Tabelle
set identity_insert Tabelle off

ASP.NET-Webdienst

roth am Donnerstag, 1.März 2007 um 16:35

Erstellen des Servers:

1. Erstellen eines Projektes vom Typ ASP.NET-Webdienstes

2. In der Code-Ansicht implementieren der Methoden mit dem Attribut [WebMethod]

3. Testen des Servers mit F5(Starten). Es erscheint eine generierte Website mit den implementierten Methoden.

4. Um Zwischenergebnisse zu speichern (den Zustand halten) erhält das WebMethod-Attribut den Parameter EnableSession ( [WebMethod(EnableSession=true)] ). In der dazugehörigen Service-Methode ist eine Sessionvariable anzulegen, welche den entsprechenden Wert speichert ( Session[”Name”] = Wert; ). AWenn für alle Clienten die gleichen daten verwendet werden sollen, ist stattdessen ein Application-Objekt zu benutzen. Zur Verhinderung paraller Zugriffe verwendet man Lock() und UnLock().

5. Zum Caching von daten (z.B. bei DB-Aufrufen) erhält WebMethod den Parameter CacheDuration.

 [WebMethod(CacheDuration=5)]

Der Zahlenwert gibt die Speicherdauer in Sekunden an.

6. Jeder Webdienst sollte einen eigenen Namensraum zugwiesen bekommen. Die jeweilige Klasse erhält dazu das Attribut: [WebService(Namespace=”http:://MeinService”)]. Dadurch wird der standardmäßig gesetzte Namensraum tempuri.org ersetzt. Um das Postfix “Soap” hinter dem Klassennamen zu vermeiden, welches durch WSDL automatisch generiert würde, erhält die Webdienst-Klasse ein weiteres Attribut: [WebServiceBinding(Name=”MeinService”)]. Die Methoden erhalten analog dazu das Attribut [SoapDocumentMethod(Binding=”MeinService”)].

Erstellen des Clients:

1. Erstellen eines neuen Projektes zum Beispiel eine Windows-Forms-Anwendung

2. Hinzufügen des Webverweises auf den Webdienst-Server. damit wird ein Proxy von Wsdl.exe generiert, welcher von Visual mit localhost.h bezeichnet wird. Die Proxy-Klasse ist von SoapHttpClientProtocl abgeleitet. Die Methode Invoke() erledigt den Aufruf der Server-Methode.

3. In einem Ereignis, welches die Methode des Webdienstes aufrufen soll, wird eine Instanz des Proxies erzeugt:

    localhost.Service service = new localhost.Service();

Auf die Webservice-Methoden kann nun über die Variable service zugegriffen werden.

4. Asynchrone Methodenaufrufe werden mit den Methoden BeginXXX() und EndXXX() im Proxy realisiert. Dazu ist eine Rückruf-Methode einzusetzen oder die IsCompleted-Eigenschaft abzufragen. Der Rückgabewert der BeginXXX-Methode ist in einer IAsyncResult-Variable zu speichern, welche beim Aufruf der EndXXX-Methode als Parameter zu übergeben ist.

5. Zum Zustandhalten muss dem Webdienst ein CookieContainer-Objekt hinzugefügt werden:

    service = new localhost.SpeicherService();

    service.CookieContainer = new CookieContainer();

Debuggen von Webdiensten

Der Webdienst läuft in einem anderen Prozeß (AspNet_Wp.exe) als der Client und ignoriert somit Haltepunkte. Um den Webdienst im Debugger zu untersuchen, muss der Prozeß AspNet_Wp.exe über den Menüpunkt “Prozesse” an den Client angefügt werden.

SOAP-Erweiterung

Eine SOAP-Erweiterung ermöglicht den Zugriff auf den Datenstrom in verschieden Zuständen. Damit läßt sich der Datenstrom auswerten und verändern (z.B. Verschlüsseln und Komprimieren). Der Zugriff auf den Datenfluss kann sowohl bei der Server-Anfrage an den Punkten BeforeDeserialize und AfterDeserialize und bei der Server-Antwort an den Punkten BeforeSerialize und AfterSerialize erfolgen.

SOAP-Erweiterungen werden durch Ableiten von der Klasse SoapExtension erzeugt. Dazu sind bei der Implementierung die Methoden ProcessMessage(), Initialize() und GetInitialize() zu überschreiben. Wenn Daten verändert werden sollen ist zusätzlich die Methode ChainStream() zu überschreiben. Greifen mehrere SOAP-Erweiterungen auf eine Webdienst-Methode zu ist die Reihenfolge des Zugriffs durch Gruppen und Prioritäten festzulegen. Soll die SOAP-Erweiterung auf alle Methoden angewendet werden, kann dies durch Eintrag in der Web.config erfolgen:

<webServices>
    <soapExtensionTypes>
        <add type=”Klassenname, Assembly” priority=”1″ group=”0″/>
    </soapExtensionType>
</webServices> 

Die Anwendung einer SOAP-Erweiterung auf einzelne Methoden erfolgt durch das Setzen des entsprechenden Attributes. Dieses ist von der Klasse SoapExtensionAttribute abzuleiten. Es müssen außerdem mindestens die Eigenschaften ExtensionType und Priority implementiert werden.

SOAP-Header

SOAP-Header transportieren Daten, welche nichts mit dem eigentlichen Methodenaufruf zu tun haben. Häufig wird dies für die Authentifizierung mit SessionId bzw. Kundennummer genutzt. SOAP-Header werden von der Klasse SoapHeader abgeleitet. Sinnvollerweise ist der Code außerhalb des eigentlichen Webdienstes zu implentieren (in einer DLL, welche in das Verzeichnis bin des Webdienstes zu kopieren ist). Der Zugriff auf die Daten im Header geschieht über den Parameter vom Typ SoapMessage der Methode ProcessMessage aus der SOAP-Erweiterung.

Die Webdienst-Methode, welche die SOAP-Header-Daten nutzen soll, erhält das Attribut: [SoapHeader(”headername”)]. Außerdem ist in der dazugehörigen Webdienst-Klasse eine public-Variable vom Typ der SOAP-Header-Klasse mit dem Namen “headername” zu deklarieren. Im Client ist dann noch eine Instanz der SOAP-Header-Klasse anzulegen und diese wird der Instanz des Proxies zugewiesen; natürlich bevor die eigentliche Methode aufgerufen wird. Dem SOAP-Header-Attribut können neben dem MemberName noch die Parameter Direction ( In, Out, InOut ) und Required (true,false) übergeben werden.


404 Not Found error was encountered while trying to use an ErrorDocument to handle the request.

Not Found

Additionally, a 404 Not Found

The requested URL /blog/wp-content/themes/default/tent.php was not found on this server.