System.Data.Common.DbDataReader.IsDBNullAsync(int)

Here are the examples of the csharp api class System.Data.Common.DbDataReader.IsDBNullAsync(int) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

public Task<bool> IsDbNullAsync(int ordinal)
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("IsDbNullAsync");
      return _sqlDataReader.IsDBNullAsync(ordinal);
    }

public Task<bool> IsDbNullAsync(int ordinal, System.Threading.CancellationToken cancellationToken)
    {
      if (_sqlDataReader == null)
        throw new NotSupportedException("IsDbNullAsync");
      return _sqlDataReader.IsDBNullAsync(ordinal, cancellationToken);
    }

public static async Task<string> GetFieldStringAsync(this DbDataReader reader, int fieldIndex)
    {
      if (await reader.IsDBNullAsync(fieldIndex))
        return null;
      return await reader.GetFieldValueAsync<string>(fieldIndex);
    }

public static async Task<int> GetFieldIntAsync(this DbDataReader reader, int fieldIndex)
    {
      if (await reader.IsDBNullAsync(fieldIndex))
        return -1;
      return await reader.GetFieldValueAsync<int>(fieldIndex);
    }

public static async Task<TValue> GetValueOrDefaultAsync<TValue>(this DbDataReader record, int ordinal, TValue @default = default(TValue))
		{
			return (await record.IsDBNullAsync(ordinal).ConfigureAwait(false)) ? @default : (await record.GetFieldValueAsync<TValue>(ordinal).ConfigureAwait(false));
		}

[ConfigureAwait( false )]
		internal static async Task<MessageCacheEntry> Read( DbDataReader reader )
		{
			var id = reader.GetInt64( 0 );
			var sender = reader.GetInt64( 1 );
			var recipient = reader.GetInt64( 2 );

			string data = string.Empty;
			if( !await reader.IsDBNullAsync( 3 ) )
			{
				data = await reader.GetFieldValueAsync<string>( 3 );
			}

			return new MessageCacheEntry( (ulong)id, (ulong)sender, (ulong)recipient, data );
		}

[ConfigureAwait( false )]
		internal static async Task<UserCacheEntry> Read( DbDataReader reader )
		{
			var id = reader.GetInt64( 0 );
			var name = await reader.GetFieldValueAsync<string>( 1 );

			string data = string.Empty;
			if( !await reader.IsDBNullAsync( 2 ) )
			{
				data = await reader.GetFieldValueAsync<string>( 2 );
			}

			return new UserCacheEntry( (ulong)id, name, data );
		}

public static async Task<TValue> GetValueOrDefaultAsync<TValue>(this DbDataReader record, string fieldName, TValue @default = default(TValue))
		{
			var ordinal = record.GetOrdinal(fieldName);
			return (await record.IsDBNullAsync(ordinal).ConfigureAwait(false)) ? @default : (await record.GetFieldValueAsync<TValue>(ordinal).ConfigureAwait(false));
		}

private async Task<IList<string>> GetAllTables(DbConnection connection)
        {
            var tables = new List<string>();

            string commandText = DbAdapter.BuildTableCommandText(this);

            using (var cmd = connection.CreateCommand())
            {
                cmd.CommandText = commandText;
                using (var reader = await cmd.ExecuteReaderAsync())
                {
                    while (await reader.ReadAsync())
                    {
                        if (!await reader.IsDBNullAsync(0))
                        {
                            tables.Add($"{DbAdapter.QuoteCharacter}{reader.GetString(0)}{DbAdapter.QuoteCharacter}.{DbAdapter.QuoteCharacter}{reader.GetString(1)}{DbAdapter.QuoteCharacter}");
                        }
                        else
                        {
                            tables.Add($"{DbAdapter.QuoteCharacter}{reader.GetString(1)}{DbAdapter.QuoteCharacter}");
                        }
                    }
                }
            }

            return tables.ToList();
        }

private async Task<string> GetDatabaseSchemaAsync(DbConnection connection)
        {
         /n ..... /n //View Source file for more details /n }