Советы по написанию свободного интерфейса в С# 3

Я после нескольких хороших советов для свободного общения на С#. Я просто сам об этом узнал, но хотел услышать, что другие думают за пределами статей, которые я читаю. В частности, я следую:

Когда слишком много говорит?
Есть ли какие-либо плавные шаблоны?
что находится на С#, что делает беглый интерфейс более свободным (например, методы расширения)
- это сложный беглый интерфейс, который по-прежнему остается свободным?
рефакторинг для свободного общения или рефакторинга существующего свободного интерфейса.
какие-либо хорошие примеры, с которыми вы работали или могли рекомендовать?

Если бы вы могли опубликовать один совет или мысль, или что-либо другое в сообщении. Я хочу посмотреть, как они тоже проголосовали.

Спасибо заранее.

Ответ 1

На четвертом месте;

Да, я думаю, что сложный беглый интерфейс может быть белым.

Я думаю, что беглые интерфейсы - это скорее компромисс. (хотя и хороший!) Было много исследований по использованию естественного языка для программирования, и, как правило, естественный язык недостаточно точен, чтобы выражать программы.

Свободные интерфейсы построены так, что они пишут как язык программирования, допускается только небольшое подмножество того, что вы можете выразить на естественном языке, но они читаются как естественный язык.

Если вы посмотрите на издевательства носорогов, например, часть письма была сложной по сравнению с обычной библиотекой. Я взял меня дольше, чтобы узнать в основном из-за свободного интерфейса, но он делает код намного легче читать. Поскольку программы обычно пишутся один раз и читаются много раз, это хороший компромисс.

Итак, чтобы немного оценить мою точку зрения. Свободный интерфейс, который сложно писать, но легко читается, может быть белым.

Ответ 2

Самая сложная проблема, с которой я столкнулся в качестве потребителя с плавными интерфейсами, заключается в том, что большинство из них не являются действительно свободными intefaces - вместо этого они действительно являются примерами того, что я называю "разборчивыми интерфейсами".

Свободный интерфейс подразумевает, что его основной целью является упрощение для SPEAK, тогда как четкий интерфейс подразумевает, что его основная цель - легко прочесть его. Большинство беглых интерфейсов, как правило, смехотворно трудно кодировать, но, наоборот, невероятно легко ПРОЧИТАТЬ позже другими.

Assert().That().This(actual).Is().Equal().To(expected).
    Except().If(x => x.GreaterThan(10));

... намного легче читать позже, чем на самом деле сочинять в коде!

Ответ 3

Вы используете кирпич при использовании наследования наряду с плавными интерфейсами, потому что использование полиморфных методов разбивает ваши цепочки вызовов, и вы определенно не хотите, чтобы ваши интерфейсы были невосприимчивы, используя уродливое литье и paranthesis там, где они не нужны. Я написал статью о шаблоне, который предоставляет обходное решение, использующее общие конструкторы и общие методы расширения с общими ограничениями: http://liviutrifoi.wordpress.com/2009/02/16/fluent-interfaces-constraints-at-compile-time/

Ответ 4

Moq скрывает нелегированные методы, такие как equals, ToString и т.д., чтобы сделать их свободный интерфейс еще проще в использовании.

Скрывающий системный объект - статья, объясняющая преимущество этого.

Ответ 5

И на ваш второй и третий вопрос;

Три плавных шаблона, которые я заметил

Первый использует оператор using (С# 2.0) для запуска кода в определенном контексте, например:

using(var transaction = new Transaction())
{
  // ..
  // ..
}

Это использует конструктор и средство удаления транзакции для настройки транзакции, а затем запускает код в этом контексте.

Второй делает почти то же самое, но с лямбдой, это часто используется в Rhino Mocks, например.

(new Transaction()).Run( () => mycode(); );

Самый известный свободный интерфейс - использовать возвращаемые типы для вызова цепочных методов. В основном методы возвращают это, поэтому вы можете связывать вызовы с одним и тем же объектом. Но вы также можете возвращать разные объекты для изменения контекста в зависимости от вызванного метода. Если у вас есть объект, который может работать только в транзакции (извините, не могу придумать другой пример), вы можете дать ему метод StartTransaction, который возвращает инициализированную транзакцию, в которой вы можете запускать вызов и stoptransaction, в псевдокоде:

class Runner
{
  Transaction StartTransaction()
  {
    return new Transaction(this);
  }
}

class Transaction
{
  Transaction Run()
  Transaction StopTransaction()
}

где вызов выглядит как

var runner = new Runner();
runner
  .StartTransaction()
  .Run()
  .StopTransaction();

Конечно, вам нужно добавить все виды обработки ошибок и т.д.

Ответ 6

Я тоже просто прыгаю, узнав, как написать свободный интерфейс для небольшого приложения на работе. Я спросил и немного исследовал, и нашел, что хороший подход для написания свободного интерфейса - это использование "шаблона Builder", подробнее об этом читайте здесь.

По сути, именно так я начал свой:

public class Coffee
{
    private bool _cream;
    private int _ounces;

    public Coffee Make { get new Coffee(); }

    public Coffee WithCream()
    {
        _cream = true;
        return this;
    }

    public Coffee WithOuncesToServe(int ounces)
    {
        _ounces = ounces;
        return this;
    }
}

Здесь кросс-пост для аналогичного вопроса, который у меня есть для реализации закрытия в свободном интерфейсе.

Ответ 7

Одно дело, что вы должны учитывать морфологию синтаксиса английского языка и следить за тем, чтобы вы не вводили недокументированную последовательную связь внизу.

// Snarky employees get a raise.
employees.WhereSnarky().GiveRaise();

против.

// Depending on implementation, everyone may get a raise.
employees.GiveRaise().WhereSnarky();

Ответ 8

Когда-то назад у меня были те же сомнения, что и сейчас. Я провел некоторое исследование, и теперь я пишу несколько сообщений, чтобы помочь в этих темах.

Посмотрите в своем блоге:

И в следующих статьях я расскажу о каждом из упомянутых вами моментов.

С уважением Андре Вианна