Jakie interfejsy wykonałeś lub widziałeś w C#, które były bardzo cenne? Co było w nich takiego wspaniałego?

Po raz pierwszy słyszę określenie " płynny interfejs."Ale dwa przykłady, które przychodzą na myśl to LINQ i immutable collections.

Pod okładkami LINQ znajduje się szereg metod, z których większość to metody rozszerzenia, które pobierają co najmniej jedną liczbę IEnumerable i zwracają inną liczbę IEnumerable. Pozwala to na bardzo wydajne łączenie metod

var query = someCollection.Where(x => !x.IsBad).Select(x => x.Property1);

Typy niezmienne, a dokładniej zbiory mają bardzo podobny wzór. Niezmienne zbiory zwracają nową zbiór dla tego, co normalnie byłoby operacją mutującą. Tak więc budowanie kolekcji często zamienia się w serię łańcuchowych wywołań metod.

var array = ImmutableCollection<int>.Empty.Add(42).Add(13).Add(12);

Uwielbiam płynny interfejs w CuttingEdge.Warunki .

Z ich próbki:

{[0]}

Odkryłem, że jest o wiele łatwiejszy do odczytania i sprawia, że znacznie skuteczniej sprawdzam moje warunki wstępne (i warunki postu) w metodach niż gdy mam 50 instrukcji if do obsługi tych samych kontroli.

Oto jeden, który zrobiłem wczoraj. Dalsza myśl może doprowadzić mnie do zmiany podejścia, ale nawet jeśli tak," płynne " podejście pozwoliło mi osiągnąć coś, czego inaczej nie mógłbym mieć.

Najpierw trochę historii. ostatnio nauczyłem się (tutaj na StackOverflow) sposobu przekazywania wartości do metody tak, że metoda będzie w stanie określić zarówno nazwę , jak i wartość . Na przykład jednym z powszechnych zastosowań jest Walidacja parametrów. Na przykład:

public void SomeMethod(Invoice lastMonthsInvoice)
{
     Helper.MustNotBeNull( ()=> lastMonthsInvoice);
}

Uwaga nie ma łańcucha zawierającego "lastMonthsInvoice" , co jest dobre, ponieważ ciągi są do bani dla refaktoryzacji. Jednak komunikat o błędzie Może powiedzieć coś w stylu "parametr' lastMonthsInvoice ' nie może być null."oto post który wyjaśnia, dlaczego to działa i wskazuje na post na blogu faceta.

Ale to tylko tło. używam tego samego pojęcia, ale w inny sposób. Piszę testy jednostkowe i chcę zrzucić niektóre wartości właściwości są wysyłane do konsoli, więc pojawiają się na wyjściu testu jednostkowego. Znudziło mi się pisanie tego:

Console.WriteLine("The property 'lastMonthsInvoice' has the value: " + lastMonthsInvoice.ToString());

... ponieważ muszę nazwać właściwość jako ciąg znaków, a następnie odnieść się do niej. Więc zrobiłem to gdzie mogłem to wpisać:

ConsoleHelper.WriteProperty( ()=> lastMonthsInvoice );

I uzyskaj to wyjście:

Property [lastMonthsInvoice] is: <whatever ToString from Invoice

Produkuje>

Tutaj płynne podejście pozwoliło mi zrobić coś, czego inaczej nie mógłbym zrobić.

Chciałem zrobić ConsoleHelper.WriteProperty weź tablicę params, aby mogła ona zrzucić wiele takich wartości właściwości do konsoli. Aby to zrobić, jego podpis wyglądałby tak:

public static void WriteProperty<T>(params Expression<Func<T>>[] expr)

Więc mogę to zrobić:

ConsoleHelper.WriteProperty( ()=> lastMonthsInvoice, ()=> firstName, ()=> lastName );

Jednak to nie działa z powodu wnioskowania typu. innymi słowy, wszystkie te wyrażenia nie zwracają tego samego typu. lastMonthsInvoice jest fakturą. firstName i lastName są ciągami znaków. Nie mogą być używane w tym samym wywołaniu do WriteProperty, ponieważ T nie jest taki sam we wszystkich oni.

Tutaj płynne podejście przyszło na ratunek. Sprawiłem, że writeproperty() zwróciło coś. Typ, który zwrócił jest czymś, co mogę wywołać i() na. To daje mi taką składnię:

ConsoleHelper.WriteProperty( ()=> lastMonthsInvoice)
     .And( ()=> firstName)
     .And( ()=> lastName);

Jest to przypadek, w którym płynne podejście pozwalało na coś, co w przeciwnym razie nie byłoby możliwe (a przynajmniej nie było wygodne).

Oto pełna implementacja. Jak już mówiłem, napisałem to wczoraj. Prawdopodobnie zobaczysz miejsce na poprawę, a może nawet lepiej zbliża się. Cieszę się z tego.

public static class ConsoleHelper
{
    // code where idea came from ...
    //public static void IsNotNull<T>(Expression<Func<T>> expr)
    //{
    // // expression value != default of T
    // if (!expr.Compile()().Equals(default(T)))
    // return;

    // var param = (MemberExpression)expr.Body;
    // throw new ArgumentNullException(param.Member.Name);
    //}

    public static PropertyWriter WriteProperty<T>(Expression<Func<T>> expr)
    {
        var param = (MemberExpression)expr.Body;
        Console.WriteLine("Property [" + param.Member.Name + "] = " + expr.Compile()());
        return null;
    }

    public static PropertyWriter And<T>(this PropertyWriter ignored, Expression<Func<T>> expr)
    {
        ConsoleHelper.WriteProperty(expr);
        return null;
    }

    public static void Blank(this PropertyWriter ignored)
    {
        Console.WriteLine();
    }
}

public class PropertyWriter
{
    /// <summary>
    /// It is not even possible to instantiate this class. It exists solely for hanging extension methods off.
    /// </summary>
    private PropertyWriter() { }
}

Oprócz tych podanych tutaj, popuplar RhinoMocks Unit test mock Framework używa płynnej składni, aby określić oczekiwania na obiektach mock:

// Expect mock.FooBar method to be called with any paramter and have it invoke some method
Expect.Call(() => mock.FooBar(null))
    .IgnoreArguments()
    .WhenCalled(someCallbackHere);

// Tell mock.Baz property to return 5:
SetupResult.For(mock.Baz).Return(5);

SubSonic 2.1 ma przyzwoity dla query API:

DB.Select()
  .From<User>()
  .Where(User.UserIdColumn).IsEqualTo(1)
  .ExecuteSingle<User>();

Tweetsharp używa również płynnego API:

var twitter = FluentTwitter.CreateRequest()
              .Configuration.CacheUntil(2.Minutes().FromNow())
              .Statuses().OnPublicTimeline().AsJson();

I Fluent NHibernate jest ostatnimi czasy wściekłością:

public class CatMap : ClassMap<Cat>  
{  
  public CatMap()  
  {  
    Id(x => x.Id);  
    Map(x => x.Name)  
      .WithLengthOf(16)  
      .Not.Nullable();  
    Map(x => x.Sex);  
    References(x => x.Mate);  
    HasMany(x => x.Kittens);  
  }  
}  

Ninject też ich używa, ale nie mogłem szybko znaleźć przykładu.

Nazwa Metody

Interfejsy płynne nadają się do czytelności, o ile nazwy metod są rozsądnie wybierane.

System.Typ.IsInstanceOfType

Jest członkiem System.Type i pobiera obiekt i zwraca true, jeśli obiekt jest instancją tego typu. Niestety, naturalnie czytasz to od lewej do prawej jak to:

o.IsInstanceOfType(t);  // wrong

Kiedy faktycznie jest odwrotnie:

t.IsInstanceOfType(o);  // right, but counter-intuitive

Ale nie wszystkie metody mogłyby być nazwane (lub umieszczone w BCL), aby przewidzieć, jak mogą pojawić się w" pseudo-angielskim " kodzie, więc nie jest to tak naprawdę krytyka. Zwracam tylko uwagę na inny aspekt płynnych interfejsów - wybór nazw metod w celu wywołania jak najmniejszego zaskoczenia.

Inicjalizatory Obiektów

Z wielu przykładów podanych tutaj, jedynym powodem, dla którego biegły interfejs jest używany tak, że kilka właściwości nowo przydzielonego obiektu może być zainicjalizowanych w ramach jednego wyrażenia.

var myObj = new MyClass
            {
                SomeProperty = 5,
                Another = true,
                Complain = str => MessageBox.Show(str),
            };

To może wyjaśniać, dlaczego użytkownicy C# są mniej zaznajomieni z terminem "fluent interface" do łączenia łańcuchów wywołań tego samego obiektu - nie jest to tak często potrzebne w C#.

Ponieważ właściwości mogą mieć ustawiacze kodowane ręcznie, To jest możliwością wywołania kilku metod na nowo zbudowanym obiekcie, bez konieczności zwracania każdej metody tego samego obiektu.

Ograniczenia to:

• Ustawiacz właściwości może przyjąć tylko jeden argument
• Ustawiacz właściwości nie może być ogólny

Chciałbym, abyśmy mogli wywoływać metody i włączać się w zdarzenia, a także przypisywać do właściwości wewnątrz bloku inicjalizacji obiektu.

var myObj = new MyClass
            {
                SomeProperty = 5,
                Another = true,
                Complain = str => MessageBox.Show(str),
                DoSomething()
                Click += (se, ev) => MessageBox.Show("Clicked!"),
            };

I dlaczego taki blok modyfikacji mają zastosowanie tylko natychmiast po budowie? Możemy mieć:

myObj with
{
    SomeProperty = 5,
    Another = true,
    Complain = str => MessageBox.Show(str),
    DoSomething(),
    Click += (se, ev) => MessageBox.Show("Clicked!"),
}

with będzie nowym słowem kluczowym, które działa na obiekcie jakiegoś typu i tworzy ten sam obiekt i typ-zauważ, że będzie to wyrażenie , a nie instrukcja . Tak więc dokładnie uchwyciłby ideę łączenia w "płynnym interfejsie".

Więc możesz użyć składni w stylu inicjalizatora niezależnie od tego, czy otrzymałeś obiekt z new wyrażenia, czy z IOC lub metoda fabryczna itp.

W rzeczywistości można użyć with po całkowitym new i byłoby to równoważne aktualnemu stylowi inicjalizacji obiektu:

var myObj = new MyClass() with
            {
                SomeProperty = 5,
                Another = true,
                Complain = str => MessageBox.Show(str),
                DoSomething(),
                Click += (se, ev) => MessageBox.Show("Clicked!"),
            };

I jak wskazuje Charlie w komentarzach:

public static T With(this T with, Action<T> action)
{
    if (with != null)
        action(with);
    return with;
}

Powyższy wrapper po prostu wymusza nieodwracalne działanie, aby coś zwrócić, a hej presto-wszystko może być "płynne" w tym sensie.

Odpowiednik inicjalizatora, ale z włączeniem zdarzenia:

var myObj = new MyClass().With(w =>
            {
                w.SomeProperty = 5;
                w.Another = true;
                w.Click += (se, ev) => MessageBox.Show("Clicked!");
            };

I na metodzie fabrycznej zamiast new:

var myObj = Factory.Alloc().With(w =>
            {
                w.SomeProperty = 5;
                w.Another = true;
                w.Click += (se, ev) => MessageBox.Show("Clicked!");
            };

Nie mogłem się oprzeć, aby sprawdzić w stylu"maybe monad"dla null, więc jeśli masz coś, co może zwrócić null, nadal możesz zastosować With do niego, a następnie sprawdzić go pod kątem null-ness.

Criteria API w NHibernate ma ładny płynny interfejs, który pozwala robić fajne rzeczy takie jak:

Session.CreateCriteria(typeof(Entity))
    .Add(Restrictions.Eq("EntityId", entityId))
    .CreateAlias("Address", "Address")
    .Add(Restrictions.Le("Address.StartDate", effectiveDate))
    .Add(Restrictions.Disjunction()
        .Add(Restrictions.IsNull("Address.EndDate"))
        .Add(Restrictions.Ge("Address.EndDate", effectiveDate)))
    .UniqueResult<Entity>();

Nowy HttpClient WCF Rest Starter Kit Preview 2 jest świetnym płynnym API. zobacz mój wpis na blogu, aby uzyskać próbkę http://bendewey.wordpress.com/2009/03/14/connecting-to-live-search-using-the-httpclient/

Napisałem trochę płynnego wrappera do System. Net. Mail, który moim zdaniem sprawia, że kod pocztowy jest dużo bardziej czytelny(i łatwiej zapamiętać składnię).

var email = Email
            .From("[email protected]")
            .To("[email protected]", "bob")
            .Subject("hows it going bob")
            .Body("yo dawg, sup?");

//send normally
email.Send();

//send asynchronously
email.SendAsync(MailDeliveredCallback);

Http://lukencode.com/2010/04/11/fluent-email-in-net/

Jak wspomniał @ John Sheehan , Ninject używa tego typu API do określania wiązań. Oto przykładowy kod z ich user guide :

Bind<IWeapon>().To<Sword>();
Bind<Samurai>().ToSelf();
Bind<Shogun>().ToSelf().Using<SingletonBehavior>();