如何将二叉树存储为实体框架对象的属性（代码优先）

Question

To preface, I am using Entity Framework 6 with a code first approach.

I created a simple binary tree node class for storing a series of 'rules'. I want to store the tree as an object in the database but still be able to access it directly as a property of the object it belongs to.

The problem is I encounter this error when trying to create the tree as a property of the object:

A circular ComplexType hierarchy was detected. Self-referencing ComplexTypes are not supported.

Here is the definition for the table I want to store the tree in:

    <Table("Logic", Schema:="dbo")> _
Public Class Logic
    <Key>
    Public Property ID As Integer
    Public Property Expression As String
    Public Property Tree As LanguageTest5.Survey.BinaryExpressionNode
End Class

And this is the definition of the Tree:

    <Serializable, ComplexType>
Public Class BinaryExpressionNode
    Public Property Value As Object
    Public Property LeftNode As BinaryExpressionNode
    Public Property RightNode As BinaryExpressionNode

    Public Sub New(Val As Object)
        Value = Val
    End Sub
End Class

Is there another way I can have Tree as an accessible property of Logic without having to manually serialize/deserialize it?

UPDATE: Since I wasn't able to avoid serialization, I decided to just store the tree in the database as a string using postfix notation: "1 2 or 3 4 or and" From there it is pretty simple to build up the tree.

The accepted answer works nicely, provided you are familiar with serialization. In my particular case the serialization was too complex and I didn't want to take the time to sort it out.

I did put the suggestion to the test with some simpler objects and it worked without issue.

Answer 1

One approach is to make two properties on the Logic class as follows : 1. Store the tree as serialized string in a database property in order to avoid the storage problems - store the whole tree as one object in the database. 2. Make non-database property through which you access the deserialized tree and its nodes.

I suppose that you are going to traverse the tree in code after it is extracted from the database.

UPDATE Here is an example of a non database property. This is a real example. Do not count in that this is an abstract class. It is the same if it was not. The [NotMapped] attribute gets the job done. Here is a complete reference to Entity Framework Data Annotations where you can find the attribute. :

public abstract class Document : Entity
    {
        [Required]
        [StringLength(50)]
        public virtual string Egn { get; set; }

        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public virtual Guid Guid { get; set; }

        public virtual string Subject { get; set; }

        [NotMapped]
        public abstract EntityDataAccessKeyType EntityDataAccessKeyType { get; }
        [NotMapped]
        public abstract int EntityDataAccessKeyId { get; }
    }

In the getter of the non database property you can implement the deserialization and return the object rather then a string. You can implement the serialization in the setter. This way you will "abstract away" the process of serialization-deserialization inside the non database property and you will continue to work with objects.

Do not fear of performance hit unless your trees are "humongous". You can always make a unit test in which you can test the count "barrier" after which the object gets too heavy.

For the serialization-deserialization you can use Json.NET .