Beispiel #1
0
        public static async Task <TEntity> GetNodeAsync <TEntity>(
            this ITransaction transaction,
            long nodeId) where TEntity : class
        {
            var parameters = new Neo4jParameters()
                             .WithValue("p1", nodeId);

            var statementResultCursor = await transaction.RunAsync(GetNodeStatement, parameters);

            return(await statementResultCursor.MapSingleAsync <TEntity>());
        }
        public static TEntity GetNode <TEntity>(
            this ISession session,
            long nodeId) where TEntity : class
        {
            var parameters = new Neo4jParameters()
                             .WithValue("p1", nodeId);

            return(session
                   .Run(Constants.Statement.GetNode, parameters)
                   .Map <TEntity>()
                   .SingleOrDefault());
        }
Beispiel #3
0
        public static TEntity GetNode <TEntity>(
            this ITransaction transaction,
            long nodeId) where TEntity : class
        {
            var parameters = new Neo4jParameters()
                             .WithValue("p1", nodeId);

            return(transaction
                   .Run(GetNodeStatement, parameters)
                   .Map <TEntity>()
                   .SingleOrDefault());
        }
        public static async Task <TEntity> GetNodeAsync <TEntity>(
            this IAsyncSession asyncSession,
            long nodeId) where TEntity : class
        {
            var parameters = new Neo4jParameters()
                             .WithValue("p1", nodeId);

            var resultCursor = await asyncSession.RunAsync(Constants.Statement.GetNode, parameters)
                               .ConfigureAwait(false);

            return(await resultCursor.MapSingleAsync <TEntity>().ConfigureAwait(false));
        }
        public static IResult SetNode <TEntity>(
            this ITransaction transaction,
            TEntity entity) where TEntity : class
        {
            var nodeId = EntityAccessor.GetNodeId(entity);

            if (nodeId == null)
            {
                throw new InvalidOperationException(Constants.NodeIdUnspecifiedMessage);
            }

            var parameters = new Neo4jParameters()
                             .WithValue("p1", nodeId)
                             .WithEntity("p2", entity);

            return(transaction.Run(Constants.Statement.SetNode, parameters));
        }
Beispiel #6
0
        public static async Task <IStatementResultCursor> SetNodeAsync <TEntity>(
            this ITransaction transaction,
            TEntity entity) where TEntity : class
        {
            var nodeId = EntityAccessor.GetNodeId(entity);

            if (nodeId == null)
            {
                throw new InvalidOperationException(NodeIdUnspecifiedMessage);
            }

            var parameters = new Neo4jParameters()
                             .WithValue("p1", nodeId)
                             .WithEntity("p2", entity);

            return(await transaction.RunAsync(SetNodeStatement, parameters));
        }
        public static async Task <IResultCursor> SetNodeAsync <TEntity>(
            this IAsyncTransaction asyncTransaction,
            TEntity entity) where TEntity : class
        {
            var nodeId = EntityAccessor.GetNodeId(entity);

            if (nodeId == null)
            {
                throw new InvalidOperationException(Constants.NodeIdUnspecifiedMessage);
            }

            var parameters = new Neo4jParameters()
                             .WithValue("p1", nodeId)
                             .WithEntity("p2", entity);

            return(await asyncTransaction.RunAsync(Constants.Statement.SetNode, parameters)
                   .ConfigureAwait(false));
        }