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

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

public T Resolve(DbDataReader reader, IIdentityMap map, QueryStatistics stats)
        {
            if (!typeof(T).IsSimple())
            {
                var json = reader.As<DbDataReader>().GetTextReader(0);
                return _serializer.FromJson<T>(json);
            }


            return reader.GetFieldValue<T>(0);
        }

public TResult Resolve(DbDataReader reader, IIdentityMap map, QueryStatistics stats)
        {
            try
            {
                return reader.GetFieldValue<TResult>(0);
            }
            catch (InvalidCastException e)
            {
                throw new InvalidOperationException(NullResultMessage, e);
            }
        }

virtual public Task<T> GetFieldValueAsync<T>(int ordinal, CancellationToken cancellationToken) {
            if (cancellationToken.IsCancellationRequested) {
                return ADP.CreatedTaskWithCancellation<T>();
            }
            else {
                try {
                    return Task.FromResult<T>(GetFieldValue<T>(ordinal));
                }
                catch (Exception e) {
                    return ADP.CreatedTaskWithException<T>(e);
                }
            }
        }

public MySqlGeometry GetMySqlGeometry(int i)
    {
      try
      {
        IMySqlValue v = GetFieldValue(i, false);
        if (v is MySqlGeometry || v is MySqlBinary)
          return new MySqlGeometry(MySqlDbType.Geometry, (Byte[])v.Value);
      }
      catch
      {
        Throw(new Exception("Can't get MySqlGeometry from value"));
      }
      return new MySqlGeometry(true);
    }

public T? Resolve(DbDataReader reader, IIdentityMap map, QueryStatistics stats)
        {
            return reader.IsDBNull(0) ? null : (T?)reader.GetFieldValue<T>(0);
        }

public static T GetValueOrDefault<T>([NotNull] this DbDataReader reader, [NotNull] string name)
        {
            var idx = reader.GetOrdinal(name);
            return reader.IsDBNull(idx)
                ? default(T)
                : reader.GetFieldValue<T>(idx);
        }

public void Postprocess(DbDataReader reader, IList<Exception> exceptions)
        {
            reader.Read();
            var values = reader.GetFieldValue<int[]>(0);

            applyDataFromSproc(values);
        }

public StreamState Resolve(DbDataReader reader, IIdentityMap map, QueryStatistics stats)
        {
            var id = reader.GetFieldValue<Guid>(0);
            var version = reader.GetFieldValue<int>(1);
            var typeName = reader.IsDBNull(2) ? null : reader.GetFieldValue<string>(2);
            var timestamp = reader.GetFieldValue<DateTime>(3);
            var created = reader.GetFieldValue<DateTime>(4);

            Type aggregateType = null;
            if (typeName.IsNotEmpty())
            {
                aggregateType = _events.AggregateTypeFor(typeName);
            }

            return new StreamState(id, version, aggregateType, timestamp.ToUniversalTime(), created);
        }

public StreamState Resolve(DbDataReader reader, IIdentityMap map, QueryStatistics stats)
        {
            var id = reader.GetFieldValue<string>(0);
            var version = reader.GetFieldValue<int>(1);
            var typeName = reader.IsDBNull(2) ? null : reader.GetFieldValue<string>(2);
            var timestamp = reader.GetFieldValue<DateTime>(3);
            var created = reader.GetFieldValue<DateTime>(4);

            Type aggregateType = null;
            if (typeName.IsNotEmpty())
            {
                aggregateType = _events.AggregateTypeFor(typeName);
            }

            return new StreamState(id, version, aggregateType, timestamp.ToUniversalTime(), created);
        }

public T Handle(DbDataReader reader, IIdentityMap map, QueryStatistics stats)
        {
            var hasNext = reader.Read();
            return hasNext && !reader.IsDBNull(0)
                ? reader.GetFieldValue<T>(0)
                : default(T);
        }

public T Resolve(int startingIndex, DbDataReader reader, IIdentityMap map)
        {
            var json = reader.GetTextReader(startingIndex);
            var id = reader[startingIndex + 1];

            var version = reader.GetFieldValue<Guid>(3);
            var typeAlias = reader.GetString(startingIndex + 2);

            var actualType = _mapping.TypeFor(typeAlias);

            return map.Get<TBase>(id, actualType, json, version) as T;
        }

public override T Resolve(int startingIndex, DbDataReader reader, IIdentityMap map)
        {
            var json = reader.GetTextReader(startingIndex);
            var id = reader[startingIndex + 1];
            var typeAlias = reader.GetString(startingIndex + 2);

            var version = reader.GetFieldValue<Guid>(3);

            return map.Get<T>(id, _hierarchy.TypeFor(typeAlias), json, version);
        }

public virtual T Resolve(int startingIndex, DbDataReader reader, IIdentityMap map)
        {
            if (reader.IsDBNull(startingIndex)) return null;

            var json = reader.GetTextReader(startingIndex);
            var id = reader[startingIndex + 1];

            var version = reader.GetFieldValue<Guid>(startingIndex + 2);

            return map.Get<T>(id, json, version);
        }

public virtual T Fetch(object id, DbDataReader reader, IIdentityMap map)
        {
            var found = reader.Read();
            if (!found) return null;

            var json = reader.GetTextReader(0);

            var version = reader.GetFieldValue<Guid>(2);

            return map.Get<T>(id, json, version);
        }

public void Postprocess(DbDataReader reader, IList<Exception> exceptions)
        {
            var success = false;
            if (reader.Read())
            {
                var version = reader.GetFieldValue<Guid>(0);
                success = version == _newVersion;
            };

            checkAndStoreVersions(exceptions, success);
        }

private T GetOptionalFieldValue<T>(DbDataReader reader, string fieldName)
        {
            int ordinal;
            if (_fields.TryGetValue(fieldName, out ordinal) && !reader.IsDBNull(ordinal))
                return reader.GetFieldValue<T>(ordinal);
            return default(T);
        }

private T? GetOptionalFieldValue<T>(DbDataReader reader, string fieldName, T? defaultValue) where T : struct
        {
            int ordinal;
            if (_fields.TryGetValue(fieldName, out ordinal) && !reader.IsDBNull(ordinal))
                return reader.GetFieldValue<T>(ordinal);
            return defaultValue;
        }

public async Task<dynamic> Consultar()
		{
			using (Banco banco = new Banco())
			{
				var lstRetorno = new List<dynamic>();

				DbDataReader reader = await banco.ExecuteReaderAsync("SELECT id, sigla, nome FROM partido order by nome;");
				while (reader.Read())
				{
					lstRetorno.Add(new
					{
						id = reader.GetFieldValue<uint>(0),
						tokens = new[] { reader.GetFieldValue<string>(1), reader.GetFieldValue<string>(2) },
						text = reader.GetFieldValue<string>(2)
					});
				}

				return lstRetorno;
			}
		}

private static async Task<T> ExecuteScalarImplAsync<T>(
            SpannerConnection spannerConnection,
            ExecuteSqlRequest request,
            int commandTimeout,
            ISpannerTransaction spannerTransaction,
            DbTransaction transaction,
            Logger logger,
            CancellationToken cancellationToken)
        {
            using (var reader = await ExecuteDbDataReaderImplAsync(
                spannerConnection,
                request,
                commandTimeout,
                spannerTransaction,
                CommandBehavior.SingleRow,
                null,
                logger,
                cancellationToken)
                .ConfigureAwait(false))
            {
                if (await reader.ReadAsync(cancellationToken).ConfigureAwait(false) && reader.HasRows &&
                    reader.FieldCount > 0)
                {
                    return reader.GetFieldValue<T>(0);
                }
            }
            return default;
        }

public override T Fetch(object id, DbDataReader reader, IIdentityMap map)
        {
            if (!reader.Read()) return null;

            var json = reader.GetTextReader(0);
            var typeAlias = reader.GetString(2);

            var actualType = _hierarchy.TypeFor(typeAlias);

            var version = reader.GetFieldValue<Guid>(3);

            return map.Get<T>(id, actualType, json, version);
        }

public IEvent Resolve(DbDataReader reader, IIdentityMap map, QueryStatistics stats)
        {
            var id = reader.GetGuid(0);
            var eventTypeName = reader.GetString(1);
            var version = reader.GetInt32(2);
            var dataJson = reader.GetTextReader(3);


            var mapping = Events.EventMappingFor(eventTypeName);

            if (mapping == null)
            {
                var dotnetTypeName = reader.GetFieldValue<string>(8);
                if (dotnetTypeName.IsEmpty())
                {
                    throw new UnknownEventTypeException(eventTypeName);
                }

                var type = Events.TypeForDotNetName(dotnetTypeName);
                mapping = Events.EventMappingFor(type);
            }

            var data = _serializer.FromJson(mapping.DocumentType, dataJson).As<object>();

            var sequence = reader.GetFieldValue<long>(4);
            var stream = reader.GetFieldValue<Guid>(5);
            var timestamp = reader.GetFieldValue<DateTimeOffset>(6);
            var tenantId = reader.GetFieldValue<string>(7);

            var @event = EventStream.ToEvent(data);
            @event.Version = version;
            @event.Id = id;
            @event.Sequence = sequence;
            @event.StreamId = stream;
            @event.Timestamp = timestamp;
            @event.TenantId = tenantId;


            return @event;
        }

public IEvent Resolve(DbDataReader reader, IIdentityMap map, QueryStatistics stats)
        {
            var id = reader.GetGuid(0);
            var eventTypeName = reader.GetString(1);
            var version = reader.GetInt32(2);
            var dataJson = reader.GetTextReader(3);


            var mapping = Events.EventMappingFor(eventTypeName);

            if (mapping == null)
            {
                var dotnetTypeName = reader.GetFieldValue<string>(8);
                if (dotnetTypeName.IsEmpty())
                {
                    throw new UnknownEventTypeException(eventTypeName);
                }

                var type = Events.TypeForDotNetName(dotnetTypeName);
                mapping = Events.EventMappingFor(type);
            }

            var data = _serializer.FromJson(mapping.DocumentType, dataJson).As<object>();

            var sequence = reader.GetFieldValue<long>(4);
            var stream = reader.GetFieldValue<string>(5);
            var timestamp = reader.GetFieldValue<DateTimeOffset>(6);
            var tenantId = reader.GetFieldValue<string>(7);

            var @event = EventStream.ToEvent(data);
            @event.Version = version;
            @event.Id = id;
            @event.Sequence = sequence;
            @event.StreamKey = stream;
            @event.Timestamp = timestamp;
            @event.TenantId = tenantId;


            return @event;
        }

public DocumentMetadata Handle(DbDataReader reader, IIdentityMap map, QueryStatistics stats)
        {
            if (!reader.Read()) return null;

            var version = reader.GetFieldValue<Guid>(0);
            var timestamp = reader.GetFieldValue<DateTime>(1);
            var dotNetType = reader.GetFieldValue<string>(2);
            var docType = GetOptionalFieldValue<string>(reader, DocumentMapping.DocumentTypeColumn);
            var deleted = GetOptionalFieldValue<bool>(reader, DocumentMapping.DeletedColumn);
            var deletedAt = GetOptionalFieldValue<DateTime>(reader, DocumentMapping.DeletedAtColumn, null);
            var tenantId = GetOptionalFieldValue<string>(reader, TenantIdColumn.Name);

            var metadata = new DocumentMetadata(timestamp, version, dotNetType, docType, deleted, deletedAt);
            metadata.TenantId = tenantId ?? Tenancy.DefaultTenantId;

            return metadata;
        }

public IEnumerable<T> Query<T>(string sql, params object[] parameters)
        {
            using (var command = CreateCommand(sql, parameters))
            {
                using (var dataReader = command.ExecuteReader())
                {
                    var results = Enumerable.Empty<T>();

                    while (dataReader.Read())
                    {
                        results = results.Concat(new[] { dataReader.GetFieldValue<T>(0) });
                    }

                    return results;
                }
            }
        }

public override T GetFieldValue<T>(int ordinal)
        {
            InduceErrorIfClosed();
            WaitForReaderOrThrow();

            if (this.IsPseudoColumnReference(ordinal))
            {
                // It is a reference to our ShardName pseudo column.
                // In this case, only a string type is valid for our T parameter, so check that, and 
                // either return properly or throw an InvalidCast.
                //

                if (typeof(T) == typeof(string))
                {
                    string rVal = this.GetCurrentShardLabel();
                    return (T)Convert.ChangeType(rVal, typeof(T));
                }
                throw new InvalidCastException();
            }
            else
            {
                return this.GetCurrentDataReader().GetFieldValue<T>(ordinal);
            }
        }