相关疑难解决方法(0)

为什么喜欢构图而不是继承呢？每种方法都有哪些权衡取舍？什么时候应该选择继承而不是作文？

使用实体框架4.1代码优先于模型/数据库优先使用EDMX图表有什么优缺点？

我正在尝试完全理解使用EF 4.1构建数据访问层的所有方法.我正在使用Repository模式和IoC.

我知道我可以使用代码优先方法:手动定义我的实体和上下文并用于ModelBuilder微调模式.

我还可以创建一个EDMX图表并选择一个代码生成步骤,该步骤使用T4模板生成相同的POCO类.

在这两种情况下,我最终POCO都得到了ORM不可知的对象和源自的上下文DbContext.

数据库优先似乎最吸引人,因为我可以在企业管理器中设计数据库,快速同步模型并使用设计器对其进行微调.

那么这两种方法有什么区别？是仅仅关于VS2010与企业管理器的偏好？

我正在阅读有关访客模式的内容,它看起来像Double Dispatch.两者之间有什么区别吗？这两个术语是否意思相同.

参考:http://www.vincehuston.org/dp/visitor.html

危险......危险史密斯博士......前面的哲学文章

这篇文章的目的是确定将验证逻辑放在我的域实体之外(实际上是聚合根)是否实际上给了我更大的灵活性或它是神风代码

基本上我想知道是否有更好的方法来验证我的域实体.这就是我计划这样做的方式,但我希望你的意见

我考虑的第一种方法是:

class Customer : EntityBase<Customer>
{
   public void ChangeEmail(string email)
   {
      if(string.IsNullOrWhitespace(email))   throw new DomainException(“...”);
      if(!email.IsEmail())  throw new DomainException();
      if(email.Contains(“@mailinator.com”))  throw new DomainException();
   }
}

我实际上不喜欢这种验证,因为即使我将验证逻辑封装在正确的实体中,这也违反了Open/Close原则(Open for extension但Close for modification)我发现违反这个原则,代码维护就变成了当应用程序在复杂性中成长时,真正的痛苦.为什么？因为域规则的变化比我们想要承认的更频繁,并且如果规则被隐藏并嵌入到这样的实体中,它们很难测试,难以阅读,难以维护但是我不喜欢这个的真正原因方法是:如果验证规则发生变化,我必须来编辑我的域实体.这是一个非常简单的例子,但在RL中验证可能更复杂

因此遵循Udi Dahan的哲学,明确角色,以及Eric Evans在蓝皮书中的推荐,接下来的尝试是实现规范模式,就像这样

class EmailDomainIsAllowedSpecification : IDomainSpecification<Customer>
{
   private INotAllowedEmailDomainsResolver invalidEmailDomainsResolver;
   public bool IsSatisfiedBy(Customer customer)
   {
      return !this.invalidEmailDomainsResolver.GetInvalidEmailDomains().Contains(customer.Email);
   }
}

但后来我才意识到,为了遵循这种方法,我必须首先改变我的实体,以便传递值为valdiated,在这种情况下是电子邮件,但是改变它们会导致我的域事件被触发,我不想直到新电子邮件有效为止

因此,在考虑了这些方法后,我推出了这个方法,因为我要实现CQRS架构:

class EmailDomainIsAllowedValidator : IDomainInvariantValidator<Customer, ChangeEmailCommand>
{
   public void IsValid(Customer entity, ChangeEmailCommand command)
   {
      if(!command.Email.HasValidDomain())  throw new DomainException(“...”);
   } …

我想知道在实施战略设计模式时使用委托与OOP的优缺点是什么？

你建议使用哪一种？或委托解决什么样的问题？如果OOP更好,我们为什么要使用OOP？

谢谢!

-tep

我终于忍受了Dependency Injection(早就应该); 我开始玩Unity并遇到战略模式的问题.我可以使用容器向我返回基于名称的策略的特定实现,但我没有看到我应该如何在上下文中获得正确的策略.
让我们举一个简单的例子说明:上下文是一辆汽车,它有一个IEngine(策略),有2个实现,FastEngine和SlowEngine.代码将沿着这些方向看:

public interface IEngine
{
    double MaxSpeed
    {
        get;
    }
}

internal class FastEngine:IEngine
{
    public double MaxSpeed
    {
        get 
        { 
            return 100d; 
        }
    }
}

internal class SlowEngine:IEngine
{
    public double MaxSpeed
    {
        get
        {
            return 10d;
        }
    }
}

public class Car
{
    private IEngine engine;
    public double MaximumSpeed
    {
        get
        {
            return this.engine.MaxSpeed;
        }
    }

    public Car(IEngine engine)
    {
        this.engine = engine;
    }
}

我的问题如下:我应该如何实例化快车或慢车？我可以使用容器为我提供每个实现,我可以设置一个"默认"实现来使用:

IUnityContainer container = new UnityContainer();
container.RegisterType<IEngine, FastEngine>();
container.RegisterType<IEngine, FastEngine>("Fast"); …

这是我到目前为止所拥有的:

namespace Strategy
{
    interface IWeaponBehavior
    {
        void UseWeapon();
    }
}

namespace Strategy
{
    class Knife : IWeaponBehavior
    {
        public void UseWeapon()
        {
            Console.WriteLine("You used the knife to slash the enemy! SLASH SLASH!");
        }
    }
}

namespace Strategy
{
    class Pan : IWeaponBehavior
    {
        public void UseWeapon()
        {
            Console.WriteLine("You use the pan! 100% Adamantium power! BONG!");
        }
    }
}

现在,如果我有一个Character.cs超类.该超类如何实现武器行为,以便子类可以更具体.

namespace Strategy
{
    class Character
    {
        public IWeaponBehavior weapon;

        public Character(IWeaponBehavior specificWeapon)
        {
            weapon = specificWeapon;
        }        
    }
}

namespace …

我已经看过并使用过很多基于JDBC的旧代码,这些代码通常都是以CRUD方法开始的.我的问题特别涉及检索方法或"发现者".通常我发现DAO开始时有两种方法:

• 找到并返回ALL
• 基于唯一标识符检索特定实例

通常情况下,这两个发现者是不够的.我通常最终会看到一个DAO类被反复修改以添加如下所示的finder方法:

• 找到并返回所有{condition}

当需要支持新的{conditions}或修改现有方法以添加新参数作为标志来修改方法内的SQL查询以支持其他条件时,会发生更多方法.

这是一种丑陋的方法,违反了开放封闭原则.每当需要支持一些新的检索条件时,看到DAO类不断修改,这一直是我的一个难得.对这个问题的研究经常指向Repository Pattern和封装条件,以便将其作为规范或查询对象进行检索,然后将它们传递给finder方法.但是,如果你有一个整个数据集的内存集合,或者你正在使用某种ORM(我正在使用旧的JDBC代码),这似乎是可行的.

我已经考虑过延迟加载整个数据集的解决方案,DAO作为内存中的集合进行管理,然后使用规范模式作为检索查询.然后我在集合上实现某种观察器,它只是在调用创建,更新或删除方法时更新数据库.但显然性能和可扩展性受到严重影响.

有什么想法吗？

感谢您到目前为止的回复.我有一个想法 - 您对使用命令/策略模式封装数据访问请求有何看法？每个单独的Concrete Command都可以表示特定类型的访问,并且可以传递给Invoker.我最终得到了许多具体的Command Command类,但是每一个都只关注一种访问,应该是非常可测试和隔离的.

    public abstract class Command<R>{
       public <R> execute();
       public void setArguments(CommandArguments args){
          //store arguments  
       }
    }

    //map based structure for storing and returning arguments
    public class CommandArguments{
         public String getAsString(String key);
         public String getAsInt(String key);
         //... others
    }

    //In some business class...
    Command command = CommandFactory.create("SearchByName");
    CommandArguments args = new CommandArguments();
    args.setValue("name", name);
    // others
    command.setArguments(args);
    List<Customer> list  = command.execute();

虽然我在OOAD有一些经验,但我是SOA的新手.

SOA设计的一个指导原则是"仅使用抽象类进行建模".从设计中忽略它们.抽象的使用可以有助于建模(分析阶段).

在分析阶段,我想出了一个BankAccount基类.从中派生的专业类是"FixedAccount"和"SavingsAccount".我需要创建一个服务,返回用户的所有帐户(帐户列表).应满足要求的服务结构应该是什么？

注意:如果您可以使用WCF提供代码演示,那将会很棒.

访问者模式允许在不扩展对象类的情况下编写对象上的操作.当然.但是为什么不编写一个从外部操作我的对象集合的全局函数或静态类呢？基本上,在像java这样的语言中,accept()出于技术原因需要一种方法; 但是在一种我可以在没有accept()方法的情况下实现相同设计的语言中,访问者模式是否变得微不足道？

说明:在访问者模式中,可访问的类(实体)有一个方法,.accept()其作用是自己调用访问者的.visit()方法.我可以看到java示例的逻辑:访问者.visit(n)为n它支持的每个可访问类型定义了一个不同的方法,并且.accept()必须使用技巧在运行时选择它们.但是像python或php这样的语言有动态类型,没有方法重载.如果我是访问者,我可以在.serialize()不知道实体的类型甚至方法的完整签名的情况下调用实体方法(例如).(那是"双重调度"问题,对吧？)

我知道一种接受方法可以将受保护的数据传递给访问者,但有什么意义呢？如果数据暴露给访问者类,它实际上是类接口的一部分,因为它的详细信息在类之外很重要.无论如何,暴露私人数据从来没有让我感到是访客模式的重点.

所以似乎在python,ruby或php中我可以在访问对象中没有accept方法(并且没有反射)的情况下实现类似访问者的类,对吧？如果我可以使用一系列异构对象并在没有"访问"类的任何合作的情况下调用他们的公共方法,那么这仍然应该被称为"访问者模式"吗？是否存在一些我缺失的模式的本质,或者它只是归结为"编写一个从外部操作对象来执行操作的新类"？

PS.我已经看过很多关于SO和其他地方的讨论,但找不到任何解决这个问题的东西.指针欢迎.