我正在重写一个数据输入工具的应用程序.现有应用程序位于Access中,由包含多个网格的表单组成,每个网格包含许多列,要求用户水平滚动以查看列.

表格中的当前网格在父母与子女的关系中得到了很好的规划.顶部网格代表项目,下面的网格代表所选项目中的SKU,下面的网格代表上面所选SKU的季节数据(定价,运输信息等).

我正在寻找有关这种应用程序的良好UI设计原则的建议.如何设计一个表单,使用户可以灵活地查看表单上数据的所有列,而无需滚动太多？

商业应用的UI原则有哪些优秀的在线资源？

谢谢!

我最近一直在考虑Liskov替换原则以及它与我当前任务的关系.我有一个包含菜单的主表单; 在这个主要表单中,我将一个特定的表单作为MDI子对接.此特定表单可能包含也可能不包含菜单.如果是,我想将它与主菜单合并.所以情况是这样的:

public class MainForm
{
    public void Dock(SpecificBaseForm childForm)
    {
        this.Dock(childForm);
        if (childForm is IHaveMenu)
        {
            this.Menu.Merge(childForm as IHaveMenu).Menu;
        }
    }
 }

public interface IHaveMenu
{
   Menu Menu {get;}
}

public abstract class SpecificBaseForm{}

public class SpecificFormFoo : SpecificBaseForm {}

public class SpecificFormBar: SpecificBaseForm,IHaveMenu
{
    public Menu Menu{get {return this.Menu;}}
}

现在这两个孩子并不是"完全"可互换的:一个有菜单; 另一个没有.这是在C#中误用is/as contruct吗？如果这不正确,那么干净的解决方案是什么？

假设有两个.net项目不在同一解决方案下.ProjectA在solution1下,ProjectB在solution2下.ProjectA引用了ProjectB,ProjectB引用了ProjectA.ProjectA_Class和ProjectB_Class有两个类.ProjectA_Class创建ProjectB_Class的对象,ProjectB_Class创建ProjectA_Class的对象.

namespace ProjectB
{
    public class ProjectB_Class
    {
        public ProjectB_Class()
        {
            ProjectA_Class projA = new ProjectA_Class();
        }
    }
}

namespace ProjectA
{
    public class ProjectA_Class
    {
        public ProjectA_Class()
        {
            ProjectB_Class projB = new ProjectB_Class();
        }
    }
}

我对循环依赖感到困惑.是不是它在两个类之间创建了循环依赖,尽管它们不在同一个解决方案中？我们知道如果这两个项目都在同一个解决方案中,Visual Studio将不允许我们在ProjectB中引用ProjectA,在ProjectA中引用ProjectB,因为它创建了循环依赖.它是不是在两个项目之间创建循环依赖,尽管它们不在同一个解决方案中？假设,ProjectA中有一个C类,它创建了ProjectB_Class的对象,而ProjectB_Class不使用任何C类实例.它不是循环依赖项,因为ProjectA和ProjectB都有相互引用吗？

更新1 您能解释循环依赖的条件吗？

我有一个关于 Uncle Bob 的Clean Architecture 中的“用例输出端口”的问题 。

在图像中，鲍勃叔叔将端口描述为接口。我想知道是否有要这样或者如果调用的用例交互器还可以返回一个“简单”的价值。在任何一种情况下，应用程序和业务规则层都将定义接口适配器层必须使用的接口。所以我认为对于简单的调用，只返回一个值不会违反架构理念。

真的吗？

此外，我认为演示者实现的这个输出端口接口应该像观察者模式一样工作。演示者只是观察交互者的相关“事件”。在 .NET 事件是一等公民的情况下，我认为使用其中一个是相同的想法。

这些想法是否与 Clean Architecture 背后的想法兼容？

我正在阅读 Head First Design 模式并坚持好莱坞原则。早些时候我读到了控制反转，我理解的是，这是一个设计原则（有些人也称之为模式），通过它传统的程序流程从“高层模块调用低层模块”变为“低层模块调用高层模块” ”（通常通过抽象），因此我们可以对特定的低级模块具有非常低的依赖性，并且更改低级模块不会对我们的更高级别或接近业务模块产生任何影响。

但是当作者对好莱坞原则说了以下几句话时，我感到困惑：-

第 296 页

根据好莱坞原则，我们允许低级组件将自己挂接到系统中，但高级组件决定何时需要它们以及如何需要它们。换句话说，高级组件给了低级组件“不要打电话给我们，我们会打电话给你”的待遇。

在最后一行，据说高层组件给低层组件一个“不要打电话给我们，我们会打电话给你”的待遇。这意味着我们的高级组件实际上正在调用低级组件，因此这似乎打破了控制反转原则和依赖反转原则。

请澄清这一点。

这个简单工厂是否违反开放封闭原则？

每次需要创建新的具体产品时,SimpleProductFactory都需要更改,但它遵循单一责任原则,因为这是它永远改变的唯一原因.它的唯一目的是使客户不违反开放的封闭原则,所以我认为它本身不能违反,因为很明显这个代码是需要的.

我对更换工厂不感兴趣,但是这个具体的例子是否违规.

产品

interface Product{
  public int getPrice();
}

牛奶

class Milk implements Product{
  public int getPrice(){ return 5; }
}

芯片

class Chips implements Product{
  public int getPrice(){ return 3; }
}

SimpleProductFactory

class SimpleProductFactory{

  public Product createProduct(String productName){

    if(productName.equals("milk")){
      return new Milk();
    }
    else if(productName.equals("chips")){
      return new Chips();
    }
    return null;
  }
}

客户

class Client{
  public static void main(String[] args) {
    SimpleProductFactory productFactory = new SimpleProductFactory();
    Product prod = productFactory.createProduct("milk");
    System.out.println(prod.getPrice());

  }
}

寻找关于存储和转换已知值(即米到英尺)的一般设计模式原则.谷歌搜索没有运气,所以我必须遗漏一些东西.

假设在单个表中有多个具有各种UOM的字段,最佳做法是什么？目前许多领域都是隐含的,我们正在考虑对此进行标准化.我们希望让用户自由进入他们的UOM,而其他人则可以在他们喜欢的UOM中查看.

我应该存储"输入的值"并转换为一些常见的原语(用户输入的脚我转换为米并存储它)？我应该将此输入的脚值存储为审核备份吗？

我不是某个数据库表的唯一消费者,其他应用程序总是在知道值+ UOM与原始用户输入值的转换时更好.

对于我可能缺少的精确度是否存在严重的转换影响.米>英尺>米应该是足够可靠的业务线应用转换(转换可以是小数点后17位,但显示和输入值限制为2-4位小数)

任何其他的想法或链接指向我正确的方向,所以我不是重新发明一个已知问题的解决方案？

请注意,我没有设想一些运算符重载的大解决方案,但更多的是在普通的Joe Developer可以维护的实际应用程序中.

类似的还有这与正确的输入和输出类型涉及几个问题是这样.我的问题更多的是正确的做法,方法命名,选择参数类型,事故等维护中的唤醒IEnumerable.

Linq几乎所有地方都处理,IEnumerable而这不是它,但它也引入了一些我们称之为延迟执行的异类.现在,当我们认为最好的想法是采用最基本的类型时,我们可能在设计我们的方法(特别是扩展方法)时出错了.所以我们的方法看起来像:

public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> lstObject)
{
    foreach (T t in lstObject)
       //some fisher-yates may be
}

显而易见的危险是当我们将上述功能与懒惰混合Linq并且如此易受影响时.

var query = foos.Select(p => p).Where(p => p).OrderBy(p => p); //doesn't execute
//but
var query = foos.Select(p => p).Where(p => p).Shuffle().OrderBy(p => p);
//the second line executes up to a point.

这是一个很大的编辑:

澄清上面这一行 - 我的问题不是关于第二个表达没有得到评估,严重不是.程序员都知道.我担心的是Shuffle到目前为止实际执行查询的方法.查看第一个查询,其中没有任何内容被执行.现在类似于构造另一个Linq表达式(应该稍后执行)时,我们的自定义函数正在播放spoilsport.换句话说,如何让调用者知道Shuffle并不是他们在Linq表达点上想要的那种功能.我希望这一点被带回家.道歉!:)虽然它就像去检查方法一样简单,但我问你们通常如何防御性地编程......

上面的例子可能没那么危险,但你明白了.这是某些(自定义)函数与Linq延迟执行的想法不相符.问题不仅在于性能,还在于意外的副作用. …

显然YAGNI和KISS之间存在语法差异,但我看不出它们之间存在任何语义差异.它们真的本质上是一样的吗？

我是面向对象编程概念的新手(在java中),我经常遇到以下设计问题:

我经常创建具有实例变量的类,这些变量在初始化时是未知的.随着时间的推移填充这些变量.这不是一个真正的问题,因为这些变量在填充之前是空的,因此我的问题更多地是关于这种情况下的最佳实践.

让我用一个例子解释一下.我上课了Car.每Car有color,vMax,weight,horsepower等.

当初始化Car只是它color,weight并且horsepower是已知的.- >Car(color, weight, horsepower)

在vMax现在可以计算(比方说:weight/horsepower).令我困惑的是,Car在初始化之后,"不完整"意味着vMax只会随着时间的推移填充.

我觉得这很难看,当然汽车的例子很简单.我经常会有10多个属性的类,其中一些是随着时间的推移计算出来的,后者在代码中后来用于计算该对象的更多属性.然后变得很难知道哪些变量已经在某一点填充而哪些不是.

我只是想知道这是"正常"和OOP的工作方式,还是应该避免这种情况.如果是的话,我会很高兴看到一些设计提示.

迈克尔