/// <summary>
/// Converts a list <paramref name="value"/> to an <see cref="IRdfListAdapter{T}"/> if necessary and return the RDF:List's head
/// </summary>
/// <returns>an <see cref="IEntity"/></returns>
/// <exception cref="ArgumentException">when value is not a collection</exception>
public override IEnumerable<Node> ToNodes(object value, IEntityProxy proxy, IPropertyMapping property, IEntityContext context)
{
if (!(value is IEnumerable))
{
throw new ArgumentException("Value must implement IEnumerable", "value");
}
if (typeof(IRdfListAdapter<>).IsAssignableFromSpecificGeneric(value.GetType()))
{
yield return Node.FromEntityId(((IEntity)value.GetType().GetProperty("Head").GetValue(value)).Id);
}
else
{
var nodeType = GetNodeType(property);
var ownerType = GetOwnerType(property);
var itemType = property.ReturnType.GetGenericArguments()[0].FindItemType();
var ctor = typeof(RdfListAdapter<,,>).MakeGenericType(ownerType, nodeType, itemType)
.GetConstructor(new[] { typeof(IEntityContext), typeof(IEntity), typeof(OverridingGraphSelector) });
var paremeters = proxy.GraphSelectionOverride ?? new OverridingGraphSelector(proxy.Id, proxy.EntityMapping, property);
var rdfList = ctor.Invoke(new object[] { context, proxy, paremeters });
var interfaceMapping = rdfList.GetType().GetInterfaceMap(typeof(IRdfListAdapter<>).MakeGenericType(itemType));
var addMethodInfo = interfaceMapping.InterfaceMethods.First(item => item.Name == "Add");
foreach (var item in (IEnumerable)value)
{
addMethodInfo.Invoke(rdfList, new[] { item });
}
yield return Node.FromEntityId(((IEntity)interfaceMapping.InterfaceMethods.First(item => item.Name == "get_Head").Invoke(rdfList, null)).Id);
}
}
private void server_ClientIdentified(object sender, EventArgs <Client> e)
{
Client value = e.Value;
ChannelMember waitingMember;
if (!this.waitingMembers.TryGetValue(value.ID, out waitingMember))
{
value.Close();
return;
}
this.waitingMembers.Remove(value.ID);
waitingMember.Client = value;
waitingMember.Client.Disconnected += delegate(object _, EventArgs __)
{
waitingMember.Close();
};
IEntityProxy conn = base.Connect(waitingMember.ChannelJoined.Entity, new UnifiedNetwork.Entity.Location(value.ID, "PlayerService.PlayerService"));
waitingMember.BindCharacterConn(conn);
waitingMember.CharacterConn.Closed += delegate(object _, EventArgs <IEntityProxy> __)
{
waitingMember.Close();
};
waitingMember.FrontendConn = base.Connect(waitingMember.ChannelJoined.Entity, new UnifiedNetwork.Entity.Location(waitingMember.FID, "FrontendServiceCore.FrontendService"));
waitingMember.FrontendConn.Closed += delegate(object _, EventArgs <IEntityProxy> __)
{
waitingMember.Close();
};
waitingMember.ChannelJoined.Enter(waitingMember);
waitingMember.IsInChannel = true;
waitingMember.FrontendConn.RequestOperation(new NotifyEnterChannelResult
{
ResultEnum = EnterChannelResult.Success
});
}
public static void UpdateRankBasis_Pvp(IEntityProxy connection, long gID, string rankID, int score, string guildName)
{
string text = "Pvp_";
text += rankID;
UpdateRankBasisUtility.UpdateRankBasis(connection, gID, text, (long)score, guildName);
}
public string ToXml(object entity)
{
XmlBuilder builder = new XmlBuilder();
builder.tag(typeof(T).Name);
foreach (PropertySchema property in GetPropertyList())
{
string xmlValue = string.Empty;
object propertyValue = GetPropertyValue(entity, property.Name);
if (propertyValue != null)
{
TypeCode typeCode = Type.GetTypeCode(property.PropertyType);
if (property.PropertyType.IsArray)
{
xmlValue = propertyValue.ToString();
}
else if (typeCode == TypeCode.Object && !property.PropertyType.IsValueType)
{
IEntityProxy entityProxy = EntityProxyManager.Instance.GetEntityProxyFromType(property.PropertyType);
xmlValue = entityProxy.ToXml(propertyValue);
}
else
{
xmlValue = propertyValue.ToString();
}
}
builder = builder.newline.tab.tag(property.Name).text(xmlValue, true).end;
}
builder = builder.newline.end;
return(builder.ToString());
}
public IEntityProxy GetEntityProxyFromType(Type type)
{
ThrowExceptionUtil.ArgumentNotNull(type, "type");
ThrowExceptionUtil.ArgumentConditionTrue(
!type.IsValueType && Type.GetTypeCode(type) == TypeCode.Object,
"type", "the type should be class. not support {0}".FormatWith(type));
IEntityProxy result = null;
try
{
lock (lockobject)
{
if (!entityProxyTable.ContainsKey(type))
{
PrepareForType(type);
}
//Logger.Debug(string.Format("threadid:{0}", Thread.CurrentThread.ManagedThreadId));
result = entityProxyTable[type] as IEntityProxy;
}
}
catch (Exception e)
{
throw new ArgumentException("Create Proxy Error. Type:{0}".FormatWith(type), e);
}
return(result);
}
/// <summary>
/// Transforms the resulting <paramref name="nodes"/> to a <see cref="IRdfListAdapter{T}"/>
/// </summary>
public override object FromNodes(IEntityProxy parent, IPropertyMapping property, IEntityContext context, [AllowNull] IEnumerable<Node> nodes)
{
var listHead = (IEntity)base.FromNodes(parent, property, context, nodes);
var ownerType = GetOwnerType(property);
var nodeType = GetNodeType(property);
var itemType = property.ReturnType.GetGenericArguments()[0].FindItemType();
var ctor = typeof(RdfListAdapter<,,>).MakeGenericType(ownerType, nodeType, itemType)
.GetConstructor(new[] { typeof(IEntityContext), typeof(IEntity), nodeType, typeof(OverridingGraphSelector) });
object head;
if (listHead == null)
{
head = context.GetType().GetInterfaceMap(typeof(IEntityContext))
.InterfaceMethods
.Where(item => (item.Name == "Create") && (item.IsGenericMethodDefinition) && (item.GetParameters().Length == 1) && (item.GetParameters()[0].ParameterType == typeof(EntityId)))
.Select(item => item.MakeGenericMethod(nodeType))
.First()
.Invoke(context, new object[] { new EntityId(Vocabularies.Rdf.nil) });
}
else
{
head = typeof(EntityExtensions).GetMethod("AsEntity").MakeGenericMethod(nodeType).Invoke(null, new object[] { listHead });
}
var paremeters = parent.GraphSelectionOverride ?? new OverridingGraphSelector(parent.Id, parent.EntityMapping, property);
((IEntityProxy)((IEntity)head).UnwrapProxy()).OverrideGraphSelection(paremeters);
return ctor.Invoke(new[] { context, parent, head, paremeters });
}
public static List <T> ConvertDataToObject <T>(DataTable dataTable)
{
List <T> list = new List <T>();
Type type = typeof(T);
if (Type.GetTypeCode(type) == TypeCode.Object)
{
IEntityProxy entityProxy = EntityProxyManager.Instance.GetEntityProxyFromType(typeof(T));
Dictionary <string, string> mapping = new Dictionary <string, string>(StringComparer.CurrentCultureIgnoreCase);
foreach (PropertySchema item in entityProxy.GetPropertyList())
{
OrmColumnAttribute ormColumnAttribute = item.GetCustomerAttribute <OrmColumnAttribute>();
if (ormColumnAttribute != null && !string.IsNullOrEmpty(ormColumnAttribute.DbColumnName))
{
mapping.Add(ormColumnAttribute.DbColumnName, item.Name);
}
}
list = ConvertDataToObject <T>(dataTable, mapping);
}
else
{
foreach (DataRow row in dataTable.Rows)
{
list.Add((T)Convert(row[0], type));
}
}
return(list);
}
/// <summary>
/// Convert a instance of DataRow to a instance of the target type using the mapping.
/// using the column name of the DataRow since the mapping is null or empty.
/// </summary>
/// <typeparam name="T">the target type.</typeparam>
/// <param name="row">the instance of DataRow.</param>
/// <param name="mapping">The mapping for the column name and the property name.</param>
/// <returns>the instance of the target type.</returns>
public static T ConvertDataToObject <T>(DataRow row, Dictionary <string, string> mapping)
{
object result = null;
Type type = typeof(T);
if (Type.GetTypeCode(type) == TypeCode.Object)
{
IEntityProxy entityProxy = EntityProxyManager.Instance.GetEntityProxyFromType(type);
result = ReflectionUtil.CreateInstance(type);
if (mapping == null || mapping.Count == 0)
{
foreach (DataColumn column in row.Table.Columns)
{
entityProxy.SetPropertyValue(result, column.ColumnName, row[column]);
}
}
else
{
foreach (DataColumn column in row.Table.Columns)
{
string columnName = column.ColumnName;
if (mapping.ContainsKey(columnName))
{
entityProxy.SetPropertyValue(result, mapping[columnName], row[column]);
}
else
{
entityProxy.SetPropertyValue(result, columnName, row[column]);
}
}
}
}
return((T)result);
}
public TableSchema GetEntitySchema(Type type)
{
IEntityProxy proxy = EntityProxyManager.Instance.GetEntityProxyFromType(type);
TableSchema tableSchema = new TableSchema(OrmUtil.GetTableName(type));
foreach (PropertySchema item in proxy.GetPropertyList())
{
ColumnSchema columnSchema = new ColumnSchema(item.Name);
OrmColumnAttribute ormColumnAttribute = item.GetCustomerAttribute <OrmColumnAttribute>();
if (ormColumnAttribute != null)
{
if (!string.IsNullOrEmpty(ormColumnAttribute.DbColumnName))
{
columnSchema.ColumnName = ormColumnAttribute.DbColumnName;
}
columnSchema.IsPrimary = ormColumnAttribute.PrimaryKeyFlag;
columnSchema.IsNullable = ormColumnAttribute.AllowNullFlag;
}
columnSchema.Type = item.PropertyType;
columnSchema.IsIdentity = string.Compare(columnSchema.ColumnName, "id", true) == 0;
if (columnSchema.Type == typeof(string))
{
columnSchema.MaxLength = 200;
}
columnSchema.IsNullable = true;
tableSchema.ColumnList.Add(columnSchema);
}
return(tableSchema);
}
public static void UpdateRankBasis_Pvp(IEntityProxy connection, long cID, string rankID)
{
string text = "Pvp_";
text += rankID;
UpdateRankBasisUtility.UpdateRankBasis(connection, cID, text, 1L);
}
internal CPQuery GetWhereQuery()
{
IEntityProxy proxy = this as IEntityProxy;
string[] names = proxy.GetChangeNames();
object[] values = proxy.GetChangeValues();
if (names.Length == 0)
{
return(null); // 没有设置任何属性，应该不会发生吧？
}
CPQuery query = this.DbContext.CreateCPQuery() + " WHERE ";
for (int i = 0; i < values.Length; i++)
{
string name = names[i];
object value = values[i];
if (i > 0)
{
query = query + " AND ";
}
if (value == null)
{
query = query + " " + name + "=NULL";
}
else
{
query = query + " " + name + "=" + new QueryParameter(value);
}
}
return(query);
}
protected override void BuildCommand()
{
base.dbCommand.CommandText = this.spName;
base.dbCommand.CommandType = CommandType.StoredProcedure;
SPSchema schema = CacheManager.Instance.GetEntity <SPSchema, string>(owner.ConnectionName,
spName, TimeSpan.MaxValue,
(name) =>
{
return(owner.DbDriver.GetSpSchema(name));
});
ThrowExceptionUtil.ArgumentConditionTrue(schema != null, "tableName", "Can not find sp. Name:{0}".FormatWith(spName));
DataAdapterParser dataAdapterParser = new DataAdapterParser(owner, dataAdapter);
if (dataAdapter != null)
{
foreach (SPParameter spParameter in schema.ParameterList)
{
DbParameter parameter = owner.DbDriver.CreateParameter();
parameter.ParameterName = spParameter.Name;
parameter.Direction = spParameter.Direction;
//parameter.DbType = spParameter.DbType;
if (spParameter.DbType == "REF CURSOR")
{
IEntityProxy parameterProxy = EntityProxyManager.Instance.GetEntityProxyFromType(parameter.GetType());
if (parameter.GetType().Namespace == "System.Data.OracleClient")
{
parameterProxy.SetPropertyValue(parameter, "OracleType", 5);
//parameter.DbType = (DbType)5;
}
else
{
parameterProxy.SetPropertyValue(parameter, "OracleDbType", 0x79);
}
}
if (dataAdapter[spParameter.Name] != null)
{
parameter.Value = dataAdapter[spParameter.Name];
}
else
{
if (owner.DbDriver.DbTypeMap.ContainsKey(spParameter.DbType))
{
Type type = owner.DbDriver.DbTypeMap[spParameter.DbType];
parameter.Value = GetDefaultValue(type);
if (spParameter.Direction == ParameterDirection.InputOutput && spParameter.MaxLength > 0)
{
parameter.Size = spParameter.MaxLength * 2;
}
}
}
base.dbCommand.Parameters.Add(parameter);
}
}
}
/// <summary>Converts a list <paramref name="value"/> to an <see cref="IRdfListAdapter{T}"/> if necessary and return the RDF:List's head.</summary>
/// <returns>an <see cref="IEntity"/></returns>
/// <exception cref="ArgumentException">Thrown when value is not a collection</exception>
public override IEnumerable <INode> ToNodes(object value, IEntityProxy proxy, IPropertyMapping property, IEntityContext context)
{
if (!(value is IEnumerable))
{
throw new ArgumentException("Value must implement IEnumerable", "value");
}
if (typeof(IRdfListAdapter <>).IsAssignableFromSpecificGeneric(value.GetType()))
{
yield return(Node.FromEntityId(((IEntity)value.GetType().GetTypeInfo().GetProperty("Head").GetValue(value)).Id));
}
else
{
var nodeType = GetNodeType(property);
var ownerType = GetOwnerType(property);
var itemType = property.ReturnType.GetTypeInfo().GetGenericArguments()[0].FindItemType();
var ctor = typeof(RdfListAdapter <, ,>).MakeGenericType(ownerType, nodeType, itemType).GetTypeInfo()
.GetConstructor(new[] { typeof(IEntityContext), typeof(IEntity), typeof(OverridingGraphSelector) });
var paremeters = proxy.GraphSelectionOverride ?? new OverridingGraphSelector(proxy.Id, proxy.EntityMapping, property);
var rdfList = ctor.Invoke(new object[] { context, proxy, paremeters });
var interfaceMapping = rdfList.GetType().GetTypeInfo().GetRuntimeInterfaceMap(typeof(IRdfListAdapter <>).MakeGenericType(itemType));
var addMethodInfo = interfaceMapping.InterfaceMethods.First(item => item.Name == "Add");
foreach (var item in (IEnumerable)value)
{
addMethodInfo.Invoke(rdfList, new[] { item });
}
yield return(Node.FromEntityId(((IEntity)interfaceMapping.InterfaceMethods.First(item => item.Name == "get_Head").Invoke(rdfList, null)).Id));
}
}
public void BindCharacterConn(IEntityProxy conn)
{
this.CharacterConn = conn;
this.LookObserver = ObserverFactory.MakeObserver(conn, this.CID, "Stat");
this.LookObserver.SyncBegun += delegate(IObserver observer, Action <IObserver> callback)
{
observer.EndSync(true);
callback(observer);
};
this.LookObserver.ForceSync(delegate(IObserver _)
{
});
this.LookObserver.SetDirty += this.LookObserver_SetDirty;
this.LookObserver_SetDirty(this.LookObserver, delegate(IObserver _)
{
});
this.EquipmentObserver = ObserverFactory.MakeObserver(conn, this.CID, "Equipment");
this.EquipmentObserver.SyncBegun += delegate(IObserver observer, Action <IObserver> callback)
{
observer.EndSync(true);
callback(observer);
};
this.EquipmentObserver.ForceSync(delegate(IObserver _)
{
});
this.EquipmentObserver.SetDirty += this.EquipmentObserver_SetDirty;
this.EquipmentObserver_SetDirty(this.EquipmentObserver, delegate(IObserver _)
{
});
}
private CPQuery GetUpdateQueryCommand()
{
IEntityProxy proxy = this as IEntityProxy;
if (proxy == null)
{
throw new InvalidOperationException("请在调用BeginEdit()的返回值对象上调用Update方法。");
}
// 获取数据实体对象的主键值，如果数据实体没有指定主键，将会抛出一个异常
Tuple <string, object> rowKey = proxy.GetRowKey();
CPQuery update = GetUpdateQuery(rowKey);
if (update == null)
{
return(null);
}
CPQuery query = update
+ " WHERE " + rowKey.Item1 + " = " + new QueryParameter(rowKey.Item2);
proxy.ClearChangeFlags(); // 清除修改标记，防止多次调用
return(query);
}
/// <summary>Transforms the resulting <paramref name="nodes"/> to a <see cref="IRdfListAdapter{T}"/>.</summary>
public override object FromNodes(IEntityProxy parent, IPropertyMapping property, IEntityContext context, IEnumerable <INode> nodes)
{
var listHead = (IEntity)base.FromNodes(parent, property, context, nodes);
var ownerType = GetOwnerType(property);
var nodeType = GetNodeType(property);
var itemType = property.ReturnType.GetTypeInfo().GetGenericArguments()[0].FindItemType();
var ctor = typeof(RdfListAdapter <, ,>).MakeGenericType(ownerType, nodeType, itemType).GetTypeInfo()
.GetConstructor(new[] { typeof(IEntityContext), typeof(IEntity), nodeType, typeof(OverridingGraphSelector) });
object head;
if (listHead == null)
{
head = context.GetType().GetTypeInfo().GetRuntimeInterfaceMap(typeof(IEntityContext))
.InterfaceMethods
.Where(item => (item.Name == "Create") && (item.IsGenericMethodDefinition) && (item.GetParameters().Length == 1) && (item.GetParameters()[0].ParameterType == typeof(EntityId)))
.Select(item => item.MakeGenericMethod(nodeType))
.First()
.Invoke(context, new object[] { new EntityId(Vocabularies.Rdf.nil) });
}
else
{
head = typeof(EntityExtensions).GetTypeInfo().GetMethod("AsEntity").MakeGenericMethod(nodeType).Invoke(null, new object[] { listHead });
}
var paremeters = parent.GraphSelectionOverride ?? new OverridingGraphSelector(parent.Id, parent.EntityMapping, property);
((IEntityProxy)((IEntity)head).UnwrapProxy()).OverrideGraphSelection(paremeters);
return(ctor.Invoke(new[] { context, parent, head, paremeters }));
}
/// <summary>
/// 执行INSERT操作，并返回新的自增列ID
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public static int InsertReturnNewId(this Entity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
IEntityProxy proxy = entity as IEntityProxy;
if (proxy == null)
{
throw new InvalidOperationException("当前方法只能在实体代理对象上调用。");
}
CPQuery query = entity.GetInsertQuery();
// 在 insert 语句后面加上一个调用。
query = query + "; select SCOPE_IDENTITY();";
proxy.ClearChangeFlags(); // 清除修改标记，防止多次调用
// 执行INSERT操作，并查询最新的ID
return(query.ExecuteScalar <int>());
}
/// <summary>
/// 转换辅助类。 mapping暂未使用
/// </summary>
/// <param name="type"></param>
/// <param name="dataAdapter"></param>
/// <param name="mapping"></param>
/// <returns></returns>
private static object ConvertDataToObject(Type type, BeeDataAdapter dataAdapter, Dictionary <string, string> mapping)
{
ThrowExceptionUtil.ArgumentNotNull(type, "type");
ThrowExceptionUtil.ArgumentNotNull(dataAdapter, "dataAdapter");
object result = ReflectionUtil.CreateInstance(type);
if (result != null)
{
IEntityProxy entityProxy = EntityProxyManager.Instance.GetEntityProxyFromType(type);
foreach (string key in dataAdapter.Keys)
{
string value = dataAdapter[key] as string;
if (value != null && value.Length == 0)
{
/// 空字符串并且目标类型不是字符型则不转换
PropertySchema schema = entityProxy[key];
if (schema != null && schema.PropertyType != typeof(string))
{
continue;
}
}
entityProxy.SetPropertyValue(result, key, dataAdapter[key]);
}
}
return(result);
}
public void SetValue(IEntityProxy instance, string columnName, object value, ColumnMapper mapper)
{
var parts = columnName.Split('.');
var obj = instance;
var columns = this;
var type = GetObjectType(obj);
if (typeof(IEntityProxy).IsAssignableFrom(type))
{
type = type.BaseType;
}
for (int i = 0; i < parts.Length; i++)
{
var part = parts[i];
var propertyName = columns[part].PropertyName;
var pi = type.GetProperty(propertyName);
if (pi == null || !pi.CanWrite)
{
continue;
}
if (i == parts.Length - 1)
{
var mappedValue = mapper.MapToType(value, pi);
pi.SetValue(obj, mappedValue);
obj.State = EntityState.Unchanged;
}
else
{
columns = columns[part].ReferenceTable;
obj = pi.GetValue(obj) as IEntityProxy;
type = GetObjectType(obj);
}
}
}
public static void UpdateRankBasis_SoloTimeAttack(IEntityProxy connection, long cID, string questId, long score)
{
string text = "SoloTimeAttack_";
text += questId;
UpdateRankBasisUtility.UpdateRankBasis(connection, cID, text, score);
}
public static void UpdateRankBasis_UseItem(IEntityProxy connection, long cID, string itemClass)
{
string text = "";
if (itemClass.StartsWith("javelin"))
{
text = "UseItem_javelin";
}
else if (itemClass.StartsWith("handbomb"))
{
text = "UseItem_handbomb";
}
else if (itemClass.StartsWith("flashbang"))
{
text = "UseItem_flashbang";
}
else if (itemClass.StartsWith("mining_bomb"))
{
text = "UseItem_mining_bomb";
}
else if (itemClass.StartsWith("sticky_bomb"))
{
text = "UseItem_sticky_bomb";
}
if (text.Length > 0)
{
UpdateRankBasisUtility.UpdateRankBasis(connection, cID, text, 1L);
}
}
private static void UpdateRankBasis(IEntityProxy connection, long gID, string rankID, long score, string guildName)
{
if (FeatureMatrix.IsEnable("CharacterRank") && connection != null)
{
UpdateRankBasis op = new UpdateRankBasis(gID, rankID, score, guildName);
connection.RequestOperation(op);
}
}
internal CPQuery GetUpdateQuery(Tuple <string, object> rowKey)
{
IEntityProxy proxy = this as IEntityProxy;
string[] names = proxy.GetChangeNames();
object[] values = proxy.GetChangeValues();
if (names.Length == 0)
{
return(null); // 没有设置任何属性，应该不会发生吧？
}
int keyIndex = -1; // 标记主键字段在数组的哪个位置
if (rowKey != null)
{
keyIndex = Array.IndexOf(names, rowKey.Item1);
}
if (names.Length == 1 && keyIndex == 0)
{
return(null); // 如果仅仅只设置了主键字段，这样的更新是无意义的
}
int forcount = values.Length;
if (keyIndex == forcount - 1) // 主键出现在最后面
{
forcount--;
}
CPQuery query = this.DbContext.CreateCPQuery()
+ "UPDATE " + GetTableName() + " SET ";
for (int i = 0; i < forcount; i++)
{
if (i == keyIndex) // 忽略主键字段
{
continue;
}
string name = names[i];
object value = values[i];
if (value == null)
{
query = query + " " + name + "=NULL";
}
else
{
query = query + " " + name + "=" + new QueryParameter(value);
}
if (i < forcount - 1)
{
query.AppendSql(","); // 注意，这个逗号的拼接，有可能主键出现在所有字段的最后。
}
}
return(query);
}
public ControllerInfo(Type type)
{
try
{
this.Type = type;
this.Name = GetControllerName();
entityProxy = EntityProxyManager.Instance.GetEntityProxyFromType(type);
BeeControllerAttribute beeControllerAttribute = entityProxy.GetCustomerAttribute <BeeControllerAttribute>();
if (beeControllerAttribute != null)
{
DefaultFlag = beeControllerAttribute.DefaultFlag;
if (!string.IsNullOrEmpty(beeControllerAttribute.ControllerName))
{
if (!string.IsNullOrEmpty(beeControllerAttribute.AreaName))
{
this.Name = "{0}|{1}".FormatWith(beeControllerAttribute.AreaName, beeControllerAttribute.ControllerName);
}
else
{
this.Name = beeControllerAttribute.ControllerName;
}
}
else
{
if (!string.IsNullOrEmpty(beeControllerAttribute.AreaName))
{
this.Name = "{0}|{1}".FormatWith(beeControllerAttribute.AreaName, this.Name);
}
}
}
this.LowerName = Name.ToLower();
DefaultAction = "Index";
foreach (MethodSchema item in entityProxy.GetMethodList())
{
ActionAttribute actionAttribute = item.GetCustomerAttribute <ActionAttribute>();
if (actionAttribute != null && actionAttribute.DefaultFlag)
{
DefaultAction = item.Name;
break;
}
}
// 构造一个Controller实例， 以初始化类静态构造函数。
//ReflectionUtil.CreateInstance(type);
entityProxy.CreateInstance();
}
catch (Exception e)
{
throw new CoreException("type:{0}".FormatWith(type), e);
}
}
/// <summary>
/// 获取真正的类型
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static Type GetRealType(object obj)
{
IEntityProxy iep = obj as IEntityProxy;
if (iep != null)
{
return(iep.GetEntityType());
}
return(obj.GetType());
}
protected virtual void Delete(IEntityProxy entity, TableAttribute table, IEnumerable <ColumnInfo> columns)
{
var delete = new DeleteExpression(new TableExpression(table));
foreach (var column in columns.Where(c => c.IsIdentity))
{
delete.AddWhere(column.ToEqualExpression(entity));
}
ExecuteNonQuery(delete);
}
/// <summary>
/// 根据当前实体创建代理对象，然后可执行数据库更新操作，
/// 代理对象将监视属性的赋值过程，当给代理对象的属性赋值后，对应的字段会标记为更新状态。
/// </summary>
/// <param name="context"></param>
/// <returns>与实体相关的代理对象</returns>
internal Entity GetProxy(DbContext context)
{
// context ，允许参数为 null
IEntityProxy proxy = CreateProxy();
(proxy as Entity)._context = context; // 仅在代理对象时才被赋值
proxy.Init(this);
return(proxy as Entity);
}
internal static MvcRouteDispatcher CreateMvcDispatcher()
{
if (mvcDispatchType == typeof(MvcRouteDispatcher))
{
return(new MvcRouteDispatcher());
}
else
{
IEntityProxy entityProxy = EntityProxyManager.Instance.GetEntityProxyFromType(mvcDispatchType);
return(entityProxy.CreateInstance() as MvcRouteDispatcher);
}
}
private void SetNamedGraphOverride(IEntityProxy proxy, IPropertyMapping property)
{
var paremeters = GraphSelectionOverride ?? new OverridingGraphSelector(Id, _entityMapping, property);
if (proxy != null)
{
if ((proxy.Id is BlankId) || (typeof(IRdfListNode <>).IsAssignableFromSpecificGeneric(proxy.EntityMapping.EntityType)))
{
proxy.OverrideGraphSelection(paremeters);
}
}
}
protected virtual void Insert(IEntityProxy entity, TableAttribute table, ColumnInfoCollection columns)
{
var values = new ValuesExpression();
var insert = new InsertExpression(new TableExpression(table))
{
Values = values
};
var type = entity.GetType().BaseType;
var discriminator = columns.SingleOrDefault(c => c.IsDiscriminatorColumn);
if (discriminator != null)
{
values.AddColumn(discriminator.ToColumnExpression());
values.AddValue(Expression.Constant(type.FullName));
}
foreach (var pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
try
{
var column = columns.SingleOrDefault(c => c.DescribesProperty(pi));
if (column == null)
{
continue;
}
var value = pi.GetValue(entity);
if (column.IsIdentity)
{
var defaultValue = Activator.CreateInstance(pi.PropertyType);
if (!value.Equals(defaultValue))
{
insert.IsIdentityInsertEnabled = true;
}
else
{
continue;
}
}
values.AddColumn(column.ToColumnExpression());
values.AddValue(Expression.Constant(value));
}
catch (Exception ex)
{
Debugger.Break();
}
}
ExecuteNonQuery(insert);
}
private void NotifyPropertyChanged(IEntityProxy proxy, string propertyName)
{
if (proxy == null)
{
throw new ArgumentNullException("proxy");
}
var currentHandler = propertyChangedEventHandler;
if (currentHandler != null)
{
currentHandler(proxy, new PropertyChangedEventArgs(propertyName));
}
}
public bool DSState()
{
DSWaitingSystem dswaitingSystem = this.service.DSWaitingSystem;
if (dswaitingSystem != null)
{
IEntityProxy frontendConn = this.service.Connect(this.service.DSServiceEntity, new Location(base.Operation.FrontendID, "FrontendServiceCore.FrontendService"));
frontendConn.SendConsole(dswaitingSystem.ToString(), new object[0]);
}
else
{
DSService.RequestDSBossOperation(base.Operation);
}
return(true);
}
/// <summary>
/// Not used
/// </summary>
public IEnumerable<Node> ToNodes(object value, IEntityProxy proxy, IPropertyMapping property, IEntityContext context)
{
var dictionaryIface = typeof(IDictionary<,>).MakeGenericType(property.ReturnType.GenericTypeArguments);
var dictionaryType = GetDictionaryType(property);
if (!dictionaryIface.IsInstanceOfType(value))
{
throw new ArgumentException(string.Format("Value must be a of type {0}", dictionaryIface), "value");
}
var dictionary = value as IRdfDictionary;
if (dictionary == null)
{
dictionary = (IRdfDictionary)dictionaryType.GetConstructors()
.Single(c => c.GetParameters().Length == 3)
.Invoke(new[] { proxy.Id, context, value });
}
return dictionary.DictionaryEntries.Select(entity => Node.FromEntityId(entity.Id));
}
/// <summary>Get an <see cref="ObservableCollection{T}"/> containing <paramref name="nodes"/>' values.</summary>
public override object FromNodes(IEntityProxy parent, IPropertyMapping property, IEntityContext context, [AllowNull] IEnumerable<Node> nodes)
{
var convertedValues = nodes.Select(node => ((ICollectionMapping)property).ElementConverter.Convert(node, context));
var collectionElements = ((IEnumerable<object>)Aggregator.Aggregate(convertedValues)).ToArray();
var genericArguments = property.ReturnType.GetGenericArguments();
if (typeof(IEntity).IsAssignableFrom(genericArguments.Single()))
{
genericArguments = new[] { typeof(IEntity) };
}
var castMethod = EnumerableCast.MakeGenericMethod(genericArguments);
var convertedCollection = castMethod.Invoke(null, new object[] { collectionElements });
var observable = (INotifyCollectionChanged)typeof(ObservableCollection<>).MakeGenericType(genericArguments)
.GetConstructor(new[] { typeof(IEnumerable<>).MakeGenericType(genericArguments) })
.Invoke(new[] { convertedCollection });
observable.CollectionChanged += (sender, args) => Impromptu.InvokeSet(parent, property.Name, sender);
return observable;
}
/// <summary>Gets a node for each collection element.</summary>
public override IEnumerable<Node> ToNodes(object collection, IEntityProxy proxy, IPropertyMapping property, IEntityContext context)
{
return from object value in (IEnumerable)collection
select base.ToNodes(value, proxy, property, context).Single();
}
/// <summary>Converts <paramref name="nodes"/> and returns the aggregated the result.</summary>
public virtual object FromNodes(IEntityProxy parent, IPropertyMapping property, IEntityContext context, IEnumerable<Node> nodes)
{
var convertedValues = nodes.Select(node => property.Converter.Convert(node, context));
return _aggregator.Aggregate(convertedValues);
}
/// <summary>
/// Transforms the resulting nodes to a dictionary
/// </summary>
/// <param name="parent">The parent entity.</param>
/// <param name="property">The property.</param>
/// <param name="context">The context.</param>
/// <param name="nodes">ignored</param>
public object FromNodes(IEntityProxy parent, IPropertyMapping property, IEntityContext context, IEnumerable<Node> nodes)
{
var constructor = GetDictionaryType(property).GetConstructors().Single(c => c.GetParameters().Count() == 2);
return constructor.Invoke(new object[] { parent.Id, context });
}
/// <summary>Converts the given <paramref name="value"/> to <see cref="Node"/>s.</summary>
public virtual IEnumerable<Node> ToNodes(object value, IEntityProxy proxy, IPropertyMapping property, IEntityContext context)
{
return new[] { property.Converter.ConvertBack(value) };
}
