/// <summary>
/// 配置模型属性对应的字段名
/// </summary>
/// <typeparam name="T">模型类型</typeparam>
/// <param name="property">模型属性的表达式</param>
/// <param name="columnName">模型属性对应的字段名称</param>
public static void HasColumnName <T>(Expression <Func <T, object> > property, string columnName)
{
var member = property?.GetMember();
if (member?.IsPropertyOrField() != true)
{
throw Error.ArgumentException("指定的表达式不是属性或字段。", nameof(property));
}
if (columnName.IsNullOrWhiteSpace())
{
throw Error.ArgumentNullException(nameof(columnName));
}
var m = new ColumnMeta(member, typeof(T));
//if (CachedIgnoreColumns.Contains(m))
//{
// throw Error.Exception($"属性 {m} 已经被忽略，不能设置列名。");
//}
lock (CachedColumnNames)
{
if (CachedColumnNames.ContainsKey(m))
{
throw Error.Exception($"已经设置了字段 {m} 对应的列名称为 {CachedColumnNames[m]}，不能重复设置。");
}
CachedColumnNames.Add(m, columnName);
}
}
/// <summary>
/// 忽略成员
/// </summary>
/// <typeparam name="T">模型类型</typeparam>
/// <param name="property">要忽略的模型属性的表达式</param>
public static void IgnoreColumn <T>(Expression <Func <T, object> > property)
{
var member = property?.GetMember();
if (member?.IsPropertyOrField() != true)
{
throw Error.ArgumentException("指定的表达式不是属性或字段。", nameof(property));
}
lock (CachedIgnoreColumns)
{
var keys = GetKeyMetas <T>();
var m = new ColumnMeta(member, typeof(T));
if (keys != null && keys.Any(x => x.Member == member))
{
throw Error.Exception($"属性 {m} 已经配置为主键，不能忽略。");
}
//if (CachedColumnNames.ContainsKey(m))
//{
// throw Error.ArgumentException("属性已经配置字段名:" + CachedColumnNames[m] + "。", nameof(property));
//}
if (!CachedIgnoreColumns.Contains(m))
{
CachedIgnoreColumns.Add(m);
}
}
}
/// <summary>
/// 配置模型的自增主键
/// </summary>
/// <typeparam name="T">模型类型</typeparam>
/// <param name="property">模型自增列属性的表达式</param>
/// <param name="columnName">自增主键列对应的字段名称</param>
public static void HasIdentity <T>(Expression <Func <T, object> > property, string columnName = null)
{
var member = property?.GetMember();
if (member?.IsPropertyOrField() != true)
{
throw Error.ArgumentException("指定的表达式不是属性或字段。", nameof(property));
}
lock (CachedTableIdentities)
{
var m = new ColumnMeta(member, typeof(T));
var type = typeof(T);
if (CachedTableIdentities.ContainsKey(type))
{
throw Error.Exception(
$"已经设置了类型 {type.FullName} 对应的自增列为 {CachedTableIdentities[type].ColumnName}，不能重复设置。");
}
CachedTableIdentities.Add(type, m);
if (!string.IsNullOrWhiteSpace(columnName))
{
HasColumnName(property, columnName);
}
}
}
/// <summary>
/// 返回模型对应的字段名
/// </summary>
/// <param name="member">模型的成员信息</param>
/// <param name="type">模型类型</param>
/// <returns>成员对应的列名称</returns>
public static string GetColumnName(MemberInfo member, Type type)
{
if (member?.IsPropertyOrField() != true)
{
throw Error.ArgumentException("指定的表达式不是属性或字段。", nameof(member));
}
var m = new ColumnMeta(member, type);
return(GetColumnName(m));
}
/// <summary>
/// 判断某字段是否被忽略
/// </summary>
/// <param name="memberInfo">属性或字段成员信息</param>
/// <param name="type">模型类型</param>
/// <returns>返回该字段是否忽略映射</returns>
public static bool IsIgnore(MemberInfo memberInfo, Type type)
{
if (memberInfo == null)
{
throw Error.ArgumentNullException(nameof(memberInfo));
}
lock (CachedIgnoreColumns)
{
var m = new ColumnMeta(memberInfo, type);
return(CachedIgnoreColumns.Contains(m));
}
}
internal static string GetColumnName(ColumnMeta columnMeta)
{
if (columnMeta == null)
{
throw Error.ArgumentNullException(nameof(columnMeta));
}
lock (CachedColumnNames)
{
if (CachedColumnNames.ContainsKey(columnMeta))
{
return(CachedColumnNames[columnMeta]);
}
return(columnMeta.Name);
}
}
/// <summary>
/// 配置模型的唯一主键列名
/// </summary>
/// <typeparam name="T">模型类型</typeparam>
/// <param name="properties">模型主键属性的表达式</param>
public static void HasKey <T>(params Expression <Func <T, object> >[] properties)
{
if (properties.IsNullOrEmpty())
{
throw Error.ArgumentNullException(nameof(properties));
}
var members = properties.Select(x => x.GetMember()).Distinct().ToArray();
if (members.Any(x => !x.IsPropertyOrField()))
{
throw Error.ArgumentException("参数中包含不是属性或字段的表达式。", nameof(properties));
}
lock (CachedTableKeys)
{
var type = typeof(T);
if (CachedTableKeys.ContainsKey(type))
{
var keys = string.Join(",", GetKey <T>());
throw Error.Exception($"已经设置了类型 {type.FullName} 对应的主键为 {keys}，不能重复设置。");
//CachedTableKeys[type] = key;
}
var metas = new ColumnMeta[members.Length];
for (var index = 0; index < members.Length; index++)
{
var member = members[index];
var m = new ColumnMeta(member, type);
if (CachedIgnoreColumns.Contains(m))
{
throw Error.Exception($"属性 {m} 已经被忽略，不能设置为主键。");
}
metas[index] = m;
}
CachedTableKeys.Add(type, metas);
}
}
