stefankoelle/buildbroken-blog-archive
1
0
Fork 0
mirror of https://github.com/skoelle/buildbroken-blog-archive.git synced 2026-09-17 18:30:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix code blocks

Browse Source
This commit is contained in:
stefankoelle
2026-09-10 22:54:41 +02:00
parent 2dc30200a1
commit cd8a75ec13
9 changed files with 519 additions and 666 deletions
Download Patch File Download Diff File Expand all files Collapse all files
content/posts/anonyme-datentypen.md
+9 -9
View File
@@ -13,17 +13,17 @@ Anonyme Datentypen sind Klassen, die erst beim Kompilieren durch den Compiler de
Definiert und intstanziert werden sie mit new und einem Objektinitialisierer:
```
var mitarbeiter = new { Name = "Müller", Abteilung = "IT" };
```csharp
var mitarbeiter = new { Name = "Müller", Abteilung = "IT" };
```
var ist der implizite Typ und **nicht** der anonyme Datentyp. Er fungiert hier lediglich als container für die Instanz des anonymen Datentyps, die mit new {} erzeugt wird.
Gibt man keinen Namen für die Properties an, werden die Namen der Properties verwendet, mit denen initialisiert wird.
```
var abteilung = new { Abteilungsname = "IT" };
var mitarbeiter = new { Name = "Müller" , abteilung.Abteilungsname };
```csharp
var abteilung = new { Abteilungsname = "IT" };
var mitarbeiter = new { Name = "Müller" , abteilung.Abteilungsname };
Console .WriteLine(mitarbeiter.Abteilungsname);
```
@@ -33,11 +33,11 @@ Anonyme Datentypen bieten sich an, wenn man Abfragen mit Linq ausführt und entw
Hier ein Beispiel aus einem Castle Monorail Projekt, in dem eine erweiterte Liste an eine vm gegeben wird, ohne eine neue Klasse definieren zu müssen. Es soll dabei eine Liste erstellt werden, in der die Mitarbeiter mit ihrem Horoskop verknüpft werden :
```
public void Action() {
```csharp
public void Action() {
IList < Mitarbeiter > mitarbeiterListe = m_service.GetMitarbeiter();
var mitarbeiterMitHoroskopListe = ( from mitarbeiter in mitarbeiterListe
select new { Mitarbeiter = mitarbeiter,
var mitarbeiterMitHoroskopListe = ( from mitarbeiter in mitarbeiterListe
select new { Mitarbeiter = mitarbeiter,
Horoskop = GetHoroskop(mitarbeiter.Geburtsdatum) });
PropertyBag[ "mitarbeiterMitHoroskopListe" ] = mitarbeiterMitHoroskopListe;
}
content/posts/async-refactored.md
+63 -104
View File
@@ -8,137 +8,96 @@ author: "Thomas Christian"
categories: ["Architektur", "Pattern", "Tipps"]
---
Nach dem ich meinen vorherigen Artikel zum Thema [“Asynchrone Kommunikation mit dem Async-Pattern”](/posts/async/) vorgestellt hatte, hat Ralf Westphal auf seinem Blog [“One Man Think Tank Gedanken”](http://ralfw.blogspot.com/2010/05/asynchrone-kommunikation-mit-ebcs-statt.html) das Vorgehen zur Implementierung einer asynchronen Kommunikation mit Hilfe von Event-Based-Components vorgestellt, welches eine sehr gute Alternative zum Async-Pattern ist. Seinen Eintrag nehme ich zum Anlass, um meine Beispiel-Implementierung des Async-Pattern zu refaktorisieren, um eine bessere Trennung der Verantwortlichkeiten und somit eine bessere Lesbarkeit zu erreichen.
Nach dem ich meinen vorherigen Artikel zum Thema ["Asynchrone Kommunikation mit dem Async-Pattern"](/posts/async/) vorgestellt hatte, hat Ralf Westphal auf seinem Blog ["One Man Think Tank Gedanken"](http://ralfw.blogspot.com/2010/05/asynchrone-kommunikation-mit-ebcs-statt.html) das Vorgehen zur Implementierung einer asynchronen Kommunikation mit Hilfe von Event-Based-Components vorgestellt, welches eine sehr gute Alternative zum Async-Pattern ist. Seinen Eintrag nehme ich zum Anlass, um meine Beispiel-Implementierung des Async-Pattern zu refaktorisieren, um eine bessere Trennung der Verantwortlichkeiten und somit eine bessere Lesbarkeit zu erreichen.
In das Form wird die Abhängigkeit “CalcProxy” injected.
In das Form wird die Abhängigkeit "CalcProxy" injected.
```csharp
static void Main()
{
CalcProxy calcProxy = new CalcProxy(new Calculator());
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1(calcProxy));
CalcProxy calcProxy = new CalcProxy(new Calculator());
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1(calcProxy));
}
```
Im Gegensatz zur vorherigen Version wird in der Form nun nicht mehr der Calculator direkt erzeugt und verwendet, sondern auf den injekteten CalcProxy zugegriffen.
```csharp
public partial class Form1 : Form {
private readonly ICalcProxy m_calcProxy;
private readonly ICalcProxy m\_calcProxy;
public Form1(ICalcProxy calcProxy) {
InitializeComponent();
m_calcProxy = calcProxy;
m_calcProxy.CalcCompleted += CalculatorCalcCompleted;
}
public Form1(ICalcProxy calcProxy) {
        InitializeComponent();
        m\_calcProxy = calcProxy;
        m\_calcProxy.CalcCompleted += CalculatorCalcCompleted;
    }
private void Run\_Click(object sender, EventArgs e) {
int number;
if (Int32.TryParse(txbEingabe.Text, out number)) {
            m\_calcProxy.CalcAsync(number, number);
        }
    }
void CalculatorCalcCompleted(object sender, CalcEventArgs eventArgs) {
        lblCounter.Text = eventArgs.UserState.ToString();
    }
private void Run_Click(object sender, EventArgs e) {
int number;
if (Int32.TryParse(txbEingabe.Text, out number)) {
m_calcProxy.CalcAsync(number, number);
}
}
void CalculatorCalcCompleted(object sender, CalcEventArgs eventArgs) {
lblCounter.Text = eventArgs.UserState.ToString();
}
}
```
Der CalcProxy wiederum bekommt die Abhängigkeit zum Calculator injected und stellt für die Calculator.Calc-Methode sowohl eine synchrone als auch eine asynchrone Methode zur Verfügung.
```csharp
public class CalcProxy : ICalcProxy {
private readonly ICalculator m_calculator;
public event CalcCompletedEventHandler CalcCompleted;
private AsyncOperation m_asyncOperation;
private bool m_isRunning;
private readonly ICalculator m\_calculator;
public CalcProxy(ICalculator calculator) {
m_calculator = calculator;
}
public event CalcCompletedEventHandler CalcCompleted;
public int Calc(int number) {
return m_calculator.Calc(number);
}
private AsyncOperation m\_asyncOperation;
public void CalcAsync(int number, object userState) {
lock (this) {
if (m_isRunning) {
throw new InvalidOperationException("Diese Operation wird bereits ausgeführt");
}
m_isRunning = true;
m_asyncOperation = AsyncOperationManager.CreateOperation(userState);
ThreadPool.QueueUserWorkItem(ExecuteCalc, number);
}
}
private bool m\_isRunning;
public CalcProxy(ICalculator calculator) {
        m\_calculator = calculator;
    }
public int Calc(int number) {
return m\_calculator.Calc(number);
    }
public void CalcAsync(int number, object userState) {
lock (this) {
if (m\_isRunning) {
throw new InvalidOperationException("Diese Operation wird bereits ausgeführt");
            }
            m\_isRunning = true;
            m\_asyncOperation = AsyncOperationManager.CreateOperation(userState);
ThreadPool.QueueUserWorkItem(ExecuteCalc, number);
        }
    }
private void ExecuteCalc(object state) {
var result = Calc((int)state);
        m\_asyncOperation.PostOperationCompleted(CalcCompletedSuccessful, result);
    }
private void CalcCompletedSuccessful(object result) {
if (CalcCompleted != null) {
            CalcCompleted(this, new CalcEventArgs(null, false, (int)result, result));
        }
    }
private void ExecuteCalc(object state) {
var result = Calc((int)state);
m_asyncOperation.PostOperationCompleted(CalcCompletedSuccessful, result);
}
private void CalcCompletedSuccessful(object result) {
if (CalcCompleted != null) {
CalcCompleted(this, new CalcEventArgs(null, false, (int)result, result));
}
}
}
```
Nun enthält der Calculator nur noch die Methode die für den Calculator notwendig ist, nämlich die Calc-Methode.
```csharp
public class Calculator : ICalculator {
public int Calc(int number) {
Thread.Sleep(10000);
return number \* number;
    }
public int Calc(int number) {
Thread.Sleep(10000);
return number * number;
}
}
```
## Kommentare (Archiv)
@@ -155,7 +114,7 @@ return number \* number;
[Mai 6, 2010 um 4:38 pm](/posts/async-refactored/)
[...] This post was mentioned on Twitter by .NET German Bloggers, DeveloperBlogs. DeveloperBlogs said: Asynchrone Kommunikation mit dem Async-Pattern (Refactored): Nach dem ich meinen vorherigen Artikel zum Thema “Asy… <http://bit.ly/9eV2kr> [...]
[...] This post was mentioned on Twitter by .NET German Bloggers, DeveloperBlogs. DeveloperBlogs said: Asynchrone Kommunikation mit dem Async-Pattern (Refactored): Nach dem ich meinen vorherigen Artikel zum Thema "Asy… <http://bit.ly/9eV2kr> [...]
3. **[Rainer Hilmer](http://dotnet-forum.de/blogs/rainerhilmer/default.aspx)**
[Juli 24, 2010 um 1:56 pm](/posts/async-refactored/)
content/posts/async.md
+60 -119
View File
@@ -42,25 +42,25 @@ Der Code hinter der UI sieht folgendermaßen aus. Beim instanziieren des Forms,
Bei dem Drücken des „Run“-Buttons, wird die Methode Calculator.CalcAsync(…) aufgerufen.
```
public partial class Form1 : Form {
private ICalculator m_calculator;
public Form1() {
InitializeComponent();
m_calculator = new Calculator ();
m_calculator.CalcCompleted += Calculator_CalcCompleted;
}
```csharp
public partial class Form1 : Form {
private ICalculator m_calculator;
public Form1() {
InitializeComponent();
m_calculator = new Calculator();
m_calculator.CalcCompleted += Calculator_CalcCompleted;
}
private void Run_Click( object sender, EventArgs e) {
int number;
if ( Int32 .TryParse(txbEingabe.Text, out number)) {
m_calculator.CalcAsync(number, number);
}
}
private void Run_Click(object sender, EventArgs e) {
int number;
if (Int32.TryParse(txbEingabe.Text, out number)) {
m_calculator.CalcAsync(number, number);
}
}
void Calculator_CalcCompleted( object sender, CalcEventArgs eventArgs) {
lblCounter.Text = eventArgs.Result.ToString();
}
void Calculator_CalcCompleted(object sender, CalcEventArgs eventArgs) {
lblCounter.Text = eventArgs.Result.ToString();
}
}
```
@@ -68,119 +68,60 @@ Sobald die Berechnung fertig ist, wird das CalcCompleted-Event ausgelöst und so
Der Calculator sieht wie folgt aus:
```
public interface ICalculator {
event Calculator . CalcCompletedEventHandler CalcCompleted;
int Calc( int number);
void CalcAsync( int number, object userState);
```csharp
public interface ICalculator {
event Calculator.CalcCompletedEventHandler CalcCompleted;
int Calc(int number);
void CalcAsync(int number, object userState);
}
public class Calculator : ICalculator {
public delegate void CalcCompletedEventHandler ( object sender, CalcEventArgs eventArgs);
public event CalcCompletedEventHandler CalcCompleted;
private AsyncOperation m_asyncOperation;
private bool m_isRunning;
public class Calculator : ICalculator {
public delegate void CalcCompletedEventHandler(object sender, CalcEventArgs eventArgs);
public event CalcCompletedEventHandler CalcCompleted;
private AsyncOperation m_asyncOperation;
private bool m_isRunning;
public int Calc( int number) {
Thread .Sleep(10000);
return number * number;
public int Calc(int number) {
Thread.Sleep(10000);
return number * number;
}
public void CalcAsync(int number, object userState) {
lock (this) {
if (m_isRunning) {
throw new InvalidOperationException("Diese Operation wird bereits ausgeführt");
}
m_isRunning = true;
m_asyncOperation = AsyncOperationManager.CreateOperation(userState);
ThreadPool.QueueUserWorkItem(ExecuteCalc, number);
}
}
private void ExecuteCalc(object state) {
int result = Calc((int)state);
m_asyncOperation.PostOperationCompleted(CalcCompletedSuccessful, result);
}
private void CalcCompletedSuccessful(object result) {
if (CalcCompleted != null) {
CalcCompleted(this, new CalcEventArgs(null, false, (int)result, result));
}
}
}
public void CalcAsync( int number, object userState) {
lock ( this ) {
if (m_isRunning) {
throw new InvalidOperationException ( "Diese Operation wird bereits ausgeführt" );
}
m_isRunning = true ;
m_asyncOperation = AsyncOperationManager .CreateOperation(userState);
ThreadPool .QueueUserWorkItem(ExecuteCalc, number);
}
public class CalcEventArgs : AsyncCompletedEventArgs {
public CalcEventArgs(Exception error, bool cancelled, int result, object userState)
: base(error, cancelled, userState) {
Result = result;
}
public int Result { get; private set; }
}
```
        .
        .
        .
```
}
```
Wie man im Interface des Calculator sieht, gibt es eine synchrone und eine asynchrone Methode für die Berechnung. Uns interessiert allerdings nur die asynchrone Methode. Das lock und die Prüfung auf m\_isRunning verhindern lediglich, dass die asynchrone Methode während ihrer Ausführung öfter aufgerufen wird. Das Wesentliche an dieser Methode ist der Aufruf von AsyncOperationManager.CreateOperation, denn dieser Aufruf stellt einen Synchronisationskontext bereit, der die Threads miteinander synchronisiert. Für die eigentliche Berechnung wird sich über den ThreadPool ein neuer Thread besorgt, der sich dann um die Abarbeitung der ExecuteCalc in einem eigenen Thread kümmert.
```
public class Calculator : ICalculator {
```
        .
        .
        .
```
private void ExecuteCalc( object state) {
int result = Calc(( int )state);
m_asyncOperation.PostOperationCompleted(CalcCompletedSuccessful, result);
}
private void CalcCompletedSuccessful( object result) {
if (CalcCompleted != null ) {
CalcCompleted( this , new CalcEventArgs ( null , false , ( int )result, result));
}
}
}
public class CalcEventArgs : AsyncCompletedEventArgs {
public CalcEventArgs( Exception error, bool cancelled, int result, object userState)
: base (error, cancelled, userState) {
Result = result;
}
public int Result { get ; private set ; }
}
```
Wie man im Interface des Calculator sieht, gibt es eine synchrone und eine asynchrone Methode für die Berechnung. Uns interessiert allerdings nur die asynchrone Methode. Das lock und die Prüfung auf m\_isRunning verhindern lediglich, dass die asynchrone Methode während ihrer Ausführung öfter aufgerufen wird. Das Wesentliche an dieser Methode ist der Aufruf von AsyncOperationManager.CreateOperation, denn dieser Aufruf stellt einen Synchronisationskontext bereit, der die Threads miteinander synchronisiert. Für die eigentliche Berechnung wird sich über den ThreadPool ein neuer Thread besorgt, der sich dann um die Abarbeitung der ExecuteCalc in einem eigenen Thread kümmert.
Sobald die Berechnung abgeschlossen ist, wird der Thread mit dem MainThread über den Aufruf von PostOperationCompleted synchronisiert und das CalcCompleted-Event ausgelöst und das Ergebnis in das Label geschrieben (s. o.).
6 public partial class Form1 : Form {
7 private ICalculator m\_calculator;
8 public Form1() {
9 InitializeComponent();
10 m\_calculator = new Calculator();
11 m\_calculator.CalcCompleted += Calculator\_CalcCompleted;
12 }
13
14 private void Run\_Click(object sender, EventArgs e) {
15 int number;
16 if (Int32.TryParse(txbEingabe.Text, out number)) {
17 m\_calculator.CalcAsync(number, number);
18 }
19 }
20
21 void Calculator\_CalcCompleted(object sender, CalcEventArgs eventArgs) {
22 lblCounter.Text = eventArgs.UserState.ToString();
23 }
24 }
## Kommentare (Archiv)
1. <img src="/images/async/3e7b6cb163ea9cc8549abcb8b5a03e2e.jpeg" width="32" height="32" class="avatar avatar-32 photo" alt="Avatar"/> **[Ralf Westphal](http://ralfw.blogspot.com/)**
content/posts/code-to-html.md
+10 -10
View File
@@ -21,12 +21,12 @@ Hierfür habe ich folgende Konfiguration verwendet:
Nach der Bestätigung der Konfiguration sieht das Ergebnis folgendermaßen aus :
```
/// <summary>
/// Summary
/// </summary>
class Program {
static void Main() {
```csharp
/// <summary>
/// Summary
/// </summary>
class Program {
static void Main() {
// Kommentar
Console .WriteLine( "Hello World" );
}
@@ -37,11 +37,11 @@ Console .WriteLine( "Hello World" );
1. **Stefan Kölle**
[Juni 9, 2009 um 12:23](/posts/code-to-html/)
[Juni 9, 2009 um 12:23](/posts/code-to-html/)
Leider kann man den Code vom Blog dann nur schwer wieder in Visual Studio zurueck kopieren.
Leider kann man den Code vom Blog dann nur schwer wieder in Visual Studio zurueck kopieren.
2. **Thomas Christian**
[Juni 10, 2009 um 11:45](/posts/code-to-html/)
[Juni 10, 2009 um 11:45](/posts/code-to-html/)
Wenn man die “Number lines from” weglässt, dann kann man den Code wieder gut aus der Seite kopieren.
Wenn man die “Number lines from” weglässt, dann kann man den Code wieder gut aus der Seite kopieren.
content/posts/design-by-contract-teil2.md
+41 -52
View File
@@ -15,44 +15,41 @@ Erstens muss man die IDE anpassen: im März kommt .NET 4.0 raus und da wird Desi
Jetzt zum Code: Nehmen wir eine ganz einfache Klasse `Bill` deren Objekte mit einem `IRepository` gespeichert bzw. geladen werden.
```
using System.Diagnostics.Contracts;
namespace ContractsPrototyp
```csharp
using System.Diagnostics.Contracts;
namespace ContractsPrototyp
{
public class Bill
public class Bill
{
public int Id { get ; set ; }
public string Number { get ; set ; }
public double Value { get ; set ; }
public int Id { get ; set ; }
public string Number { get ; set ; }
public double Value { get ; set ; }
}
10
11
public interface IRepository
public interface IRepository
{
Bill GetBill( string number);
void SaveBill( Bill bill);
Bill GetBill( string number);
void SaveBill( Bill bill);
}
```
Die Kontrakte kann man in den einzelnen Methoden oder für eine ganze Klasse schreiben (unter dem Attribut `ContractInvariantMethode`) aber ich finde am schönsten, dass man die auch auslagern kann: durch eine gegenseitige Markierung können Kontrakt-Klassen und Interfaces als “Paare” definiert werden:
```
```csharp
[ ContractClass ( typeof ( RepositoryContracts ))]
public interface IRepository
public interface IRepository
{
Bill GetBill( string number);
void SaveBill( Bill bill);
Bill GetBill( string number);
void SaveBill( Bill bill);
}
[ ContractClassFor ( typeof ( IRepository ))]
public class RepositoryContracts : IRepository
public class RepositoryContracts : IRepository
{
public Bill GetBill( string number)
public Bill GetBill( string number)
{
Contract .Requires(! string .IsNullOrEmpty(number));
return null ;
return null ;
}
25
public void SaveBill( Bill bill)
public void SaveBill( Bill bill)
{
Contract .Ensures(bill.Id > 0);
}
@@ -63,43 +60,40 @@ Eine Vorbedingung wird mit `Contract.Requires` und eine Nachbedingung mit `Contr
Die eigentliche Implementierung der Klasse schaut dann so aus:
```
public class Repository : IRepository
```csharp
public class Repository : IRepository
{
public Bill GetBill( string nummer)
public Bill GetBill( string nummer)
{
//Würde das Objekt aus Datenhaltung laden
return new Bill ();
return new Bill ();
}
38
public void SaveBill( Bill bill)
public void SaveBill( Bill bill)
{
//Würde das Objekt speichern und ihm eine Id zuweisen
if (BillIsValid( bill )) bill.Id++;
if (BillIsValid( bill )) bill.Id++;
}
44
private static bool BillIsValid( Bill bill)
private static bool BillIsValid( Bill bill)
{
return ! string .IsNullOrEmpty(bill.Nummer);
return ! string .IsNullOrEmpty(bill.Nummer);
}
}
```
Woher können wir wissen, dass das funktioniert? Es ist einfach, wir schreiben ein Paar Tests dazu!
Woher können wir wissen, dass das funktioniert? Es ist einfach, wir schreiben ein Paar Tests dazu!
Bei Kontraktverletzung wird eine Exception geworfen. Um diese – und dadurch die genaue Verletzung – überprüfen zu können braucht man etwas Workaround:
```
```csharp
[ TestFixture ]
public class BillTests
public class BillTests
{
private IRepository m_repository;
private string m_message;
60
private IRepository m_repository;
private string m_message;
[ SetUp ]
public void Setup()
public void Setup()
{
m_repository = new Repository ();
m_message = string .Empty;
m_repository = new Repository ();
m_message = string .Empty;
Contract .ContractFailed += ( sender, e ) =>
{
e.SetUnwind();
@@ -110,37 +104,32 @@ m_message = e.Message;
Danach sind die Tests dann einfach:
```
```csharp
[ Test ]
public void Laden_mit_leerer_Nummer_verletzt_Kontrakt()
public void Laden_mit_leerer_Nummer_verletzt_Kontrakt()
{
76
try
{
m_repository.GetBill( null );
m_repository.GetBill( null );
}
catch
{
//Nichts
}
85
Assert .That( m_message, Is .EqualTo( "Precondition failed: !string.IsNullOrEmpty(number)" ) );
Assert .That( m_message, Is .EqualTo( "Precondition failed: !string.IsNullOrEmpty(number)" ) );
}
88
[ Test ]
public void Speichern_Rechnung_ohne_Nummer_verletzt_Kontrakt()
public void Speichern_Rechnung_ohne_Nummer_verletzt_Kontrakt()
{
92
try
{
m_repository.SaveBill( new Bill {Value = 25} );
m_repository.SaveBill( new Bill {Value = 25} );
}
catch
{
//Nichts
}
101
Assert .That( m_message, Is .EqualTo( "Postcondition failed: bill.Id > 0" ) );
Assert .That( m_message, Is .EqualTo( "Postcondition failed: bill.Id > 0" ) );
}
```
content/posts/plugin-pattern.md
+52 -60
View File
@@ -9,46 +9,44 @@ categories: ["How-To"]
tags: ["Architektur", "C#", "HowTo", "Plug-In"]
---
In meinem ersten Blog-Post möchte ich euch in vereinfachter Form meine Umsetzung des Plug-In-Patterns vorstellen.
In meinem ersten Blog-Post möchte ich euch in vereinfachter Form meine Umsetzung des Plug-In-Patterns vorstellen.
Voraussetzungen für dieses Pattern sind:
* eine Host-Applikation die das Plug-In laden möchte
* ein Plug-In welches es zu laden gilt
* und die Schnittstellen Plugin und IHost
Zu allererst brauchen wir eine gemeinsame Schnittstelle, die sowohl vom Plug-In als auch vom Host (die Applikation welche das Plug-In verwenden soll) benutzt werden soll. Über diese Schnittstelle kommuniziert der Host mit dem Plug-In.
Zu allererst brauchen wir eine gemeinsame Schnittstelle, die sowohl vom Plug-In als auch vom Host (die Applikation welche das Plug-In verwenden soll) benutzt werden soll. Über diese Schnittstelle kommuniziert der Host mit dem Plug-In.
Es würde sich das Interface IPlugIn anbieten. In meinem Fall verwende ich allerdings kein Interface sondern eine abstrakte Klasse, da ich bereits Logik direkt in die Schnittstelle implementieren möchte. In meinem Fall heißt die abstrakte Klasse einfach nur Plugin. Im weiteren Verlauf werde ich zu meiner abstrakten Klasse Schnittstelle sagen.
```
public abstract class Plugin {
private IHost m_host;
public Plugin( string name) {
```csharp
public abstract class Plugin {
private IHost m_host;
public Plugin( string name) {
Name = name;
}
6
public string Name { get ; set ; }
public string Author { get ; set ; }
public string Version { get ; set ; }
public bool IsRegistered { get ; private set ; }
11
/// <summary>
/// Setzt oder gibt die Host-Application.
/// </summary>
/// <value> Host-Application. </value>
public IHost Host {
get { return m_host; }
set {
if ( value != null ) {
if (m_host == null ) {
m_host = value ;
if (m_host.Register( this )) {
IsRegistered = true ;
public string Name { get ; set ; }
public string Author { get ; set ; }
public string Version { get ; set ; }
public bool IsRegistered { get ; private set ; }
/// <summary>
/// Setzt oder gibt die Host-Application.
/// </summary>
/// <value> Host-Application. </value>
public IHost Host {
get { return m_host; }
set {
if ( value != null ) {
if (m_host == null ) {
m_host = value ;
if (m_host.Register( this )) {
IsRegistered = true ;
}
}
} else {
if (m_host.Unregister( this )) {
m_host = value ;
IsRegistered = false ;
} else {
if (m_host.Unregister( this )) {
m_host = value ;
IsRegistered = false ;
}
}
}
@@ -56,17 +54,17 @@ IsRegistered = false ;
}
```
Ich glaube, der Aufbau der Schnittstelle Plugin sollte bis auf die Property “Host” klar sein. Wie man sieht, benötigt man bei diesem Pattern zusätzlich zur Schnittstelle Plugin noch das IHost-Interface.
Ich glaube, der Aufbau der Schnittstelle Plugin sollte bis auf die Property “Host” klar sein. Wie man sieht, benötigt man bei diesem Pattern zusätzlich zur Schnittstelle Plugin noch das IHost-Interface.
Dieses Interface ist direkter Bestandteil der Schnittstelle Plugin. Nun kann man sich natürlich die Frage stellen, warum das Plug-In den Host kennen muss und somit von diesem abhängig ist.
Zum einen ist es in der Regel so, dass ein Plug-In für nur einen Host entwickelt wird und zum anderen wollte ich dem Host gewisse Richtlinien zum Registrieren und Lösen des Plug-Ins vorgeben.
Das Interface IHost sieht folgendermaßen aus:
```
public interface IHost {
bool Register(Plugin plugin);
bool Unregister(Plugin plugin);
```csharp
public interface IHost {
bool Register(Plugin plugin);
bool Unregister(Plugin plugin);
}
```
@@ -74,51 +72,45 @@ Dieses Interface muss von der Host-Applikation implementiert werden, damit sich
Eine vereinfachte Darstellung der Implementierung des IHost -Interfaces sieht folgendermaßen aus:
```
public class HostApplication : IHost {
private List<Plugin> m_pluginList;
3
```csharp
public class HostApplication : IHost {
private List<Plugin> m_pluginList;
//Konstruktor
public HostApplication() {
m_pluginList = new List<Plugin>();
7
public HostApplication() {
m_pluginList = new List<Plugin>();
//Lädt alle verfügbaren Plug-Ins zb. aus einem Verzeichnis
List<Plugin> plugins = GetPlugins();
foreach (Plugin plugin in plugins) {
foreach (Plugin plugin in plugins) {
//ruft implizit die IHost.Register-Methode auf
plugin.Host = this ;
plugin.Host = this ;
}
}
15
public void ShowPlugins() {
foreach (Plugin plugin in m_pluginList) {
public void ShowPlugins() {
foreach (Plugin plugin in m_pluginList) {
//Ausgabe der Namen aller am Host registrierten Plug-Ins
Console.WriteLine(plugin.Name);
}
}
22
public void UnloadPlugins() {
foreach (Plugin plugin in m_pluginList) {
public void UnloadPlugins() {
foreach (Plugin plugin in m_pluginList) {
//ruft implizit die IHost.Unregister-Methode auf
plugin.Host = null ;
plugin.Host = null ;
}
}
29
#region IHost-Implementierung
public bool Register(Plugin plugin) {
if (!m_pluginList.Contains(plugin)) {
#region IHost-Implementierung
public bool Register(Plugin plugin) {
if (!m_pluginList.Contains(plugin)) {
m_pluginList.Add(plugin);
return true ;
return true ;
}
return false ;
return false ;
}
38
public bool Unregister(Plugin plugin) {
if (m_pluginList.Contains(plugin)) {
public bool Unregister(Plugin plugin) {
if (m_pluginList.Contains(plugin)) {
m_pluginList.Remove(plugin);
return true ;
return true ;
}
return false ;
return false ;
}
#endregion
}
content/posts/reflection.md
+143 -153
View File
@@ -19,55 +19,53 @@ Für dieses Beispiel habe ich eine kleine Konsolen-Anwendung geschrieben (TestAp
**TestClass.cs**
```
using System.Security.Cryptography;
using System.Text;
namespace TestProject {
class TestClass {
public string Name { get ; set ; }
public string Surname { get ; set ; }
private string Password { get ; set ; }
public string GetFullName() {
return string .Format( "{0} {1}" , Name ?? string .Empty, Surname ?? string .Empty).Trim();
```csharp
using System.Security.Cryptography;
using System.Text;
namespace TestProject {
class TestClass {
public string Name { get ; set ; }
public string Surname { get ; set ; }
private string Password { get ; set ; }
public string GetFullName() {
return string .Format( "{0} {1}" , Name ?? string .Empty, Surname ?? string .Empty).Trim();
}
public void SetPasswort( string password){
public void SetPasswort( string password){
Password = password;
}
private static string CalcPassword( string password){
MD5 md5 = MD5 .Create();
private static string CalcPassword( string password){
MD5 md5 = MD5 .Create();
byte [] data = md5.ComputeHash( Encoding .Default.GetBytes(password));
StringBuilder hashPassword = new StringBuilder ();
foreach ( byte b in data){
StringBuilder hashPassword = new StringBuilder ();
foreach ( byte b in data){
hashPassword.Append(b);
}
return hashPassword.ToString();
return hashPassword.ToString();
}
public static string DoSomething( string value) {
public static string DoSomething( string value) {
// do something
return value;
return value;
}
}
```
**SecondTestClass.cs**
```
namespace TestProject {
public class SecondTestClass {
public int Addition( int a, int b) {
return a + b;
```csharp
namespace TestProject {
public class SecondTestClass {
public int Addition( int a, int b) {
return a + b;
}
public int Multiply( int a, int b) {
return a * b;
public int Multiply( int a, int b) {
return a * b;
}
public double Divide( int a, int b) {
if (b == 0) return 0;
return a / b;
public double Divide( int a, int b) {
if (b == 0) return 0;
return a / b;
}
}
}
.
.
```
## Auslesen von Assembly- Type-Informationen
@@ -76,33 +74,32 @@ Mit der Methode Thread.GetDomain().GetAssemblies() bekommt man alle referenziert
Um sich nun alle Assemblies der aktuellen Domäne anzeigen zu lassen, könnte man folgendes schreiben:
```
static void Main( string [] args) {
SecondTestClass secondTestClass = new SecondTest Class ();
Assembly [] assemblies = Thread .GetDomain().GetAssemblies();
foreach ( var assembly in assemblies) {
```csharp
static void Main( string [] args) {
SecondTestClass secondTestClass = new SecondTest Class ();
Assembly [] assemblies = Thread .GetDomain().GetAssemblies();
foreach ( var assembly in assemblies) {
Console .WriteLine( string .Format( "-- {0} ver.: {1}" , assembly.GetName().Name
, assembly.GetName().Version));
, assembly.GetName().Version));
}
Console .ReadLine();
}
```
.
Nun könnte man noch alle zur Verfügung stehenden Typen(Klassen) aus der TestProject-Assembly anzeigen.
```
static void Main( string [] args) {
SecondTestClass secondTestClass = new SecondTestClass ();
Assembly [] assemblies = Thread .GetDomain().GetAssemblies();
foreach ( var assembly in assemblies) {
```csharp
static void Main( string [] args) {
SecondTestClass secondTestClass = new SecondTestClass ();
Assembly [] assemblies = Thread .GetDomain().GetAssemblies();
foreach ( var assembly in assemblies) {
Console .WriteLine( string .Format( "-- {0} ver.: {1}" , assembly.GetName().Name
, assembly.GetName().Version));
if (assembly.GetName().Name.Equals( "TestProject" )) {
, assembly.GetName().Version));
if (assembly.GetName().Name.Equals( "TestProject" )) {
Type [] types = assembly.GetTypes();
foreach ( var type in types) {
Console .WriteLine( " ++{0}" , type.Name);
foreach ( var type in types) {
Console .WriteLine( " ++{0}" , type.Name);
}
}
}
@@ -110,24 +107,23 @@ Console .ReadLine();
}
```
.
Wenn man nun allerdings Informationen eines bestimmten Types haben möchte, so werden diese Informationen aus den Metadaten des Moduls geladen, in dem sich der Type befindet. Um zum Beispiel alle öffentlichen Methoden eines Types anzuzeigen, könnte man folgendes schreiben:
```
static void Main( string [] args) {
SecondTestClass secondTestClass = new SecondTestClass ();
Assembly [] assemblies = Thread .GetDomain().GetAssemblies();
foreach ( var assembly in assemblies) {
```csharp
static void Main( string [] args) {
SecondTestClass secondTestClass = new SecondTestClass ();
Assembly [] assemblies = Thread .GetDomain().GetAssemblies();
foreach ( var assembly in assemblies) {
Console .WriteLine( string .Format( "-- {0} ver.: {1}" , assembly.GetName().Name
, assembly.GetName().Version));
if (assembly.GetName().Name.Equals( "TestProject" )) {
, assembly.GetName().Version));
if (assembly.GetName().Name.Equals( "TestProject" )) {
Type [] types = assembly.GetTypes();
foreach ( var type in types) {
Console .WriteLine( " ++ {0}" , type.Name);
foreach ( var type in types) {
Console .WriteLine( " ++ {0}" , type.Name);
MethodInfo [] methodInfos = type.GetMethods();
foreach ( var info in methodInfos) {
Console .WriteLine( " ++ {0}" , info.Name);
foreach ( var info in methodInfos) {
Console .WriteLine( " ++ {0}" , info.Name);
}
}
}
@@ -136,11 +132,10 @@ Console .ReadLine();
}
```
.
Es fällt auf, dass auch die Methoden ToString, Equals, GetHashCode und GetType in beiden Klassen angezeigt werden, obwohl diese in den Klassen überhaupt nicht deklariert wurden. Das liegt daran, dass alle Typen von object ableiten und object diese Methoden implementiert. Was noch auffällt ist, dass nur öffentliche Methoden angezeigt werden. Möchte man sich auch die privaten Methoden anzeigen lassen, so muss man der Methode type.GetMethods Parameter übergeben. Diese Methode verlangt BindingFlags, die man mit dem Bitweise ODER-Operator (|) miteinander verknüpfen kann. Um sich nun öffentliche und private Methoden anzeigen zu lassen, muss der Aufruf der Methode type.GetMethods folgendermaßen lauten:
```
```csharp
MethodInfo[] methodInfos = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
```
@@ -148,81 +143,80 @@ Dieser Aufruf gibt an, dass man alle öffentlichen und nicht-öffentlichen Insta
Das ganze könnte man natürlich noch in der Form weiter treiben, dass man sich die kompletten Methodensignaturen mit Modifizierer, Schlüsselwort und Rückgabewert anzeigen lässt:
```
static void Main( string [] args) {
SecondTestClass secondTestClass = new SecondTestClass ();
Assembly [] assemblies = Thread .GetDomain().GetAssemblies();
foreach ( var assembly in assemblies) {
```csharp
static void Main( string [] args) {
SecondTestClass secondTestClass = new SecondTestClass ();
Assembly [] assemblies = Thread .GetDomain().GetAssemblies();
foreach ( var assembly in assemblies) {
Console .WriteLine( string .Format( "-- {0} ver.: {1}" , assembly.GetName().Name, assembly.GetName().Version));
if (assembly.GetName().Name.Equals( "TestProject" )) {
if (assembly.GetName().Name.Equals( "TestProject" )) {
Type [] types = assembly.GetTypes();
foreach ( var type in types) {
Console .WriteLine( " ++ {0}" , type.Name);
MethodInfo [] methodInfos = type.GetMethods( BindingFlags .Public | BindingFlags .NonPublic
| BindingFlags .Instance
| BindingFlags .Static);
foreach ( var info in methodInfos) {
string modifier = GetModifier(info);
string keyword = GetKeyword(info);
string parameters = GetParameters(info);
if (! string .IsNullOrEmpty(keyword)) {
keyword = string .Format( "{0} " , keyword);
foreach ( var type in types) {
Console .WriteLine( " ++ {0}" , type.Name);
MethodInfo [] methodInfos = type.GetMethods( BindingFlags .Public | BindingFlags .NonPublic
| BindingFlags .Instance
| BindingFlags .Static);
foreach ( var info in methodInfos) {
string modifier = GetModifier(info);
string keyword = GetKeyword(info);
string parameters = GetParameters(info);
if (! string .IsNullOrEmpty(keyword)) {
keyword = string .Format( "{0} " , keyword);
}
Console .WriteLine( " ++ {0} {1}{2}{3}({4})" , modifier, keyword
, info.ReturnParameter, info.Name, parameters);
Console .WriteLine( " ++ {0} {1}{2}{3}({4})" , modifier, keyword
, info.ReturnParameter, info.Name, parameters);
}
}
}
}
Console .ReadLine();
}
private static string GetModifier( MethodInfo info) {
if (info.IsPublic) return "public" ;
return "private" ;
private static string GetModifier( MethodInfo info) {
if (info.IsPublic) return "public" ;
return "private" ;
}
private static string GetKeyword( MethodInfo info) {
if (info.IsStatic) return "static" ;
if (info.IsVirtual) return "virtual" ;
return string .Empty;
private static string GetKeyword( MethodInfo info) {
if (info.IsStatic) return "static" ;
if (info.IsVirtual) return "virtual" ;
return string .Empty;
}
private static string GetParameters( MethodInfo info) {
StringBuilder parameters = new StringBuilder ();
private static string GetParameters( MethodInfo info) {
StringBuilder parameters = new StringBuilder ();
ParameterInfo [] parameterInfos = info.GetParameters();
if (parameterInfos != null ) {
foreach ( ParameterInfo parameterInfo in parameterInfos) {
if (! string .IsNullOrEmpty(parameters.ToString())) {
if (parameterInfos != null ) {
foreach ( ParameterInfo parameterInfo in parameterInfos) {
if (! string .IsNullOrEmpty(parameters.ToString())) {
parameters.Append( ", " );
}
parameters.AppendFormat( "{0} {1}" , parameterInfo.ParameterType.Name, parameterInfo.Name);
}
}
return parameters.ToString();
return parameters.ToString();
}
```
.
Nicht immer ist bereits während der Entwicklung bekannt, aus welchem Assembly man Informationen benötigt. Sodass die Methode Thread.GetDomain().GetAssemblies() nicht verwendet werden kann. Eine weitere Möglichkeit an ein Assembly zu kommen ist es direkt zu laden. Dafür bietet die Klasse Assembly die statische Methode Assembly.LoadFrom zum Laden von Assemblies. Statt dem Laden des Assembly über die aktuelle Domäne, wird das nächste Beispiel so modifiziert, dass die TestProject-Assembly direkt aus einem Verzeichnis heraus geladen wird.
```
static void Main( string [] args) {
Assembly assembly = Assembly .LoadFrom( @"c:\TestProject.dll" );
if (assembly != null ) {
```csharp
static void Main( string [] args) {
Assembly assembly = Assembly .LoadFrom( @"c:\TestProject.dll" );
if (assembly != null ) {
Console .WriteLine( string .Format( "-- {0} ver.: {1}" , assembly.GetName().Name, assembly.GetName().Version));
Type [] types = assembly.GetTypes();
foreach ( var type in types) {
Console .WriteLine( " ++ {0}" , type.Name);
foreach ( var type in types) {
Console .WriteLine( " ++ {0}" , type.Name);
MethodInfo [] methodInfos =
type.GetMethods( BindingFlags .Public | BindingFlags .NonPublic | BindingFlags .Instance |
type.GetMethods( BindingFlags .Public | BindingFlags .NonPublic | BindingFlags .Instance |
BindingFlags .Static);
foreach ( var info in methodInfos) {
string modifier = GetModifier(info);
string keyword = GetKeyword(info);
string parameters = GetParameters(info);
if (! string .IsNullOrEmpty(keyword)) {
keyword = string .Format( "{0} " , keyword);
foreach ( var info in methodInfos) {
string modifier = GetModifier(info);
string keyword = GetKeyword(info);
string parameters = GetParameters(info);
if (! string .IsNullOrEmpty(keyword)) {
keyword = string .Format( "{0} " , keyword);
}
Console .WriteLine( " ++ {0} {1}{2}{3}({4})" , modifier, keyword, info.ReturnParameter,
Console .WriteLine( " ++ {0} {1}{2}{3}({4})" , modifier, keyword, info.ReturnParameter,
info.Name, parameters);
}
}
@@ -237,21 +231,21 @@ Man sieht, dass die gleiche Ausgabe wie bereits im vorherigen Beispiel generiert
Nachdem die Vorgehensweise nun klar sein sollte, möchte ich nun den eigentlich interessanten Teil demonstrieren. Wie kann man nun auf Methoden usw. zugreifen und wie können Werte aus einem Type gelesen und veränder werden? Wenn man die Methode SecondTestClass.Addition(int a, int b) aufrufen möchte, dann braucht man die Methodeninformationen von dem Type SecondTestClass aus dem TestProject-Assembly. D.h. man muss wie in den obigen Beispielen auch über alle Typen iterieren, um an den gesuchten Type SecondTestClass zu kommen. Hat man den gesuchten Type gefunden, so kann man sich von diesem alle Methoden in einem Array zurückgeben lassen. Dieses Array kann dann wieder ganz normal durchlaufen und nach der gewünschten Methode durchsucht werden. Hat man die Methode gefunden so muss zuerst eine Instanz von dem Objekt erzeugt werden und dafür gibt es den Activator, der die statische Methode CreateInstance beinhaltet. Als Parameter übergibt man ihr den Type von dem eine Instanz erzeugt werden soll. Jetzt kann man über die MethodInfo die Methode aufrufen. Dazu muss der Methode die Instanz des Objektes übergeben werden, von welchem die Methode aufgerufen werden soll und zusätzlich noch ein Array von Objekten, welche die zu übergebenen Parameter beinhaltet. Hat die Methode keine Parameter, so muss null übergeben werden. Dabei muss der Rückgabewert in den erwarteten Wert gecastet werden. Das ganze könnte dann folgendermaßen aussehen:
```
static void Main( string [] args) {
Assembly assembly = Assembly .LoadFrom( @"c:\TestProject.dll" );
if (assembly != null ) {
```csharp
static void Main( string [] args) {
Assembly assembly = Assembly .LoadFrom( @"c:\TestProject.dll" );
if (assembly != null ) {
Console .WriteLine( string .Format( "-- {0} ver.: {1}" , assembly.GetName().Name, assembly.GetName().Version));
Type [] types = assembly.GetTypes();
foreach ( var type in types) {
if (type.Name.Equals( "SecondTestClass" )) {
Console .WriteLine( " ++ {0}" , type.Name);
foreach ( var type in types) {
if (type.Name.Equals( "SecondTestClass" )) {
Console .WriteLine( " ++ {0}" , type.Name);
MethodInfo [] methodInfos = type.GetMethods();
foreach ( var info in methodInfos) {
if (info.Name.Equals( "Addition" )) {
object obj = Activator .CreateInstance(type);
int value = ( int )info.Invoke(obj, new object [] { 2, 5 });
Console .WriteLine( " ++ {0}(2 + 5) = {1}" , info.Name, value);
foreach ( var info in methodInfos) {
if (info.Name.Equals( "Addition" )) {
object obj = Activator .CreateInstance(type);
int value = ( int )info.Invoke(obj, new object [] { 2, 5 });
Console .WriteLine( " ++ {0}(2 + 5) = {1}" , info.Name, value);
}
}
}
@@ -263,18 +257,17 @@ Console .ReadLine();
Aufruf der Methode Addition
.
Bei statischen Methoden kann das Erzeugen der Instanz weggelassen werden und für den Parameter des Instanz-Objektes kann null übergeben werden.
```
if (type.Name.Equals( "TestClass" )) {
Console .WriteLine( " ++ {0}" , type.Name);
MethodInfo [] methodInfos = type.GetMethods( BindingFlags .NonPublic | BindingFlags .Static);
foreach ( var info in methodInfos) {
if (info.Name.Equals( "CalcPassword" )) {
string value = ( string )info.Invoke( null , new object [] { "myPassword" });
Console .WriteLine( " ++ {0}(\"myPassword\") = {1}" , info.Name, value);
```csharp
if (type.Name.Equals( "TestClass" )) {
Console .WriteLine( " ++ {0}" , type.Name);
MethodInfo [] methodInfos = type.GetMethods( BindingFlags .NonPublic | BindingFlags .Static);
foreach ( var info in methodInfos) {
if (info.Name.Equals( "CalcPassword" )) {
string value = ( string )info.Invoke( null , new object [] { "myPassword" });
Console .WriteLine( " ++ {0}(\"myPassword\") = {1}" , info.Name, value);
}
}
}
@@ -282,24 +275,23 @@ Console .WriteLine( " ++ {0}(\"myPassword\") = {1}" , info.Name, value);
Das übergebene Passwort wurde über eine statische Methode gehashed.
.
Um den Wert einer Property auszulesen, muss anstelle von MethodInfo die PropertyInfo verwendet werden. Aus dieser kann dann über die Methode PropertyInfo.GetValue der aktuelle Wert zurückgegeben werden. Da in diesem Beispiel nach dem Instanzieren des Objektes noch keine Werte zugewiesen wurden, sind die Properties leer.
```
static void Main( string [] args) {
Assembly assembly = Assembly .LoadFrom( @"C:\ TestProject.dll" );
if (assembly != null ) {
```csharp
static void Main( string [] args) {
Assembly assembly = Assembly .LoadFrom( @"C:\ TestProject.dll" );
if (assembly != null ) {
Console .WriteLine( string .Format( "-- {0} ver.: {1}" , assembly.GetName().Name, assembly.GetName().Version));
Type [] types = assembly.GetTypes();
foreach ( var type in types) {
if (type.Name.Equals( "TestClass" )) {
Console .WriteLine( " ++ {0}" , type.Name);
object obj = Activator .CreateInstance(type);
PropertyInfo [] propertyInfos = type.GetProperties( BindingFlags .Public | BindingFlags .NonPublic
| BindingFlags .Instance);
foreach ( var info in propertyInfos) {
Console .WriteLine( " ++ {0} = {1}" , info.Name, info.GetValue(obj, null ));
foreach ( var type in types) {
if (type.Name.Equals( "TestClass" )) {
Console .WriteLine( " ++ {0}" , type.Name);
object obj = Activator .CreateInstance(type);
PropertyInfo [] propertyInfos = type.GetProperties( BindingFlags .Public | BindingFlags .NonPublic
| BindingFlags .Instance);
foreach ( var info in propertyInfos) {
Console .WriteLine( " ++ {0} = {1}" , info.Name, info.GetValue(obj, null ));
}
}
}
@@ -308,25 +300,23 @@ Console .ReadLine();
}
```
.
Wenn man nun die Properties mit Werten belegen möchte, so muss man analog zur Methode PropertyInfo.GetValue, die Methode PropertyInfo. SetValue verwenden.
```
if (type.Name.Equals( "TestClass" )) {
Console .WriteLine( " ++ {0}" , type.Name);
PropertyInfo [] propertyInfos = type.GetProperties( BindingFlags .Public | BindingFlags .NonPublic
| BindingFlags .Instance);
propertyInfos[0].SetValue(obj, "Peter" , null );
propertyInfos[1].SetValue(obj, "Müller" , null );
propertyInfos[2].SetValue(obj, "myPassword" , null );
foreach ( var info in propertyInfos) {
Console .WriteLine( " ++ {0} = {1}" , info.Name, info.GetValue(obj, null ));
```csharp
if (type.Name.Equals( "TestClass" )) {
Console .WriteLine( " ++ {0}" , type.Name);
PropertyInfo [] propertyInfos = type.GetProperties( BindingFlags .Public | BindingFlags .NonPublic
| BindingFlags .Instance);
propertyInfos[0].SetValue(obj, "Peter" , null );
propertyInfos[1].SetValue(obj, "Müller" , null );
propertyInfos[2].SetValue(obj, "myPassword" , null );
foreach ( var info in propertyInfos) {
Console .WriteLine( " ++ {0} = {1}" , info.Name, info.GetValue(obj, null ));
}
}
```
.
## Wozu braucht man jetzt aber nun die Reflection?
content/posts/stupiddb1.md
+66 -67
View File
@@ -28,47 +28,46 @@ Als Vorteile gegenüber z.B. MogileFS, CouchDB zählt für uns vor allem, dass k
Die Nutzung selbst ist denkbar einfach. Folgendes Mitarbeiter-Objekt möchte ich speichern.
```
public class Mitarbeiter
```csharp
public class Mitarbeiter
{
public int Id { get ; set ; }
public string Name { get ; set ; }
public string Vorname { get ; set ; }
public string Ort { get ; set ; }
public string Plz { get ; set ; }
72
public string VollerName
public int Id { get ; set ; }
public string Name { get ; set ; }
public string Vorname { get ; set ; }
public string Ort { get ; set ; }
public string Plz { get ; set ; }
public string VollerName
{
get { return string .Format( “{0} {1}” , Vorname, Name); }
get { return string .Format( “{0} {1}” , Vorname, Name); }
}
}
```
Dazu nutzt man die Put-Methode der StupidDB.
```
IStupidDB stupidDB = new StupidDB ( “test” );
Mitarbeiter mitarbeiter = new Mitarbeiter
```csharp
IStupidDB stupidDB = new StupidDB ( “test” );
Mitarbeiter mitarbeiter = new Mitarbeiter
{
Id = 1,
Name = “Christian” ,
Vorname = “Thomas” ,
Ort = “Rosenheim” ,
Plz = “83026”
Name = “Christian” ,
Vorname = “Thomas” ,
Ort = “Rosenheim” ,
Plz = “83026”
};
stupidDB.Put( “TestPartition” , “EinMitarbeiter” , mitarbeiter );
stupidDB.Put( “TestPartition” , “EinMitarbeiter” , mitarbeiter );
```
Um das gleiche Objekt wieder zu lesen, nutzt man mal eine Get Methode. Die Parameter sind Partition und Key:
```
Mitarbeiter mitarbeiterAusgelesen =
```csharp
Mitarbeiter mitarbeiterAusgelesen =
( Mitarbeiter )stupidDB.GetObject(
“TestPartition” ,
“EinMitarbeiter” ,
typeof ( Mitarbeiter )
);
if (mitarbeiterAusgelesen != null )
if (mitarbeiterAusgelesen != null )
{
Console .WriteLine( “Name des Mitarbeiters: {0}” ,
mitarbeiterAusgelesen.VollerName);
@@ -77,13 +76,13 @@ mitarbeiterAusgelesen.VollerName);
Die StupidDB selbst wird über die app.config definiert.
```
```csharp
< configuration >
< configSections >
< section name = “ stupidDB “ type = “ Aztec.StupidDB.DBConfigCollection, Aztec.StupidDB, Version=1.0.0.0, Culture=neutral “ allowLocation = “ true “ allowDefinition = “ Everywhere “ />
< section name = “ stupidDB “ type = “ Aztec.StupidDB.DBConfigCollection, Aztec.StupidDB, Version=1.0.0.0, Culture=neutral “ allowLocation = “ true “ allowDefinition = “ Everywhere “ />
</ configSections >
< stupidDB >
< DB name = “ test “ root = “ temp\test “ tiefe = “ 3 “ versionierung = “ false “ />
< DB name = “ test “ root = “ temp\test “ tiefe = “ 3 “ versionierung = “ false “ />
</ stupidDB >
</ configuration >
```
@@ -94,77 +93,77 @@ Wer sich den aktuellen Code einmal ansehen möchte, kann dies gerne unter folgen
1. **Doku**
[March 1, 2010 at 9:59 am](/posts/stupiddb1/)
[March 1, 2010 at 9:59 am](/posts/stupiddb1/)
Coole Sache, gibt es dazu eine Doku der Funktionen wie .Backup
und der möglichen werte, wie Tiefe, Versionierung etc?
Coole Sache, gibt es dazu eine Doku der Funktionen wie .Backup
und der möglichen werte, wie Tiefe, Versionierung etc?
Vielen Dank.
Vielen Dank.
2. **[Stefan Kölle](http://www.stefankoelle.de/)**
[March 1, 2010 at 12:21 pm](/posts/stupiddb1/)
[March 1, 2010 at 12:21 pm](/posts/stupiddb1/)
Es gibt aktuell noch keine Doku, im Code wird einiges erklaert jedoch sicher nicht ausreichend.
Es gibt aktuell noch keine Doku, im Code wird einiges erklaert jedoch sicher nicht ausreichend.
In der aktuellen Ausgabe der dotnetpro gibt es jedoch einen Artikel zu StupidDB, dort erklaere ich die Parameter noch einmal genauer. Auch das Thema Tiefe, Versionierung usw. <http://www.dotnetpro.de/CurrentIssue.aspx>
In der aktuellen Ausgabe der dotnetpro gibt es jedoch einen Artikel zu StupidDB, dort erklaere ich die Parameter noch einmal genauer. Auch das Thema Tiefe, Versionierung usw. <http://www.dotnetpro.de/CurrentIssue.aspx>
3. **UweD**
[March 9, 2010 at 5:47 pm](/posts/stupiddb1/)
[March 9, 2010 at 5:47 pm](/posts/stupiddb1/)
Scheint ja wirklich toll zu sein. Leider findet man im Web noch nicht allzuviel darüber. Der Artikel in der dotnetpro sagt einiges, aber zu dem Pfad kann ich nirgends etwas finden.
Wenn ich root=“temp\test“ angebe, wo liegt das dann physisch?
Scheint ja wirklich toll zu sein. Leider findet man im Web noch nicht allzuviel darüber. Der Artikel in der dotnetpro sagt einiges, aber zu dem Pfad kann ich nirgends etwas finden.
Wenn ich root=“temp\test“ angebe, wo liegt das dann physisch?
4. **[Stefan Kölle](http://www.stefankoelle.de/)**
[March 9, 2010 at 5:52 pm](/posts/stupiddb1/)
[March 9, 2010 at 5:52 pm](/posts/stupiddb1/)
Hallo, Uwe,
Hallo, Uwe,
man kann bei root einfach einen absoluten Pfad angeben, z.B. c:\temp\stupiddb\
man kann bei root einfach einen absoluten Pfad angeben, z.B. c:\temp\stupiddb\
Ohne der Angabe eines Pfades wird die StupidDB im Ausfuehrungsverzeichnis angelegt.
Ohne der Angabe eines Pfades wird die StupidDB im Ausfuehrungsverzeichnis angelegt.
Gruss
Stefan
Gruss
Stefan
5. **Uwe**
[January 4, 2011 at 11:17 am](/posts/stupiddb1/)
[January 4, 2011 at 11:17 am](/posts/stupiddb1/)
Hallo,
ich bin nun nicht so firm in C#. Gibt es Beispiel für IStupidDB.Dir ?
Hallo,
ich bin nun nicht so firm in C#. Gibt es Beispiel für IStupidDB.Dir ?
Danke
Uwe
Danke
Uwe
6. **[Andreas Seebauer](http://www.in-your-face.org/)**
[January 12, 2011 at 12:05 pm](/posts/stupiddb1/)
[January 12, 2011 at 12:05 pm](/posts/stupiddb1/)
Hallo, Uwe,
Hallo, Uwe,
hier ein kleines Beispiel für die Verwendung von IStupidDB.Dir in C#:
hier ein kleines Beispiel für die Verwendung von IStupidDB.Dir in C#:
IStupidDB sdb = new StupidDB(“meinDbName”);
string partition = “Beispielpartition”;
string key = “Beispielkey”;
// Speichern des strings “Beispiel” unter Key “Beispielkey” in Partition “Beispielpartition”
sdb.Put(partition, key, “Beispiel”);
// Auflisten aller Keys in Partition “Beispielpartition”
List listKeys = sdb.Dir(partition);
IStupidDB sdb = new StupidDB(“meinDbName”);
string partition = “Beispielpartition”;
string key = “Beispielkey”;
// Speichern des strings “Beispiel” unter Key “Beispielkey” in Partition “Beispielpartition”
sdb.Put(partition, key, “Beispiel”);
// Auflisten aller Keys in Partition “Beispielpartition”
List listKeys = sdb.Dir(partition);
Mit den zurückgelieferten Keys können dann die Objekte via GetObject ausgelesen werden.
Ich hoffe das beantwortet deine Frage.
Mit den zurückgelieferten Keys können dann die Objekte via GetObject ausgelesen werden.
Ich hoffe das beantwortet deine Frage.
Gruß
Andreas
Gruß
Andreas
7. **Uwe**
[January 12, 2011 at 4:23 pm](/posts/stupiddb1/)
[January 12, 2011 at 4:23 pm](/posts/stupiddb1/)
Hallo Andreas,
nein, nicht ganz!
Laut Doc gibt es
Dir – Listet alle Schlüssel einer Partition) und
Dir – Liefert ein IDictionary aller Schlüssel mit zugehörigem Objekt .
Hallo Andreas,
nein, nicht ganz!
Laut Doc gibt es
Dir – Listet alle Schlüssel einer Partition) und
Dir – Liefert ein IDictionary aller Schlüssel mit zugehörigem Objekt .
Mit geht es um das 2. Dir.
Mit geht es um das 2. Dir.
Uwe
Uwe
content/posts/unittests-webforms.md
+75 -92
View File
@@ -15,72 +15,64 @@ Nehmen wir zum Beispiel ein einfaches Formular. Nach Absenden des Formulars soll
<img src="/images/unittests-webforms/TestableWebForm.jpg" alt="Testable WebForm"/>   <img src="/images/unittests-webforms/TestableWebForm_Sent.jpg" alt="Testable WebForm Sent"/>
Und nun zum Quellcode: Die automatisch erstellte .designer.cs muss entfernt werden, was man sowieso tun sollte, da man automatisch erstellten Code – also Code, den keiner außer Microsoft unter Kontrolle hat – vermeiden sollte.
Und nun zum Quellcode: Die automatisch erstellte .designer.cs muss entfernt werden, was man sowieso tun sollte, da man automatisch erstellten Code – also Code, den keiner außer Microsoft unter Kontrolle hat – vermeiden sollte.
Die Inhalte der .designer.cs – also die Definitionen der Web-Elemente – werden in der Klasse als `Public Properties` erstellt und instantiiert, um bei Zugriffen wie `TextBox.Text` keine NullReferenceException zu bekommen.
```
using System;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using framework.Testable.Web.UI;
5
namespace TestableWebForm
```csharp
using System;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using framework.Testable.Web.UI;
namespace TestableWebForm
{
public class DefaultPage : System.Web.UI. Page
public class DefaultPage : System.Web.UI. Page
{
10
#region Controls
public HtmlForm Formular;
public TextBox Value1 = new TextBox ();
public TextBox Value2 = new TextBox ();
public Label Result = new Label ();
public Button Submit = new Button ();
#region Controls
public HtmlForm Formular;
public TextBox Value1 = new TextBox ();
public TextBox Value2 = new TextBox ();
public Label Result = new Label ();
public Button Submit = new Button ();
#endregion
```
Um das Verhalten testen zu können, haben wir Adapter für die Klassen `System.Web.UI.Page`, `System.Web.HttpRequest` und `System.Web.HttpResponse` geschrieben, und zwar für die Properties und Methoden die uns vorerst interessieren: z.B. `Page.IsPostBack, Page.Request, Response.Redirect(string url, bool endResponse)`. Bei der Benennung haben wir einfach den Namespace `System` mit `framework.Testable` ersetzt und wir haben natürlich zu jedem Testable-Objekt einen Interface erstellt.
```
1
namespace framework.Testable.Web
```csharp
namespace framework.Testable.Web
{
namespace UI
namespace UI
{
public interface IPage
public interface IPage
{
bool IsPostBack{ get ; }
IHttpRequest Request{ get ; set ; }
IHttpResponse Response{ get ; set ; }
bool IsPostBack{ get ; }
IHttpRequest Request{ get ; set ; }
IHttpResponse Response{ get ; set ; }
}
12
public class Page : IPage
public class Page : IPage
{
private readonly System.Web.UI. Page m_page;
private IHttpRequest m_request;
private IHttpResponse m_response;
18
public Page( System.Web.UI. Page page )
private readonly System.Web.UI. Page m_page;
private IHttpRequest m_request;
private IHttpResponse m_response;
public Page( System.Web.UI. Page page )
{
m_page = page;
m_request = new HttpRequest ( m_page );
m_response = new HttpResponse ( m_page );
m_request = new HttpRequest ( m_page );
m_response = new HttpResponse ( m_page );
}
25
public bool IsPostBack
public bool IsPostBack
{
get { return m_page.IsPostBack; }
get { return m_page.IsPostBack; }
}
30
public IHttpRequest Request
public IHttpRequest Request
{
get { return m_request; }
set { m_request = value ; }
get { return m_request; }
set { m_request = value ; }
}
36
public IHttpResponse Response
public IHttpResponse Response
{
get { return m_response; }
set { m_response = value ; }
get { return m_response; }
set { m_response = value ; }
}
}
}
@@ -91,68 +83,61 @@ Um alle gemockte Objekte setzen zu können, haben wir unserer `Page`-Klasse auch
Das war ungefähr alles: in der Seite nutzt man dann anstelle der eigenen Request und Response-Objekten die `Testable`-Objekte.
```
public class DefaultPage : System.Web.UI. Page
```csharp
public class DefaultPage : System.Web.UI. Page
{
…
private IPage m_page;
public void SetTestableObjects( IPage page )
private IPage m_page;
public void SetTestableObjects( IPage page )
{
m_page = page;
}
24
public void Page_Load( object sender, EventArgs e )
public void Page_Load( object sender, EventArgs e )
{
if (m_page == null ) m_page = new Page ( this );
int multiple = 1;
if (! string .IsNullOrEmpty( m_page.Request.GetParamValue( "multiple" ) )) multiple = Convert .ToInt32( m_page.Request.GetParamValue( "multiple" ) );
if (m_page.IsPostBack)
if (m_page == null ) m_page = new Page ( this );
int multiple = 1;
if (! string .IsNullOrEmpty( m_page.Request.GetParamValue( "multiple" ) )) multiple = Convert .ToInt32( m_page.Request.GetParamValue( "multiple" ) );
if (m_page.IsPostBack)
{
Result.Text = ( ( Convert .ToInt32( Value1.Text ) + Convert .ToInt32( Value2.Text ))*multiple ).ToString();
Result.Text = ( ( Convert .ToInt32( Value1.Text ) + Convert .ToInt32( Value2.Text ))*multiple ).ToString();
}
}
```
Damit ist die Web-Anwendung bereit zum Testen. So schaut zum Beispiel ein Test für das Laden der Seite aus:
```
using framework.Testable.Web;
using framework.Testable.Web.UI;
using NUnit.Framework;
using Rhino.Mocks;
using TestableWebForm;
6
namespace Tests
```csharp
using framework.Testable.Web;
using framework.Testable.Web.UI;
using NUnit.Framework;
using Rhino.Mocks;
using TestableWebForm;
namespace Tests
{
[ TestFixture ]
public class WebFormTests
public class WebFormTests
{
private IPage m_page;
private IHttpRequest m_request;
private IHttpResponse m_response;
private DefaultPage m_defaultPage;
16
private IPage m_page;
private IHttpRequest m_request;
private IHttpResponse m_response;
private DefaultPage m_defaultPage;
[ SetUp ]
public void Init()
public void Init()
{
m_page = MockRepository .GenerateStub< IPage >();
m_request = MockRepository .GenerateStub< IHttpRequest >();
m_response = MockRepository .GenerateStub< IHttpResponse >();
m_page = MockRepository .GenerateStub< IPage >();
m_request = MockRepository .GenerateStub< IHttpRequest >();
m_response = MockRepository .GenerateStub< IHttpResponse >();
m_page.Request = m_request;
m_page.Response = m_response;
}
26
[ Test ]
public void PageLoad_Loading_EmptyFields()
public void PageLoad_Loading_EmptyFields()
{
// Arrange
31
32
// Act
m_defaultPage = new DefaultPage ();
m_defaultPage = new DefaultPage ();
m_defaultPage.SetTestableObjects(m_page);
m_defaultPage.Page_Load( null , null );
37
m_defaultPage.Page_Load( null , null );
// Assert
Assert .IsEmpty( m_defaultPage.Value1.Text );
Assert .IsEmpty( m_defaultPage.Value2.Text );
@@ -162,24 +147,22 @@ Assert .IsEmpty(m_defaultPage.Result.Text);
Und so für PostBack inklusive QueryString-Parameter:
```
```csharp
[ Test ]
public void PageLoad_PostBackWithRequestValue_ResultIsCorrect()
public void PageLoad_PostBackWithRequestValue_ResultIsCorrect()
{
// Arrange
const int value1 = 1;
const int value2 = 2;
const int value3 = 3;
m_request.Expect( a => a.GetParamValue( "multiple" ) ).IgnoreArguments().Repeat.Twice().Return( value3.ToString() );
m_page.Expect( a => a.IsPostBack ).Return( true );
72
const int value1 = 1;
const int value2 = 2;
const int value3 = 3;
m_request.Expect( a => a.GetParamValue( "multiple" ) ).IgnoreArguments().Repeat.Twice().Return( value3.ToString() );
m_page.Expect( a => a.IsPostBack ).Return( true );
// Act
m_defaultPage = new DefaultPage ();
m_defaultPage = new DefaultPage ();
m_defaultPage.SetTestableObjects( m_page );
m_defaultPage.Value1.Text = value1.ToString();
m_defaultPage.Value2.Text = value2.ToString();
m_defaultPage.Page_Load( null , null );
79
m_defaultPage.Page_Load( null , null );
// Assert
Assert .IsTrue( m_defaultPage.Result.Text == ( (value1 + value2)*value3 ).ToString() );
}
@@ -187,6 +170,6 @@ Assert .IsTrue( m_defaultPage.Result.Text == ( (value1 + value2)*value3 ).ToStri
Dieses Vorgehen hat uns nicht nur den seit langen gesuchten Weg zum Testen von Webanwendungen geebnet, sondern zwingt auch den Entwickler dazu, alle Funktionalitäten, die nicht in einer Webseite sondern in die dll-s gehören, auszulagern. Damit dürfte es auch der richtige Weg der Clean Code Developers für die Arbeit mit WebForms sein.
Was die Adapter-Klassen betrifft: inzwischen haben wir auch System.IO “adaptiert” und bald werden die anderen System-Klassen folgen, je nach Bedarf.
Was die Adapter-Klassen betrifft: inzwischen haben wir auch System.IO “adaptiert” und bald werden die anderen System-Klassen folgen, je nach Bedarf.
[Download VS2008-Projekt](/assets/TestableWebForm.zip)