标签: self-reference

如何从该模块中获取对模块的引用？另外,如何获得包含该模块的包的引用？

在RI中发现自己做了很多这样的事情:

adataframe[adataframe$col==something]<-adataframe[adataframe$col==something)]+1

这种方式有点冗长乏味.有没有办法让我
引用我想要改变的对象,比如

adataframe[adataframe$col==something]<-$self+1 

？

我阅读了很多程序员的帖子,这些帖子遇​​到了Unable,以确定依赖操作的有效排序.在实体框架中使用自引用关系时,由于外键约束,模型要求或存储生成的值 -例外,可能存在依赖关系.

我正在努力建立一个亲子关系:

public class Category {
    public int CategoryId { get; set; }
    public string Name { get; set; }
    public int ParentId { get; set; }
    public Category Parent { get; set; }
    public List<Category> Children { get; set; }
}

这是我使用的配置(Fluent API):

Property(c => c.ParentId).IsOptional();
HasMany(c => c.Children).WithOptional(c => c.Parent).HasForeignKey(c => c.ParentId);
//HasOptional(c => c.Parent).WithMany(c => c.Children).HasForeignKey(c => c.ParentId);

当我尝试保存这样的新类别时,HasMany()和HasOptional()配置都会导致"无法确定依赖操作的有效排序..."异常:

context.Categories.Add(new Category { Name = "test" });

我不明白为什么EF不插入带有null parentId的Category.数据库允许ParentId外键为null.

你能告诉我怎么做吗？

我正在尝试使用SQLAlchemy上的声明来实现自引用的多对多关系.

这种关系代表两个用户之间的友谊.在线我发现(在文档和谷歌中)如何建立一个自我参照的m2m关系,在某种程度上角色是有区别的.这意味着在这个m2m关系中,UserA例如是UserB的老板,所以他将他列为"下属"属性或者你有什么.同样,UserB在'上级'下列出UserA.

这没有问题,因为我们可以用这种方式声明一个backref到同一个表:

subordinates = relationship('User', backref='superiors')

当然,那里的'上级'属性在课堂上并不明确.

无论如何,这是我的问题:如果我想反馈到我正在调用backref的相同属性怎么办？像这样:

friends = relationship('User',
                       secondary=friendship, #this is the table that breaks the m2m
                       primaryjoin=id==friendship.c.friend_a_id,
                       secondaryjoin=id==friendship.c.friend_b_id
                       backref=??????
                       )

这是有道理的,因为如果A和B交朋友关系角色是相同的,如果我调用B的朋友,我应该得到一个包含A的列表.这是完整的问题代码:

friendship = Table(
    'friendships', Base.metadata,
    Column('friend_a_id', Integer, ForeignKey('users.id'), primary_key=True),
    Column('friend_b_id', Integer, ForeignKey('users.id'), primary_key=True)
)

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)

    friends = relationship('User',
                           secondary=friendship,
                           primaryjoin=id==friendship.c.friend_a_id,
                           secondaryjoin=id==friendship.c.friend_b_id,
                           #HELP NEEDED HERE
                           )

对不起,如果这是太多的文字,我只想尽可能明确地用这个.我似乎无法在网上找到任何参考资料.

如前所述这里,功能包,以及在类的静态方法,还是需要使用packagename.functionname的语法或import packagename.*对每个功能(因为进口功能的工作空间的一部分,而不是全球).这意味着稍后更改包/类名可能会成为一个繁琐的麻烦.

有没有办法做类似的事情import this.*,即一个包/类名不可知的方法来访问同一个包/类中的所有函数/静态方法？

我想在RoR应用程序中自我介绍模型,但我不确切知道如何.我想保存链接列表,其中下一个节点具有前一个节点的id.我该怎么做这种导轨方式？这是一对一的关系.

在Excel中的工作表函数中,如何自引用您所在的单元格,列或行？

请注意,这对条件格式非常有用.

如果我定义一个函数:

def f(x):
    return x+3

我以后可以将对象存储为函数的属性,如下所示:

f.thing="hello!"

我想从函数本身的代码中做到这一点.问题是,如何从内部获取对函数的引用？

我遇到了我正在制作的程序中的接口问题.我想创建一个接口,它的一个方法接收/返回对自己对象类型的引用.它是这样的:

public interface I {
    ? getSelf();
}

public class A implements I {
    A getSelf() {
        return this;
    }
}

public class B implements I {
    B getSelf() {
        return this;
    }
}

我不能使用"I",它是"？",因为我不想返回对接口的引用,而是类.我搜索并发现Java中没有办法"自我引用",所以我不能只用"？"来代替它.在"自"关键字的示例中或类似的东西.实际上,我找到了一个类似的解决方案

public interface I<SELF> {
    SELF getSelf();
}

public class A implements I<A> {
    A getSelf() {
        return this;
    }
}

public class B implements I<B> {
    B getSelf() {
        return this;
    }
}

但它看起来似乎是一种解决方法或类似的东西.还有另一种方法吗？

我经常通过向它添加自引用("反身")类型参数约束来使一个简单的界面变得更加复杂.例如,我可能会这样:

interface ICloneable
{
    ICloneable Clone();
}

class Sheep : ICloneable
{
    ICloneable Clone() { … }
} //^^^^^^^^^^

Sheep dolly = new Sheep().Clone() as Sheep;
                                //^^^^^^^^

成:

interface ICloneable<TImpl> where TImpl : ICloneable<TImpl>
{
    TImpl Clone();
}

class Sheep : ICloneable<Sheep>
{
    Sheep Clone() { … }
} //^^^^^

Sheep dolly = new Sheep().Clone();

主要优点:实现类型(例如Sheep)现在可以引用自身而不是其基类型,从而减少了对类型转换的需求(如最后一行代码所示).

虽然这非常好,但我也注意到这些类型参数约束并不直观,并且在更复杂的场景中变得非常难以理解.^*)

问题:有没有人知道另一种C#代码模式可以实现相同的效果或类似的东西,但是更容易掌握？

_{*)此代码模式可能不直观且难以理解,例如以下方式:}

• _{声明X<T> where T : X<T>似乎是递归的,人们可能想知道为什么编译器不会陷入无限循环,推理,"如果T是X<T>,那么X<T>实际上是一个 …}