public T GetEntity <T>(
DataReaderEnumerator enumerator,
params Reflection.IPropertyAssigner[] CustomPropertyAssigners) where T : new()
{
return(GetEntities <T>(enumerator, CustomPropertyAssigners)
.FirstOrDefault());
}
public T RunScalarFunctionResult <T>(string ScalarFunctionName, T DefaultValue, out bool Result, params IDataParameter[] parameters)
{
Result = false;
DBOpenResults firstConnectionState = DBOpenResults.Failed;
try
{
firstConnectionState = Open();
if (!IsConnectionOpen && firstConnectionState == DBOpenResults.Failed)
{
return(DefaultValue);
}
var reader = RunStatement(BuildScalarFunctionStatement(ScalarFunctionName, parameters), parameters, out Result);
while (reader.Read())
{
return((T)reader.GetValue(0));
}
DataReaderEnumerator.HandleDataReader(reader);
}
catch (System.Exception e)
{
SetLastExceptionError(e);
Result = false;
}
finally
{
Close(firstConnectionState);
}
return(DefaultValue);
}
public virtual DataReaderEnumerator CreateTableEnumerator(string TableName, string[] OrderByColumns)
{
var enumerator = new DataReaderEnumerator()
{
RunProcedureHandler = (out bool result) =>
{
return(RunStatement(BuildTableStatement(TableName, OrderByColumns), null, out result));
}
};
return(enumerator);
}
public DataReaderEnumerator CreateProcedureEnumerator(string SPName, IDataParameter[] parameters)
{
var enumerator = new DataReaderEnumerator()
{
RunProcedureHandler = (out bool result) =>
{
return(RunProcedure(SPName, parameters, out result));
}
};
return(enumerator);
}
/// <summary>
/// Runs as Procedure. No Paging / Ordering.
/// </summary>
public DataReaderEnumerator CreateStatementEnumerator(string Statement, params IDataParameter[] parameters)
{
var enumerator = new DataReaderEnumerator()
{
RunProcedureHandler = (out bool result) =>
{
return(this.RunStatement(Statement, parameters, out result));
}
};
return(enumerator);
}
public virtual DataReaderEnumerator CreateTableFunctionEnumerator(string TableFunctionName, string[] OrderByColumns, params IDataParameter[] parameters)
{
var enumerator = new DataReaderEnumerator()
{
RunProcedureHandler = (out bool result) =>
{
return(RunStatement(BuildTableFunctionStatement(TableFunctionName, OrderByColumns, parameters), parameters, out result));
}
};
return(enumerator);
}
public void WrapDataReader(DbDataReader reader, Action <DbDataReader> action)
{
try
{
if (action != null)
{
action(reader);
}
}
catch (Exception e)
{
throw e;
}
finally
{
DataReaderEnumerator.HandleDataReader(reader);
}
}
public IEnumerable <T> GetEntities <T>(
DataReaderEnumerator enumerator,
params Reflection.IPropertyAssigner[] CustomPropertyAssigners) where T : new()
{
var _keepConnection = this.Open();
if (_keepConnection == DBOpenResults.Failed)
{
yield break;
}
try
{
Reflection.PropertyAssignerAttribute _PropertyAssigner = null;
bool ignoreProperty = false;
Type ColumnType = null;
using (enumerator)
{
enumerator.Open();
if (!enumerator.CurrentRow.isValid)
{
yield break;
}
var typeProperties = typeof(T).GetProperties();
Reflection.PropertyAssignerAttribute[] properties = new Reflection.PropertyAssignerAttribute[typeProperties.Length];
for (int pIndex = 0; pIndex < typeProperties.Length; pIndex++)
{
var p = typeProperties[pIndex];
//reset every property
ignoreProperty = false;
#region try get _PropertyAssigner for this property
//custom assigner in high priority
_PropertyAssigner = CustomPropertyAssigners == null ? null : CustomPropertyAssigners
.OfType <Reflection.PropertyAssignerAttribute>()
.FirstOrDefault(c => c.CustomPropertyName == p.Name);
if (_PropertyAssigner == null)
{
foreach (var attr in p.GetCustomAttributes(typeof(Reflection.IPropertyAssigner), true))
{
if (attr is Reflection.PropertyAssignerIgnoreAttribute)
{
ignoreProperty = true;
break;
}
if (attr is Reflection.PropertyAssignerAttribute)
{
_PropertyAssigner = attr as Reflection.PropertyAssignerAttribute;
}
}
if (ignoreProperty)
{
continue;
}
}
if (_PropertyAssigner != null)
{
_PropertyAssigner.Property = p;
_PropertyAssigner.CustomPropertyName = p.Name;
}
#endregion
#region match column to this property
for (int i = 0; i < enumerator.CurrentRow.Columns.Length; i++)
{
ColumnType = enumerator.CurrentRow.DataReader.GetFieldType(i);
if (_PropertyAssigner != null)
{
#region property with assigner (as attribute/custom)
if ((_PropertyAssigner.DBColumnName ?? _PropertyAssigner.CustomPropertyName ?? p.Name) == enumerator.CurrentRow.Columns[i])
{
if (_PropertyAssigner.HasConvertor)
{
if (_PropertyAssigner.CustomValueConverter != null)
{
}
else if (!String.IsNullOrEmpty(_PropertyAssigner.TypeConvertFunctionName))
{
_PropertyAssigner.GetConvertFunction <T>();
}
_PropertyAssigner.ColumnIndex = i;
properties[pIndex] = _PropertyAssigner;
}
else if (ColumnType == p.PropertyType ||
ColumnType == Nullable.GetUnderlyingType(p.PropertyType) ||
CheckTypesConverter(p.PropertyType, ColumnType) ||
p.PropertyType.IsAssignableFrom(ColumnType))
{
_PropertyAssigner.ColumnIndex = i;
properties[pIndex] = _PropertyAssigner;
}
}
#endregion
}
else
{
#region property without assigner
if (p.Name == enumerator.CurrentRow.Columns[i])
{
if (ColumnType == p.PropertyType ||
ColumnType == Nullable.GetUnderlyingType(p.PropertyType) ||
CheckTypesConverter(p.PropertyType, ColumnType) ||
p.PropertyType.IsAssignableFrom(ColumnType))
{
properties[pIndex] = new Reflection.PropertyAssignerAttribute()
{
ColumnIndex = i,
Property = p,
DBColumnName = enumerator.CurrentRow.Columns[i]
};
}
else
{
var fixedValueConverter = HasFixedAssigner(ColumnType, p.PropertyType);
if (fixedValueConverter != null)
{
properties[pIndex] = new Reflection.PropertyAssignerAttribute()
{
ColumnIndex = i,
Property = p,
DBColumnName = enumerator.CurrentRow.Columns[i],
CustomValueConverter = fixedValueConverter
};
}
else
{
throw new Reflection.IncompatibleColumnTypeException()
{
DbColumnName = enumerator.CurrentRow.Columns[i],
DbColumnType = ColumnType,
DbColumnExpectedType = p.PropertyType
};
}
}
}
#endregion
}
if (properties[pIndex] != null)
{
break;
}
}
#endregion
}
#region print values
T value;
bool hasValue = false;
while (enumerator.Read())
{
value = new T();
foreach (var p in properties)
{
if (p == null || p.Property.SetMethod == null)
{
continue;
}
hasValue = hasValue || !enumerator.CurrentRow.DataReader.IsDBNull(p.ColumnIndex);
p.Assign(enumerator.CurrentRow.DataReader, value);
}
yield return(hasValue ? value : default(T));
}
#endregion
}
}
finally
{
if (_keepConnection == DBOpenResults.SuccessfullyOpened)
{
Close();
}
}
}
