Beim nächsten Treffen der .Net Developer-Group Ulm dürfen wir diesesmal Dariusz Parys begrüßen, der zum Thema “Architektur der Datenanbindungsschicht, insbesondere ADO.NET Data Services und Entity Framework” spricht. Der Abstract verspricht schon mal einen sehr spannenden Abend:

LINQ to SQL, ADO.NET, Entity Framework, Entity Data Model, REST mit ADO.NET Data Services oder Serialisierung mit WCF ? – neben einem Überblick über die Alternativen und detailliertere Darstellung des Entity Frameworks wird darauf eingegangen, welche Kriterien beim O/R-Mapping zur Bewertung zur Verfügung stehen und diskutiert, welcher Nutzen darin liegt, die Datenanbindung von einer technischen Ebene auf eine logische zu heben.

Ích glaube das dürfte ein Themengebiet sein mit dem im Moment jeder Entwickler in irgendeiner Weise käpft und so dürfte sich Dariusz schon mal auf eine ganze Reihe von Fragen einstellen (Mir selbst fallen da schon eine ganze Reihe ein).

Wer also Interesse an dem Thema hat, ist herzlich eingeladen am Dienstag 17.02.2008 um 18:00 zu uns zu kommen.

Weitere Infos unter:

http://www.dotnet-ulm.de

Das patterns & practices Team hat einen Application Architect Guide veröffentlicht. Das 365 Seiten umfassende Dokument kann kostenlos von CodePlex heruntergeladen werden und beschreibt Architekturansätze für Windows, Web, Mobile und andere Anwendungen. Neben theoretischen Grundlagen werden auch explizite Guidelines für verschiedene Design-Aspekte einer Anwendung beschrieben.

Absolut empfehlenswert!

patterns & practices: Application Architecture Guide 2.0 (The Book) - Home

Über das PropertyGrid-Control habe ich ja mehrmals gebloggt (z.B. hier). Dieses Control verwendie ich recht häufig um z.B. den Inhalt eigene Konfigurations-Klassen zu editieren. Zusammen mit der XML-Serialisierung lassen sich so sehr flexible Konfigurationsmöglichkeiten schaffen.

Nun hatte ich die Anforderung eine dynamische Datenstruktur an ein PropertyGrid zu binden. Da stand ich zunächst vor einem Problem. Bisher habe ich nur Objekte mit Properties unterschiedlicher Typen an das PropertyGrid gebunden. Nun habe ich eine Liste von Objekten, die die Elemente im PropertyGrid beschreiben. Wie aber diese an das PropertyGrid binden?

Das schöne ist, das das PropertyGrid sich hier als sehr flexibel erweist. Man muss folgende Schritte durchführen:

1. Man brauch eine Klasse für ein einzelnes Property
   
2. Dann brauchen wir eine Collection für diese Properties. Diese leiten wir von CollectionBase und ICustomTypeDescriptor ab und implementieren die Interfaces. Entscheidend ist hier die Methode GetProperties. Hier werden nun ine PropertyDescriptionCollection aus unseren Properties aufgebaut. Diese Methode ruft das PropertyGrid auf um sich dieProperties zu besorgen, die es rendern soll. Hier können wir nun also von einer belibigen Datenstruktur die benötigten
   Informationen für das PropertyGrid aufbauen.
   
3. Dafür brauch wir jetzt noch einen cCustomPropertyDescriptor. Diesen leiten wir von PropertyDescriptor ab und implementieren es.
   
4. Nun können wir unsere Properties aufbauen und an das PropertyGrid binden. Ich habe das CustomPropertyGrid als eigenes Control angelegt. Der Code ist nun sehr simpel:

               1:
              private
              void Form1_Load(object sender,
EventArgs e)

               2: {

               3: cPropertyCollection
props = new cPropertyCollection();

               4: props.Add(new cPropertyItem("BoolValue", "This
is a boolean value", false, true, "Properties"));

               5: props.Add(new cPropertyItem("StringValue", "This
is a string value", false, "Test123", "Properties"));

               6: props.Add(new cPropertyItem("Folder", "Path
for folder", false, "", "Path"));

               7:  

               8:
              this.artisoPropertyGrid1.SelectedObject
= props;

               9: }

Damit erhält man folgendes Ergebnis. Man sieht die dynamisch angelegten Properties mit ihrem Name, in die Kategorien untergliedert und mit der Beschreibung. Das PropertyGrid wählt automatisch die gewohnten Controls abhängig vom Datentyp aus.

Dis ist schon ganz nett. Ich möchte aber für das Folder-Property einen entsprechenden Editor angeben können. Bei statischen Klassen vrwendet man einfach Attribute, aber bei dynamischen? Dazu wird die verfügbare Dokumentation sehr, sehr dünn. Hierzu haben wir auf der Property-Klasse eine Attribute-Arary. Diese Attribute können wir nun in der GetProperties-Klasse an den cCostomPropertyDescriptor übergeben. Der Aufbau der Properties sieht dann so aus:

               1:
              private
              void Form1_Load(object sender,
EventArgs e)

               2: {

               3: cPropertyCollection
props = new cPropertyCollection();

               4: props.Add(new cPropertyItem("BoolValue", "This
is a boolean value", false, true, "Properties"));

               5: props.Add(new cPropertyItem("StringValue", "This
is a string value", false, "Test123", "Properties"));

               6: props.Add(new cPropertyItem("Folder", "Path
for folder", false, "", "Path",

               7:
              new TypeConverterAttribute(),

               8:
              new EditorAttribute(typeof(System.Windows.Forms.Design.FolderNameEditor), typeof(System.Drawing.Design.UITypeEditor))));

               9:  

               10:
              this.artisoPropertyGrid1.SelectedObject
= props;

               11: }

Nun kann man im Feld für den Wert für das Property "Folder" auf einen Button klicken und erhält einen Dialog zur Auswahl eines Verzeichnisses.

In diesem White Paper werden verschiedene Konzepte für das Requirement Management mit Visual Studio und einigen 3rd Party Tools beschrieben. Leider fehlt bei den 3rd Party Tools unser artiso WorkitemManager ;-)

http://www.microsoft.com/downloads/details.aspx?FamilyId=EEF7BB41-C686-4C9F-990B-F78ACE01C191&displaylang=en#filelist

Objekte und Listen lassen sich jetzt in C# 3.0 sehr schön initialisieren. War bisher um ein relativ einfaches Objekt zu initialisieren sehr viel Code erforderlich, hat sich das nun deutlich verkürzt:

Bisher:

List<cProduct> Products = new List<cProduct>();
cProduct Product = new cProduct(); Product.ID
= 1; Product.BusinessDevelopmentComment = "";
Product.MarketingComments = ""; Product.VersionDescriptions
= new List<cProductVersionDescription>();
Product.INNs = new List<cProductINNItem>();
cProductVersionDescription VersionDescription = new cProductVersionDescription();
VersionDescription.ID = 1; VersionDescription.LastPCMDate = DateTime.Now; VersionDescription.LastPCMDecision
= "Go"; VersionDescription.NPV = 689.54; VersionDescription.ProductID
= 1; VersionDescription.ProductVersionID = 1; VersionDescription.VersionName = "Version1";
Product.VersionDescriptions.Add(VersionDescription); cProductINNItem INN = new cProductINNItem();
INN.INN = 8; INN.Dosage = 1.5; INN.DosageUnit = 1; INN.Volume = 1; INN.Comment = "Test-Comment";
INN.INNOrder = 1; Product.INNs.Add(INN); INN = new cProductINNItem();
INN.INN = 2; INN.Dosage = 2.5; INN.DosageUnit = 2; INN.Volume = 2; INN.Comment = "Test-Comment2";
INN.INNOrder = 2; Product.INNs.Add(INN);

Neu mit C#3.0:

List<cProduct> Products = new List<cProduct>
{ new cProduct{ ID = 1, BusinessDevelopmentComment
= "", MarketingComments = "",
VersionDescriptions = new List<cProductVersionDescription>
{ new cProductVersionDescription{ ID=1, LastPCMDate=DateTime.Now,
LastPCMDecision="Go", NPV=689.54, ProductID=1,
ProductVersionID=1, VersionName="Version1"} },
INNs = new List<cProductINNItem> { new cProductINNItem{
INN=8, Dosage=1.5, DosageUnit=1, Volume=1, Comment="Test-Comment",
INNOrder=1}, new cProductINNItem{ INN=2, Dosage=2.5,
DosageUnit=2, Volume=2, Comment="Test-Comment2",
INNOrder=2} } } };

Bisher konnte man den Code noch etwas vereinfachen, indem man einen entsprechenden Konstruktor für die Objekte erstellt hat, in dem die Initialisierungswerte übergeben werden konnten. Hier bietet die neue Version aber den Vorteil, dass diese leichter zu leesen ist, da die Parameter hier entsprechend bezeichnet sind. Beim Konstruktor musste immer Intellisense zu Hilfe genommen werden um herauszufinden, um welchen Parameter es sich handelt.

Scott Mitchell  hat 75 Tutorials zum Thema Data Access mit ASP.Net 2.0 geschrieben. Hier ist praktisch alles an Technologie beschrieben, was für die Programmierung von datenbankbasierten Webanwendungen mit ASP.Net 2.0 notwendig ist. Einzig LINQ wird momentan noch ausgespart. Eine wirklich tolle Sammlung an guten Informationen.

Data Access Tutorials : The Official Microsoft ASP.NET 2.0 Site

Hat man ein typisiertes DataSet und arbeitet darin mit mehreren TableAdaptern, dann stellt sich die Frage, wie Updates auf diesen TableAdaptern in eine Transaktion zusammengefasst werden können. Das Problem dabei ist, dass jeder TableAdapter seine eigene Connection nutzt. Es gibt grundsätzlich zwei Lösungsansätze:

1. Man verwendet den TransactionScope aus dem System.Transactions-Namespace. Diese Vorgehensweise hat allerdings den Nachteil, dass die verschiedenen Connections nur über eine Distributed Transactions verwaltet werden können. Das ist nicht unbedingt das Nonplusultra was die Performance angeht und eigentlich ja auch mit Kanonen auf Spatzen geschossen, da typischerweise alle TableAdapter ja auf die gleiche Datenbank gehen dürften und damit die Ditributed Transactions etwas überkandidelt sind.
   
2. Man verwendet eine Connection für alle TableAdpater. Hierzu gibt es glücklicherweise die Möglichkiet, dass man die Connection der Tableadapter austauschen kann. Man kann z.B. einfach die Connection des ersten TableAdapters allen anderen zuweisen und dann auf dieser Connection mit BeginTransaction eine neue Transaktion beginnen und diese dann mit Commit bzw. RollBack abschließen. Alternativ kann man natürlich auch manuell eine Connection erzeugen und diese dann allen TableAdaptern zuweisen.

Eine sehr schöne Beschreibung dieser Lösungsansätze hat John Waters unter folgendem Link veröffentlicht: ADO.NET : Getting TableAdapters to participate in transactions

 Wie man mit .net (VB2005) auf das Active Directory zugreift und dort Benutzer ausliest und verwaltet zeigt, der Blog-Beitrag von Armin Stockner.

Link to Armin Stockner : Active Directory with VB2005

Auf Codeplex gibt es einen Guidance zu Visual Studio 2005 Team System, der verschiedene Vorgehensweisen mit VSTS beschreibt. Themen sind u.a:

• How To: Structure Your Windows Applications for Team Foundation Server
• How To: Structure Your Source Control Folders in Team Foundation Server  
• How To: Structure Your ASP.NET Applications for Team Foundation Server
• Explained - Structuring Your Solutions and Projects in Source Control with Team Foundation Server
• Explained: Branching in Team Foundation Server
• How to automate common version control tasks
• How to plan your branching structure
• How to use branching to support a release
• How to use branching to maintain a previous release
• How to use branching to stabilize your development and build process
• How to use branching to stabilize feature development
• How to use branching to stabilize development across teams
• How to use branching to isolate external dependencies
• How to use TFS to perform continuous integration builds
• How to choose one team project vs multiple team projects
• How to organize your source tree
• How to define workspace mappings
• How to use workspaces to isolate code changes on your machine

und vieles anderes mehr!

Link to patterns & practices: Visual Studio 2005 Team System Guidance

Bei der Dotnet Usergroup Bremen wurde das Thema in einem kleinen Artikel ausführlich diskutiert.

Link to DOTnet Usergroup Bremen

Danke an Chris für den Link

Ein wirklich gutes Dokument zum Thema Databinding in WinForms mit Visual Studio 2005 findet sich unter

http://www.windowsforms.net/Samples/Go%20To%20Market/Data%20Binding/DataBinding%20FAQ.doc#_Toc117313112

10 häufige Fallstricke bi der Veröffentlichung von ASP.Net Webseiten und deren Vermeidung, zum Teil auch der technische Hintergrund werden in folgendem Artikel beschrieben:

http://www.microsoft.com/germany/msdn/library/net/aspnet/StoerungsfreiAusgefuehrteSitesDurchVermeidenDieserZehnVerbreitetenASPNETFehlerquellen.mspx?mfr=true

Bei der Erstellung von UIs sollte darauf geachtet werden, dass möglichst wenig Funktionalität in der Benutzeroberfläche selbst implementiert wird. Das folgende Entwurfsmuster beschreibt eine Vorgehensweise:

http://www.microsoft.com/germany/msdn/library/architecture/EntwurfsmusterModelViewPresenter.mspx?mfr=true

Der Artikel beschreibt wie unter ASP.Net 2.0 Ressoucen eingesetzt werden und wie sich damit Web-Anwendungen lokalisieren lassen.

http://www.microsoft.com/germany/msdn/library/net/aspnet/RessourcenUndLokalisierungInASPNET20.mspx?mfr=true

Die Verwaltung von Konfigurationseinstellungen hat sich in .net 2.0 gegenüber .net 1.1 geändert. Es stehen Funktionen zum Schreiben von Konfigurationsparameter und auch benutzerspezifische Konfigurationsparameter zur Verfügung. Die Verwendung der Konfigurationeinstellungen unter .net 2.0 beschreibt der Artikel http://msdn.microsoft.com/vcsharp/default.aspx?pull=/library/en-us/dnvs05/html/SettingsCS_RL.asp

.Net Applikationen werden normalerweise Just in Time compiliert. Durch eine Vorkompilierung können sich Vorteile in Punkto Performance uns Speichernutzung ergeben. Dazu bietet das .net Framework das Tool NGen. Wie dieses Tool eingesetzt werden kann und was dabei zu beachten ist beschreibt dieser deutschsprachige Artikel.

http://www.microsoft.com/germany/msdn/library/net/DieLeistungsvorteileDurchNGen.mspx?mfr=true

Das Buch beschreibt das Thema Threading in C' recht ausführlich und lässt sich auch als PDF herunterladen.

http://www.albahari.com/threading/

Oft möchte man den Monatsnamen eines Datums in der jeweiligen Landessprache des Anwenders ausgeben. Dies kann man einfach mit einer Zeile Code bewerkstelligen:

Alternativ kann man auch die Kurzform der Monate über die Eigenschaft AbbreviatedMonthNames abfragen.

Will man eine spezifische Sprache zur Ausgabe verwenden, kann man dies natürlich auch tun indem man einfach das entsprechende CultureInfo-Objekt verwendet:

MSDN Solve ist die Lösung für alle Entwickler, die praxis-orientierte Hilfestellungen bei typischen Programmier-Herausforderungen suchen. MSDN Solve liefert verständliche Antworten auf immer wiederkehrende Fragen aus dem IT-Alltag und sorgt dafür, dass Sie Stolperfallen in Software-Projekten künftig leicht umschiffen.

http://www.microsoft.com/germany/msdn/solve/default.mspx

Die aktuelle Bildschirmauflösung abzufragen ist in .NET denkbar einfach, möchte man jedoch alle verfügbaren Auflösungen erfragen und eventuell sogar eine neue Auflösung setzen, muss man auf die Win32 API-Mittel zurückgreifen. Dieser Beitrag stellt eine Klasse zur Verfügung mit der mit jeweils einer Zeile Code über die verfügbaren Auflösungen iteriert werden bzw. eine neue Auflösung festgelegt werden kann

http://www.codegod.de/WebAppCodeGod/Main.aspx?pid=168

Ein wenig bekanntes Control ist das FlowLayoutPanel, das in VS 2005 standardmäßig enthalten ist. Mit diesem Control kann man Unterelemente in einer fließenden Ansicht darstellen wie das z.B. auch von Web-Seiten bekannt ist. Sie möchten eine Liste von Textboxen die untereinander stehen? Kein Problem mit dem FlowLayoutPanel. Sie können eine beliebige Richtung wählen (von rechts nach links, von oben nach unten etc.). Passen nicht alle Control in die Reihe, wird automatisch ein Umgruch eingefügt. Damit ist das FlowLayoutPanel wesentlich flexibler als man diese Funktion z.B. mit Docking erreichen könnte. Vor allem bei dynamisch generierten Control leistet das FlowLayoutPanel gute Dienste!

Oft möchte man Daten, die aus Excel in die Zwischenablage kopiert wurden, in der Anwendung verarbeiten. Dies geht recht einfach, da die Excel-Daten in der Zwischenablage einfach als CSV-Format vorliegen.

Man holt sich die Daten aus der Zwischenablage und prüft diese, ob sie im CSV-Format vorliegen. Dann kann man mit Hilfe eines StreamReaders die Daten lesen. Die Daten kommen dann in einem Format wie z.B. 5,8;8,9;7,5. Das lässt sich nun problemlos in der eigenen Anwendung verarbeiten.

Um von generischen Objekten den Typ abzufragen kann man folgenden Code verwenden:

Dieser Code liefert ein Array zurück, das im ersten Element System.String und im zweiten System.Double enthält.

Weitere Infos unter http://msdn2.microsoft.com/en-us/library/b8ytshk6.aspx

Eine sehr umfangreiche Link-Liste zu den 3 Hauptthemen von .Net 3.0 gibt es unter:

Teil 1: Windows Presentation Foundation
Teil 2: Windows Communication Foundation
Teil 3: Windows Workflow Foundation

Eine Reihe von interessanten Artikel findet man unter http://www.theserverside.net/tt/articles/index.tss

Teil 1 : http://www.theserverside.net/tt/articles/showarticle.tss?id=UnitTest
Teil 2 : http://www.theserverside.net/tt/articles/showarticle.tss?id=UnitTest2
Teil 3 : http://www.theserverside.net/tt/articles/showarticle.tss?id=UnitTest3

http://msdn.microsoft.com/practices/compcat/default.aspx?pull=/library/en-us/dnpag/html/scalenet.asp

Statt try-catch-finally gibt es auch noch eine Alternative mit Hilfe sog. Scopes.

http://blog.veloursnebel.de/PermaLink,guid,fb472ac8-d855-4224-a2e0-ddf758492b17.aspx

Will man Fenster mit ungewöhnlichen Formen erzeugen (wie z.B. unten), ist das mit Hilfe der Region-Eigenschaft kein Problem.

http://www.microsoft.com/germany/msdn/library/net/windowsforms/WindowsFormsUmrisseFreiBestimmen.mspx?mfr=true

http://www.microsoft.com/germany/msdn/webcasts/serien/MSDNWCS-0607-01.mspx

Unter http://www.microsoft.com/germany/msdn/webcasts/serien/MSDNWCS-0605-02.mspx gibt es eine Webcast-Serie zur Entwicklung mit Office 2007 und .Net

Von Microsoft gibt es ein deutschsprachiges Portal das sich mit Themen rund um die Software-Architektur beschäftigt:

http://www.microsoft.com/germany/architecture/default.mspx

Unter IDesign gibt es einen Download, mit dem das My-Objekt von VB auch unter C# genutzt werden kann.

http://www.idesign.net/idesign/DesktopDefault.aspx?tabindex=-1&tabid=19&download=141

The My class in VB often simplifies and streamlines many operations, from Network programming to clipboard, to audio access, and so on. What takes sometimes a programming fit in C# can be done in one line using the My class in VB. If VB has Me and My, then C# should have this and That. The That class is the C# equivalent of the VB My class. It is a static class that uses the VB implementation as much as possible, and it requires adding a referencing to Microsoft.VisualBasic. The That class is instrumental when working in heterogeneous environments and when dealing with in porting of VB to C# or visa-versa.

Weitere interessante Downloads gibt's unter http://www.idesign.net/idesign/DesktopDefault.aspx?tabindex=5&tabid=11#ES

http://webperformanceinc.com/library/reports/TestingAspDotNet/index.html

http://www.cimtec.dk/dot-net/DataBinding/DataBinding.htm

Beschreibt auch das Databindung zu User-Controls.

Bisher war es recht mühsahm, Oberflächen für verschiedene Sprachen zu erstellen. Mit VS 2005 ist das jetzt ein Kinderspiel. Einfach auf der Form die Eigenschaft Localizable auf true setzen. Dann die Oberfläche für die Standard-Sprache aufbauen. Anschließend die Eigenschaft Language auf der Form auf eine explizite Sprache einstellen und Anpassungen vornehmen (Lables, Buttons etc. neu beschriften). VS legt für die Zweitsprache automatisch eine .resx-Datei an, in der diese sprachspezifischen Einstellungen gespeichert werden.

Während des editierens kann man beliebig zwischen den Sprachen umschalten und die Oberfläche für die jeweilige Einstellung editieren. Genial ist dabei, dass nicht nur Texte in den sprachspezifischen Ressource-Dateien gespeichert werden, sondern auch alle anderen Einstellungen. Wird ein Button z.B. in Englisch mit "Save" betittelt, kann es sein, dass die deutsche Bezeichnung "Speichern" zu lang ist und der Platz nicht ausreicht. Kein Problem. Den Button einfach in der deutschen Einstellung vergrößern und schon wird auch die Größe des Buttons in Abhängigkeit der Sprache gewählt.

Dass viele Operationen mit einem string recht langsam ist, ist ja weitgehend bekannt, auch dass man hier besser einen StringBuilder verwendet. Folgendes Beispiel ist unter Performance-Aspekten sehr ungünstig:

string Text = "";
for (int i=0; i<100000; i++)
{
   Text += "x";
}

Was weniger bekant ist, die Erklärung dafür. Wird einem String ein neuer Wert zugeweisen, so wird das Objekt jedes mal neu angelegt. In dem obigen Beispiel wird also 100000 mal ein neues String-Objekt angelegt und das alte verworfen. Das kostet natürlich Zeit. Dahingegen ist der StringBuilder dynamisch erweiterbar. Nach der initialisierung wird er mit einer Kapazität von 16 Zeichen angelegt. Die Kapazität verdoppelt sich nun jedesmal, wenn die Kapazität überschritten wird. Mit dem einfügen des 17. Zeichens wird die Kapazität also auf 32 erhöht etc. Beim Stringbuilder kann man im Konstruktor auch schon eine größere Kapazität angeben.

In der AssemblyInfo.vb bzw. AssemblyInfo.cs gibt es zwei Einträge zur steuerung der Versionierung.

Das Problem dabei ist, dass die AssemblyVersion durch * automatisch nummeriert werden kann, dass das aber bei der AssemblyFileVersion nicht funktioniert. Möchte man, dass beide gleich sind, muss man lediglich die AssemblyFileVersion löschen.

Microsoft bietet unter http://www.microsoft.com/germany/msdn/webcasts/library.aspx?id=1032301564 eine neue Reihe von WebCastts für .Net Entwickler an.

Mit Hilfe der Eigenschaft UpdateBatchSize kann eingestellt werden, wieviele Update-Befehle beim Updaten eines Datasets in die Datenbank zusammengefasst werden sollen.

DataAdapter and Batch Updates. In the previous version of ADO.NET, when updating a database with changes from a DataSet, the Update method of a DataAdapter performs updates to the database one row at a time.

As the method iterates through the rows in the specified DataTable, it examines each DataRow to see if the row has been modified. If the row has been modified, the method calls the appropriate UpdateCommand, InsertCommand or DeleteCommand, depending on the value of the RowState property for that row. Every row update involves a network round-trip to the database.

In ADO.NET 2.0, the DataAdapter exposes an UpdateBatchSize property. Setting the property to a positive integer value causes updates to the database to be sent as batches of the specified size. For example, setting the UpdateBatchSize to 10 will group 10 separate statements and submit them as a single batch. Setting the UpdateBatchSize to 0 will cause the DataAdapter to use the largest batch size that the server can handle. Setting it to 1 disables batch updates as rows are sent one at a time.

Event Behavior Changes with Batch Updates. The DataAdapter class has two update-related events i.e. RowUpdating and RowUpdated. In previous versions of ADO.NET, and when batch processing is disabled, each of these events is generated once for each row processed. RowUpdating is generated before the update occurs, and RowUpdated is generated after the database update is completed.

When batch processing is enabled, multiple rows are updated in a single database operation. Therefore, only one RowUpdated event occurs for each batch, whereas the RowUpdating event occurs for each row processed.

When batch processing is disabled, the two events are fired with one-to-one interleaving where one RowUpdating event and one RowUpdated event fire for a row, then one RowUpdating and one RowUpdated event fire for the next row, until all of the rows are processed.