C# 检索包含所有子元素（和子元素）的对象

我想检索一个

对象

，它本身有一些属于

对象

类型的属性。这些子对象再次包含一些

对象

作为属性

如果我试图从数据库中检索数据，我会得到第一级的子级结果，但是后续级的数据是

null

。在下面的示例中，

窗口

为

null

。从其他属性中，我按预期返回数据。如果我查看数据库，这种关系似乎是正确的。只有数据读取有故障

关系

汽车

门

窗口

public class Window
{
    [PrimaryKey, AutoIncrement]
    public int Id { get; set; }

    public bool Automatic { get; set; }
}

范例

public MainPage()
{
    InitializeComponent();

    Window window = new Window();
    window.Automatic = true;

    Door door = new Door();
    door.Side = "left";
    door.Window = window;

    Car car = new Car();
    car.Color = "red";
    car.Model = "MX5";
    car.Door = door;

    this.car = car;

}

protected override async void OnAppearing()
{
    base.OnAppearing();

    await App.Database.StoreCarAsync(this.car);
    Car existingCar = await App.Database.GetCarAsync(this.car.Id);
    System.Diagnostics.Debug.WriteLine("finished");
}

数据库

public class Database
{
    private readonly SQLiteAsyncConnection database;

    public Database(string databasePath)
    {
        this.database = new SQLiteAsyncConnection(databasePath);
        this.database.CreateTableAsync<Car>().Wait();
        this.database.CreateTableAsync<Door>().Wait();
        this.database.CreateTableAsync<Window>().Wait();
    }

    public async Task<Car> GetCarAsync(int carId)
    {
        var queryResult = await this.database.Table<Car>().Where(c => c.Id == carId).CountAsync();
        if (queryResult > 0)
        {
            return await this.database.GetWithChildrenAsync<Car>(carId);
        }
        else
        {
            return null;
        }
    }

    public async Task<Door> GetDoorAsync(int doorId)
    {
        var queryResult = await this.database.Table<Door>().Where(d => d.Id == doorId).CountAsync();
        if (queryResult > 0)
        {
            return await this.database.GetWithChildrenAsync<Door>(doorId);
        }
        else
        {
            return null;
        }
    }

    public async Task<Window> GetWindowAsync(int windowId)
    {
        var queryResult = await this.database.Table<Window>().Where(w => w.Id == windowId).CountAsync();
        if (queryResult > 0)
        {
            return await this.database.GetWithChildrenAsync<Window>(windowId);
        }
        else
        {
            return null;
        }
    }

    public async Task StoreCarAsync(Car car)
    {
        await this.StoreDoorAsync(car.Door);

        var foundItem = await this.GetCarAsync(car.Id);
        if (foundItem != null)
        {
            await this.database.UpdateWithChildrenAsync(car);
        }
        else
        {
            await this.database.InsertWithChildrenAsync(car);
        }
    }

    public async Task StoreDoorAsync(Door door)
    {
        await this.StoreWindowAsync(door.Window);

        var foundItem = await this.GetDoorAsync(door.Id);
        if (foundItem != null)
        {
            await this.database.UpdateWithChildrenAsync(door);
        }
        else
        {
            await this.database.InsertWithChildrenAsync(door);
        }
    }

    public async Task<int> StoreWindowAsync(Window window)
    {
        var foundItem = await this.GetWindowAsync(window.Id);
        if (foundItem != null)
        {
            return await this.database.UpdateAsync(window);
        }
        else
        {
            return await this.database.InsertAsync(window);
        }
    }
}

公共类数据库
{
专用只读SQLiteAsyncConnection数据库；
公共数据库（字符串数据库路径）
{
this.database=新的SQLiteAsyncConnection（databasePath）；
this.database.CreateTableAsync（）.Wait（）；
this.database.CreateTableAsync（）.Wait（）；
this.database.CreateTableAsync（）.Wait（）；
}
公共异步任务GetCarAsync（int carId）
{
var queryResult=wait this.database.Table（）。其中（c=>c.Id==carId.CountAsync（）；
如果（查询结果>0）
{
返回等待此.database.GetWithChildrenAsync（carId）；
}
其他的
{
返回null；
}
}
公共异步任务GetDoorAsync（int doorId）
{
var queryResult=wait this.database.Table（）。其中（d=>d.Id==doorId.CountAsync（）；
如果（查询结果>0）
{
return wait this.database.GetWithChildrenAsync（doorId）；
}
其他的
{
返回null；
}
}
公共异步任务GetWindowAsync（int windowId）
{
var queryResult=wait this.database.Table（）。其中（w=>w.Id==windowId.CountAsync（）；
如果（查询结果>0）
{
return wait this.database.GetWithChildrenAsync（windowId）；
}
其他的
{
返回null；
}
}
公共异步任务StoreCarAsync（汽车）
{
等待这个.StoreDoorAsync（car.Door）；
var foundItem=wait this.GetCarAsync（car.Id）；
if（foundItem！=null）
{
等待这个.database.UpdateWithChildrenAsync（car）；
}
其他的
{
等待这个.database.InsertWithChildrenAsync（car）；
}
}
公共异步任务StoreDoorAsync（门）
{
等待这个.StoreWindowAsync（door.Window）；
var foundItem=wait this.GetDoorAsync（door.Id）；
if（foundItem！=null）
{
等待这个.database.UpdateWithChildrenAsync（door）；
}
其他的
{
等待这个.database.InsertWithChildrenAsync（door）；
}
}
公共异步任务StoreWindowAsync（窗口窗口）
{
var foundItem=wait this.GetWindowAsync（window.Id）；
if（foundItem！=null）
{
返回等待this.database.UpdateAsync（窗口）；
}
其他的
{
返回等待this.database.InsertAsync（窗口）；
}
}
}

这不可能吗？或者我做错了什么

PS：我正在使用最新的

SQLiteNetExtensions.Async v2.0.0-alpha2

NuGet包。

您应该使用它来阅读完整的关系层次结构。首先标记实体关系以允许级联读取，例如：

public class Car
{
    //snip

    [OneToOne(CascadeOperations = CascadeOperation.CascadeRead)]
    public Door Door { get; set; }
}

return await this.database.GetWithChildrenAsync<Door>(doorId, recursive: true);

然后，当您从数据库读取数据时，将

recursive

参数设置为true。例如：

public class Car
{
    //snip

    [OneToOne(CascadeOperations = CascadeOperation.CascadeRead)]
    public Door Door { get; set; }
}

return await this.database.GetWithChildrenAsync<Door>(doorId, recursive: true);

return等待这个.database.GetWithChildrenAsync（doorId，递归：true）；

您应该使用来阅读完整的关系层次结构。首先标记实体关系以允许级联读取，例如：

public class Car
{
    //snip

    [OneToOne(CascadeOperations = CascadeOperation.CascadeRead)]
    public Door Door { get; set; }
}

return await this.database.GetWithChildrenAsync<Door>(doorId, recursive: true);

然后，当您从数据库读取数据时，将

recursive

参数设置为true。例如：

public class Car
{
    //snip

    [OneToOne(CascadeOperations = CascadeOperation.CascadeRead)]
    public Door Door { get; set; }
}

return await this.database.GetWithChildrenAsync<Door>(doorId, recursive: true);

return等待这个.database.GetWithChildrenAsync（doorId，递归：true）；

我将

级联操作

属性添加到

汽车

和

车门

recursive

对于

GetCarAsync（）

和

GetDoorAsync（）

也是如此。

Window

的结果仍然是

null

。我必须以不同的方式存储它，还是应该使用

cascadeensert

？好的，我的错。我完全从文件系统中删除了数据库，现在它可以工作了。仍然有旧的数据库。。。还有一个问题：

CascadeRead

可以与

cascadeinert

结合使用吗？还是只能存在一个或另一个？什么时候使用哪个？您可以同时使用：

[OneToMany（CascadeOperations=CascadeOperation.CascadeRead | CascadeOperation.CascadeInsert）]

我将

CascadeOperation

属性添加到

Car

和

Door

recursive

对于

GetCarAsync（）

和

GetDoorAsync（）

也是如此。

Window

的结果仍然是

null

。我必须以不同的方式存储它，还是应该使用

cascadeensert

？好的，我的错。我完全从文件系统中删除了数据库，现在它可以工作了。仍然有旧的数据库。。。还有一个问题：

CascadeRead

可以与

cascadeinert

结合使用吗？还是只能存在一个或另一个？何时使用哪种？您可以同时使用：

[OneToMany（CascadeOperations=CascadeOperation.CascadeRead | CascadeOperation.CascadeInsert）]