/// <summary> /// Groups Transactions/Connections./Connections. /// </summary> /// <param name="this">Connection Source</param> /// <param name="body">Execution body.</param> public static T Pool <T>(this IConnectionSource @this, Func <IPool, T> body) { using var pool = new Pool(@this); var res = body(pool); return(res); }
/// <summary> /// Groups Transactions/Connections./Connections. /// </summary> /// <param name="this">Connection Source</param> /// <param name="body">Execution body.</param> public static void Pool(this IConnectionSource @this, Action <IPool> body) { @this.Pool(p => { body(p); return(0); }); }
public static void WithConnection <TCon>(this IConnectionSource <TCon> source, Action <TCon> action) { source.WithConnection(con => { action(con); return(true); }); }
public static T CallInTransaction <T>(IConnectionSource source, Func <IConnectionSource, T> runInsideTransaction) { using (ITransaction transaction = source.StartTransaction()) { var result = runInsideTransaction(source); transaction.Commit(); return(result); } }
/// <summary> /// Creates/Rollbacks/Disposes Transaction /// </summary> /// <param name="body">Use Transaction.</param> /// <param name="this">Desired connection source.</param> /// <param name="token">Cancellation Token.</param> private static void Transaction(this IConnectionSource @this, Action <Transaction> body, CancellationToken token) { @this.Transaction(tran => { body(tran); return(0); }, token); }
// ReSharper disable once MemberCanBePrivate.Global // ReSharper disable once MemberCanBePrivate.Global /// <summary> /// Executes SqlCommand and returns Result. /// </summary> /// <param name="body">Use to Customize and to execute Command.</param> /// <param name="command">CommandText.</param> /// <param name="token">Cancellation token.</param> /// <param name="this">Desired database context.</param> /// <typeparam name="T">Generic Type T</typeparam> /// <returns>Database Query Result of Type T.</returns> public static Task <T> QueryAsync <T>(this IConnectionSource @this, string command, Func <ICommand <T>, T> body, CancellationToken token) { return(@this.TransactionAsync(tran => { using var cmd = new Command <T>(command, tran); var res = body(cmd); return res; }, token)); }
public Pool(IConnectionSource connectionSource) { switch (connectionSource) { case Transaction t: _transactions.Add(t.Connection.Context.Name, t); break; } _connectionSource = connectionSource ?? ContextController.DefaultContext; _connectionSource.CommandCreated += OnCommandCreated; }
/// <summary> /// Creates/Rollbacks/Disposes Transaction /// </summary> /// <param name="body">Use Transaction.</param> /// <param name="this">Desired connection source.</param> /// <param name="token">Cancellation Token.</param> /// <typeparam name="T">Generic Type T.</typeparam> /// <returns>Query Results of Type T.</returns> private static T Transaction <T>(this IConnectionSource @this, Func <Transaction, T> body, CancellationToken token) { if (body.Method.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) != null) { throw new InvalidOperationException("Async Lambdas not supported, please use a Pool."); } var transaction = @this as ManagedTransaction; var ts = @this as IPool; var tran = transaction ?? @this?.Transaction() ?? new Transaction(ContextController.DefaultContext) { Token = token }; // ReSharper disable once ConditionIsAlwaysTrueOrFalse var handleTransaction = transaction == null && ts == null && @this == null; var conn = tran.Connection; if (conn.State == ConnectionState.Closed) { conn.Open(); } tran.OnTransactionCreated(tran); if (tran.DbTransaction == null) { tran.DbTransaction = conn.BeginTransaction(); } try { var res = body(tran); if (handleTransaction) { tran.Commit(); } return(res); } catch (Exception) { if (handleTransaction) { tran.Rollback(); } throw; } finally { if (handleTransaction) { tran.Dispose(); conn.Close(); conn.Dispose(); } } }
protected async Task <TCommandResult> ExecuteCommandAsync( IConnectionSource connectionSource, ReadPreference readPreference, TimeSpan timeout, CancellationToken cancellationToken) { var slidingTimeout = new SlidingTimeout(timeout); using (var connection = await connectionSource.GetConnectionAsync(slidingTimeout, cancellationToken)) { var protocol = CreateProtocol(connectionSource.ServerDescription, readPreference); return(await protocol.ExecuteAsync(connection, slidingTimeout, cancellationToken)); } }
public static async Task <TResult> ExecuteAsync <TResult>( this IWireProtocol <TResult> protocol, IConnectionSource connectionSource, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken)) { Ensure.IsNotNull(protocol, "protocol"); var slidingTimeout = new SlidingTimeout(timeout); using (var connection = await connectionSource.GetConnectionAsync(slidingTimeout, cancellationToken)) { return(await protocol.ExecuteAsync(connection, slidingTimeout, cancellationToken)); } }
public void RegisterConnectionSource(string name, IConnectionSource connectionSource) { if (String.IsNullOrEmpty(name)) throw new ArgumentException("name is null or empty.", "name"); if (connectionSource == null) throw new ArgumentNullException("connectionSource", "connectionSource is null."); if (connectionSources.ContainsKey(name)) throw new ArgumentException( string.Format("A connection source has already been registered with the name: {0}", name), "name"); connectionSources.Add(name, connectionSource); }
/// <summary> /// Groups Transactions/Connections. /// </summary> /// <param name="this">Connection Source</param> /// <param name="body">Execution body.</param> public static Task <T> PoolAsync <T>(this IConnectionSource @this, Func <IPool, Task <T> > body) { var source = new CancellationTokenSource(); var token = source.Token; return(Task.Run(async() => { using var pool = new Pool(@this) { TokenSource = source }; var res = await body(pool); pool.Commit(); return res; }, token)); }
// constructors public Cursor( IConnectionSource connectionSource, CollectionNamespace collectionNamespace, BsonDocument query, IReadOnlyList <TDocument> firstBatch, long cursorId, int batchSize, int limit, IBsonSerializer <TDocument> serializer, MessageEncoderSettings messageEncoderSettings, TimeSpan timeout, CancellationToken cancellationToken) { _connectionSource = Ensure.IsNotNull(connectionSource, "connectionSource"); _collectionNamespace = Ensure.IsNotNull(collectionNamespace, "collectionNamespace"); _query = Ensure.IsNotNull(query, "query"); _firstBatch = Ensure.IsNotNull(firstBatch, "firstBatch"); _cursorId = cursorId; _batchSize = Ensure.IsGreaterThanOrEqualToZero(batchSize, "batchSize"); _limit = Ensure.IsGreaterThanOrEqualToZero(limit, "limit"); _serializer = Ensure.IsNotNull(serializer, "serializer"); _messageEncoderSettings = messageEncoderSettings; _timeout = timeout; _cancellationToken = cancellationToken; if (_limit == 0) { _limit = int.MaxValue; } if (_firstBatch.Count > _limit) { _firstBatch = _firstBatch.Take(_limit).ToList(); } _count = _firstBatch.Count; // if we aren't going to need the connection source we can go ahead and Dispose it now if (_cursorId == 0) { _connectionSource.Dispose(); _connectionSource = null; } }
// constructors public Cursor( IConnectionSource connectionSource, string databaseName, string collectionName, BsonDocument query, IReadOnlyList <TDocument> firstBatch, long cursorId, int batchSize, IBsonSerializer <TDocument> serializer, TimeSpan timeout, CancellationToken cancellationToken) { _connectionSource = cursorId == 0 ? connectionSource : Ensure.IsNotNull(connectionSource, "connectionSource"); _databaseName = Ensure.IsNotNullOrEmpty(databaseName, "databaseName"); _collectionName = Ensure.IsNotNullOrEmpty(collectionName, "collectionName"); _query = Ensure.IsNotNull(query, "query"); _firstBatch = Ensure.IsNotNull(firstBatch, "firstBatch"); _cursorId = cursorId; _batchSize = Ensure.IsGreaterThanOrEqualToZero(batchSize, "batchSize"); _serializer = Ensure.IsNotNull(serializer, "serializer"); _timeout = timeout; _cancellationToken = cancellationToken; }
/// <summary> /// Creates/Rollbacks/Disposes Transaction /// </summary> /// <param name="body">Use Transaction.</param> /// <param name="this">Desired connection source.</param> /// <param name="token">Cancellation Token.</param> /// <returns>Awaitable Task</returns> public static Task TransactionAsync(this IConnectionSource @this, Action <Transaction> body, CancellationToken token) { return(Task.Run(() => @this.Transaction(body, token), token)); }
internal ManagedTransaction(IConnectionSource connection, string databaseName) : base(connection, databaseName) { TransactionCreated += connection.OnTransactionCreated; CommandCreated += connection.OnCommandCreated; ConnectionSource = connection; }
// constructors public ConnectionSourceHandle(IConnectionSource connectionSource) : this(new ReferenceCounted <IConnectionSource>(connectionSource)) { }
public bool Execute(IConnectionSource source, out int rowsAltered, params Value[] parameters) { return(Execute(source.QueryCompiler, out rowsAltered, parameters)); }
internal Transaction(IConnectionSource connection) { Connection = connection.Connection(); ConnectionSource = connection; CommandCreated += connection.OnCommandCreated; }
internal Transaction(IConnectionSource connection, string databaseName) { Connection = connection.Connection(databaseName); CommandCreated += connection.OnCommandCreated; }
public object Execute(IConnectionSource source, Type type, params Value[] parameters) { return(Execute(source.QueryCompiler, type, parameters)); }
public void Setup() { _connectionSource = Substitute.For <IConnectionSource>(); }
public void Setup() { _connectionSource = Substitute.For<IConnectionSource>(); }
// constructors public ConnectionSourceHandle(IConnectionSource connectionSource) : this(new ReferenceCounted<IConnectionSource>(connectionSource)) { }
/// <summary> /// Creates/Rollbacks/Disposes Transaction on desired database context. /// </summary> /// <param name="this">Database context.</param> /// <param name="body">Use Transaction.</param> /// <typeparam name="T">Generic Type T.</typeparam> /// <returns>QueryResult of Type T</returns> // ReSharper disable once MemberCanBePrivate.Global public static Task <T> TransactionAsync <T>(this IConnectionSource @this, Func <Transaction, T> body) { return(Task.Run(() => Transaction(@this, body))); }
/// <summary> /// Creates/Rollbacks/Disposes Transaction on desired database context. /// </summary> /// <param name="this">Database context.</param> /// <param name="body">Use Transaction.</param> /// <param name="token">Cancellation Token.</param> /// <typeparam name="T">Generic Type T.</typeparam> /// <returns>QueryResult of Type T</returns> // ReSharper disable once MemberCanBePrivate.Global public static Task <T> TransactionAsync <T>(this IConnectionSource @this, Func <Transaction, T> body, CancellationToken token) { return(Task.Run(() => Transaction(@this, body, token), token)); }
// static methods public static IConnectionHandle GetConnection(this IConnectionSource connectionSource, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken)) { return(connectionSource.GetConnectionAsync(timeout, cancellationToken).GetAwaiter().GetResult()); }
public IPreparedStatement Prepare(IConnectionSource source) { return(Prepare(source.QueryCompiler)); }
public StudentRepositoryService(IConnectionSource connectionSource) { _connectionSource = connectionSource; }
/// <summary> /// Creates/Rollbacks/Disposes Transaction /// </summary> /// <param name="body">Use Transaction.</param> /// <param name="this">Desired connection source.</param> /// <typeparam name="T">Generic Type T.</typeparam> /// <returns>Query Results of Type T.</returns> // ReSharper disable once MemberCanBePrivate.Global public static T Transaction <T>(this IConnectionSource @this, Func <Transaction, T> body) { return(@this.Transaction(body, CancellationToken.None)); }
/// <summary> /// Creates/Rollbacks/Disposes Transaction /// </summary> /// <param name="body">Use Transaction.</param> /// <param name="this">Desired connection source.</param> // ReSharper disable once MemberCanBePrivate.Global public static void Transaction(this IConnectionSource @this, Action <Transaction> body) { @this.Transaction(body, CancellationToken.None); }
public IEnumerable <string[]> Execute(IConnectionSource source, params Value[] parameters) { return(Execute(source.QueryCompiler, parameters)); }
internal ManagedTransaction(IConnectionSource connection) : base(connection) { TransactionCreated += connection.OnTransactionCreated; CommandCreated += connection.OnCommandCreated; ConnectionSource = connection; }