private List <ColumnInfo> GetColumns(IRow headerRow, Type type)
{
//
// Column mapping priority:
// Map<T> > ColumnAttribute > naming convention > column filter.
//
var sheetName = headerRow.Sheet.SheetName;
var columns = new List <ColumnInfo>();
var columnsCache = new List <object>(); // Cached for export usage.
// Prepare a list of ColumnInfo by the first row.
foreach (ICell header in headerRow)
{
// Custom mappings via attributes.
var column = GetColumnInfoByAttribute(header, type);
// Naming convention.
if (column == null && HasHeader && MapHelper.GetCellType(header) == CellType.String)
{
var s = header.StringCellValue;
if (!string.IsNullOrWhiteSpace(s))
{
column = GetColumnInfoByName(s.Trim(), header.ColumnIndex, type);
}
}
// Column filter.
if (column == null)
{
column = GetColumnInfoByFilter(header, _columnFilter);
if (column != null) // Set default resolvers since the column is not mapped explicitly.
{
column.Attribute.TryPut = _defaultPutResolver;
column.Attribute.TryTake = _defaultTakeResolver;
}
}
if (column == null)
{
continue; // No property was mapped to this column.
}
if (header.CellStyle != null)
{
column.HeaderFormat = header.CellStyle.DataFormat;
}
columns.Add(column);
columnsCache.Add(column);
}
var typeDict = TrackedColumns.ContainsKey(sheetName)
? TrackedColumns[sheetName]
: TrackedColumns[sheetName] = new Dictionary <Type, List <object> >();
typeDict[type] = columnsCache;
return(columns);
}
private ColumnInfo GetColumnInfoByDynamicAttribute(ICell header)
{
var cellType = MapHelper.GetCellType(header);
var index = header.ColumnIndex;
foreach (var pair in DynamicAttributes)
{
var attribute = pair.Value;
// If no header, cannot get a ColumnInfo by resolving header string.
if (!HasHeader && attribute.Index < 0)
{
continue;
}
var headerValue = HasHeader ? GetHeaderValue(header) : null;
var indexMatch = attribute.Index == index;
var nameMatch = cellType == CellType.String && string.Equals(attribute.Name, header.StringCellValue);
// Index takes precedence over Name.
if (indexMatch || (attribute.Index < 0 && nameMatch))
{
// Use a clone so no pollution to original attribute,
// The origin might be used later again for multi-column/DefaultResolverType purpose.
attribute = attribute.Clone(index);
return(new ColumnInfo(headerValue, attribute));
}
}
return(null);
}
private Type GetDynamicType(ISheet sheet)
{
var firstRowIndex = sheet.FirstRowNum;
var firstRow = sheet.GetRow(firstRowIndex);
var names = new Dictionary <string, Type>();
foreach (var header in firstRow)
{
var column = GetColumnInfoByDynamicAttribute(header);
var type = Helper.InferColumnDataType(sheet, HasHeader ? sheet.FirstRowNum : -1, header.ColumnIndex);
if (column != null)
{
names[column.Attribute.PropertyName] = type ?? typeof(string);
}
else
{
var headerValue = GetHeaderValue(header);
var tempColumn = new ColumnInfo(headerValue, header.ColumnIndex, null);
if (_columnFilter != null && !_columnFilter(tempColumn))
{
continue;
}
string propertyName;
if (HasHeader && MapHelper.GetCellType(header) == CellType.String)
{
propertyName = MapHelper.GetVariableName(header.StringCellValue, IgnoredNameChars,
TruncateNameFrom, header.ColumnIndex);
}
else
{
propertyName = MapHelper.GetVariableName(null, null, null, header.ColumnIndex);
}
names[propertyName] = type ?? typeof(string);
DynamicAttributes[propertyName] = new ColumnAttribute((ushort)header.ColumnIndex)
{
PropertyName = propertyName
};
}
}
return(AnonymousTypeFactory.CreateType(names, true));
}
