public virtual T CreateDataAccessObject <T, K>(K primaryKey, PrimaryKeyType primaryKeyType)
where T : DataAccessObject
{
var objectPropertyAndValues = this.GetObjectPropertyValues <K>(typeof(T), primaryKey, primaryKeyType);
if (objectPropertyAndValues.Any(keyValue => keyValue.Value == null))
{
throw new MissingOrInvalidPrimaryKeyException();
}
var existing = this.GetCurrentDataContext(false).GetObject(this.GetConcreteTypeFromDefinitionType(typeof(T)), objectPropertyAndValues);
if (existing != null)
{
T obj = null;
ActionUtils.IgnoreExceptions(() => obj = this.GetReference <T, K>(primaryKey, primaryKeyType));
throw new ObjectAlreadyExistsException(obj, null, "CreateDataAccessObject");
}
else
{
var retval = this.RuntimeDataAccessModelInfo.CreateDataAccessObject <T>(this, true);
retval.ToObjectInternal().SetPrimaryKeys(objectPropertyAndValues);
retval.ToObjectInternal().FinishedInitializing();
retval.ToObjectInternal().SubmitToCache();
return(retval);
}
}
private void mapAttributeInformation(String propertyName, Attribute annotation)
{
if (typeof(Column).IsAssignableFrom(annotation.GetType()))
{
if (((Column)annotation).fetch == FetchType.EAGER)
{
fetchTypes.Add(propertyName, FetchType.EAGER);
}
if (annotation.GetType() == typeof(OneToMany))
{
OneToMany oneToManyAtt = (OneToMany)annotation;
oneToMany.Add(propertyName, oneToManyAtt.pkName + "@" +
oneToManyAtt.tableName + "@" + oneToManyAtt.fkName);
return;
}
}
if (annotation.GetType() == typeof(Id))
{
Id idAtt = (Id)annotation;
idName = propertyName;
primaryKeyType = idAtt.type;
}
mappings.Add(propertyName, ((MappingAttribute)annotation).name);
}
/// <summary>
/// 生成唯一主建
/// </summary>
/// <param name="keyType">主建类型</param>
/// <param name="keyLen">主建长度</param>
/// <returns></returns>
public static string MakePrimaryKey(PrimaryKeyType keyType, PrimaryKeyLen keyLen)
{
var primaryKey = string.Empty;
lock (locker)
{
switch (keyType)
{
case PrimaryKeyType.Other:
if (keyLen == PrimaryKeyLen.V4)
{
primaryKey = GetGuidString();
}
else
{
primaryKey = BitConverter.ToInt64(Guid.NewGuid().ToByteArray(), 0).ToString();
}
break;
default:
if (keyLen == PrimaryKeyLen.V1)
{
primaryKey = GetKeyString(keyType);
}
else
{
primaryKey = GetKeyString(keyType, (int)keyLen);
}
break;
}
}
return(primaryKey);
}
/// <summary>
/// 创建key字符串 10位
/// </summary>
/// <param name="keyType">主建类型</param>
/// <returns></returns>
private static string GetKeyString(PrimaryKeyType keyType)
{
try
{
int keyLen = 10;
var primaryKey = string.Empty;
lock (locker)
{
var k = BitConverter.ToInt32(Guid.NewGuid().ToByteArray(), 0);
if (k < 0)
{
k = -k;
}
primaryKey = (int)keyType + k.ToString();
while (primaryKey.Length < keyLen)
{
primaryKey += new Random(k).Next();
}
primaryKey = primaryKey.Substring(0, keyLen);
}
return(primaryKey);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
/// <summary>
/// 根据主键类型转换为编码字符串
/// </summary>
/// <param name="pkType">主键类型</param>
/// <returns>编码字符串</returns>
public static string ToCodeString(this PrimaryKeyType pkType)
{
switch (pkType)
{
case PrimaryKeyType.INT:
return("int");
case PrimaryKeyType.STRING:
return("string");
case PrimaryKeyType.GUID:
return("Guid");
case PrimaryKeyType.SNOWFLAKE:
return("long");
default:
return(null);
}
}
/// <summary>
/// Initialises a new instance of TableAttribute with the specified table name, primary key property and the primary key type.
/// </summary>
/// <param name="tableName">The name of the table in the system which holds the data for the attributed class.</param>
/// <param name="primaryKey">The name of the property in the attributed class which provides a unique identifier for this class.</param>
/// <param name="keyType">The type of primary key used to identify unique instances of this class.</param>
public TableAttribute(string tableName, string primaryKey, PrimaryKeyType keyType)
{
this.tableName = tableName;
this.primaryKey = primaryKey;
this.keyType = keyType;
defaultOrder = String.Empty;
}
public virtual T GetReference <T, K>(K primaryKey, PrimaryKeyType primaryKeyType = PrimaryKeyType.Auto)
where T : DataAccessObject
{
var propertyValues = this.GetObjectPropertyValues <K>(typeof(T), primaryKey, primaryKeyType);
return(this.GetReference <T>(propertyValues));
}
private void AddKeyMapping(PrimaryKeyType type, string columnName, string propertyName)
{
AddMapping(columnName, propertyName);
KeyType = type;
KeyGeneration = PrimaryKeyGeneration.None;
KeyColumn = columnName;
KeyProperty = propertyName;
}
public override bool Equals(object obj)
{
TypeFk compareTo = obj as TypeFk;
if (compareTo != null)
{
return(PrimaryKeyType.Equals(compareTo.PrimaryKeyType) && ForeignKeyType.Equals(compareTo.ForeignKeyType));
}
return(base.Equals(obj));
}
public virtual IQueryable <T> GetQueryableByPrimaryKey <K>(K primaryKey, PrimaryKeyType primaryKeyType = PrimaryKeyType.Auto)
{
if (this.idType == null)
{
throw new NotSupportedException($"Type {this.typeDescriptor.PersistedName} does not define any primary keys");
}
if (typeof(K) == this.idType && !this.idType.IsDataAccessObjectType())
{
if (this.typeDescriptor.PrimaryKeyCount != 1)
{
throw new ArgumentException("Composite primary key expected", nameof(primaryKey));
}
var parameterExpression = Expression.Parameter(typeof(T), "value");
var body = Expression.Equal(Expression.Property(parameterExpression, this.primaryKeyProperty), Expression.Constant(primaryKey));
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
else if (primaryKeyType == PrimaryKeyType.Single || TypeDescriptor.IsSimpleType(typeof(K)))
{
if (this.typeDescriptor.PrimaryKeyCount != 1)
{
throw new ArgumentException("Composite primary key expected", nameof(primaryKey));
}
var parameterExpression = Expression.Parameter(typeof(T), "value");
var body = Expression.Equal(Expression.Property(parameterExpression, this.primaryKeyProperty), Expression.Constant(Convert.ChangeType(primaryKey, this.idType)));
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
else
{
var deflated = this.DataAccessModel.GetReference <T, K>(primaryKey, primaryKeyType);
var parameterExpression = Expression.Parameter(typeof(T), "value");
var body = Expression.Equal(parameterExpression, Expression.Constant(deflated));
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
}
public virtual IQueryable <T> GetQueryableByPrimaryKey <K>(K primaryKey, PrimaryKeyType primaryKeyType = PrimaryKeyType.Auto)
{
if (typeof(K) == IdType)
{
if (this.typeDescriptor.PrimaryKeyCount != 1)
{
throw new ArgumentException("Composite primary key expected", "primaryKey");
}
var parameterExpression = Expression.Parameter(typeof(T), "value");
var body = Expression.Equal(Expression.Property(parameterExpression, PrimaryKeyInfoCache <T> .IdPropertyInfo), Expression.Constant(primaryKey));
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
else if (primaryKeyType == PrimaryKeyType.Single || TypeDescriptor.IsSimpleType(typeof(K)))
{
if (this.typeDescriptor.PrimaryKeyCount != 1)
{
throw new ArgumentException("Composite primary key expected", "primaryKey");
}
var parameterExpression = Expression.Parameter(typeof(T), "value");
var body = Expression.Equal(Expression.Property(parameterExpression, PrimaryKeyInfoCache <T> .IdPropertyInfo), Expression.Constant(Convert.ChangeType(primaryKey, IdType)));
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
else
{
var deflated = this.DataAccessModel.GetReference <T, K>(primaryKey, primaryKeyType);
var parameterExpression = Expression.Parameter(typeof(T), "value");
var body = Expression.Equal(parameterExpression, Expression.Constant(deflated));
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
}
public virtual IQueryable <T> GetManyByPrimaryKey <K>(IEnumerable <K> primaryKeys, PrimaryKeyType primaryKeyType)
{
if (this.idType == null)
{
throw new NotSupportedException($"Type {this.typeDescriptor.PersistedName} does not define any primary keys");
}
if (primaryKeys == null)
{
throw new ArgumentNullException(nameof(primaryKeys));
}
if (primaryKeyType == PrimaryKeyType.Single || TypeDescriptor.IsSimpleType(typeof(K)) || (typeof(K) == this.idType && primaryKeyType != PrimaryKeyType.Composite))
{
if (!TypeDescriptor.IsSimpleType(this.idType))
{
throw new ArgumentException($"Type {typeof(K)} needs to be convertable to {this.idType}", nameof(primaryKeys));
}
if (this.typeDescriptor.PrimaryKeyCount != 1)
{
throw new ArgumentException("Composite primary key type expected", nameof(primaryKeys));
}
}
if (primaryKeyType == PrimaryKeyType.Single || TypeDescriptor.IsSimpleType(typeof(K)) || (typeof(K) == this.idType && primaryKeyType != PrimaryKeyType.Composite))
{
var propertyInfo = this.primaryKeyProperty;
var parameterExpression = Expression.Parameter(propertyInfo.PropertyType);
var body = Expression.Call(MethodInfoFastRef.EnumerableContainsMethod.MakeGenericMethod(propertyInfo.PropertyType), Expression.Constant(primaryKeyType), Expression.Property(parameterExpression, propertyInfo));
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
else
{
var parameterExpression = Expression.Parameter(typeof(T));
var deflatedObjects = primaryKeys
.Select(c => this.DataAccessModel.GetReference <T, K>(c, primaryKeyType))
.ToArray();
var body = Expression.Call(PrimaryKeyInfoCache <T> .EnumerableContainsMethod, Expression.Constant(deflatedObjects), parameterExpression);
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
}
public virtual IQueryable <T> GetManyByPrimaryKey <K>(K[] primaryKeys, PrimaryKeyType primaryKeyType)
{
return(this.GetManyByPrimaryKey((IEnumerable <K>)primaryKeys, primaryKeyType));
}
protected internal ObjectPropertyValue[] GetObjectPropertyValues <K>(Type type, K primaryKey, PrimaryKeyType primaryKeyType = PrimaryKeyType.Auto)
{
if (primaryKey == null)
{
throw new ArgumentNullException(nameof(primaryKey));
}
var key = new Pair <RuntimeTypeHandle, RuntimeTypeHandle>(type.TypeHandle, Type.GetTypeHandle(primaryKey));
if (!this.objectPropertyValuesByAnonymousKeyFuncByType.TryGetValue(key, out var func))
{
var isSimpleKey = false;
var typeOfPrimaryKey = primaryKey.GetType();
var typeDescriptor = this.TypeDescriptorProvider.GetTypeDescriptor(type);
var idPropertyType = typeDescriptor.PrimaryKeyProperties[0].PropertyType;
if (primaryKeyType == PrimaryKeyType.Single || TypeDescriptor.IsSimpleType(typeOfPrimaryKey) || (typeDescriptor.PrimaryKeyCount == 1 && idPropertyType.IsAssignableFrom(typeOfPrimaryKey) && primaryKeyType == PrimaryKeyType.Auto))
{
isSimpleKey = true;
}
if (isSimpleKey && typeDescriptor.PrimaryKeyCount != 1)
{
throw new InvalidOperationException($"Composite primary key expected for type {type} instead of key of type {typeOfPrimaryKey}");
}
var parameter = Expression.Parameter(typeof(object));
var constructor = ConstructorInfoFastRef.ObjectPropertyValueConstructor;
var typedParameter = Expression.Convert(parameter, typeOfPrimaryKey);
var initializers = new List <Expression>();
var replacementPrimaryKeyValues = new Dictionary <string, Expression>();
if (typeDescriptor.PrimaryKeyDerivableProperties.Count > 0)
{
var properties = typeDescriptor
.PrimaryKeyDerivableProperties
.Where(c => typeOfPrimaryKey.GetMostDerivedProperty(c.PropertyName) != null)
.ToList();
replacementPrimaryKeyValues = properties.ToDictionary
(
c => c.ComputedMemberAssignTarget.Name,
c => SqlMemberAccessReplacer.Replace
(
c.ComputedMemberAssignmentValue,
c.PropertyInfo,
Expression.Convert(Expression.Property(typedParameter, typedParameter.Type.GetMostDerivedProperty(c.PropertyName)), c.PropertyInfo.PropertyType)
)
);
}
foreach (var property in typeDescriptor.PrimaryKeyProperties)
{
var isObjectType = property.PropertyType.IsDataAccessObjectType();
Expression valueExpression;
if (isSimpleKey)
{
valueExpression = parameter;
}
else
{
if (!replacementPrimaryKeyValues.TryGetValue(property.PropertyName, out valueExpression))
{
valueExpression = Expression.Property(typedParameter, typedParameter.Type.GetMostDerivedProperty(property.PropertyName));
}
}
Expression primaryKeyValue;
var propertyInfo = DataAccessObjectTypeBuilder.GetPropertyInfo(GetConcreteTypeFromDefinitionType(typeDescriptor.Type), property.PropertyName);
if (isObjectType)
{
var method = MethodInfoFastRef.DataAccessModelGetReferenceMethod.MakeGenericMethod(propertyInfo.PropertyType, valueExpression.Type);
if (isSimpleKey || valueExpression.Type.IsDataAccessObjectType())
{
primaryKeyValue = valueExpression;
}
else
{
primaryKeyValue = Expression.Call(Expression.Constant(this), method, valueExpression, Expression.Constant(PrimaryKeyType.Composite));
}
}
else
{
primaryKeyValue = Expression.Call(MethodInfoFastRef.ConvertChangeTypeMethod, Expression.Convert(valueExpression, typeof(object)), Expression.Constant(propertyInfo.PropertyType));
}
var newExpression = Expression.New
(
constructor,
Expression.Constant(propertyInfo.PropertyType),
Expression.Constant(property.PropertyName),
Expression.Constant(property.PersistedName),
Expression.Constant(property.PropertyName.GetHashCode()),
Expression.Convert(primaryKeyValue, typeof(object))
);
initializers.Add(newExpression);
}
var body = Expression.NewArrayInit(typeof(ObjectPropertyValue), initializers);
var lambdaExpression = Expression.Lambda(typeof(Func <object, ObjectPropertyValue[]>), body, parameter);
func = (Func <object, ObjectPropertyValue[]>)lambdaExpression.Compile();
this.objectPropertyValuesByAnonymousKeyFuncByType = this.objectPropertyValuesByAnonymousKeyFuncByType.Clone(key, func);
}
return(func(primaryKey));
}
public virtual T GetReference <T>(object primaryKey, PrimaryKeyType primaryKeyType = PrimaryKeyType.Auto)
where T : DataAccessObject
{
return((T)GetReference(typeof(T), GetObjectPropertyValues(typeof(T), primaryKey, primaryKeyType)));
}
/// <summary>
/// 生成唯一主建
/// </summary>
/// <param name="keyType">主建类型</param>
/// <returns></returns>
public static string MakePrimaryKey(PrimaryKeyType keyType)
{
return(MakePrimaryKey(keyType, PrimaryKeyLen.V2));
}
public List <T> ExcelToList <T>(List <string> properties, string filePath, string sheetName, bool isFirstRowColumn, string primaryKey, PrimaryKeyType pkType, int startKey)
{
List <T> retList = ReadToList <T>(properties, filePath, sheetName, isFirstRowColumn, primaryKey, pkType, startKey);
return(retList);
}
/// <summary>
/// Initializes a new instance of the <see cref="PrimaryKeyAttribute"/> class.
/// </summary>
/// <param name="generator">The generator.</param>
/// <param name="column">The column.</param>
public PrimaryKeyAttribute(PrimaryKeyType generator, string column)
{
Generator = generator;
Column = column;
}
public PrimaryKeyAttribute(PrimaryKeyType generator)
{
_generator = generator;
}
/// <summary>
/// Initializes a new instance of the <see cref="PrimaryKeyAttribute"/> class.
/// </summary>
/// <param name="generator">The generator.</param>
public PrimaryKeyAttribute(PrimaryKeyType generator)
{
this.generator = generator;
}
protected internal ObjectPropertyValue[] GetObjectPropertyValues <K>(Type type, K primaryKey, PrimaryKeyType primaryKeyType = PrimaryKeyType.Auto)
{
if (Equals(primaryKey, default(K)) && typeof(K).IsClass)
{
throw new ArgumentNullException(nameof(primaryKey));
}
var idType = primaryKey.GetType();
var primaryKeyTypeHandle = Type.GetTypeHandle(primaryKey);
Func <object, ObjectPropertyValue[]> func;
if (!this.propertyInfoAndValueGetterFuncByType.TryGetValue(primaryKeyTypeHandle, out func))
{
var isSimpleKey = false;
var typeOfPrimaryKey = Type.GetTypeFromHandle(primaryKeyTypeHandle);
var typeDescriptor = this.TypeDescriptorProvider.GetTypeDescriptor(type);
var idPropertyType = typeDescriptor.PrimaryKeyProperties[0].PropertyType;
if (primaryKeyType == PrimaryKeyType.Single || TypeDescriptor.IsSimpleType(idType) || (idPropertyType.IsAssignableFrom(idType) && primaryKeyType == PrimaryKeyType.Auto))
{
isSimpleKey = true;
}
if (isSimpleKey && typeDescriptor.PrimaryKeyCount != 1)
{
throw new InvalidOperationException("Composite primary key expected");
}
var parameter = Expression.Parameter(typeof(object));
var constructor = ConstructorInfoFastRef.ObjectPropertyValueConstructor;
var typedParameter = Expression.Convert(parameter, typeOfPrimaryKey);
var initializers = new List <Expression>();
var replacementPrimaryKeyValues = new Dictionary <string, Expression>();
if (typeDescriptor.PrimaryKeyDerivableProperties.Count > 0)
{
var properties = typeDescriptor
.PrimaryKeyDerivableProperties
.Where(c => idType.GetProperty(c.PropertyName, BindingFlags.Instance | BindingFlags.Public) != null)
.ToList();
replacementPrimaryKeyValues = properties.ToDictionary
(
c => c.ComputedMemberAssignTarget.Name,
c => MemberAccessReplacer.Replace
(
c.ComputedMemberAssignmentValue, c.PropertyInfo,
Expression.Property(typedParameter, c.PropertyName)
)
);
}
foreach (var property in typeDescriptor.PrimaryKeyProperties)
{
var isObjectType = property.PropertyType.IsDataAccessObjectType();
Expression valueExpression;
if (isSimpleKey)
{
valueExpression = parameter;
}
else
{
if (!replacementPrimaryKeyValues.TryGetValue(property.PropertyName, out valueExpression))
{
valueExpression = Expression.PropertyOrField(typedParameter, property.PropertyName);
}
}
Expression primaryKeyValue;
var propertyInfo = DataAccessObjectTypeBuilder.GetPropertyInfo(this.GetConcreteTypeFromDefinitionType(typeDescriptor.Type), property.PropertyName);
if (isObjectType)
{
var method = MethodInfoFastRef.DataAccessModelGetReferenceMethod.MakeGenericMethod(propertyInfo.PropertyType, valueExpression.Type);
if (isSimpleKey || valueExpression.Type.IsDataAccessObjectType())
{
primaryKeyValue = valueExpression;
}
else
{
primaryKeyValue = Expression.Call(Expression.Constant(this), method, valueExpression, Expression.Constant(PrimaryKeyType.Composite));
}
}
else
{
primaryKeyValue = Expression.Call(MethodInfoFastRef.ConvertChangeTypeMethod, Expression.Convert(valueExpression, typeof(object)), Expression.Constant(propertyInfo.PropertyType));
}
var newExpression = Expression.New
(
constructor,
Expression.Constant(propertyInfo.PropertyType),
Expression.Constant(property.PropertyName),
Expression.Constant(property.PersistedName),
Expression.Constant(property.PropertyName.GetHashCode()),
Expression.Convert(primaryKeyValue, typeof(object))
);
initializers.Add(newExpression);
}
var body = Expression.NewArrayInit(typeof(ObjectPropertyValue), initializers);
var lambdaExpression = Expression.Lambda(typeof(Func <object, ObjectPropertyValue[]>), body, parameter);
func = (Func <object, ObjectPropertyValue[]>)lambdaExpression.Compile();
var newPropertyInfoAndValueGetterFuncByType = new Dictionary <RuntimeTypeHandle, Func <object, ObjectPropertyValue[]> >(this.propertyInfoAndValueGetterFuncByType)
{
[primaryKeyTypeHandle] = func
};
this.propertyInfoAndValueGetterFuncByType = newPropertyInfoAndValueGetterFuncByType;
}
return(func(primaryKey));
}
protected internal virtual DataAccessObject GetReference <K>(Type type, K primaryKey, PrimaryKeyType primaryKeyType)
{
var primaryKeyValues = this.GetObjectPropertyValues(type, primaryKey, primaryKeyType);
return(this.GetReference(type, primaryKeyValues));
}
/// <summary>
/// 将excel中的数据导入到泛型List中
/// </summary>
/// <param name="filePath">文件保存的绝对路径，包含文件名</param>
/// <param name="sheetName">excel工作薄sheet的名称</param>
/// <param name="isFirstRowColumn">第一行是否为表头</param>
/// <returns>返回的List</returns>
private List <T> ReadToList <T>(List <string> properties, string filePath, string sheetName, bool isFirstRowColumn, string primaryKey = "", PrimaryKeyType pkType = PrimaryKeyType.无, int startKey = -1)
{
_workbook = null;
ISheet sheet = null;
List <T> list = new List <T>();
int startRow = -1;
if (pkType == PrimaryKeyType.数字 && startKey == -1)
{
return(null);
}
try
{
_fs = new FileStream(filePath, FileMode.Open, FileAccess.Read);
if (filePath.IndexOf(".xlsx") > 0) // 2007版本
{
_workbook = new XSSFWorkbook(_fs);
}
else if (filePath.IndexOf(".xls") > 0) // 2003版本
{
_workbook = new HSSFWorkbook(_fs);
}
if (_workbook == null)
{
return(null);
}
if (sheetName != null)
{
sheet = _workbook.GetSheet(sheetName);
if (sheet == null) //如果没有找到指定的sheetName对应的sheet，则尝试获取第一个sheet
{
sheet = _workbook.GetSheetAt(0);
}
}
else
{
sheet = _workbook.GetSheetAt(0);
}
if (sheet != null)
{
IRow firstRow = sheet.GetRow(0);
int cellCount = firstRow.LastCellNum; //一行最后一个cell的编号 即总的列数
//最后一列的标号
int rowCount = sheet.LastRowNum;
//查询第一列不合并的行
for (int i = 0; i <= rowCount; ++i)
{
IRow startRw = sheet.GetRow(i);
if (startRw != null)
{
for (int j = startRw.FirstCellNum; j < cellCount; ++j)
{
ICell cell = startRw.GetCell(j);
if (cell != null)
{
string cellValue = cell.StringCellValue;
if (cell.IsMergedCell)
{
if (j + 1 < cellCount)
{
ICell cellAdd = startRw.GetCell(j + 1);
if (cellAdd.StringCellValue == "")
{
break;
}
}
}
else
{
if (cellValue == "")
{
break;
}
}
if (j + 1 == cellCount)
{
startRow = i;
break;
}
}
}
}
if (startRow >= 0)
{
break;
}
}
int col = 0;
//取得数据
for (int i = startRow + 1; i <= rowCount; ++i)
{
IRow row = sheet.GetRow(i);
if (row == null)
{
continue; //没有数据的行默认是null
}
T s = System.Activator.CreateInstance <T>();
//属性赋值
if (pkType == PrimaryKeyType.无)
{
foreach (var item in properties)
{
if (row.GetCell(col) != null) //没有数据的单元格都默认是null
{
typeof(T).GetProperty(item).SetValue(s, row.GetCell(col), null);
}
++col;
}
}
else
{
foreach (var item in properties)
{
if (row.GetCell(col) != null) //没有数据的单元格都默认是null
{
PropertyInfo pi = typeof(T).GetProperty(item);
if (item.Equals(primaryKey))
{
if (pkType == PrimaryKeyType.数字)
{
pi.SetValue(s, startKey, null);
startKey++;
}
else
{
pi.SetValue(s, Guid.NewGuid(), null);
}
}
else
{
pi.SetValue(s, row.GetCell(col), null);
}
}
++col;
}
}
list.Add(s);
}
}
return(list);
}
catch (Exception ex)
{
Console.WriteLine("Exception: " + ex.Message);
return(null);
}
}
public virtual T Create <K>(K primaryKey, PrimaryKeyType primaryKeyType)
{
return(this.DataAccessModel.CreateDataAccessObject <T, K>(primaryKey, primaryKeyType));
}
public virtual T GetByPrimaryKey <K>(K primaryKey, PrimaryKeyType primaryKeyType)
{
return(GetQueryableByPrimaryKey(primaryKey, primaryKeyType).Single());
}
public virtual T GetByPrimaryKeyOrDefault <K>(K primaryKey, PrimaryKeyType primaryKeyType)
{
return(this.GetQueryableByPrimaryKey(primaryKey, primaryKeyType).SingleOrDefault());
}
public PrimaryKeyAttribute(PrimaryKeyType generator, String column) : this(generator)
{
_column = column;
}
public bool Is(PrimaryKeyType type)
{
return(Type == type);
}
public virtual IDataAccessObjectAdvanced CreateDataAccessObject <K>(Type type, K primaryKey, PrimaryKeyType primaryKeyType)
{
if (!typeof(IDataAccessObjectAdvanced).IsAssignableFrom(type) ||
!typeof(DataAccessObject <>).IsAssignableFromIgnoreGenericParameters(type))
{
throw new ArgumentException("Type must be a DataAccessObjectType", nameof(type));
}
var objectPropertyAndValues = this.GetObjectPropertyValues(type, primaryKey, primaryKeyType);
if (objectPropertyAndValues.Any(keyValue => keyValue.Value == null))
{
throw new MissingOrInvalidPrimaryKeyException();
}
var existing = this.GetCurrentDataContext(false).GetObject(this.GetConcreteTypeFromDefinitionType(type), objectPropertyAndValues);
if (existing != null)
{
IDataAccessObjectAdvanced obj = null;
ActionUtils.IgnoreExceptions(() => obj = this.GetReference(type, primaryKey, primaryKeyType));
throw new ObjectAlreadyExistsException(obj, null, "CreateDataAccessObject");
}
else
{
var retval = this.RuntimeDataAccessModelInfo.CreateDataAccessObject(type, this, true);
retval.ToObjectInternal().SetPrimaryKeys(objectPropertyAndValues);
retval.ToObjectInternal().FinishedInitializing();
retval.ToObjectInternal().SubmitToCache();
return(retval);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PrimaryKeyAttribute"/> class.
/// </summary>
/// <param name="generator">The generator.</param>
/// <param name="column">The PK column.</param>
public PrimaryKeyAttribute(PrimaryKeyType generator, String column) : this(generator)
{
this.column = column;
}
public virtual IQueryable <T> GetManyByPrimaryKey <K>(IEnumerable <K> primaryKeys, PrimaryKeyType primaryKeyType)
{
if (primaryKeys == null)
{
throw new ArgumentNullException("primaryKeys");
}
if (primaryKeyType == PrimaryKeyType.Single || TypeDescriptor.IsSimpleType(typeof(K)) || (typeof(K) == IdType && primaryKeyType != PrimaryKeyType.Composite))
{
if (!TypeDescriptor.IsSimpleType(IdType))
{
throw new ArgumentException(string.Format("Type {0} needs to be convertable to {1}", typeof(K), IdType), "primaryKeys");
}
if (this.typeDescriptor.PrimaryKeyCount != 1)
{
throw new ArgumentException("Composite primary key type expected", "primaryKeys");
}
}
if (primaryKeyType == PrimaryKeyType.Single || TypeDescriptor.IsSimpleType(typeof(K)) || (typeof(K) == IdType && primaryKeyType != PrimaryKeyType.Composite))
{
var propertyInfo = PrimaryKeyInfoCache <T> .IdPropertyInfo;
var parameterExpression = Expression.Parameter(propertyInfo.PropertyType, "value");
var body = Expression.Call(null, MethodInfoFastRef.EnumerableContainsMethod.MakeGenericMethod(propertyInfo.PropertyType), Expression.Constant(primaryKeyType), Expression.Property(parameterExpression, propertyInfo));
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
else
{
var parameterExpression = Expression.Parameter(typeof(T), "value");
var deflatedObjects = primaryKeys
.Select(c => this.DataAccessModel.GetReference <T, K>(c, primaryKeyType))
.ToArray();
var body = Expression.Call(null, PrimaryKeyInfoCache <T> .EnumerableContainsMethod, Expression.Constant(deflatedObjects), parameterExpression);
var condition = Expression.Lambda <Func <T, bool> >(body, parameterExpression);
return(this.Where(condition));
}
}
public virtual T GetReference <K>(K primaryKey, PrimaryKeyType primaryKeyType)
{
return(this.DataAccessModel.GetReference <T, K>(primaryKey, primaryKeyType));
}
/// <summary>
/// Initializes a new instance of the <see cref="PrimaryKeyAttribute"/> class.
/// </summary>
/// <param name="generator">The generator.</param>
/// <param name="column">The column.</param>
public PrimaryKeyAttribute(PrimaryKeyType generator, string column)
{
Generator = generator;
Column = column;
}
