eigentlich viel zu spät möchte ich allen Leserinnen und Lesern noch ein schönes neues Jahr 2012 wünschen und mich für das Interesse im vergangenen Jahr bedanken. 19.000 Besuche in 2011 sind eine beeindruckende Zahl. Die Artikelserie „von Spaghetticode zu MVVM“ war mit Abstand am häufigsten nachgefragt. Ich werde mich bemühen, bald wieder mehr von dieser Art zu bringen oder auch ganz neue Themen beleuchten. Aktuell ist es in diesem Blog leider etwas ruhiger geworden, da eine volle Stelle und Familie doch insgesamt sehr fordernd sind. Ich lese noch viel und arbeite mich in interessante Themen ein, jetzt müssen daraus „nur“ noch Artikel werden … Ich hoffe, in den Semesterferien werde ich hier wieder produktiv.

Ich würde mich freuen, wenn Sie Themen, die Sie interessieren, per Mail oder als Kommentar schicken, oder wenn Sie gar einen Post selbst schreiben würden. Im letzten SS gab es einige interessante Posts von Studierenden. In Rücksprache mit dem Autor/der Autorin editiere ich gerne und veröffentliche unter dem angegebenen Namen/Pseudonym.

Viele Grüße und bis bald,

ubt

<h1>Demo Auto-Globals</h1>
<input type="text" name="name2" id="name2" />
<form accept-charset="utf-8" method="get" action="demo.html">
<div>
<label for="firstName">Vorname:</label><input type="text" name="name" id="firstName" /><span id="x"></span>
<button onclick="alert(firstName);">test von firstName</button>
<button onclick="alert(name2);alert(x);">test von span-Element und input außerhalb</button>
</div>
</form>

Der erste Button zeigt sowohl im IE als auch im Firefox die Variable firstName als Input-Element an. Beim zweiten Button wird im Firefox nichts ausgegeben, während der IE sowohl das außerhalb des Form-Tags gelegene Input-Element als solches kennt, als auch das span-Tag.
Möchte man diese Variablen dagegen per JavaScript innerhalb des Script-Tags oder innerhalb einer eingebundenen JavaScript-Datei verwenden, so stehen sie nicht zur Verfügung.
Folgender Code zeigt somit nichts an:

function globals()
{
  alert(firstName);
}

mit HTML-Code:

<button onclick="demo();">input-global in JS unbekannt</button>

Falls Sie mit Objektschablonen und globalen „Instanzen“ arbeiten, dann achten Sie darauf, diese globalen Variablen anders alle alle Ids Ihrer HTML-Tags zu nennen. Wie gesagt, diese nur den Click-Handlern bekannten Globals haben mich sehr überrascht.

1. Bereits bei der Eingabe soll klar sein, was in dem jeweiligen Feld erwartet wird.
2. Ist JavaScript deaktiviert, erfolgt die Validierung ausschließlich auf dem Server. Das Formular wird dennoch abgeschickt.
3. Das Formular lässt sich auch mit der Tastatur allein korrekt ausfüllen und abschicken.
4. Unvollständig, falsch oder nicht ausgefüllte Formularfelder führen dazu, dass das Formular nicht abgeschickt wird (bei aktiviertem JavaScript).
5. Fehlermeldungen müssen für alle Benutzer wahrnehmbar und leicht verständlich sein und sind leicht zu korrigieren.
6. Die clientseitige Validierung ist eine gute Unterstützung für die Benutzer, das Formular effizient auszufüllen. Sie wird nicht als nervig wahrgenommen.
7. Fehlermeldungen sind leicht an die gewählte Sprache anpassbar (Internationalisierung).

Die ersten Forderungen lassen sich einfach umsetzen:

Zu 1.: Pflichtfelder werden typischerweise mit * markiert, ggf. gibt es zusätzliche Angaben in welchem Format die Eingabe (z.B. Telefon oder Datum) zu erfolgen hat. Damit bei der Eingabe in ein Formularelement auch vorgelesen werden kann, welche Information gewünscht ist, gehört zu jedem Eingabeelement (select, textarea, input type text oder password oder radio oder checkbox) ein Label-Element. Dabei wird das for-Attribut des Labels mit dem id-Attribut des Eingabeelements verknüpft, wie folgendes Beispiel zeigt:

<label for="lastName">Nachname:</label><input type="text" name="name" id="lastName" value="" size="10" />

Zu 2.: Die Validierung wird im onsubmit-Attribut des Form-Tags aufgerufen und nicht an ein change-Ereignis o.ä. gebunden. Wird von der Methode ein „false“ zurückgegeben, so wird durch die gezeigte Aufrufmethodik die Default-Action, also das Abschicken des Formulars, nicht ausgeführt.

<form action="script.php" method="post" accept-charset="UTF-8" onsubmit="return formOk();">

Alternativ kann hier auch das Event übergeben werden und seit DOM2 mit preventDefault die Ausführung der Default-Action verhindert werden.

Zu 3: Eingaben und Aktionen der Benutzer sind an entsprechende Formularfelder oder Links gebunden. Diese lassen sich generell mit Tabs fokussieren und durch ein Return wird auch ein click-Ereignis ausgelöst.

Zu 4: Die in zu 2. verwendete JavaScript-Funktion formOk gibt im Fehlerfall „false“ zurück. Damit wird die Default-Action des Formulars nicht ausgeführt, d.h. das Formular wird nicht abgeschickt. Bei deaktiviertem JavaScript wird das Formular an den Server geschickt.

Zu 5-7: Schwieriger ist die Frage, wie die Fehlermeldungen zu kommunizieren sind. Früher wurde hierfür ausschließlich eine alert-Meldung verwendet. Diese fällt dem Benutzer direkt auf und wird auch vom Screenreader direkt vorgelesen. Mehrere alert-Fehlermeldungen werden als nervig empfunden und nachdem die Box weggeklickt wurde, hat man oft auch vergessen, was zu korrigieren ist. Zusätzlich ist also auch eine Markierung (roter Hintergrund, …) der fehlerhaften Eingabeelemente hilfreich. Alert-Boxen werden als „nicht schön“ empfunden und von Designern ungern eingesetzt. Daher werden häufig nur noch entsprechende Fehlertexte und Styleänderungen im HTML direkt vorgenommen. Diese Änderungen werden jedoch von Screenreadern nicht notwendigerweise bemerkt und somit nicht vorgelesen. Folgender Ansatz stellt Designer und Screenreader (getestet mit JAWS und Windows7-System-Reader) gleichermaßen zufrieden und ist daher uneingeschränkt zu empfehlen:
Sie können in Ihrem HTML-Code Fehlermeldungen vorbereiten: Fügen Sie ein a-Tag mit href-Attribut als Fehlermeldung ein und setzen den Focus darauf. Idealerweise fügen Sie für alle fehlerhaften Felder ein a-Tag in eine Liste ein, diese Liste kann ggf. für sehende Menschen versteckt werden. Zusätzlich werden fehlerhafte Felder sichtbar markiert. Folgender Code veranschaulicht die dargestellte Strategie:

HTML-Seite:

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<title>test</title>
<script type="text/javascript" src="demo.js"></script>
<link rel="stylesheet" type="text/css" href="demo.css" />
</head>
<body>
<h1>Demo Formularvalidierung</h1>
<p id="formwarnings">
<a href="#">Fehler in der Eingabe:</a>
<ul>
<li  id="link_name"><a href="#name">Name ist ein Pflichtfeld</a></li>
<li id="link_zip"><a href="#zip">Postleitzahl ist ein Pflichtfeld, fünfstellige Zahl</a></li>
</ul>
</p>
<form action="script.php" accept-charset="utf-8" method="post" onsubmit="return isValid();">
<div>
<label for="name">Name *</label><input id="name" name="name" type="text" />
<label for="zip">Postleitzahl *</label><input id="zip" name="name" type="text" />
<input type="submit" value="abschicken" />
</div>
</form>
</body>
</html>

CSS:

.hideWarning {display:none;}
.showWarning{display:block;}
.warning{border: 1px solid red;}

JavaScript:

"use strict";
function isValid()
{
  var ok = true;
  var pattern = /^[0-9]{5}$/;
  var inputField = document.getElementById("zip");
  if (!pattern.test(inputField.value))
  {
    ok = false;
    showWarning("zip");
    inputField.focus();
  }
  inputField = document.getElementById("name");
  if (inputField.value.length == 0)
  {
    ok = false;
    showWarning("name");
    inputField.focus();
  }
  return ok;
}

function showWarning(id)
{
  document.getElementById(id).className = "warning";
  document.getElementById("link_" + id).className = "showWarning";
  document.getElementById("formwarnings").className = "showWarning";
}

Wie Sie sehen, enthält der JavaScript-Code keine Strings zur Erzeugung von Fehlermeldungen, diese sind im HTML-Code bereits vorbereitet. Damit kann das Script auch in übersetzten HTML-Seiten eingesetzt werden, Internationalisierung ist somit vorbereitet.

Links zum Thema:

• Übersetzungen von WCAG2.0 und im Original
• barrierefreie Eventhandlers
• WAI-ARIA
• automatischer Test auf Barrierefreiheit: WAVE

1. Softwareentwicklung (insb. Anwendungsentwicklung für mobile Endgeräte): 61 %
2. Projektmanagement: 44%
3. Support: 35%
4. Netzwerktechnik (insb. Cloud-Computing und Virtualisierung): 35 %
5. Business Intelligence (BI): 23%
6. Datenmanagement und Systemintegration: 18%
7. Web 2.0: 18%
8. Sicherheit: 17%
9. Telekommunikation: 9%

Grundkenntnisse in den genannten Bereichen sollte jeder Informatik-Absolvent mitbringen. Wer sich gute Kenntnisse und Methoden in Softwareentwicklung angeeignet hat, kann sich auch in eine andere Entwicklungsumgebung und Programmiersprache einarbeiten. Viele Absolventen fangen als Entwickler an. Diese Studie verdeutlicht wieder einmal, wie wichtig es ist, als Informatiker wirklich programmieren zu können. Denn auch für alle anderen aufgelisteten Fähigkeiten sind Programmierkenntnisse zum Anpassen vorhandener Werkzeuge hilfreich. Für das Projektmanagement wird typischerweise eine entsprechende Berufserfahrung vorausgesetzt.

Methoden und Eigenschaften, die zu einer Klasse gehören, also nicht zu einer einzelnen Instanz, nennt man statisch. Hierfür dient das Schlüsselwort static. Unabhängig von der Anzahl der Instanzen einer Klasse, sind sie einmal vorhanden. Statische Klassen — genauer gesagt statische Methoden oder Eigenschaften einer Klasse — können weder als Parameter übergeben noch von einer Methode zurückgegeben werden. Sie lassen sich auch nicht in eine Liste einfügen (z.B. bei Observer/Ereignissen). Daher können sie auch nicht Bestandteil eines Interfaces oder Eigenschaften anderer Klassen sein. Sie können somit nicht im Sinne von Aggregation oder Komposition verwendet werden. Ein Casten ist ebenfalls nicht möglich, da es keine Instanz zum Casten gibt.

Singleton ist ein Entwurfsmuster, dessen Implementation dafür sorgt, dass es nur eine Instanz dieser Klasse geben kann. Nach außen hin verhält sich ein Singleton wie eine normale Instanz einer Klasse, kann also als Parameter etc. verwendet werden. Ein Singleton kann auch einfach serialisiert werden und so z.B. remote oder in Webdiensten verwendet werden. Im Prinzip ist es ein Geheimnis der Klasse, dass diese einmalig ist, den Nutzern kann es egal sein. Das Singleton-Dasein gehört zur inneren Logik der Klasse. Das Testen von Singletons kann insbesondere bei asynchronen Prozessen schwierig sein. Die Implementation eines Singletons verwendet typischerweise eine statische Eigenschaft. Singletons lassen sich einfach durch polymorphe Klassen austauschen und somit gut bei automatischen Tests durch „Scheinobjekte“ (mocking) simulieren.

Funktionsbibliotheken (z.B. mathematische Funktionen wie sin etc.) werden oft und sinnvollerweise als statische Methoden implementiert, da ihr Rückgabewert nur von den übergebenen Parametern abhängt. Singletons kommen im Kontext von Logging, Authorisierung, Monitoring, Druckaufträge und anderen Diensten zum Einsatz. Hier ist es wichtig, dass es ein hauptverantwortliches Objekt, eben das Singleton gibt. Beide Technologien werden manchmal verwendet, um globale Variablen „einzuschmuggeln“, hier ist natürlich Vorsicht geboten.

Bzgl. der Performance gibt es unterschiedliche Aussagen und je nach Implementation wird ein Singleton erst dann erzeugt, wenn es tatsächlich benötigt wird, während statische Eigenschaften direkt im Speicher angelegt werden. Im Allgemeinen, werden diese Performancedetails jedoch nicht als Argument für die eine odere andere Variante angeführt. Die Verwendung von Singleton bzw. statischen Methoden sollte sich an der Semantik und der geplanten Verwendung orientieren und damit aus dem Zusammenhang ergeben.

Links zum Thema:

• Wikipedia
• .Net Design Patterns
• Martin Fowler

Wesentlicher Ausschnitt des zugehörigen Markups:

<form ...>
<p>
<select id="ShoppingCart" ...>
<option ...>Palermo</option>
<option ...>Hawaii</option>
<option ...>Vegetaria</option>
<option ...>Salami</option>
</select>
</p>
<p><span id="TotalPrice">23,50</span> &euro;</p>
...
</form>

Mit dem Firefox-Addin Selenium lassen sich sehr einfach Web-Oberflächetests entwickeln. Was Sie hierfür tun müssen beschreiben ich anhand eines einfachen Anwendungsfall der gegebenen Pizzaanwendung.
Gegeben sei folgender Anwendungsfall:
Löschen im Warenkorb: Im Warenkorb kann man alle Pizzen oder auch mehrere ausgewählte Pizzen löschen. Der Preis wird aktualisiert.
Test: Warenkorb füllen mit jeweils einer Palermo, Hawaii, Vegetaria und Salami. Dann die Salami und die Hawaii markieren und diese Auswahl löschen. Im Warenkorb verbleiben Palermo und Vegetaria. Neuer Preis: 13,50 €

Im Folgenden beschreibe ich die Umsetzung des dargestellten Test mit Selenium. Starten Sie hierzu Firefox->Webentwickler->Selenium IDE

Rechts-Klicken Sie auf den angelegten Testfall und wählen Sie Properties aus. Vergeben Sie einen sinnvollen Namen. Gehen sie nun in das Tab „Table“ und drücken Sie den Aufnahmeknopf.
Laden Sie Ihre Bestellseite, legen Sie die Pizzen Palermo, Hawaii, Vegetaria und Salami in den Warenkorb. Markieren Sie Salami und Hawaii im Warenkorb und wählen Sie „Auswahl löschen“. Beenden Sie die Testaufzeichnung.
Nun müssen Sie noch überprüfen, ob die richtigen Pizzen im Warenkorb stehen und der Preis stimmt.
Klicken Sie hierzu ans Ende der bisher erzeugten und in der Tabelle angezeigten Befehle und definieren Sie folgenden neuen Befehl:
Command: assertText
Target: TotalPrice
Value: 13,50
Die verbleibenden Pizzen im Select-Feld kann man mit folgendem Befehl überprüfen:
Command: assertSelectOptions
Target: ShoppingCart
Value: Palermo,Vegetaria

Auf diese Weise kann man weitere Testfälle erstellen und in einer Suite speichern. Selenium verwendet hierzu eine leicht verständliche HTML-Struktur. Gut gefällt mir auch die Auto-Vervollständigung, so dass man bei den Asserts recht gut die passenden Befehle findet. Die Referenz der einzelnen Commands ist kompakt und dennoch verständlich gehalten.
Die Tests können einzeln ausgeführt werden oder alle Tests einer „Suite“ können ausgeführt werden. Es gibt Breakpoints und bei Asserts gibt es im Fehlerfall die übliche Meldung mit dem erwarteten und dem tatsächlichen Wert.

Ich persönlich habe immer einen Zettel greifbar, auf dem ich alle ToDos notieren kann, eine einfache Txt-Datei auf dem Desktop, in der ich mir Links, Stichworte etc. notiere und in der Vorbereitungszeit natürlich einen Zeitplan. Zu Wochenbeginn räume ich immer meine Ablage und meine Mails auf. Aber, meine Anforderungen sind anders als Ihre.

Ein Student berichtete mir von positiven Erfahrungen mit der Pomodoro-Technik. Wie gehen Sie mit Ihren Aufgaben und Ihrer Zeit um?

Hier nun die Links:

• Getting Things Done
• Pomodoro-Technik
• Empfehlungen bei Studienstrategie.de
• Getting Results the Agile Way
• Empfehlungen von Werner Stangl

Wenn Sie im Blick haben möchten, wofür Sie wie viel Zeit verwenden, dann schauen Sie sich Klok (auch als Freeware) an.

In diesem Artikel werden wir uns an eine Implementierung einer Skybox in XNA herantasten und hilfreiche Tipps geben, wie man diese schnell und unkompliziert in sein eigenes Projekt einbauen kann.

Zunächst einmal: Was ist eigentlich eine Skybox?
Eine Skybox besteht aus sechs Bildern, die man bildlich gesprochen auf einen Würfel, auf jede Seite natürlich ein Bild, aufpresst. Hinzu kommt, wie man unten sieht, dass die Skybox, wie auch andere 3D-Objekte aus Meshes besteht. Meshes sind nichts anderes als Ansammlungen von Polygonen, die man nach dem Laden nur noch zeichnen muss:

Codefragment 1:

foreach (ModelMesh mesh in skyboxModel.Meshes)
{
  foreach (Effect currentEffect in mesh.Effects)
  {
    Matrix worldMatrix = skyboxTransforms[mesh.ParentBone.Index] *
    Matrix.CreateTranslation(cameraPosition);
    currentEffect.CurrentTechnique =
    currentEffect.Techniques["Textured"];
    currentEffect.Parameters["xWorld"].SetValue(worldMatrix);
    currentEffect.Parameters["xView"].SetValue(viewMatrix);

    currentEffect.Parameters["xProjection"].SetValue(projectionMatrix);

    currentEffect.Parameters["xTexture"].SetValue(skyboxTextures[i++]);
  }
  mesh.Draw();
}

Zu den Effekte die in diesem Codefragment benutzt werden kommen wir später noch.

Hier entstand allerdings bereits ein Problem, mit dem wir klarkommen mussten: Unsere sechs Grafiken für die Skybox, die wir mit Hilfe von GIMP hergerichtet hatten, sahen in den Überschneidungsgebieten, also Ecken und Kanten zu den anliegenden Grafiken, nicht gut aus. Man sah jede Kante und spitzzulaufende Ecke.

Somit mussten wir unser Konzept, dass wir wirklich das Schiff in der Skybox bewegen, nochmal umkrempeln. Anstatt die Skybox „festzuhalten“ und das Schiff in ihr zu bewegen, haben wir es genau andersherum gemacht. Das Schiff ist immer an derselben Position, auch wenn man meint, man fliegt in eine Richtung. Wir bewegen alles um das Schiff herum. Somit sind wir der Problematik, eine dynamisch erweiternde Skybox zu bauen, direkt aus dem Weg gegangen. Man muss gestehen, wirklich schön ist diese Lösung nicht, aber praktikabel bei unserem kleinen Projekt.

Allerdings war das leider noch nicht alles. Eine weitere Implementierung muss man noch vornehmen, um diese schöne Weltraumansicht genießen zu können. Die Grafiken müssen natürlich noch irgendwie an die Skybox geklebt werden. Das Ganze machen wir über unsere „Skybox.x“ (Auszug im Anhang). Hier muss man seine 6 Skyboxgrafiken noch in die MeshMaterialList reinbasteln.

Eigentlich war es das dann auch schon. Eigentlich: Wir hatten herausgefunden, dass XNA einen Shader benötigt um Dreiecke zu zeichnen. Sprich: Ohne einen Effekt, kein Bild. Wir haben uns dazu einen BasicShader besorgt und somit nicht nur unsere Dreiecke gezeichnet, sondern auch ein DefaultLightening gewonnen.

Codefragment 2: Implementierung des Shaders

effect = Content.Load<Effect>("effects");

Dieser Einzeiler reicht schon, um den Effekt zur Verfügung zu stellen.
Je nach Anforderung muss man nun noch die entsprechenden Funktionen aufrufen, um die Effekte anzuwenden. Für das DefaultLightening muss man nur die gleichnamige Funktion aufrufen:

Codefragment 3:

effect.EnableDefaultLighting();

Im Codefragment 1 werden vier Effektparameter und eine Effekttechnik verwendet. Diese sind soweit selbsterklärend, sodass die Technik, mit der wir unsere Welt darstellen, auf Texturen basieren. Es gibt auch noch weitere Techniken, die der Shader bereitstellt, zum Beispiel pretransformed, colored, Pointsprites und andere, mit denen wir uns aber nicht weiter auseinandergesetzt haben. Die Parameter, die wir dem Effekt zuweisen sind auch soweit logisch. Wir müssen unserem Effekt natürlich mitteilen, auf welche projektionsMatrix, viewMatrix, worldMatrix und welche Textur er sich bezieht. Somit wird der Effekt auf jedes Bild/Textur, dass durch die foreach-Schleife im Codefragment 1 gezogen wird, angewendet.

Quellen:

• http://www.riemers.net/eng/Tutorials/XNA/Csharp/series1.php mit Unterseiten
• http://www.xnamag.de/articles.php?cid=6 mit Unterseiten
• http://msdn.microsoft.com/de-de/library/bb198548.aspx

Jetzt musste ich nur noch rausfinden, dass als zu bindendes Objekt DataView deutlich besser geeignet ist, als das DataSet selbst und folgender Code läuft wunderbar:

//MainWindow.cs
InitializeComponent();
DataContext = new DBViewModel();

//DBViewModel.cs
class DBViewModel
{
  private const string CONN_STRING = @"Server=localhost;Database=SQLLectureDemo;Uid=demo;Pwd=geheim;";
  private const string SELECT_SQL = "SELECT Id, Name, Birthday, Matrikel FROM Student";
  private ICommand _saveCmd;
  private DataSet _students;

  public DBViewModel()
  {
    _students = ReadDataIntoDataSet();
    _saveCmd = new DelegateCommand((param) => SaveDataSetChangesToDb());
  }

  public DataView Students
  {
    get { return _students.Tables[0].DefaultView; }
  }

  public ICommand SaveCmd
  {
    get { return _saveCmd; }
  }

  private static DataSet ReadDataIntoDataSet()
  {
    DataSet myDataSet;
    using (MySqlConnection conn = new MySqlConnection(CONN_STRING))
    {
      conn.Open();
      MySqlCommand cmd = new MySqlCommand(SELECT_SQL, conn); //fetches primary key, as needed by commandbuilder
      MySqlDataAdapter myMySqlDataAdapter = new MySqlDataAdapter(cmd);
      myDataSet = new DataSet(); //disconnected storage
      myMySqlDataAdapter.Fill(myDataSet, "Student");
      myMySqlDataAdapter.Dispose(); //not needed any longer!
      conn.Close();
    }
    return myDataSet;
  }

  private void SaveDataSetChangesToDb()
  {
    using (MySqlConnection conn = new MySqlConnection(CONN_STRING))
    {
      conn.Open();
      MySqlCommand cmd = new MySqlCommand(SELECT_SQL, conn);
      MySqlDataAdapter da = new MySqlDataAdapter(cmd); //select cmd as used to fill the dataset!
      MySqlCommandBuilder builder = new MySqlCommandBuilder(da); //needed to build the commands
      da.Update(_students, "Student");
      conn.Close();
    }
  }
}

Mit MainWindow.xaml:

<DataGrid  Height ="250" HorizontalAlignment="Stretch" Margin="0"  AutoGenerateColumns="True"  ItemsSource="{Binding Path=Students}"  Name="dataGrid"  AlternatingRowBackground="#FF1ACE1A" VerticalScrollBarVisibility="Visible" HorizontalScrollBarVisibility="Visible" />
<Button Name="btnSave" Content="write changes to database" Command="{Binding Path=SaveCmd}" />

Dabei verwende ich die in Artikel „WPF: Von Spaghetticode zu MVVM – Teil 5 von 9″ eingeführte Klasse DelegateCommand.

Das Beispiel greift auf eine MySql-Datenbank zu. Wenn Sie den ConnectionString anpassen und bei den DB-Klassen anstelle des Prefixes MySql nur das Prefix Sql verwenden, so funktioniert das Beispiel auch für den Sql-Server von Microsoft.

Dieses Buch ist ebenfalls dazu geeignet, sich über Spiele in C# und Visual Studio 2010 einzuarbeiten. Jedes Kapitel schließt mit w/f-Fragen ab, deren Lösungen (mit Begründungen) am Buchende zu finden sind. Das Buch ist in drei Abschnitte gegliedert:

1. Getting started
2. Images, Sound and Text
3. Writing proper games (including multiplayer network games!)

Der Autor schreibt, dass das Buch zum Lernen von C# und objektorientierter Programmierung geeignet sei. Nach meiner Einschätzung wird dieses Ziel nicht erreicht.

Bei der Entwicklung eines XNA-Spiels  sind von Entwicklungsstufe zu Entwicklungsstufe immer mehr Objekte zu zeichnen. Diese alle in einer Klasse zu verwirklichen führt  dazu, dass diese schnell unübersichtlich wird. Um dieses Problem modular zu lösen stellt XNA die sogenannten „GameComponent“s zu Verfügung.  Damit lässt sich beispielsweise die Hintergrundkarte unseres Autorennspiels verwirklichen.

public class MapComponent : Microsoft.Xna.Framework.GameComponent
{
  public MapComponent(Game game) : base(game)
  {
  }

  public override void Initialize()
  {
    base.Initialize();
  }

  public override void Update(GameTime gameTime)
  {
    base.Update(gameTime);
  }
}

Die Funktionen von GameComponents werden automatisch zur passenden Zeit vom XNA Framework aufgerufen, sobald man sie zu einer Collection von Components hinzugefügt hat.

GameComponents realisieren das Initialisieren und das Updaten einer Komponente. Um eine Komponente periodisch mitzeichnen zu lassen, ist das Interface DrawableGameComponent zu verwenden. Dieses erweitert die Klasse um die Funktionen

- Draw(),
- LoadContent(),
- UnloadContent().

Um nun verschiedene Karten benutzen zu können, wird der Konstruktor um einen Identifier erweitert, welcher in der Funktion „LoadContent“ genutzt wird, um die Textur der Karte zu laden. In der Funktion „Draw“ wir die Karte anschließend gezeichnet.

public class MapComponent : Microsoft.Xna.Framework.DrawableGameComponent
{
  public MapComponent(Game game, string mapIdentifier)
    : base(game)
  {
  }

  public override void Initialize()
  {
    base.Initialize();
  }

  protected override void LoadContent()
  {
    _spriteBatch = new SpriteBatch(base.Game.GraphicsDevice);
    _map = base.Game.Content.Load<Texture2D>(_mapId);
  }

  protected override void UnloadContent()
  {
  }

  public override void Update(GameTime gameTime)
  {
  }

  public override void Draw(GameTime gameTime)
  {
    _spriteBatch.Begin();
    _spriteBatch.Draw(_map, new Vector2(0, 0), _map.Bounds, Color.White, 0f, new Vector2(0, 0), 1f, SpriteEffects.None, 1f);
    _spriteBatch.End();
  }
}

Um diese GameComponent nun in der Hauptklasse des Spieles einzufügen muss folgendes getan werden:

MapComponent map;
public Game1()
{
  map = new MapComponent(this, „PFAD/ZUR/BILD_RESSOURCE “);
  Components.Add(map);
}

Das war alles, den Rest erledigt XNA automatisch.

Ein gutes Tutorial zu XNA-GameComponet findet man unter: http://www.xnamag.de/article.php?aid=16

Ein nützliches Mittel, um Berichte aus verschiedenen Datenquellen zu erstellen, ist Crystal Reports. Als Datenquelle kann man hier verschiedene Datenquellen angeben.  Es ist dann ebenfalls möglich, aus dieser Datenquelle nur eine bestimmte Menge beziehungsweise bestimmte Daten anzeigen zu lassen. In unserem Fall ist die Datenquelle eine SQL-Datenbank. Eine Möglichkeit, diese Daten darzustellen, besteht darin, zuerst die Daten mittels SqlDataAdapter in ein DataSet zu schreiben und dieses anschließend als XML-Datei abzuspeichern. Danach fügt man zu dem Projekt einen Crystal-Report hinzu und wählt als Quelle diese XML-Datei aus, welche diesem Bericht als Struktur dient. Um nun einen Bericht im CrystalReportViewer anzeigen zu können, erstellt man erst einmal ein ReportDocument und ein DataSet:

ReportDocument report = new ReportDocument();
DataSet myDataSet = new DataSet();

Dieses DataSet befüllt man wieder mit einem SqlDataAdapter und lädt dann den CrystalReport und setzt die Datenquelle:

report.Load(@"CCrystalReport1.rpt");
report.SetDataSource(myDataSet);
crystalReportViewer1.ReportSource = report;

Nachdem Entwickler ihr Projekt geschrieben haben, wünschen sich viele eine Bewertung oder Verbesserungsvorschläge ihres Codes herbei. Dafür gibt es bereits zahlreiche, automatisch generierte Analyestools und Metriken. Visual Studio bietet auch eine solche Form von Codeanalyse an, welche sehr umfangreich ist. Die Hinweise sind hier zahlreich: Sie reichen von der Sicherheit über Namenkonventionen und Design bis hin zur Performance. Doch wie kann ich das selbst bestimmen?

Vorhandene Regeln und Regelsätze

Unter den Projekteigenschaften findet sich der Tab „Codeanalyse“. Dort können wir einen von zahlreichen, von Microsoft zu Verfügung gestellten Regelsätzen, auswählen. Ein Regelsatz ist dabei eine Zusammenstellung von Regeln. Wird nun einer der Regelsätze geöffnet, offenbart sich bereits das gesamte Sortiment von vorhandener Regeln.

Bild 1: Vorhandene Regeln von VS 2010

Nun können wir die uns zusagenden Regeln durch Selektieren zusammenstellen. Möchten wir nun diese Regeln auf unser Projekt anwenden, können wir einfach durch einen Rechtsklick im Projektmappenexplorer auf unser Projekt „Codeanalyse“ auswählen. Schon prüft VS 2010 unser Projekt auf alle von uns ausgewählten Regeln des gegebenen Regelsatzes.

Eigene Regelsätze erstellen

Haben wir unsere Lieblingsregeln gefunden und wollen diese dauerhaft abspeichern, ist dies relativ schnell erledigt. Hierzu die gewünschten Regeln auswählen und anschließend unter „Datei“ „speichern unter“ auswählen. Am besten wird diese Datei (*.ruleset) unter dem angebotenen Pfad gespeichert (C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\Rule Sets bei 64-bit Systemen und C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\Rule Sets bei 32-bit Systemen). Wenn wir nun den Namen und die Beschreibung noch ein wenig aufhübschen wollen, können wir die eben abgespeicherte Datei mit einem Texteditor öffnen, editieren und die ersten beiden Zeilen mit folgendem Codefragment ersetzen.

<?xml version="1.0" encoding="utf-8"?>
<RuleSet Name="Regelname" Description="Beschreibung der Regel." ToolsVersion="10.0">

Nun wird auch in VS 2010 der korrekte Name mit passender Beschreibung angezeigt.

Eigene Regel schreiben

Doch was ist, wenn uns die von Microsoft gegebenen Regeln nicht ausreichen, sondern wir unsere eigene, spezielle Regel aufstellen wollen? Hier wird es ein wenig kniffliger, da Microsoft kaum bis gar keine Dokumentation dazu ausgibt. Doch erstmal eine kurze Erklärung, wie das ganze Konstrukt „eigene Regel“ am einfachsten und effizientesten funktioniert: Wir erstellen ein neues Projekt, schreiben dort die Implementierung der Regel. In eine dazugehörige XML-Datei werden Metadaten hinterlegt, welche mit dem Projekt verknüpft sind. Anschließend bekommen wir eine *.dll-Datei erzeugt, welche unsere Regel darstellt. Zuletzt binden wir diese Regel noch in unseren Regelsatz ein und fertig! Aber alles noch mal Schritt für Schritt:

1. Zuerst müssen wir eine neue Projektmappe erstellen und ein dazugehöriges Klassenbibliotheks-Projekt (welches uns die *.dll-Datei liefert) hinzufügen. Dieses haben wir in unserem Beispiel „MyCustomFxCopRules“ genannt (gleiche Namen von Projektmappe und Projekt sind hier wichtig!).
2. Nun müssen wir dem Projekt zwei Referenzen einverleiben, ohne welche unsere Regeln nicht funktionieren würden. Diese sind die FxCopSdk.dll und die Microsoft.Cci.dll. Dazu entladen wir unser Projekt (Rechtklick auf das Projekt, „Projekt entladen“) und öffnen die *.csproj- Datei (Rechtsklick auf das entladene Projekt).
3. Wir fügen dann folgenden Code in die <ItemGroup> ein:

<Reference Include="FxCopSdk">
  <HintPath>$(CodeAnalysisPath)\FxCopSdk.dll</HintPath>
  <Private>False</Private>
</Reference>
<Reference Include="Microsoft.Cci">
  <HintPath>$(CodeAnalysisPath)\Microsoft.Cci.dll</HintPath>
  <Private>False</Private>
</Reference>

4. Nachdem wir gespeichert haben, laden wir das Projekt wieder (Rechtsklick auf das Projekt, “Projekt erneut laden“).
5. Jetzt müssen wir die erwähnte XML-Datei anlegen und mit Inhalt füllen. Dazu im Projektmappenexplorer eine XML-Datei hinzufügen (Rechtklick auf das Projekt, „Hinzufügen“, „Neues Element“, „XML-Datei“ auswählen). Diese haben wir hier „RuleMetadata.xml“ genannt.
6. In diese XML-Datei stecken wir den unten stehenden Code. Resolution entspricht hier dem Text, der im Fehlerliste-Fenster von VS 2010 angezeigt wird. MessageLevel besagt, was ausgeworfen werden soll, wenn die Regel eintritt. Ebenso FixCategories.

<?xml version="1.0" encoding="utf-8" ?>
<Rules FriendlyName="My Custom FxCop Rules">
  <Rule TypeName="FalscheNotation" Category="MyRules" CheckId="CR1000">
    <Name>FalscheNotation</Name>
    <Description>Prüft, ob alle Felder einer bestimmten Schreibweise entprechen.</Description>
    <Resolution>Feld {0} ist nicht in gewuenschter Notation. Feld Name sollte beginnen mit: '{1}'.</Resolution>
    <MessageLevel Certainty="100">Warning</MessageLevel>
    <FixCategories>NonBreaking</FixCategories>
    <Url />
    <Owner />
    <Email />
  </Rule>
</Rules>

Extrem wichtig ist, dass der TypeName genau der Klasse entspricht, wie wir sie in der Implementation benutzen. Das sehen wir jetzt, denn nun widmen wir uns der Implementierung: Diese eigene geschriebene Regel prüft lediglich, ob der Name eines static-Felds eine bestimmte Schreibweise hat bzw. ob der Name eines nicht-static-Felds eine bestimmte Schreibweise hat. In diesem konkreten Fall wird geprüft ob der Name eines statischen Feldes mit „static_“ beginnt. Sollte dies nicht der Fall sein, wird eine Warnung ausgegeben. Zweck des ganzen sollte vielmehr die Einbindung der Regel in Visual Studio und die Funktionsweise des ganzes sein.

7. In eine *.cs-Datei (Name in unserem Beispiel :„Definition.cs“, aber prinzipiell egal) fügen wir nun folgenden Code ein:

//Folgende Usings benötigt unser Code:
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Xml;
 using Microsoft.FxCop.Sdk;
 //Muss immer im selben Namespace des Projektes geschrieben werden
 namespace MyCustomFxCopRules
 {
   // Die Standart-Klasse erbt von BaseIntrospectionRule, einer von FxCop vorgegeben Klasse
  internal abstract class BaseFxCopRule : BaseIntrospectionRule
  {
    //Deklaration der Rule (BaseFxCopRule), welche als Namen ("MyCustomFxCopRules.RuleMetadata") unbedingt den Projektnamen + Namen der XML Datei beinhalten muss
    protected BaseFxCopRule(string ruleName) : base(ruleName, "MyCustomFxCopRules.RuleMetadata", typeof(BaseFxCopRule).Assembly)
    { }
  }
  //Anschließend Kommt die "eigentliche" Klasse bzw. Rule, welche von der Standard-Klasse wiederrum erbt. Exakte Namenskonvention ist einzuhalten!
 internal sealed class FalscheNotation : BaseFxCopRule
 {
   public FalscheNotation()
     : base("FalscheNotation")
   { }
   //Hier müssen wir überschreiben, dass nicht-externe Code Elemente sichtbar gemacht werden, da es diese sind, die analysiert werden.
   public override TargetVisibilities TargetVisibility
   {
     get
     {
       return TargetVisibilities.NotExternallyVisible;
     }
   }
   //Überschreiben der Methode Check (von FxCop Basismethode zum Überprüfung allermöglichen Dinge). Hier geschieht die eigentliche Logik der Rule.
   //Der Returnwert ist vom Typ ProblemCollection, welcher signalisiert, ob ein Warning/Break/Error o.ä. ausgeworfen werden soll
   //Default wert ist null, was einem "alles in Ordnung" entspricht.
   public override ProblemCollection Check(Member member)
   {
     Field field = member as Field;
     if (field == null)
     {
       //Die Rule erscheint nun nur bei Field
       //Sollte nichts gefunden worden sein, wird ein null als ProblemCollection zurückgegeben, was ein "alles in Ordnung" repräsentiert.
      return null;
     }
     //Unterscheidung, ob das Feld, was gefunden wurde, statisch ist oder nicht....
     if (field.IsStatic)
     {
       //Nun wird geschaut ob ein "static_" vor dem Feld steht
       CheckFieldName(field, s_staticFieldPrefix);
     }
     else
     {
       //Nun wird geschaut ob ein "nonStatic_" vor dem Feld steht
       CheckFieldName(field, s_nonStaticFieldPrefix);
     }
     return Problems;
   }
   private const string s_staticFieldPrefix = "static_";
   private const string s_nonStaticFieldPrefix = "nonStatic_";
   //Wenn CheckFieldName ein Problem findet (also der string nicht dem entspricht, was in expectedPrefix steht), wird ein "Problem" von Typ ProblemCollection erzeugt.
   private void CheckFieldName(Field field, string expectedPrefix)
   {
     if (!field.Name.Name.StartsWith(expectedPrefix, StringComparison.Ordinal))
     {
       Resolution resolution = GetResolution(field, // Field {0} entspricht nicht der gewünschten Notation.
               expectedPrefix // Field Name sollte eigentlich beginnen mit: {1}.
       );
       Problem problem = new Problem(resolution);
       Problems.Add(problem);
     }
   }
 }
}

8. Wenn wir nun das Projekt erstellen, finden wir unsere gewünschte *.dll-Datei (im Verzeichnis: MyCustomFxCopRules\MyCustomFxCopRules) und kopieren diese in das VS 2010-Regel- Verzeichnis (C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\Rules bei 64-bit Systemen und C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\Rules bei 32-bit Systemen).
9. Nach einem Neustart von VS 2010 öffnen wir nun unser eigentliches Projekt, auf welches unsere Regel angewendet werden soll. Hier öffnen wir wieder unser vorhin erstellten Regelsatz (unser Beispiel: „MyCustomRuleSet“).
10. Nun sollte die erstellte Regel ganz unten unter „MyRules“ angezeigt werden. Wichtig ist, dass nicht aktivierte Regeln angezeigt werden (siehe Bild).Bild 2: Eigene Regel
11. Selektieren wir unsere hinzugefügte Regel und speichern den Regelsatz, wird unsere Regel bei der Codeanalyse angewendet.

Quellen:

• Gewusst wie: Erstellen eines benutzerdefinierten Regelsatzes
• How to write custom static code analysis rules and integrate them into Visual Studio 2010

Facebook wird immer beliebter und immer mehr Facebook-Apps sprießen aus dem Boden. Jetzt stellt sich die Frage: Wie kann ich meine C#-WPF-Desktopanwendung mit der Facebook API erweitern, um z.B. einen Eintrag auf der eigenen Pinnwand zu veröffentlichen? Die Antwort darauf wird in diesem Blogeintrag gegeben!

Verwendet wird dabei das „Facebook C# SDK V5.0“, welches auf http://facebooksdk.codeplex.com/ kostenlos zur Verfügung steht. Bevor es aber losgehen kann, muss man eine Anwendung bei Facebook registrieren. Dies funktioniert auf folgendem Formular: http://www.facebook.com/developers/createapp.php. Eine Anmeldung ist nur mit einem bestätigten Facebook-Account möglich. Dazu muss man seine Handynummer oder Kreditkarte angeben. Anschließend erhält man die, für die Entwicklung benötigte „Anwendungs-ID“. Damit ist es aber noch nicht genug, denn um auf die Pinnwand eines Benutzers schreiben zu können, muss er dies explizit erlauben. Diese Erlaubnis ist in einem so genannten „Access-Token“ verkörpert. Um das Access-Token zu erhalten, muss der Nutzer in der Anwendung erst auf eine Facebook-Webseite geleitet werden, auf der er die Nutzung seines Accounts mit der App freigibt. Dies lässt sich mit einem eingebetteten Webbrowser in der Oberfläche bewerkstelligt. Die URL setzt sich wie folgt zusammen:

string u = "https://graph.facebook.com/oauth/authorize?";

//Anwendungs-ID
u = u + "client_id=XXXXXXXXXXXXXXXXXXX";

//Berechtigung
u = u + "&scope=publish_stream";

//URL, die nach Aufruf angezeigt wird
u = u + "&redirect_uri=http://www.facebook.com/connect/login_success.html";

//Login-Typ
u = u + "&type=user_agent";
u = u + "&display=popup";

Quelle: http://frank-it-beratung.com/2011/01/29/tutorial-ein-facebook-pinnwandeintrag-mit-visual-basic-oder-c-teil-2/

Nachdem der Nutzer seine Eingaben gemacht hat, wird er von Facebook weitergeleitet. Anhand der Weiterleitungs-Url lässt sich der Erfolg erkennen. Enthält die URL den Parameter „access_token“, war dies erfolgreich. Mithilfe eines NavigationEvents lässt sich so das Access-Token bestimmen und zwischenspeichern:

void webBrowser1_Navigated(object sender, System.Windows.Navigation.NavigationEventArgs e)
{
  //der Access-Token hängt an der URL
  string q = e.Uri.ToString();
  string txtAccessToken;

  //jetzt auslesen
  if (q.Contains("#access_token="))
  {
    q = q.Substring(q.IndexOf("access_token=") + 13);
    txtAccessToken = q.Substring(0, q.IndexOf("&"));
    hauptFenster.Fb.tmpAccessToken = txtAccessToken;
    this.Close();
  }
}

Nachdem das „Access-Token“ beschafft wurde, kann mit der Verwendung des Facebook C# SDK  begonnen werden. Hierzu erstellt man sich erst einen neuen FacebookClient, in dem das AccessToken gesetzt werden muss.

Facebook.FacebookClient client = new FacebookClient(tmpAccessToken);

client.AccessToken = tmpAccessToken; //Access-Token setzen

Nun kann man darüber Befehle absetzen. In unserem Fall das Posten auf die eigene Pinnwand.

Für einen Post auf die Pinnwand können verschiedene Parameter in einem „System.Dynamic.ExpandoObject“ gesetzt werden. Darunter fallen z.B. der Text des Posts, eine Url zu einem Bild, Titel, externer Link,… Alle möglichen Parameter finden sich hier: http://developers.facebook.com/docs/reference/api/post/. Anschließend wir das Ganze an die eigene Pinnwand (entspricht https://graph.facebook.com/me/feed) gesendet. Im Folgenden ist ein Beispiel für einen Spritrechner gegeben:

dynamic par = new System.Dynamic.ExpandoObject();

par.message = message;
par.picture = "http://dummyimage.com/600x300/3B5998/fff.jpg&text=" + averageConsuption + " l/100km";
par.name = "Durchschnittsverbrauch";
par.link = "http://www.XXXXXXXXXXXXXXXXXXXXXXXXXXXXX.com“;
par.description = averageConsuption + " l/100km";

par.privacy = new
{
  value = "ALL_FRIENDS",
};

client.PostAsync("https://graph.facebook.com/me/feed", par);

Und so sieht das Ergebnis auf Facebook aus:

Viel Spaß beim Experimentieren mit der API!

Für kleine Programme und vor allem auch für Webanwendungen wie Silverlight ist es oft ausreichend und sinnvoll, eine MySQL-Datenbank anstatt eines großen MS-SQL Servers zu verwenden. Außerdem haben viele PHP- und Java-Entwickler bereits Erfahrung mit MySQL und müssen sich nicht in ein neues DBMS einarbeiten. Da die Verwendung von MySQL im .NET Framework standardmäßig nicht unterstützt wird, kann es bei der Einrichtung zu ein paar kleinen Problemen kommen. Aus diesem Grund erklären wir im Folgenden kurz und knapp wie man aus seiner C# Anwendung auf eine MySQL-Datenbank zugreifen kann.

1. Zunächst muss man den ADO.NET Treiber für MySQL herunterladen. Dieser ist kostenlos bei MySQL unter folgender Adresse zu erhalten: http://dev.mysql.com/downloads/connector/net/
2. Unter Windows am besten die Windows Installer Version herunterladen. Bei der Installation ist nichts Weiteres zu Beachten und kann somit einfach „durchgeklickt“ werden.
3. Starten Sie Visual Studio (hier 2010) und legen Sie Ihr gewünschtes Projekt an.
4. Klicken Sie im Solution Explorer mit der rechten Maustaste auf „References“ (in einer Silverlight-Anwendung natürlich im Server-Teil des Projekts) und wählen „Add Reference…“ aus.
5. Öffnen Sie den Tab „Browse“ und wechseln in das Verzeichnis, in das Sie den MySQL-Connector installiert haben und wählen Sie im Unterverzeichnis „Assemblies\v2.0“ die Datei MySql.Data aus.
6.  Im Folgenden ein Ausschnitt einer Klasse der zeigt, wie man nach Durchführung der Punkte 1 bis 5 auf eine MySQL-Datenbank zugreifen kann. Hier am Beispiel eines Webservices einer Silverlight-Applikation.

public class Service
{
  private MySqlConnection db;
  public Service()
  {
    db = new MySqlConnection("SERVER=;DATABASE=;UID=;PASSWORD=;");
    db.Open();
  }

  [OperationContract]
  public Boolean Login(String email, String passwd) {
  byte[] data = Encoding.Default.GetBytes(passwd);
  using (MD5 algorithm = MD5.Create())
  {
    String passwdHashed = BitConverter.ToString(algorithm.ComputeHash(data));

    MySqlCommand command = db.CreateCommand();
    command.CommandText = "SELECT vvorname, nachname FROM mitglied WHERE email='" + email + "' AND passwort='" + passwdHashed + "' AND rechte='admin'";

    using (MySqlDataReader reader = command.ExecuteReader())
    {

      while (reader.Read())
      {
        // hier kann man nun auf die selektieren Spalten zugreifen
        // z.B: reader[`vorname`]
      }

      reader.Close();

…
    }
  }
}

Quelle:
http://code-inside.de/blog/2007/11/27/howto-datenbankverbindungen-net-mysql/

Immer mehr Seiten im Netz unterstützen sogenannte (News-)Feeds. Die Vorteile liegen auf der Hand: Durch Feeds, seien es nun RSS- oder Atom-Feeds, lassen sich, insbesondere Newsseiten, einfach und unkompliziert überwachen und über etwaige  Änderungen informieren. Da ist es nicht verwunderlich, dass uns .NET hierfür eine gute, und vor allem eine einfache Schnittstelle für diese Aufgaben bietet.

Im Folgenden möchten wir ein kleines Beispiel zum Thema Feeds behandeln, um zu zeigen wie einfach die Nutzung der entsprechenden Klassen ist. In unserem Beispiel möchten wir den RSS Feed des Fachbereichs Informatik der Hochschule Darmstadt [1] abfragen und in einer Liste speichern und ausgeben.

Herzstück unseres Programms sind die Syndication-Klassen[2][3], sowie die WebClient-Klasse[4], welche uns die nötigen Funktionalitäten bietet, um Atom1.0- sowie RSS2.0-Feeds zu verarbeiten. Damit wir die Syndication-Klassen nutzen können, müssen wir vorher die entsprechende Referenz einbinden. Dies ist die System.ServiceModel (in System.ServiceModel.dll). Für unser Beispiel benötigen wir zudem die Using-Direktiven für System.Collections.Generic, System.IO, System.Net, System.ServiceModel.Syndication und System.Xml.

Nun aber zu unserem Beispiel: Unser erster Schritt zur Verarbeitung der Feeds ist sicherlich überhaupt erst einmal die Feeds herunterzuladen. Wobei wir von einem Download abstrahieren möchten und das Einlesen der Datei als Stream bevorzugen. Das bietet nicht nur den Vorteil, dass wir die Datei nicht auf unserer Festplatte zwischenspeichern müssen, sondern bietet auch die Möglichkeit eines kürzeren und schöneren Codes.

Uri url = new Uri("http://www.fbi.h-da.de/index.php?id=1955&type=100"); //Url zu Feed

WebClient request = new WebClient(); //stellt die Verbindung zur Webseite her
Stream stream = request.OpenRead(url); //öffnet Url als Stream
using (StreamReader reader = new StreamReader(stream)) //öffnen eines Readers auf dem Stream
{
    //TODO: Hier möchten wir unsere Feeds parsen
}

Wir haben nun einen StreamReader für unseren Feed (in diesem Fall ein RSS-Feed) geöffnet und können diesen nun an unseren XmlReader weitergeben. Der XmlReader stellt, wie der Name schon sagt, einen weiteren Reader zur Verfügung (noch haben wir nichts gelesen!). Den XmlReader übergeben wir wiederum als Parameter an die statische Load-Funktion von SyndicationFeed. Diese bietet uns als Rückgabe eine Instanz von SyndicationFeed, welche uns Zugriff auf die runtergeladenen Feeds bietet. Mittels Items-Property bekommen wir Zugriff auf die Feeds und können nun beliebige Operationen damit durchführen. Um das Beispiel nicht unnötig aufzublasen, fügen wir das Item nur einer Liste hinzu ohne weitere Operationen auszuführen. Hier könnten wir bspw. nur Feeds einfügen, die ein bestimmtes Keyword beinhalten oder von einem bestimmten Autor verfasst wurden.

Uri url = new Uri("http://www.fbi.h-da.de/index.php?id=1955&type=100"); //Url zu Feed

List<SyndicationItem> collection = new List<SyndicationItem>();

WebClient request = new WebClient(); //stellt die Verbindung zur Webseite her
Stream stream = request.OpenRead(url); //öffnet Url als Stream
using (StreamReader reader = new StreamReader(stream)) //öffnen eines Readers auf dem Stream
{
    XmlReader xmlReader = XmlReader.Create(reader); //öffnet einen Reader zum XML parsen
    SyndicationFeed feed = SyndicationFeed.Load(xmlReader); //öffnet Parser für Feeds vom XML Reader

    //parsen:
    foreach (SyndicationItem item in feed.Items)
    {
        collection.Add(item);
    }
}

Schlussendlich möchten wir von unseren Feeds auch mal etwas sehen. SyndicationItem bietet uns hier einige Propertys um auf dessen Feed-Attribute zuzugreifen. Sind die entsprechenden Attribute nicht verfügbar, gibt das Property null zurück. In unserem Beispiel möchten wir den Titel (der sollte im Allgemeinen immer verfügbar sein) und wenn verfügbar, dessen Id auf der Konsole ausgeben. Eine vollständige Liste aller Propertys ist unter [3] zu finden.

Uri url = new Uri("http://www.fbi.h-da.de/index.php?id=1955&type=100"); //Url zu Feed

List<SyndicationItem> collection = new List<SyndicationItem>();

WebClient request = new WebClient(); //stellt die Verbindung zur Webseite her
Stream stream = request.OpenRead(url); //öffnet Url als Stream
using (StreamReader reader = new StreamReader(stream)) //öffnen eines Readers auf dem Stream
{
    XmlReader xmlReader = XmlReader.Create(reader); //öffnet einen Reader zum XML parsen
    SyndicationFeed feed = SyndicationFeed.Load(xmlReader); //öffnet Parser für Feeds vom XML Reader

    //parsen:
    foreach (SyndicationItem item in feed.Items)
    {
        collection.Add(item);
    }
}

…

foreach (SyndicationItem item in collection)
{
    if (item.Id != null)
        System.Console.Write(item.Id + ": ");
    System.Console.WriteLine(item.Title.Text);
}

Wie man sehen kann, ist die Verarbeitung von RSS Feeds unter .NET im Vergleich mit anderen Lösungen (z. B. unter C++) kinderleicht. Dass ATOM- und RSS-Feeds dabei auf die gleiche Weise verwendet werden können, setzt dem ganzen noch ein i-Tüpfelchen oben drauf und bietet eine Menge Einsatzmöglichkeiten.

Referenzen:
[1] http://www.fbi.h-da.de/index.php?id=1955type=100
[2] http://msdn.microsoft.com/en-us/library/system.servicemodel.syndication.syndicationfeed.aspx
[3] http://msdn.microsoft.com/en-us/library/system.servicemodel.syndication.syndicationitem.aspx
[4] http://msdn.microsoft.com/en-US/library/system.net.webclient%28v=VS.80%29.aspx

Oft ist es notwendig, innerhalb einer Tabelle einer Datenbank eine Auswahl zu treffen, welche der betroffenen Datensätze denn nun wirklich in Crystal-Reports angezeigt werden soll. Im folgenden Beispiel verwenden wir als Ausgangsbasis eine Datenbank mit drei Tabellen, in denen Adressen, Adressgruppen-Namen und deren Zuordnung zueinander gespeichert sind. Die Namen der einzelnen Adress-Gruppen werden zu Beginn innerhalb eines Forms in eine Combo-Box geschrieben. Aufgrund dieser Auswah wird dann automatisch gefiltert.
Gehen Sie, wie folgt vor:
Klicken Sie im Report-Steuerelement mit der rechten Maustaste, wählen Sie aus: Bericht -> Datensatz -> Auswahlformel
Es erscheint folgendes Fenster:

Geben Sie ein: <tabellenname.spaltenname> = <?Parameter>
Nun müssen Sie nur noch über den Quelltext diesen Parameter füllen und dies geht, wie folgt:

ParameterFieldDefinitions crParameterFieldDefinitions;
ParameterFieldDefinition crParameterFieldDefinition;
ParameterValues crParameterValues = new ParameterValues();
ParameterDiscreteValue crParameterDiscreteValue = new ParameterDiscreteValue();
crParameterDiscreteValue.Value = comboBox1.SelectedItem.ToString();
crParameterFieldDefinitions = cryRpt.DataDefinition.ParameterFields;
crParameterFieldDefinition = crParameterFieldDefinitions["GruppeName"];
crParameterValues = crParameterFieldDefinition.CurrentValues;
crParameterValues.Clear();
crParameterValues.Add(crParameterDiscreteValue);
crParameterFieldDefinition.ApplyCurrentValues(crParameterValues);

cryRpt ist das Objekt auf Basis eines Reports, der zuvor, wie folgt deklariert und an die Datenbank angebunden wurde:

ReportDocument cryRpt = new ReportDocument();
cryRpt.Load(@"CrystalReport4.rpt");
cryRpt.SetDatabaseLogon(BenutzerName,PassWord,ServerAdresse,DatenBankName);

Abschließend übergeben wir dann alles dem Crystal-Reports-Control und führen einen Refresh durch:

crystalReportViewer1.ReportSource = cryRpt;
crystalReportViewer1.Refresh();

Das war es! Unser Report kann nun gefiltert über eine Spalte seine Daten bekommen.

Bei der Einarbeitung hat uns folgende Seite geholfen:

• http://csharp.net-informations.com/

WebRequest ist eine abstrakte Basisklasse die zum Anforderungs-/Antwortmodell von .Net gehört. Sie ist ab .Net Framework 2.0 verfügbar und ist vorerst protokoll-unabhängig. Klassen, die von dieser erben, können auf die verschiedenen Protokolle genauer eingehen. Um eine neue Instanz von WebRequest zu erstellen, sollte man die Funktion Create() benutzen. Hier wird dann der Eingabestring (die abzufragende URI) auf ihr Protokoll untersucht und eine Instanz einer abgeleiteten Klasse zurückgegeben. Sollte beispielsweise die Webseite http://www.google.de abgefragt werden, dann liefert uns die Funktion Create() des WebRequests ein Objekt einer davon abgeleiteten Klasse HttpWebRequest. Wollen wir jetzt eine Antwort der URI erhalten, können wir per GetResponse() diese protokollspezifisch bekommen. Dabei wird ein Instanz der Klasse WebResponse zurückgegeben — genauer ein HttpWebResponse-Objekt; denn auch hier ist es so, dass WebResponse eine abstrakte Basisklasse ist, welche protokollunabhängig funktioniert. Das alles hat den Sinn, um erst während der Laufzeit auf die Protokollart eingehen zu müssen. Nachdem wir unsere Antwort erhalten haben, können wir diese weiterverarbeiten und z.B. ausgeben lassen.

// Erstellen eines WebRequests. Die Create-Methode gibt in diesem Fall ein HttpWebRequest-Objekt zurück.
HttpWebRequest req = WebRequest.Create("http://www.google.de");
// Die Antwort der URI wird in ein WebResponse-Objekt geladen und kann hier weiterverarbeitet werden. Auch hier wird ein Abgeleitetes WebResponse Objekt erstellt (ein HttpWebResponse Objekt).
WebResponse resp = req.GetResponse();
// Hier ein Beispiel, wie das WebResponse Objekt in eine string Variable weiterverarbeitet werden kann.
StreamReader sr = new StreamReader(resp.GetResponseStream());
// In unserem Beispiel enthält die string Variable jetzt den HTML Code der Webseite Google.
string htmlCode = sr.ReadToEnd();