Exemple #1
0
        public Task <OperationResultOf <TEntity> > TryGetSingleAsync(TKey key,
                                                                     CancellationToken cancellation = default,
                                                                     params Expression <Func <TEntity, object> >[] toBeIncluded)
        {
            var validationOpRes = _keyValueValidator.Validate(key);

            if (!validationOpRes)
            {
                return(Task.FromResult(validationOpRes.AsFailedOpResOf <TEntity>()));
            }

            return(_dbContextProvider.TryUseAsync(dbSession =>
                                                  InternalTryGetSingleAsync(dbSession, key,
                                                                            trackChanges: false,
                                                                            cancellation,
                                                                            toBeIncluded)));
        }
        public OperationResultOf <TValue> TryCreate(TKey key,
                                                    Action <TValue> init = null)
        {
            //Validate key
            var validateOpRes = _keyValueValidator.Validate(key);

            if (!validateOpRes)
            {
                return(validateOpRes.AsFailedOpResOf <TValue>());
            }

            // Ensure key is unique
            if (_streamStore.CheckExists(key))
            {
                return($"{key} already exists in store"
                       .AsFailedOpResOf <TValue>());
            }

            // Create new value and validate
            var newValue = new TValue();

            init?.Invoke(newValue);
            validateOpRes = _keyValueValidator.Validate(newValue);
            if (!validateOpRes)
            {
                return(validateOpRes.AsFailedOpResOf <TValue>());
            }

            // Create stream for new value
            var createStreamOpRes = _streamStore.TryCreate(key);

            if (!createStreamOpRes)
            {
                return(new OperationResultOf <TValue>());
            }

            // Serialize value and write to stream store
            return(TrySerializeAndReturnValue(
                       value: newValue,
                       destinationStream: createStreamOpRes));
        }
        public Task <OperationResultOf <TValue> > TryCreateAsync(TKey key,
                                                                 Action <TValue> init = null)
        {
            //Validate key
            var validateOpRes = _keyValueValidator.Validate(key);

            if (!validateOpRes)
            {
                return(Task.FromResult(validateOpRes.AsFailedOpResOf <TValue>()));
            }

            // Ensure key is unique
            if (_streamStore.CheckExists(key))
            {
                return(Task.FromResult(
                           $"{key} already exists in store".AsFailedOpResOf <TValue>()));
            }

            // Create new value and validate
            var newValue = new TValue();

            init?.Invoke(newValue);
            validateOpRes = _keyValueValidator.Validate(newValue);
            if (!validateOpRes)
            {
                return(Task.FromResult(validateOpRes.AsFailedOpResOf <TValue>()));
            }

            // Create stream for new value
            var createStreamOpRes = _streamStore.TryCreate(key);

            if (!createStreamOpRes)
            {
                return(Task.FromResult(new OperationResultOf <TValue>()));
            }

            return(TrySerializeAndReturnValueAsync(newValue,
                                                   createStreamOpRes));
        }