标签: circular-reference

我有一个看起来像这样的树结构：

interface TreeData {
  id : number;
  text : string;
  children : TreeData[];
}

我想将其包装到一个不可变的映射中，但由于我使用的是 TypeScript，所以我希望使用 get 和 set 具有一些类型安全性。我在网上找到了 2 篇文章，了解如何做到这一点的建议，请参阅：

https://github.com/facebook/immutable-js/issues/683 https://blog.mayflower.de/6630-typescript-redux-immutablejs.html

然而我的问题是我的 TreeData 包含 TreeData 子级的列表。如果我这样定义 ImmutableMap：

export interface ImmutableMap<T, K, V> extends Map<K, V> {
  get<I extends keyof T>( key : I & K ) : T[I] & V;
  set<S extends keyof T>( key : S & K, value : T[S] & V ) : Map<K, V>;
}

然后，当我尝试定义以下内容时，我收到一条打字稿错误消息：

type ImmutableTreeData = ImmutableMap<TreeData, string, string | …

所以，我在一个文件中有这两个数据类：

@dataclass
class A:
    children: List[B]

@dataclass
class B:
    parent: A

，这可以通过使用该__future__.annotations功能来实现。

然后我有另外两个文件，每个文件都有一堆对于我的项目来说是静态的每种类型的对象。

文件objects_A：

import objects_B

obj_a1 = A(
    children=[
        objects_B.obj_b1,
        objects_B.obj_b2
    ]
)

文件objects_B：

import objects_A

obj_b1 = B(
    parent=objects_A.obj_a1
)

obj_b2 = B(
    parent=objects_A.obj_a1
)

显然，文件之间存在循环依赖问题，但即使它们位于同一个文件中，它也不起作用，因为一种类型的变量依赖于另一种类型的变量才能成功。
初始化B内部对象obj_a1也不起作用，因为self这里没有概念。

目前，我设置parent为None（针对类型提示），然后循环进行设置obj_a1：

for obj_b in obj_a1.children:
    obj_b.parent = obj_a1

大家有什么好主意吗？
不知道它是否有帮助，但是这些对象是静态的（它们在这些声明之后不会改变）并且它们具有某种父子关系（正如您肯定已经注意到的那样）。
如果可能的话，我希望将每种类型的变量放在不同的文件中。

main.swift在 Xcode Version 13.3 (13E113) 中创建一个全新的 macOS Command Line Tool 项目，并用以下代码替换内容：

import Foundation

enum StructA {
    // case case1(value: StructB)
    case case2(expr: StructB)
}

indirect enum StructB {
    case case3
    case case4(expr: StructB)
}

导致以下编译时错误：

<unknown>:0: error: circular reference
/Users/alextj/projects/TestProject/main.swift:8:15: note: through reference here
indirect enum StructB {
              ^
<unknown>:0: note: through reference here

但是，如果取消case1注释该行，则循环引用错误就会消失！

所以下面的代码编译没有错误：

<unknown>:0: error: circular reference
/Users/alextj/projects/TestProject/main.swift:8:15: note: through reference here
indirect enum StructB {
              ^
<unknown>:0: note: through reference here

为什么？ …

如果我使用类似于下面代码的节点树结构,我是否需要担心循环引用？
我已经读过PHP使用内存分配机制,当涉及循环引用时,它可以使垃圾收集器的生活变得非常困难.

我想知道的是:

• 如果我的树只包含几个节点,比如25,这是一个问题吗？
• 是在脚本结束时释放内存还是我慢慢为服务器创建问题？
• 在什么情况下这个问题会在脚本执行期间产生影响？
• 将手动销毁引用解决问题,我应该总是这样做吗？

class Node {
    private $parent;
    private $children;

    function addChild( Node $child ) {
        $this->children[] = $child;
        $child->setParent( $this );
    }

    function setParent( $parent ) {
        $this->parent = $parent;
    }
}

//eg
$node0 = new Node;
$node1 = new Node;

// nodes 1 and 2 have a circular reference to each other
$node0->addChild( $node1 );

我正在编写一些C#代码,递归地遍历基本程序集的引用程序集,构建这些引用的有向非循环图以进行拓扑排序.我是通过Assembly类上的GetReferencedAssemblies()方法完成的.

在测试代​​码时,我发现 - 令我惊讶的是 - .NET框架中的某些程序集显然将自己列为程序集引用.一个这样的例子是System.Transactions,Version = 2.0.0.0,Culture = neutral,PublicKeyToken = b77a5c561934e089,它列出了System.Transactions,Version = 2.0.0.0,Culture = neutral,PublicKeyToken = b77a5c561934e089作为参考,可以在Reflector中验证.

一旦我意识到这一点,通过比较AssemblyNames打破无限递归是微不足道的,但我很好奇这种情况,因为我自己无法生成自递归程序集.(我可以谷歌没有关于此的信息,并添加自己作为参考不会使得到的程序集自我递归.)

简而言之:自我递归汇编引用真的是"犹太教" - 一些系统程序集引用自身的理由是什么？

谢谢.

我正在研究一个wcf项目.我的一些服务返回包含循环引用的对象.通过在DataContract属性上将IsReference设置为true来处理这些对象的序列化,因此如果我编写代码来调用这些服务,一切正常.但是对于简单的测试,我似乎更喜欢使用GUI界面WcfTestClient.exe,结果证明WcfTestClient无法显示循环引用的对象.

我知道如果没有处理任何特殊内容,尝试显示包含彼此引用的对象将导致无限递归.我只是想知道这是否意味着通过WcfTestClient测试返回循环引用对象的服务是不可能的？谢谢.

我知道循环引用(类a包含类b,类b包含类a).但由于我编程不够,我很难找到使用它们的理由.我想知道人们是否可以给我一些很好的例子,并可能解释使用它们的充分理由.

例如,现在我正在查看2D源代码教程,并且用户创建了一个相互引用的Creature和CreatureAi类.是什么原因？我还不知道,这就是为什么我在寻找示例并仍然在阅读.

我知道这必须是一个n00b问题,但我必须实现一个模型客户端 - 服务器顺序交互应用程序,并且因为客户端 - 服务器调用的数量不同,我不能只是迭代外部函数中的步骤,总是从中获取数据客户端,然后将其转发到服务器,反之亦然,所以我需要让我Server和我们Client相互了解,以便他们可以在自己之间调用他们的公共方法.一种方法是将两者都设计为单身,但我希望以更简单的方式进行,更准确地说使用循环引用:客户端存储对服务器的引用,服务器存储对客户端的引用.我知道这可能不是一个好方法,并且当它变得太深时它可能导致调用堆栈爆炸,因此欢迎对我的设计进行任何改进.

为了实现所描述的实现,我认为我可以使用std::shared_ptr,因为std::unique_ptr当我调用两个setter时,如果我还想阻止main中的两个变量被破坏,那么它将无法工作(对吗？).所以,这就是我所拥有的(简化代码):

#include <iostream>
#include <memory>

class Server;

class Client
{
public:
    void SetServer (const Server &server);
private:
    std::shared_ptr<const Server> server;
};

void Client::SetServer (const Server &server)
{
    this->server = std::shared_ptr<const Server>(&server);
}

class Server
{
public:
    void SetClient (const Client &client);
private:
    std::shared_ptr<const Client> client;
};

void Server::SetClient (const Client &client)
{
    this->client = std::shared_ptr<const Client>(&client);
}

int main ()
{
    Server server;
    Client client; …

我有点困惑.我无法找出PreserveReferences和之间的区别MaxDepth.

假设我们有以下DTO和模型.

public class PersonEntity
{
    public PersonEntity InnerPerson { get; set; }
}

public class PersonModel
{
    public PersonModel InnerPerson { get; set; }
}

如文档中所述:

以前,AutoMapper可以通过跟踪映射的内容来处理循环引用,并在每个映射上检查源/目标对象的本地哈希表,以查看该项是否已映射.事实证明,这种跟踪非常昂贵,您需要使用PreserveReferences选择使用圆形地图才能工作.或者,您可以配置MaxDepth.

我的映射:

cfg.CreateMap<PersonModel, PersonEntity>().MaxDepth(1);
cfg.CreateMap<PersonEntity, PersonModel>();

程序:

var personModel = new PersonModel();
personModel.InnerPerson = personModel;
var entity = Mapper.Map<PersonEntity>(personModel);

这就是我期望得到的:

这就是我实际得到的:

我可以使用它们(PreserveReferences和MaxDepth)来解析循环引用,但我没有看到区别.什么时候我应该在MaxDepth方法中使用不同的深度？那么,有人能提供吗？提前致谢.

如何创建带循环引用的枚举类？

简单的例子(取自这个Java问题):

enum class Hand(val beats: Hand) {
    ROCK(SCISSORS), // Enum entry 'SCISSORS' is uninitialized here
    PAPER(ROCK),
    SCISSORS(PAPER);
}