标签: object-model

在功能样式中实现对象模型是否切实可行？

OOP似乎擅长的一个问题是描述对象模型.

例如,HTML DOM是一种复杂的,有状态的野兽,它直接与UI接口,需要动态语言的可编程性.OOP功能往往在很多方面都有用:

• 成员访问限制使得与不受信任的代码(例如javascript)的连接安全
• 访问器功能和属性使得绑定到UI更加方便
• 不必一直传递对象模型使方法更简单.

如果你通过MVVM投射模型,故事的UI方面可能有点没有实际意义,但你仍然在不断地与国内内部进行斗争.

我在这个项目的F#工作,所以我可以轻松地使用OOP,但我很好奇我能在多大程度上推动它变得不切实际.是否有设计模式或任何东西？

我读过关于这一主题的帖子计算器以及几篇文章,其中包括入门Ruby的方法查找,什么是Ruby的方法查找路径.另外,我查看了Ruby Metaprogramming 2中的对象模型章节,在几个聊天室中询问,并制作了这个reddit线程.没学习C,我已经尽我所能来解决这个问题.

如上面的资源所述,在接收对象(如fido_instance)上进行方法查找时,会检查这6个位置(按顺序):

1. 单身类的fido_instance
2. IClass(来自扩展模块)
3. IClass(来自前置模块)
4. 类
5. IClass(来自附带的模块)
6. 超类(如果在此处找不到方法,请重复步骤4-6)

显然,该图是不完整的,并且所有这些单例类可能都不是在现实世界中创建的.尽管如此,这6个步骤还有很多不足之处,并未涉及以下情况.如果在单例类之上没有扩展/前置IClass fido_instance,那么就没有解释第4步是否在单例类上执行fido_instance.我不得不假设,因为整个方法查找会短路.

如果我猜测一组可以解释ruby的方法查找行为的步骤,它可能看起来像:

1. 检查fido_instance.class方法.(显然,ruby不会使用自己的#class方法来进行方法查找,但它传达了进程的逻辑)
2. 检查fido_instance.class.superclass方法.继续添加.superclass并检查方法,直到没有剩余超类.(同样,ruby不会使用自己的#superclass方法)
3. 找不到方法.从步骤1开始,这次寻找#method_missing.

我还记得读过如果接收对象是一个类,有一个单独的方法查找过程,但我不记得在哪里.

那么什么是正确的,详细的解释,不涉及了解C？

基本上我需要分清以下两点:

var simple = 5 // or "word", or 56.78, or any other "simple" object
var complex = {propname: "propvalue", "otherprop": "othervalue"}

在设计我的api时,我正在考虑如何建模以下行为.

选项1似乎更合乎逻辑,但随之而来的是强制执行不变量,例如检查电子表格是否实际属于工作簿.

选项2看起来很奇怪,电子表格知道如何删除自己,但实际上电子表格有一个对其父工作簿的引用,并可以直接将调用委托给他.

或者这真的不是一个有效的案例,因为工作簿需要验证它的电子表格,不管是什么？想法？

Workbook wb = new Workbook("Finances");
Spreadsheet ss = wb.CreateSpreadsheet("Bob's");

// option 1:
wb.RemoveSheet(ss);

// option 2:
ss.RemoveFromWorkbook();

谢谢大家

• 我有一个模型创建某种对象(让我们说一个课程).
• 我从管理员前端添加新对象

当我创建一个对象时,我想自动创建一个具有特定名称的Auth组(不重要,但该组的名称必须与创建的对象字段相同).

可能吗？我已经阅读了有关管理员操作的内容,但没有找到任何明确的内容.

我收到这个JSON响应:

{
    "status": "Ok",
    "total": 105373,
    "result": [
        {
            "id": 668839,
            "cn": "A-12157-68812",
            "pD": "09-12-2012",
            "cCD": "06-05-2012",
            "cT": "PERM",
            "fN": "COMCAST CABLE COMMUNICATIONS, LLC",
            "s": "NJ",
            "cR": "Certified",
            "pT": "ENGINEER 3",
            "vC": 6,
            "cddt": "html"
        },
        {
            "id": 725695,
            "cn": "A-12361-25668",
            "pD": "05-28-2013",
            "cCD": "12-26-2012",
            "cT": "PERM",
            "fN": "L'ONVIE INC.",
            "s": "NY",
            "cR": "Certified",
            "pT": "Biochemist",
            "vC": 6,
            "cddt": "html"
        },
        {
            "id": 0,
            "cn": "A-11199-93239",
            "pD": "05-31-2012",
            "cCD": "07-18-2011",
            "cT": "PERM",
            "fN": "ROCKWELL AUTOMATION, INC.",
            "s": "PR",
            "cR": "Certified", …

假设我想Kernel用一个我想出的方法修补模块:

module Kernel
  def say_hello
    puts "hello world"
  end
end

我现在可以做到这一点:

Object.new.say_hello # => hello world

但我也可以做以下通常不应该做的事情:

Object.say_hello # => hello world

由于Object包含Kernel它的实例方法,因此所有Object实例都应该响应say_hello.到现在为止还挺好.

然而,Object.say_hello似乎是一种类方法,只有在我们做了类似的事情时才能证明:

class << Object
  def say_hello
    puts "hello world"
  end  
end

存储say_hello在Object单例类中将允许我们将它用作类方法,而Kernel只是包含在Object其中,不应该允许这种行为.但确实如此.有人知道为什么？

谢谢

考虑以下：

// Just a sequence of adjacent fields of same the type
#[repr(C)]
#[derive(Debug)]
struct S<T> {
    a : T,
    b : T,
    c : T,
    d : T,
}

impl<T : Sized> S<T> {
    fn new(a : T, b : T, c : T, d : T) -> Self {
        Self {
            a,
            b,
            c,
            d,
        }
    }
    // reinterpret it as an array
    fn as_slice(&self) -> &[T] {
        unsafe { std::slice::from_raw_parts(self as *const Self as *const T, 4) …

我想要查询的列表中有大约10000多行(Listitems).

我想迭代一个timerJob中的每个项目 - 但我不能一次采取所有这些:对象模型覆盖 - 否,ListView阈值 - 1000 - 在FARM级别,我不能改变它.

我有什么方法可以迭代10000+(像一批)？

在写下我一再努力理解红宝石的对象模型后,我现在感到困惑:以下是我的观察.

class Bird
  def speak
   puts "tweet tweet"
  end
end

>> Bird.class
=> Class
>> Class.class
=> Class
>> Class.superclass
=> Module
>> Module.class
=> Class
>> Module.superclass
=> Object
>> Object.class
=> Class
>> Object.superclass
=> nil
>> nil.class
=> NilClass
>> NilClass.class
=> Class
>> NilClass.superclass
=> Object 
and keeps going on ....

这里发生了什么 ？什么位于祖先的顶点nil或NilClass或Object或Class？Ruby的对象模型是如何组织的.

什么是类,什么是对象？是阶级还是对象？是对象还是类？

我有以下课程;

public class Hotel
{
   public int HotelId {get; set;}
   public string Name {get; set;}
   public string Address {get; set;}
   public string City{get; set;}
}

public class District
{
   public int DistrictId {get; set;}
   public string Name {get; set;}
}

然后我需要一个可以同时包含DistrictId和HotelId的类,所以我想创建一个类如下

public class HotelDistrict
{
   public int DistrictId {get; set;}
   public int HotelId {get; set;}
}

这是正确的方法吗？或者他们是更好的选择？

枚举通常用于定义类的特定属性的状态,比如在某种对象模型中.对于其中一些属性,状态'此属性未设置'是有效的.

在这些情况下,我应该使用零None枚举值,还是使属性类型可以为空？

public MyEnum Property { get; set; }

public enum MyEnum {
    None = 0,
    Value1,
    Value2
}

要么

public MyEnum? Property { get; set; }

public enum MyEnum {
    Value1,
    Value2
}

在Python中,文档__class__被描述为属性.在对象type(元类)中,__class__似乎是一种方法.

如果我们这样做:

>>> class Foo:
        pass

>>> a = Foo()
>>> a.__class__ == type.__class__(a)
True

所以,我的问题是:

1. 当我们打电话时a.__class__,我们真的在调用这个方法type.__class__(a)吗？
2. 这__class__是不是__dict__属性成员的原因a吗？