当使用流畅的API编程或只使用方法链接时,我看到的风格大多是这样的:

var obj = objectFactory.CreateObject()
    .SetObjectParameter(paramName, value)
    .SetObjectParameter(paramName, value)
    .DoSomeTransformation();

将点放在行的开头而不是行的末尾的原因是什么:

var obj = objectFactory.CreateObject().
    SetObjectParameter(paramName, value).
    SetObjectParameter(paramName, value).
    DoSomeTransformation();

或者,这只是团队达成共识的风格吗？

如何在EF 4.0 FluentAPI CTP5中映射0..1到*关系？我一直在犯这个错误

由于"从属角色"中的所有属性都是不可为空的,因此"主体角色"的多重性必须为"1".

我不知道如何解决它..

我的代码看起来像这样

    public class Child{
        public int pID { get; set; }
        public Parent Parent_Object{ get; set; } 
        public int Parent{ get; set; } 

        public Child() {
        }
    }


    public class Parent {
        public int pID { get; set; }
        public List<Child>  Children { get; set; }

        public Parent () {
        }
    }

对于映射,代码看起来像这样

modelBuilder.Entity<Child>().HasKey(c=> c.pID);  
modelBuilder.Entity<Parent>().HasKey(c=> c.pID); 
modelBuilder.Entity<Child>().HasOptional(c=> c.Parent_Object)
                            .WithMany(p => p.Children)
                            .HasForeignKey(p => p.Parent);

也有可能只有

public Parent Parent{ get; set; } 

代替

public …

我有一个到工厂接口的调用，该接口IMachine在命令处理程序中创建一个。IMachine从工厂返回的方法可以链接在一起，以在构建器类内部创建自己的方法。我FakeItEasy现在WithSpeeds遇到的问题是，除非我将每个方法调用都配置为返回false，否则它只能识别第一个调用（即）IMachine。有没有一种方法可以不配置每个单个调用，也可以不FakeItEasy识别链上的每个方法调用？我知道我一定做错了什么，因为如果我使用OrderAssertions，并且在没有设置我的伪造机器的情况下故意使订单失败，则表明调用了所有方法。谢谢您的帮助。

命令处理程序方法的一部分

public void Handle(FooCommand commandParm)
{
  var entity = new Entity.Builder 
  { 
    Machine = _factory.CreateMachine(commandParm.MachineName)
                .WithSpeeds(commandParm.ProcessingSpeed, commandParm.StartupSpeed, commandParm.ShutDownSpeed)
                .WithOils(commandParm.Lubrication, commandParm.FinishingOil)
  };
}

测试

[TestMethod]
public void HandleSetMachineSettings_should_build_machine()
{
  // Arrange
  var settings = CommandUtilities.ReturnFooCommand();
  var _factory = A.Fake<IMachineFactory>();
  var machine = A.Fake<IMachine>();
  A.CallTo(() => _factory.CreateMachine(settings.MachineName)).Returns(machine);

  // Act
  _handler.Handle(settings);

  // Assert
  machine.Should().NotBeNull();
  A.CallTo(machine).Where(x => x.Method.Name.Equals("set_MachineNumber")).WhenArgumentsMatch(arg => arg.Get<int>(0) == settings.MachineNumber).MustHaveHappened(Repeated.Exactly.Once);
  A.CallTo(() => machine.WithSpeeds(commandParm.ProcessingSpeed, commandParm.StartupSpeed, commandParm.ShutDownSpeed)).MustHaveHappened(Repeated.Exactly.Once);
  A.CallTo(() => …

在修改自身的方法中返回对“this”对象的引用有什么好处（或缺点）？什么时候应该使用返回“this”而不是 void？

当查看代码审查堆栈交换的答案时，我注意到答案在自操作方法中使用了“返回此”。

原始类的简化：

class Item
{
    public Item(string name)
    {
        Name = name;
    }

    public string Name { get; private set; }

    public Item AddComponent(ItemComponent component)
    {
        _components.Add(component);
        return this;
    }

    private List<ItemComponent> _components = new List<ItemComponent>();
}

使用代码简化：

var fireSword = new Item("Lightbringer")
                   .AddComponent(new Valuable { Cost = 1000 })
                   .AddComponent(new PhysicalDamage { Slashing = 10 });

相关问题似乎不同用户的答案相互矛盾。

这个问题也与引用在对象创建中使用的流畅接口的答案类似。

我正在尝试获得一个我写的工作拦截器,但由于某种原因,当我请求我的组件时它似乎并没有实例化拦截器.我正在做这样的事情(原谅我,如果这不完全编译,但你应该得到这个想法):

container.Register(
    Component.For<MyInterceptor>().LifeStyle.Transient,
    AllTypes.Pick().FromAssembly(...).If(t => typeof(IView).IsAssignableFrom(t)).
    Configure(c => c.LifeStyle.Is(LifestyleType.Transient).Named(...).
                   Interceptors(new InterceptorReference(typeof(MyInterceptor)).
    WithService.FromInterface(typeof(IView)));

我在断路器的构造函数中放置了断点,它似乎根本没有实例化它.

在过去,我使用XML配置注册了我的拦截器,但我很想使用流畅的界面.

任何帮助将不胜感激!

所以,我只是在思考酷链是多么简单,以及它如何让事情变得更容易阅读.有很多语言,当将一堆函数应用于变量时,你会写下这样的东西:

i(h(g(f(x))))

你必须从右到左或从最里面到最外面阅读它.您f先申请,然后再申请,g依此类推.但如果它被链接,它看起来会更像

x|f|g|h|i

你可以像普通人一样阅读它.所以,我的问题是,必须有一些语言可以这样做,它们是什么？那些花哨的功能性编程语言是做什么的？

因此,我通常最终创建了一大堆临时变量,以便我可以将它分成不同的行并使其更具可读性:

a = f(x)
b = g(a)
c = h(b)
what_i_really_wanted_all_along = i(c)

我的魔法语言在哪里,如果它们变得太长,你仍然可以将它分成不同的行,而不需要插入变量:

x | f
  | g
  | h
  | i

我正在设计一组通用接口,以澄清一些报告的构造.

为了达到这个目的,我使用泛型,我必须在不同的流畅类之间传递三个通用参数.有时我必须通过其中的四个,但这一切都是由框架完成的,背后的想法是,只要有足够的注意力,就可以拥有一个完整的界面而无需输入任何泛型.

一个例子是

        t1.Schedule.ForSession(Session).
            WithName("TestName").
            Map.
            Args.FromResultsOfTask(t2).UsingDefaultMappings().
            And.
            WaitOnCompletionOfTask(t4);

运行FXCop产生了这种类型的无限抱怨:

Error, Certainty 85, for AvoidExcessiveParametersOnGenericTypes

我正在使用泛型来创建"类型安全"(也许类型感知更正确)接口,其中映射可以定义为

...
Map.Args.From(myObject).
    Mapping(x=>x.MyProperty).To(y=>y.ArgsProperty).
...

我可以采用哪些策略来减少泛型的使用并仍然实现编译安全的自定义映射？

有没有人成功地使用泛型(并且可以指出一组很好的例子)来实现流畅的界面？

最近我用F#开始冒险.我正在尝试创建我将在C#项目中使用的F#库.

现在我面临的问题是我有两种类型的定义(如我所愿)可以自己使用(我正在尝试为c#用法创建流畅的API).

我想如何在c#中使用它(简化示例).

Shopping shopping = new Shopping(); 
Stuff[] stuff = shopping.GoTo("Wallmart").Buy(new [] { "Candies", "Ice cream", "Milk" }).GoTo("Drug store").Buy(new [] { "Anvil" }).GetStuff();

现在我有两种类型(在separted文件中):

type ShopResult(someContext: ShoppingContext) =
 //some logic
 member this.GoTo shopName = new ToDoResult(someContext)

type ToDoResult(someContext: ShoppingContext) = 
 //some logic
 member this.Buy what = new ShopResult(someContext) 

现在文件顺序导致编译错误,我想知道我的案例是否有任何解决方案？还是让我放弃流畅的api想法？

我们熟悉用于在java和其他编程语言中调用方法的流畅接口.例如:

Picasso.with(this).load(url).into(imageView);

这可以通过setter方法实现所需类型的返回对象.

public Picasso with(Context context)
{
    this.context = context;
    return this;
}

public X load(String url)
{
    this.url = url;
    return this;
}

public Y load(ImageView imageView)
{
    this.imageView = imageView;
    return this;
}

我试图用kotlin数据类做同样的事情,但遗憾的是我找不到一种方法来覆盖我可以返回该对象的新实例的setter方法.

当我尝试强制覆盖setter方法时,我收到编译器错误.

任何关于可以做什么的想法,以便我可以调用流畅的接口或至少改变setter如何工作可能是这样的

data class CorruptOfficeAccount(.....){
     override fun addCollectedFee(Long money) :CorruptOfficeAccount {
     this.money = money/5
    }
}

这样我就可以打电话了

CorrutOfficeAccount(....).method1().addCollectedFee(20000).method3()

我希望能够做到这样的事情:

$table_object->getRows()->where($wer)->or($or)->orderBy('field', 'DESC');

如果我确定每次都会按顺序调用所有方法,那么它就很简单了,我可以在每次方法调用时返回一个对象本身的实例,以便查询得到构建并最终在orderBy方法中执行.但是我希望类能够执行如下查询:

$table_object->getRows()->where($wer);

以下代码适用于第一个代码示例(即调用所有方法时),但不适用于第二个代码,其中只有方法在getRows之后调用.它只返回自身的一个实例.

class DatabaseTable extends Database
{ 
 protected $table_name;
 protected $query;

 public function getRows()
 {
  return ($this instanceof self)? $this : false;
 }

 public function where(array $where)
 {

  foreach ($where as $field => $value){
   $w[] = $field . ' = "' . $this->escapeString($value) . '"';
  }

  $this->query = "SELECT * FROM {$this->table_name} WHERE " . join($w, ' AND '));

  return $this;
 }

 public function or(array $Clause)
 {
  foreach ($clause as $field => $value){
   $o[] = $field …

类

public class ProductType
{
    public Guid ID { get; set }
    public string Name { get; set }
    public ICollection<ProductCategory> Categories { get; set }
}

public class ProductCategory
{
    public Guid ID { get; set }
    public string Name { get; set }
    public ProductType ProductType { get; set; }
}

组态

ProductTypeConfiguration

HasMany(p => p.Categories).WithRequired().WillCascadeOnDelete(false);

题

注意属性Categories和ProductType

关系是一个(ProductType)到很多(ProductCategory),但是,a ProductCategory与单个关联ProductType!

在我的数据库中它创建了两个FKS !! 如何配置(使用FluentAPI)这种情况？

谢谢!!!

我试图为传统的经典ASP应用程序带来一些理智,作为其中的一部分,我正在尝试为我创建的一些JScript类编写Fluent API.

例如 myClass().doSomething().doSomethingElse()

这里概述了这个概念(在VBScript中)

这是我的示例JScript类:

var myClass = function () {
    this.value = '';
}

myClass.prototype = function () {

    var doSomething = function (a) {
        this.value += a;
        return this;
    },

    doSomethingElse = function (a, b) {
        this.value += (a + b);
        return this;
    },

    print = function () {
        Response.Write('Result is: ' + this.value + "<br/>");
    }

    return {
        doSomething: doSomething,
        doSomethingElse: doSomethingElse,
        print: print
    }; …

在我将Castle升级到3.2.1后,我似乎无法找到FirstNonGenericCoreInterface的正确替代品

我的代码

container.Register(
    AllTypes
        .FromAssemblyNamed("MySolution.Tasks")
        .InNamespace("MySolution.Tasks")
        .WithService.FirstNonGenericCoreInterface("MySolution.Domain"));

该方法尚未过时,我找不到使用的方法

有谁知道我应该用什么呢？