Thanks Ayende!

For me, the ideal ID class is like this:

public class Id<TEntity> where TEntity : class
    {
        public string Value { get; }

        public Id(string value)
        {
            Value = value;
        }

        public async Task<TEntity> GetEntityAsync()
        {
            var session = StaticServiceLocator.Services.GetRequiredService<IAsyncDocumentSession>();

            return await session.LoadAsync<TEntity>(Value);
        }
    }

Using the example of your book "Inside RavenDB 4.0", the Child class should be like this:

public class Child
{
    public Id<Child> Id { get; set; }
    public string Name { get; set; }
    public Id<Parent> FatherId { get; set; }
    public Id<Parent> MotherId { get; set; }
}

So, if in business code I have the child and I need the parent to do some operation with the parent, I can do:

var parent = await child.ParentId.LoadEntityAsync();

Usually, before getting the child from DB, I should called Include() method of session and the parents must be stay in the entity map, so the await operation must be finished inmediatly. Is this correct?

When I need to show data in the presentation layer, I usually use proyections from query with ProyectInto() method. Imagine this model class:

public class ChildFileModel
{
    public string Name { get; set; }
    public string FatherName { get; set; }
    public string MotherName { get; set; }
}

So, I think that I can use a proyection like this:

var childFileModel = await session.Query<Child>()
    .Where(x => x.Id.Value == "children/1-A")
    .Select(async x => new ChildFileModel
    {
        Name = x.Name,
        FatherName = (await x.FatherId.GetEntityAsync()).Name
        Mother = (await x.Mother.GetEntityAsync()).Name
    });

Is this proyection well done?

I didn't test any code of this comment, I'll test tomorrow and I'll post a reply.

Thanks you Ayende!

Hi Ayende, thanks for your response.

I'm using the same session because is scoped in the container, so the session is created once per HTTP request (using ASP.NET Core). I'll investigate about the proyection problem the next week.

Comming back to the example, I need to use HiLo algorithm with stronge-typed generic Id<TEntity> class and use it into one-to-many relationships, so I wrote a basic Person class:

public class Person
{
    public Id<Person> Id { get; set; }

    public string Name { get; set; }
    public int Age { get; set; }

    public bool IsInLegalAge => Age > 18;
        
    public Id<Person> FatherId { get; set; }
    public Id<Person> MotherId { get; set; }
}

I wrote also a custom JsonConverter to save ID as string in database:

public class IdConverter : JsonConverter
{
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var idString = (string) value.GetType().GetProperty("Value").GetValue(value);
        
        writer.WriteValue(idString);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var idString = (string) reader.Value;

        var ctor = objectType.GetConstructor(new[] {typeof(string)});
        return ctor?.Invoke(new object[] {idString});
    }

    public override bool CanConvert(Type objectType)
    {
        return objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(Id<>);
    }
}

Then, I make some instances of this class and save it into db:

var mother = new Person
{
    Age = 45,
    Name = "Mary",
};

var father = new Person
{
    Age = 49,
    Name = "John"
};

// I store mother and father because I would the entities have IDs to assign to ivan
await session.StoreAsync(mother);
await session.StoreAsync(father);

var ivan = new Person
{
    Name = "Ivan",
    Age = 23,
    MotherId = mother.Id,
    FatherId = father.Id,
};

await session.StoreAsync(ivan);
await session.SaveChangesAsync();

To generate id with the HiLo algorithm and assing it into Id property, I modified the AsyncDocumentIdGenerator convention like the post, but detecting if entity has a Id property of type Id<>

var defaultDocumentIdGenerator = documentStore.Conventions.AsyncDocumentIdGenerator;
documentStore.Conventions.AsyncDocumentIdGenerator = async (dbName, entity) =>
{
    var entityIdentifierProperty = entity.GetType().GetProperty("Id");
    var entityIdentifierPropertyType = entityIdentifierProperty?.PropertyType;

    if (entityIdentifierProperty is null || entityIdentifierPropertyType != typeof(Id<>).MakeGenericType(entity.GetType()))
        return await defaultDocumentIdGenerator(dbName, entity);

        // Note that I'm instancing a new HiLoGenerator per entity.
        // This lacks the algorithm because I get new rank per entity.
        // I tried to use the DocumentStore generator, but is private ;(
    var hiLoGenerator = new AsyncMultiDatabaseHiLoIdGenerator(documentStore, documentStore.Conventions);
    var generatedId = await hiLoGenerator.GenerateDocumentIdAsync(dbName, entity);
    
    entityIdentifierProperty.SetValue(entity,
        entityIdentifierPropertyType.GetConstructor(new []{typeof(string)})?.Invoke(new object[]{generatedId}));

    return generatedId;
};

At this point, exception is thrown in first StoreAsync (mother) call:

NotSupportedException: Cannot set identity value 'people/33-A' on property 'Id' for type 'RavenTryouts.Entities.Person' because property type is not a string.

To avoid this exception, I added modiefied FindIdentityProperty convention like the post, to detect the entities that have Id property of type Id<>:

var defaultIdentityProperty = documentStore.Conventions.FindIdentityProperty;
documentStore.Conventions.FindIdentityProperty = info =>
{
    var entityType = info.DeclaringType;
    var entityIdentifierProperty = entityType?.GetProperty("Id");
    var entityIdentifierPropertyType = entityIdentifierProperty?.PropertyType;
    
    if (entityIdentifierPropertyType is null || entityIdentifierPropertyType == typeof(Id<>).MakeGenericType(entityType))
        return defaultIdentityProperty(info);
    
    return false;
};

Doing this, I can save and load entities from database using Id<TEntity> as identity type instead of string with HiLo generator. The main problem is the lack of HiLo generator. There are any form to access the HiLo generator instance anywhere?

I tried something like this to reuse the default document generator, but I get NullReferenceError in line var generatedId = await defaultDocumentIdGenerator(dbName, entity); when I call session.StoreAsync(mother).

I created a thread into RavenDB google group about this: https://groups.google.com/forum/#!topic/ravendb/Izpdcc7nGA8