APIs (egal ob sie nur für interne Zwecke da sind oder auch an externe Entwicklern geht) sollten möglichst einfach und intuitiv zu bedienen sein.
Seit kurzem lese ich immer häufiger von "Fluent Interfaces".
Was ist das denn?
Schauen wir uns einfach mal das Wikipedia Beispiel an:
public class ExampleProgram
{
[STAThread]
public static void Main(string[] args)
{
//Standard Example
IConfiguration config = new Configuration();
config.SetColor("blue");
config.SetHeight(1);
config.SetLength(2);
config.SetDepth(3);
//FluentExample
IConfigurationFluent config =
new ConfigurationFluent().SetColor("blue")
.SetHeight(1)
.SetLength(2)
.SetDepth(3);
}
Anstatt nur einzelne Methodenaufrufe zu haben, ist es doch viel angenehmer diese in "einem Satz" niederzuschreiben. Diese Technik findet auch in diversen Javascript-Bibliotheken Einsatz (z.b: jQuery)
Sieht nicht schlecht aus - wie macht man sowas?
Es gibt (wie in dem Wikipedia Beispiel) sicherlich ein paar Tricks wie man sowas machen kann - durch Rob Conerys Storefront Projekt bin ich konkret auf das "Pipes and Filters" Pattern gekommen.
Die Idee (in der Rob Conery Version ;) )
Wir haben einen großen Datenhaufen (unser Repository), wo wir über Filter bestimmte Sachen einfach uns abzapfen können, wie wir es brauchen.
Das tolle nun daran: Man kann nicht nur ein Filter nehmen, sondern kann diese auch zusammenschließen um seine Ergebnisse noch weiter einzuengen:
Rob Conery hat dies auch in einem Screencast recht gut erklärt.
Die Umsetzung in .NET mit C# 3.0:
Als "Daten" haben wir in unserem Beispiel einfach eine simple Person Klasse:
public class Person
{
public int Age { get; set; }
public string Name { get; set; }
}Der Aufbau ist ähnlich empfunden wie bei diesem Blogpost - allerdings etwas vereinfacht (und sollte so nicht verwendet werden (Schnittstellen einbauen!))
Unser DummyPersonRepository hat nur eine Methode, welche statisch ein paar Objekte erzeugt:
public class DummyPersonRepository
{
public IQueryable<Person> GetPersons()
{
List<Person> returnValues = new List<Person>()
{
new Person() { Age = 11, Name = "Bob" },
new Person() { Age = 22, Name = "Alice" },
new Person() { Age = 20, Name = "Robert" },
new Person() { Age = 40, Name = "Hans" },
new Person() { Age = 20, Name = "Peter" },
new Person() { Age = 20, Name = "Oli" },
};
return returnValues.AsQueryable();
}
}Nun kommen unsere Filter ins Spiel - die nicht direkt ins Repository kommen! Diese werden über "Extension Methods" in einer seperaten Klasse implementiert:
public static class PersonFilters
{
public static IQueryable<Person> WithAge(this IQueryable<Person> qry, int age)
{
return (from x in qry
where x.Age == age
select x);
}
public static IQueryable<Person> NameStartsWith(this IQueryable<Person> qry, string start)
{
return (from x in qry
where x.Name.StartsWith(start)
select x);
}
}Hier fragen wir einmal nach dem Alter und ob der Name mit was bestimmten beginnt - beides als "Extension Method".
In unserem Service können wir nun so eine Methode bereitstellen:
public IList<Person> GetPersons(int age, string startsWith)
{
return this.PersonRep.GetPersons().WithAge(age).NameStartsWith(startsWith).ToList();
}Sehr einfach und effektiv :)
Ergebnis:
Am Ende können wir einfach in einer Konsolenapplikation sowas aufrufen:
static void Main(string[] args)
{
PersonService srv = new PersonService();
List<Person> resultList = srv.GetPersons(20, "R").ToList();
foreach (Person result in resultList)
{
Console.WriteLine("Name {0} - Age {1}", result.Name, result.Age);
}
Console.Read();
}Die Projektstruktur:
Natürlich ist das nur ein simples Beispiel, allerdings konnte ich dies bereits effektiv in einem Projekt einsetzen.
Neben Rob Conerys Storefront kann man sich auch diesen Democode von Mike Bosch anschauen (Teil 1 & 2) - auch er findet diese Idee sehr cool :)
Insgesamt erlaubt ein solcher Programmierstil deutlich schickeren Code - wie bereits das Wikipedia Beispiel am Anfang gezeigt haben sollte.
