Here are the examples of the csharp api class System.Data.Common.DbCommand.ExecuteNonQueryAsync() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
61 Examples
0
1. Example
View licensepublic static async Task ExecuteNonQueryExtAsync(this SqlCommand cmd)
{
await ConnectionWrapAsync(cmd, async () => await cmd.ExecuteNonQueryAsync());
}0
2. Example
View licensepublic async Task<int> ExecuteStatementNoResultAsync(string sqlCommandText, params SqlParameter[] sqlParameters)
{
SqlCommand sqlCommand = this.CreateStatementCommand(sqlCommandText, sqlParameters);
return await sqlCommand.ExecuteNonQueryAsync();
}0
3. Example
View licensepublic static async Task Run(TimerInfo myTimer, TraceWriter log)
{
var connStr = ConfigurationManager.ConnectionStrings["sqldb"].ConnectionString;
using (var conn = new SqlConnection(connStr))
{
conn.Open();
var sqlCmd = "DELETE FROM TimelineItems WHERE deleted = 'True'";
using (var cmd = new SqlCommand(sqlCmd, conn))
{
var rows = await cmd.ExecuteNonQueryAsync();
log.Info($"{rows} rows deleted.");
}
}
}0
4. Example
View licensepublic override Task<int> BulkInsertAsync<T>(IEnumerable<T> data)
=> this.CreateBulkInsertCommand(data).ExecuteNonQueryAsync();0
5. Example
View licensepublic async Task DeleteAsync(EmployeeClassification classification)
{
var sql = @"DELETE HR.EmployeeClassification WHERE EmployeeClassificationKey = @EmployeeClassificationKey;";
using (var con = new SqlConnection(m_ConnectionString))
{
await con.OpenAsync();
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@EmployeeClassificationKey", classification.EmployeeClassificationKey);
await cmd.ExecuteNonQueryAsync();
}
}
}0
6. Example
View licensepublic async Task DeleteAsync(int employeeClassificationKey)
{
var sql = @"DELETE HR.EmployeeClassification WHERE EmployeeClassificationKey = @EmployeeClassificationKey;";
using (var con = new SqlConnection(m_ConnectionString))
{
await con.OpenAsync();
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@EmployeeClassificationKey", employeeClassificationKey);
await cmd.ExecuteNonQueryAsync();
}
}
}0
7. Example
View licensepublic async Task UpdateAsync(EmployeeClassification classification)
{
var sql = @"UPDATE HR.EmployeeClassification
SET EmployeeClassificationName = @EmployeeClassificationName
WHERE EmployeeClassificationKey = @EmployeeClassificationKey;";
using (var con = new SqlConnection(m_ConnectionString))
{
await con.OpenAsync();
using (var cmd = new SqlCommand(sql, con))
{
cmd.Parameters.AddWithValue("@EmployeeClassificationKey", classification.EmployeeClassificationKey);
cmd.Parameters.AddWithValue("@EmployeeClassificationName", classification.EmployeeClassificationName);
await cmd.ExecuteNonQueryAsync();
}
}
}0
8. Example
View licensepublic static async Task<int> SetReadUncommittedAsync(this DbConnection connection)
{
if (connection == null) throw new ArgumentNullException(nameof(connection));
using (var cmd = connection.CreateCommand())
{
cmd.CommandText = "SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED";
await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);
}
return 1;
}0
9. Example
View licensepublic async Task<int> ResetTableAsync(DbConnection connection, bool dropIfExists = false)
{
var sql = BuildCreateTableSql(dropIfExists);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
10. Example
View licensepublic async Task<int> CreateAsync(DbConnection connection, T value, params object[] keyValues)
{
var sql = BuildSqlForCreate(value, keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
11. Example
View licensepublic async Task<int> DeleteAsync(DbConnection connection, params object[] keyValues)
{
var sql = BuildSqlForDelete(keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
12. Example
View licensepublic async Task<int> SaveAsync(DbConnection connection, IContainerTracker<T> tracker,
params object[] keyValues)
{
var sql = BuildSqlForSave(tracker, keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
13. Example
View licensepublic async Task<int> ResetTableAsync(DbConnection connection)
{
var sql = BuildCreateTableSql(true);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
14. Example
View licensepublic async Task<int> CreateAsync(DbConnection connection, IDictionary<TKey, TValue> dictionary,
params object[] keyValues)
{
var sql = BuildSqlForCreate(dictionary, keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
15. Example
View licensepublic async Task<int> DeleteAsync(DbConnection connection, params object[] keyValues)
{
var sql = BuildSqlForDelete(keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
16. Example
View licensepublic async Task<int> SaveAsync(DbConnection connection, TrackableDictionaryTracker<TKey, TValue> tracker,
params object[] keyValues)
{
if (tracker.HasChange == false)
return 0;
var sql = BuildSqlForSave(tracker, keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
17. Example
View licensepublic async Task<int> ResetTableAsync(DbConnection connection)
{
var sql = BuildCreateTableSql(true);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
18. Example
View licensepublic async Task<int> DeleteAsync(DbConnection connection, params object[] keyValues)
{
var sql = BuildSqlForDelete(keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
19. Example
View licensepublic async Task<int> SaveAsync(DbConnection connection, TrackablePocoTracker<T> tracker,
params object[] keyValues)
{
if (tracker.HasChange == false)
return 0;
var sql = BuildSqlForSave(tracker, keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
20. Example
View licensepublic async Task<int> ResetTableAsync(DbConnection connection)
{
var sql = BuildCreateTableSql(true);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
21. Example
View licensepublic async Task<int> CreateAsync(DbConnection connection, ICollection<T> set,
params object[] keyValues)
{
var sql = BuildSqlForCreate(set, keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
22. Example
View licensepublic async Task<int> DeleteAsync(DbConnection connection, params object[] keyValues)
{
var sql = BuildSqlForDelete(keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
23. Example
View licensepublic async Task<int> SaveAsync(DbConnection connection, TrackableSetTracker<T> tracker,
params object[] keyValues)
{
if (tracker.HasChange == false)
return 0;
var sql = BuildSqlForSave(tracker, keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
return await command.ExecuteNonQueryAsync();
}
}0
24. Example
View licenseprivate async Task ExecuteDeleteSqlAsync(DbConnection connection)
{
using (var tx = connection.BeginTransaction())
using (var cmd = connection.CreateCommand())
{
cmd.CommandTimeout = CommandTimeout ?? cmd.CommandTimeout;
cmd.CommandText = _deleteSql;
cmd.Transaction = tx;
await cmd.ExecuteNonQueryAsync();
tx.Commit();
}
}0
25. Example
View licenseprivate static async Task WriteLinksAsync(IDictionary<string, int> zones, ILookup<string, string> aliases)
{
var cs = _options.ConnectionString;
using (var connection = new SqlConnection(cs))
{
var command = new SqlCommand("[Tzdb].[AddLink]", connection) { CommandType = CommandType.StoredProcedure };
command.Parameters.Add("@LinkZoneId", SqlDbType.Int);
command.Parameters.Add("@CanonicalZoneId", SqlDbType.Int);
await connection.OpenAsync();
foreach (var alias in aliases)
{
var canonicalId = zones[alias.Key];
foreach (var link in alias)
{
command.Parameters[0].Value = zones[link];
command.Parameters[1].Value = canonicalId;
await command.ExecuteNonQueryAsync();
}
}
connection.Close();
}
}0
26. Example
View licenseprivate static async Task WriteVersion(string version)
{
var cs = _options.ConnectionString;
using (var connection = new SqlConnection(cs))
{
var command = new SqlCommand("[Tzdb].[SetVersion]", connection) { CommandType = CommandType.StoredProcedure };
command.Parameters.AddWithValue("@Version", version);
await connection.OpenAsync();
await command.ExecuteNonQueryAsync();
connection.Close();
}
}0
27. Example
View licensepublic static async Task InsertPurchaseOrderHeaderAsync(string cnStr)
{
const st/n ..... /n //View Source file for more details /n }0
28. Example
View licensepublic static async Task LogAsync(string cnStr, string logTableName)
{
string queryString = "INSERT INTO dbo." + logTableName + " (LogId, Message, LogTime) VALUES (@LogId, @Message, @LogTime)";
var logMessage = new LogMessage();
using (var cn = new SqlConnection(cnStr))
{
using (var cmd = new SqlCommand(queryString, cn))
{
cmd.Parameters.AddWithValue("@LogId", logMessage.LogId);
cmd.Parameters.AddWithValue("@Message", logMessage.Message);
cmd.Parameters.AddWithValue("@LogTime", logMessage.LogTime);
await cn.OpenAsync().ConfigureAwait(false);
await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);
}
}
}0
29. Example
View licensepublic static IObservable<int> ExecuteNonQueryObservable(this SqlCommand command)
{
Contract.Requires(command != null);
Contract.Ensures(Contract.Result<IObservable<int>>() != null);
return Observable.StartAsync(cancel => command.ExecuteNonQueryAsync(cancel));
}0
30. Example
View licensepublic async Task<int> ExecuteNonQueryAsync()
{
using (var op = SnTrace.Database.StartOperation(GetTraceData("ExecuteNonQuery")))
{
StartConnection();
var result = await _cmd.ExecuteNonQueryAsync();
op.Successful = true;
return result;
}
}0
31. Example
View licensepublic async Task<int> ExecuteNonQueryAsync(SqlCommand cmd, params SqlParameter[] Params)
{
try
{
if (Transaction != null && Transaction != default(SqlTransaction))
cmd.Transaction = Transaction;
else
cmd.Connection = SqlConn;
if (Params != null && Params.Length > 0)
{
foreach (var param in Params)
cmd.Parameters.Add(param);
}
await OpenAsync();
return await cmd.ExecuteNonQueryAsync();
}
finally
{
Close();
}
}0
32. Example
View licensepublic static async Task CreateDatabaseAsync()
{
var conn = ConnectionManager.GetDefaultConnection();
var databaseName = conn.Connection.DatabaseName;
var masterConn = conn.Connection.Clone() as Connection;
masterConn.DatabaseName = "master";
var sqlConn = new SqlConnection(masterConn.ConnectionString);
// Create a command object identifying the stored procedure
using (var cmd = sqlConn.CreateCommand())
{
//
// Set the command object so it knows to execute a stored procedure
cmd.CommandType = CommandType.Text;
cmd.CommandText =
EmbeddedAssembly.GetFromResources("DatabaseCreatorQuery.sql")
.Replace("#DatabaseName", databaseName);
//
// execute the command
try
{
await sqlConn.OpenAsync();
await cmd.ExecuteNonQueryAsync();
}
finally
{
sqlConn.Close();
}
}
}0
33. Example
View licensepublic override async Task<long> InsertAndGetAsync<T>(T data)
{
This.AssertInsertAndGet<T>();
var param = this.CreateInsertAndGetParameter(data);
var result = await param.Item1.ExecuteNonQueryAsync().ConfigureAwait(false);
if (result != 1)
throw new SystemException("Affected row count is not 1.");
return Convert.ToInt64(param.Item2.Value);
}0
34. Example
View license[Test]
public async Task BadGrammarAsync()
{
ISession session = OpenSession();
var connection = session.Connection;
try
{
var ps = connection.CreateCommand();
ps.CommandType = CommandType.Text;
ps.CommandText = "whatever";
await (ps.ExecuteNonQueryAsync());
}
catch (Exception sqle)
{
Assert.DoesNotThrow(
() => ADOExceptionHelper.Convert(Sfi.SQLExceptionConverter, sqle, "could not get or update next value", null));
}
finally
{
session.Close();
}
}0
35. Example
View license[Test]
public async Task TestDefaultValueAsync()
{
using (ISession s1 = OpenSession())
{
var cmd = s1.Connection.CreateCommand();
cmd.CommandText =
"insert into GetSetHelper(ID) values(1)";
await (cmd.ExecuteNonQueryAsync());
}
try
{
// load the object and check default values
using (ISession s2 = OpenSession())
{
GetSetHelper gs = (GetSetHelper) await (s2.LoadAsync(typeof(GetSetHelper), 1));
Assert.AreEqual(new int(), gs.A);
Assert.AreEqual(new TimeSpan(), gs.B);
Assert.AreEqual(new bool(), gs.C);
Assert.AreEqual(new DateTime(), gs.D);
Assert.AreEqual(new short(), gs.E);
Assert.AreEqual(new byte(), gs.F);
Assert.AreEqual(new float(), gs.G);
Assert.AreEqual(new double(), gs.H);
Assert.AreEqual(new decimal(), gs.I);
Assert.AreEqual(new GetSetHelper.TestEnum(), gs.L);
Assert.IsNull(gs.M);
}
}
finally
{
ExecuteStatement("delete from GetSetHelper");
}
}0
36. Example
View licenseprivate async Task ExecuteNonQueryAsync(string sql, List<SqlParameter> parameters = null)
{
using (var connection = new SqlConnection(_connectionString))
using (var command = new SqlCommand(sql, connection))
{
await connection.OpenAsync();
using (var tx = connection.BeginTransaction())
{
command.Transaction = tx;
if (parameters?.Count > 0)
{
foreach (var p in parameters)
{
command.Parameters.Add(p);
}
}
await command.ExecuteNonQueryAsync();
tx.Commit();
}
}
}0
37. Example
View licenseprivate static async Task WriteResultsToSql(
string connectionString,
Scenar/n ..... /n //View Source file for more details /n }0
38. Example
View licensepublic static async Task<int> ExecuteNonQueryAsync(this DatabaseCommand databaseCommand, bool keepConnectionOpen = false)
{
int numberOfRowsAffected;
try
{
Sequelocity.ConfigurationSettings.EventHandlers.InvokeDatabaseCommandPreExecuteEventHandlers(databaseCommand);
await databaseCommand.DbCommand.OpenConnectionAsync();
numberOfRowsAffected = await databaseCommand.DbCommand.ExecuteNonQueryAsync();
Sequelocity.ConfigurationSettings.EventHandlers.InvokeDatabaseCommandPostExecuteEventHandlers(databaseCommand);
}
catch (Exception exception)
{
Sequelocity.ConfigurationSettings.EventHandlers.InvokeDatabaseCommandUnhandledExceptionEventHandlers(exception, databaseCommand);
throw;
}
finally
{
if (keepConnectionOpen == false)
{
databaseCommand.DbCommand.CloseAndDispose();
databaseCommand.DbCommand = null;
}
}
return numberOfRowsAffected;
}0
39. Example
View licensepublic static Task<int> ExecuteNonQueryAsync(this IDbCommand command, CancellationToken cancellationToken)
{
var dbCommand = command as DbCommand;
if (dbCommand != null)
{
return cancellationToken.CanBeCanceled
? InternalExecuteNonQueryAndPropagateCancellationAsync(dbCommand, cancellationToken)
: dbCommand.ExecuteNonQueryAsync();
}
// synchronous task pattern
var taskBuilder = new TaskCompletionSource<int>();
if (cancellationToken.IsCancellationRequested)
{
taskBuilder.SetCanceled();
return taskBuilder.Task;
}
try
{
taskBuilder.SetResult(command.ExecuteNonQuery());
}
catch (Exception ex)
{
taskBuilder.SetException(ex);
}
return taskBuilder.Task;
}0
40. Example
View license[Test]
public async Task SecondLevelCacheWithHqlQueriesForItemWithCollectionsAsync()
{
using (ISession session = OpenSession())
{
IList list = await (session.CreateQuery("from Item i where i.Id > 2")
.SetCacheable(true)
.ListAsync());
Assert.AreEqual(3, list.Count);
using (var cmd = session.Connection.CreateCommand())
{
cmd.CommandText = "DELETE FROM Item";
await (cmd.ExecuteNonQueryAsync());
}
}
using (ISession session = OpenSession())
{
//should bring from cache
IList list = await (session.CreateQuery("from Item i where i.Id > 2")
.SetCacheable(true)
.ListAsync());
Assert.AreEqual(3, list.Count);
}
}0
41. Example
View license[Test]
public async Task SecondLevelCacheWithHqlQueriesAsync()
{
using (ISession session = OpenSession())
{
IList list = await (session.CreateQuery("from AnotherItem i where i.Id > 2")
.SetCacheable(true)
.ListAsync());
Assert.AreEqual(3, list.Count);
using (var cmd = session.Connection.CreateCommand())
{
cmd.CommandText = "DELETE FROM AnotherItem";
await (cmd.ExecuteNonQueryAsync());
}
}
using (ISession session = OpenSession())
{
//should bring from cache
IList list = await (session.CreateQuery("from AnotherItem i where i.Id > 2")
.SetCacheable(true)
.ListAsync());
Assert.AreEqual(3, list.Count);
}
}0
42. Example
View license[Test]
public async Task RefreshTransientAsync()
{
ISession s = OpenSession();
Foo foo = new Foo();
await (s.SaveAsync(foo));
await (s.FlushAsync());
/*
Commented to have same behavior of H3.2 (test named FooBarTest.testRefresh())
s.Close();
s = OpenSession();
btw using close and open a new session more than Transient the entity will be detached.
*/
var cmd = s.Connection.CreateCommand();
cmd.CommandText = "update " + Dialect.QuoteForTableName("foos") + " set long_ = -3";
await (cmd.ExecuteNonQueryAsync());
await (s.RefreshAsync(foo));
Assert.AreEqual(-3L, foo.Long);
await (s.DeleteAsync(foo));
await (s.FlushAsync());
s.Close();
}0
43. Example
View licensepublic async Task<int> CreateAsync(DbConnection connection, T value, params object[] keyValues)
{
var sql = BuildSqlForCreate(value, keyValues);
using (var command = _sqlProvider.CreateDbCommand(sql, connection))
{
if (_identityColumn != null)
{
using (var reader = await command.ExecuteReaderAsync())
{
if (await reader.ReadAsync())
{
var columnValue = reader.GetValue(0);
_identityColumn.InstallFromDbValue(value, columnValue);
return 1;
}
}
return 0;
}
else
{
return await command.ExecuteNonQueryAsync();
}
}
}0
44. Example
View license[Test]
public async Task BadGrammarAsync()
{
//ISQLExceptionConverter converter = Dialect.BuildSQLExceptionConverter();
ISQLExceptionConverter converter = Sfi.Settings.SqlExceptionConverter;
ISession session = OpenSession();
var connection = session.Connection;
// prepare/execute a query against a non-existent table
DbCommand ps = null;
try
{
ps = connection.CreateCommand();
ps.CommandType = CommandType.Text;
ps.CommandText = "SELECT user_id, user_name FROM tbl_no_there";
await (ps.ExecuteNonQueryAsync());
Assert.Fail("SQL compilation should have failed");
}
catch (Exception sqle)
{
Assert.AreEqual(typeof (SQLGrammarException),
converter.Convert(new AdoExceptionContextInfo {SqlException = sqle}).GetType(),
"Bad conversion [" + sqle.Message + "]");
}
finally
{
if (ps != null)
{
try
{
ps.Dispose();
}
catch (Exception)
{
// ignore...
}
}
}
session.Close();
}0
45. Example
View license[Test]
public async Task CacheAsync()
{
NHibernate.DomainModel.Immutable im = new NHibernate.DomainModel.Immutable();
using (ISession s = OpenSession())
{
await (s.SaveAsync(im));
await (s.FlushAsync());
}
using (ISession s = OpenSession())
{
await (s.LoadAsync(im, im.Id));
}
using (ISession s = OpenSession())
{
await (s.LoadAsync(im, im.Id));
NHibernate.DomainModel.Immutable imFromFind =
(NHibernate.DomainModel.Immutable) (await (s.CreateQuery("from im in class Immutable where im = ?").SetEntity(0, im).ListAsync()))[0];
NHibernate.DomainModel.Immutable imFromLoad = (NHibernate.DomainModel.Immutable) await (s.LoadAsync(typeof(NHibernate.DomainModel.Immutable), im.Id));
Assert.IsTrue(im == imFromFind, "cached object identity from Find ");
Assert.IsTrue(im == imFromLoad, "cached object identity from Load ");
}
// Clean up the immutable. Need to do this using direct SQL, since ISession
// refuses to delete immutable objects.
using (ISession s = OpenSession())
{
var connection = s.Connection;
using (var command = connection.CreateCommand())
{
command.CommandText = "delete from immut";
await (command.ExecuteNonQueryAsync());
}
}
}0
46. Example
View license[Test]
public async Task RefreshAsync()
{
ISession s = OpenSession();
Foo foo = new Foo();
await (s.SaveAsync(foo));
await (s.FlushAsync());
var cmd = s.Connection.CreateCommand();
cmd.CommandText = "update " + Dialect.QuoteForTableName("foos") + " set long_ = -3";
await (cmd.ExecuteNonQueryAsync());
await (s.RefreshAsync(foo));
Assert.AreEqual((long) -3, foo.Long);
Assert.AreEqual(LockMode.Read, s.GetCurrentLockMode(foo));
await (s.RefreshAsync(foo, LockMode.Upgrade));
Assert.AreEqual(LockMode.Upgrade, s.GetCurrentLockMode(foo));
await (s.DeleteAsync(foo));
await (s.FlushAsync());
s.Close();
}0
47. Example
View license[Test]
public async Task SecondLevelCacheWithCriteriaQueriesAsync()
{
using (ISession session = OpenSession())
{
IList list = await (session.CreateCriteria(typeof(AnotherItem))
.Add(Expression.Gt("Id", 2))
.SetCacheable(true)
.ListAsync());
Assert.AreEqual(3, list.Count);
using (var cmd = session.Connection.CreateCommand())
{
cmd.CommandText = "DELETE FROM AnotherItem";
await (cmd.ExecuteNonQueryAsync());
}
}
using (ISession session = OpenSession())
{
//should bring from cache
IList list = await (session.CreateCriteria(typeof(AnotherItem))
.Add(Expression.Gt("Id", 2))
.SetCacheable(true)
.ListAsync());
Assert.AreEqual(3, list.Count);
}
}0
48. Example
View license[Test]
public async Task SecondLevelCacheWithCriteriaQueriesForItemWithCollectionsAsync()
{
using (ISession session = OpenSession())
{
IList list = await (session.CreateCriteria(typeof(Item))
.Add(Expression.Gt("Id", 2))
.SetCacheable(true)
.ListAsync());
Assert.AreEqual(3, list.Count);
using (var cmd = session.Connection.CreateCommand())
{
cmd.CommandText = "DELETE FROM Item";
await (cmd.ExecuteNonQueryAsync());
}
}
using (ISession session = OpenSession())
{
//should bring from cache
IList list = await (session.CreateCriteria(typeof(Item))
.Add(Expression.Gt("Id", 2))
.SetCacheable(true)
.ListAsync());
Assert.AreEqual(3, list.Count);
}
}0
49. Example
View license[HttpGet]
public async Task<IActionResult> Index()
{
// [START exa/n ..... /n //View Source file for more details /n }0
50. Example
View licenseprivate static async Task WriteIntervalsAsync(IDictionary<string, int> zones, CurrentTzdbProvi/n ..... /n //View Source file for more details /n }
