/// <summary>
/// 当前类是否和传入的类兼容
/// </summary>
/// <param name="dynClass">动态类</param>
/// <returns>true , false</returns>
public bool IsAssignableFrom(DynClass dynClass)
{
if (dynClass.Name == this.Name)
{
return(true);
}
else
{
DynClass parendynType = this.BaseClass;
while (parendynType != null)
{
if (parendynType.Name == dynClass.Name)
{
return(true);
}
else
{
parendynType = parendynType.BaseClass;
}
}
}
return(false);
}
/// <summary>
/// 动态类型的Xml序列化
/// </summary>
/// <param name="dynClass"></param>
/// <returns></returns>
public static XElement ToXml(DynClass dynClass)
{
XElement eleDynClass = new XElement("Class");
eleDynClass.SetAttributeValue("Namespace", dynClass.Namespace ?? "");
eleDynClass.SetAttributeValue("Name", dynClass.Name ?? "");
eleDynClass.SetAttributeValue("BaseName", dynClass.BaseClass.Name ?? "");
eleDynClass.SetAttributeValue("InterfaceNames", string.Join(",", dynClass.InterfaceNames.ToArray()));
XElement eleDynProperties = new XElement("Properties");
eleDynClass.Add(eleDynProperties);
foreach (DynProperty dynProperty in dynClass.GetProperties())
{
XElement eleDynProperty = new XElement("Property");
eleDynProperties.Add(eleDynProperty);
// 设置DynProperty
eleDynProperty.SetAttributeValue("ID", dynProperty.ID.ToString());
eleDynProperty.SetAttributeValue("Name", dynProperty.Name);
//ToDo:这两个属性是对象，等待程序完善后，再仔细考虑怎样处理
eleDynProperty.SetAttributeValue("CurrentClassName", dynProperty.CurrentDynClass.Name);
eleDynProperty.SetAttributeValue("ClassName", dynProperty.DynClass.Name);
eleDynProperty.SetAttributeValue("Type", Enum.GetName(typeof(DynType), dynProperty.DynType));
//eleDynProperty.SetAttributeValue("InheritEntityName", dynProperty.InheritEntityName);
//eleDynProperty.SetAttributeValue("IsArray", dynProperty.IsArray.ToString());
//eleDynProperty.SetAttributeValue("IsInherited", dynProperty.IsInherited.ToString());
//eleDynProperty.SetAttributeValue("IsQueryProperty", dynProperty.IsQueryProperty.ToString());
XElement eleDynAttributes = new XElement("Attributes");
eleDynProperty.Add(eleDynAttributes);
foreach (DynObject dynAttribute in dynProperty.Attributes)
{
XElement eleDynAttribute = new XElement("Attribute");
eleDynAttributes.Add(eleDynAttribute);
//ToDo: 等待DynAttribute完善后添加
eleDynAttribute.SetAttributeValue("Name", "");
}
}
XElement eleClassDynAttributes = new XElement("Attributes");
eleDynClass.Add(eleClassDynAttributes);
foreach (DynObject dynAttribute in dynClass.Attributes)
{
XElement eleDynAttribute = new XElement("Attribute");
eleClassDynAttributes.Add(eleDynAttribute);
//ToDo: 等待DynAttribute完善后添加
eleDynAttribute.SetAttributeValue("Name", "");
}
return(eleDynClass);
}
/// <summary>
/// 根据名称获取动态类,如果没有则返回null
/// </summary>
/// <param name="className">Namespace + _ + Name of the type.</param>
/// <returns>The entity configuration</returns>
public static DynClass GetClass(string className)
{
DynClass value = null;
if (_dynClassesQuick.TryGetValue(className, out value))
{
return(value);
}
else
{
string[] namespaceAndClassName;
foreach (var item in _dynClasses)
{
namespaceAndClassName = item.Key.Split('^');
if (namespaceAndClassName.Length > 0 && namespaceAndClassName[namespaceAndClassName.Length - 1] == className)
{
_dynClassesQuick[className] = item.Value;
return(item.Value);
}
}
}
return(null);
}
/// <summary>
/// 根据名称获取动态类,如果没有则返回null
/// </summary>
/// <param name="className">Namespace + _ + Name of the type.</param>
/// <returns>The entity configuration</returns>
public static DynClass GetClassByFullName(string classFullName)
{
DynClass value = null;
if (_dynClasses.TryGetValue(classFullName, out value))
{
return(value);
}
return(null);
}
//public void AddValidate(string name, IValidate validater, DynObject validateConfig)
//{
// if (!string.IsNullOrEmpty(name) && validater != null && validateConfig != null)
// {
// _validater[name] = validater;
// _validateConfig[name] = validateConfig;
// }
//}
//public void ClearValidate()
//{
// _validater.Clear();
// _validateConfig.Clear();
//}
//public void RemoveValidate(string name)
//{
// _validater.Remove(name);
// _validateConfig.Remove(name);
//}
public DynClass GetStructName()
{
if (!string.IsNullOrEmpty(this.StructName))
{
if (_structClass == null || _structClass.Name != this.StructName)
{
_structClass = DynTypeManager.GetClass(this.StructName);
}
return(_structClass);
}
return(null);
}
/// <summary>
/// 创建类的实例
/// </summary>
/// <param name="className"></param>
/// <returns></returns>
public static DynObject CreateObject(string className)
{
DynClass dynClass = GetClass(className);
if (dynClass != null)
{
return(new DynObject(className));
}
else
{
throw new ApplicationException(string.Format("{0}类型不存在", className));
}
}
/// <summary>
/// 注册函数类
/// </summary>
/// <param name="dynClass"></param>
public static void RegistFunction(DynClass dynClass)
{
if (dynClass != null)
{
string key = dynClass.Namespace + "^" + dynClass.Name;
if (!_dynFunctions.ContainsKey(key))
{
_dynFunctions.Add(key, dynClass);
}
else
{
throw new ApplicationException("已经存在同名的FunctionClass");
}
}
}
/// <summary>
/// 创建并返回动态类型
/// </summary>
/// <param name="className"></param>
/// <returns></returns>
public static DynClass CreateFunction(string className)
{
DynClass dynClass = GetFunction(className);
if (dynClass != null)
{
return(dynClass);
}
dynClass = new DynClass(className);
_dynFunctions.Add(dynClass.Namespace + "^" + dynClass.Name, dynClass);
return(dynClass);
}
public void RemoveRelation(DynProperty dynProperty)
{
if (dynProperty == null || !this.ContainsProperty(dynProperty.Name))
{
throw new ApplicationException("寻求关联的类不存在");
}
if (dynProperty.CollectionType == CollectionType.None && dynProperty.DynType == DynType.Struct)
{
DynClass relationDynClass = DynTypeManager.GetClass(dynProperty.StructName);
if (relationDynClass == null)
{
throw new ApplicationException(string.Format("类{0}的属性{1}所添加的关联类{2}不存在", this.Name, dynProperty.Name, dynProperty.StructName));
}
relationDynClass.RelationDynClassDict.Remove(this.Name);
relationDynClass.RelationDynPropertyDict.Remove(this.Name);
}
}
/// <summary>
/// 获取所有的动态基类
/// </summary>
/// <returns></returns>
public DynClass[] GetAllBaseClasses()
{
if (_allBaseClasses == null)
{
List <DynClass> lstEntityTypes = new List <DynClass>();
DynClass parendynType = this.BaseClass;
while (parendynType != null)
{
lstEntityTypes.Add(parendynType);
parendynType = parendynType.BaseClass;
}
_allBaseClasses = lstEntityTypes.ToArray();
}
return(_allBaseClasses);
}
/// <summary>
/// 基于实体类型构造对象
/// </summary>
/// <param name="className">类名</param>
/// <param name="isHaveDefualt">是否成带默认值的对象</param>
public DynObject(string className, bool isHaveDefualt)
{
DynClass dynClass = DynTypeManager.GetClass(className);
if (dynClass == null)
{
throw new ApplicationException(string.Format("不存在名称为{0}的动态类", className));
}
_dynClass = dynClass;
if (isHaveDefualt)
{
var properties = _dynClass.GetProperties();
foreach (DynProperty dynProperty in properties)
{
SetDefaultValue(dynProperty);
}
}
}
private void eval_AdditionalFunctionEventHandler(object sender, AdditionalFunctionEventArgs e)
{
object[] parameters = e.GetParameters();
object value;
//检查是否在默认的函数库中
switch (e.Name)
{
case "GetProperty":
break;
case "Get":
if (Context == null)
{
throw new ApplicationException("执行函数失败 上下文为空");
}
if (Context == null || parameters == null || parameters.Length < 1 || string.IsNullOrEmpty(parameters[0] as string))
{
throw new ApplicationException("执行函数失败 入参输入为空");
}
if (!Context.TryGetValue(parameters[0] as string, out value))
{
throw new ApplicationException("执行函数失败 获取上下文时 没有键为" + parameters[0] + "的值");
}
e.ReturnValue = value;
return;
default:
string className = null;
//检查是否在当前应用的函数库中
if (DynStringResolver.MethodDict.TryGetValue(e.Name, out className))
{
string methodName = e.Name;
Dictionary <string, object> dict = new Dictionary <string, object>();
DynClass function = DynTypeManager.GetFunction(className);
if (function == null)
{
throw new ApplicationException("执行函数失败 没有主键为" + className + "的函数类 请查看初始化");
}
DynMethod method = function.GetMethod(methodName);
DynParameter[] dynParameters = method.GetParameters();
for (int i = 0; i < dynParameters.Length; i++)
{
value = parameters.Length > i ? parameters[i] : null;
switch (dynParameters[i].CollectionType)
{
case CollectionType.None:
value = DynStringResolver.GetTrueType(value, dynParameters[i].DynType);
break;
case CollectionType.List:
IList valueList = value as IList;
for (int j = 0; j < valueList.Count; j++)
{
valueList[j] = DynStringResolver.GetTrueType(valueList[j], dynParameters[i].DynType);
}
break;
case CollectionType.Set:
case CollectionType.Map:
break;
default:
break;
}
dict.Add(dynParameters[i].Name, value);
}
e.ReturnValue = DynTypeManager.MethodHandler(null, className + "_" + methodName, dict);
}
else
{
throw new ApplicationException("无此函数:" + e.Name);
}
break;
}
}
public DynClassModelTypInitializationException(DynClass dynClass, ClassMainType[] classMainType)
{
string types = null;
string message = string.Format("{0}类{1} 必须将属性ClassMainType设定为{2}之一值", dynClass.GetType().Name, dynClass.Name, types);
}
