pairbit / it.redis.entity Goto Github PK

void WriteKey<TKey>(in TEntity entity, in TKey key)

TEntity? EntityGet<TEntity, TKey>(in TKey key)

var id = Guid.NewGuid()
db.EntityGet<Document, Guid>(in id)

int index = 1;
db.EntityGet<Document, (Guid, int)>(in (id, index))

class MyEntity
{
  public byte[]? RedisKey { get; set; }

  public string Name { get; set; }
}

var entity = new MyEntity()
db.EntitySet(entity)

abstract class RedisEntity {
private byte[]? _redisKey;
private byte _redisKeyBits;
}

class MyEntity : RedisEntity {
public string? Data { get; set; }
}

interface IRedisEntity {
byte[]? RedisKey { get; set; }
byte RedisKeyBits { get; set; }
}

interface IMyEntity : IRedisEntity {
string Name { get; set; }
}

public static class xIRedisEntityReader
{
    public static void ReadNew<T>(this IRedisEntityReader<T> reader, HashEntry[] entries, T entity, RedisValue[] fields, int offset = 0)
    {
        if (entries == null) throw new ArgumentNullException(nameof(entries));
        if (fields == null) throw new ArgumentNullException(nameof(fields));
        if (offset < 0) throw new ArgumentOutOfRangeException(nameof(offset));
        if (entries.Length < fields.Length + offset) throw new ArgumentOutOfRangeException(nameof(entries));

        for (int i = 0; i < fields.Length; i++)
        {
            var field = fields[i];
            var value = reader.Read(entity, in field);

            entries[i + offset] = new HashEntry(field, value);
        }
    }

    public static void ReadNew<T>(this IRedisEntityReader<T> reader, HashEntry[] entries, T entity, int offset = 0)
        => reader.ReadNew(entries, entity, reader.Fields.All, offset);

    public static RedisValue Serialize<TEntity, TField>(this IRedisEntityReader<TEntity> reader, in RedisValue field, in TField value)
        => reader.GetSerializer<TField>(in field).Serialize(in value);

    public static HashEntry SerializeToHashEntry<TEntity, TField>(this IRedisEntityReader<TEntity> reader, in RedisValue field, in TField value)
        => new(field, reader.GetSerializer<TField>(in field).Serialize(in value));
}

public static async Task<TField?> EntityGetFieldStructAsync<TEntity, TField>(
        this IDatabaseAsync db, RedisKey key, RedisValue field,
        IRedisEntityWriter<TEntity>? writer = null, CommandFlags flags = CommandFlags.None)
        where TField : struct
    {
        var redisValue = await db.HashGetAsync(key, field, flags).ConfigureAwait(false);
        if (redisValue.IsNull) return default;

        TField value = default;
        (writer ?? RedisEntity<TEntity>.Writer).GetDeserializer<TField>(in field).Deserialize(in redisValue, ref value);
        return value;
    }