标签: object-equality

>>> import sys
>>> sys.version
'2.7.3 (default, Mar 13 2014, 11:03:55) \n[GCC 4.7.2]'
>>> import os
>>> os.remove is os.unlink
False
>>> os.remove == os.unlink
True

这是为什么？是不是os.unlink应该是os.remove的别名？

基本上,我想知道在这种情况下我是否应该听ReSharper ......

你会发现,与字符相比,应该使用Char.Equals(char),因为它避免了拆箱,但Resharper建议使用Object.Equals(obj).也许我在这里遗漏了什么？

private const DEFAULT_CHAR = '#';

// DependencyProperty backing
public Char SpecialChar
{
    get { return (Char)GetValue(SpecialCharProperty); }
}

// ReSharper - Access to a static member of a type via a derived type.
if (Char.Equals(control.SpecialChar, DEFAULT_CHAR)) { ... }

我猜是因为有DependencyProperty支持？

这是一个谜:

我调用setPrimitiveValue:forKey:上NSManagedObject.关键是对象的合法,持久,建模属性.但是,setPrimitiveValue:forKey:失败,通常为不同的任意属性设置值.文档说在调用setPrimitiveValue:forKey:未建模的密钥时会出现这种行为.所以似乎Core Data认为密钥是未建模的.

奇怪的部分:

当密钥被硬编码为字符串文字时,原始值确实成功设置.它只在键是变量时失败.我正在使用的变量恰好从keyPath参数传递observeValueForKeyPath:ofObject:change:context:

该keyPath变量与字符串文字相同.isEqual:返回true并且哈希值相等.的keyPath变量的类型的__NSCFString.有谁知道为什么setPrimitiveValue:forKey:会有不同的表现？(此行为在OS X 10.9.1上)

更新信息更新:

行为不当的密钥追溯到从磁盘上的文件加载的字符串.以下示例是一个孤立的案例.如果将属性字符串"mainAttr"写入磁盘并重新读入,则setPrimitiveValue:forKey:设置错误属性的值,而不是"mainAttr".

核心数据对象:

@interface Boo : NSManagedObject
@property (nonatomic, retain) NSNumber * mainAttr;
@property (nonatomic, retain) NSNumber * attr1;
@property (nonatomic, retain) NSNumber * attr2;
@property (nonatomic, retain) NSNumber * attr3;
@end

-

#import "Boo.h"

int main(int argc, const char * argv[]) {
    @autoreleasepool {
            NSManagedObjectContext *context = managedObjectContext(); …

为方便起见,我编写了一个简单的toJSON原型,用于处理我知道安全的JSON:

String.prototype.toJSON = function () {
    return JSON.parse(this.valueOf());
};

我在测试我的网络服务时使用它.不幸的是,即使这个简单的测试

var v0 = '{"echo":"hello_world"}'.toJSON(), v1 = {"echo": "hello_world"};

它失败:

console.log(v0 == v1);            // false
console.log(v0 === v1);           // false
console.log(v0.echo == v1.echo);  // true
console.log(v0.echo === v1.echo); // true

我不知道导致这个问题的JavaScript是什么？

我想知道CLR类型是否会返回以下不同的结果:

Object.Equals(objA, objB)

objA.Equals(objB)

(objA == objB)

我确实意识到在CLR之外有人可以轻松地实现IEqualtableEquals并且不正确地重载==运算符.我不关心那些不正当地实施这些的人.我所关注的是类(包括String,Int32等)以不同的方式实现这3个.

此外,如果可能的话,哪一个应该是用于整体比较的(全面).我想知道这是因为我遇到了一个文件,它使用Object.Equals(objA, objB)了整个视图模型而不是其他两个.

private string _name;
public string Name
{
    get { return _name; }
    set
    {
        if (Equals(_name, value)) return;
        ...
    }
}

private int _id;
public int Id
{
    get { return _id; }
    set
    {
        if (Equals(_id, value)) return;
        ...
    }
}

private Object _obj;
public Object TheObject
{
    get { return _obj; }
    set
    {
        if (Equals(_obj, value)) return;
        ...
    }
}

我有和collection.Counter类的实例,我也有一些对象,如:

p1 = Person(name='John')
p2 = Person(name='John')
p3 = Person(name='Jane')

我想在Counter的一个实例中保存此person对象的计数,考虑到具有相同名称的person对象必须增加相同的人数,所以如果我有一个包含所有person对象的列表:

people = [p1, p2, p3]

我用它填充我的柜台:

c = Counter(people)

我想得到以下内容:

c[p1] #prints 2
c[p2] #prints 2
c[p3] #prints 1

我的第一次尝试是__eq__为person对象实现一个新方法

def __eq__(self, other):
  return self.name == other.name

我认为这可以工作,因为计数器对象似乎基于关键对象的相等性增加了键的计数,如:

c = Counter(['A', 'A', 'B'])
c['A'] #prints 2
c['B'] #prints 1

另一个尝试可以从Counter继承并覆盖Counter用于测量对象之间相等性的基础方法,我不确定但我认为Counter使用__contains__方法.

我的问题是,如果有任何方法可以在不使用继承的情况下获得此行为,如果没有,那么最好的方法是什么呢？

我想检查两个实体之间的相等性及其one-to-many内部的关系。

显然我重写了该Object.Equals方法，但随后我收到了CS0659编译器警告：'class' overrides Object.Equals(object o) but does not override Object.GetHashCode()。

我覆盖了Object.GetHashCode，但是 Resharper 告诉我，该GetHashCode方法应该为所有对象生命周期返回相同的结果，并将在可变对象中使用。（文档）

public class Computer
{
    public long Id { get; set; }
    public ICollection<GPU> GPUs { get; set; } = new List<GPU>();

    public override bool Equals(object obj)
    {
        return obj is Computer computer &&
               GPUs.All(computer.GPUs.Contains);
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(GPUs);
    }
}

public class GPU
{
    public long Id { get; …