public virtual void TestInterFaceItem()
{
var interfaceItem = new InterfaceItem
();
interfaceItem.list = new ArrayList();
Store(interfaceItem);
Db4oAssert.PersistedCount(1, typeof (ArrayList));
}
public virtual void TestInterFaceItem()
{
var interfaceItem = new InterfaceItem
();
interfaceItem.list = new ArrayList();
Store(interfaceItem);
Db4oAssert.PersistedCount(1, typeof(ArrayList));
}
public InterfaceConfig()
{
Internal = new InterfaceItem()
{
//InterfaceType = InterfaceType.Internal,
};
External = new InterfaceItem()
{
//InterfaceType = InterfaceType.External,
};
}
private void FunctionItemInit(string name, string returnType, bool isStatic, List <ParameterItem> par, InterfaceItem interfaceItem, EA.Method method)
{
_name = name;
_parameterList = par;
_returnType = returnType;
_isStatic = isStatic;
_interface = interfaceItem;
_module = null;
_op = method;
}
public static T Wrap <T>(Type interfacetype) where T : class
{
Assembly assembly = interfacetype.Assembly;
Module module = interfacetype.Module;
AssemblyName assemblyName = new AssemblyName(assembly.FullName);
assemblyName.Name = assemblyName.Name + "$001";
AssemblyBuilder assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(module.Name);
// Console.WriteLine ("11111111");
// Console.WriteLine ("11111111");
// Console.WriteLine ("11111111");
// Console.WriteLine (interfacetype.FullName + "$1");
// Console.WriteLine (interfacetype.Namespace+"."+interfacetype.Name + "$1");
// Console.WriteLine ("11111111");
// Console.WriteLine ("11111111");
// Console.WriteLine ("11111111");
TypeBuilder typeBuilder = moduleBuilder.DefineType(interfacetype.Namespace + "." + interfacetype.Name + "$1"
, TypeAttributes.Class | TypeAttributes.Public, typeof(WrapBase), new Type[] { interfacetype });
ConstructorBuilder constructorBuilder = typeBuilder.DefineDefaultConstructor(MethodAttributes.Public);
//constructorBuilder.GetILGenerator().Emit(OpCodes.Ret);
constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
ILGenerator ctor0IL = constructorBuilder.GetILGenerator();
ctor0IL.Emit(OpCodes.Ret);
MethodInfo[] interfacemethods = interfacetype.GetMethods();
MethodInfo interfacemethodInfo;
InterfaceWrapContext interfaceWrapContext = InterfaceWrapContext.GetContext(interfacetype);
for (int i = 0; i < interfacemethods.Length; i++)
{
interfacemethodInfo = interfacemethods[i];
MethodFactory.GenerateMethod(interfacetype, interfacemethodInfo, typeBuilder);
}
Type newtype = typeBuilder.CreateType();
T t = (T)Activator.CreateInstance(newtype);
InterfaceItem interfaceItem = new InterfaceItem(t, interfacetype, interfaceWrapContext);
Lark.Core.Lark.InterfaceWrapCache[interfacetype] = interfaceItem;
return(t);
}
/// <summary>
/// 新增、修改外部接口
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public Task <ResponseModel> EditInterfaceItem(InterfaceItem model)
{
//1. 获取当前最新的接口全路径
var path = Logic.GetCurrInterfacePath(model.catgory_id, model.code);
model.path = path;
//2. 判断是否重复编码【相同分组】
var exist = Logic.ExistInterfaceCode(model.id, model.catgory_id, model.code);
if (exist)
{
return(Task.FromResult(new ResponseModel(ResponseCode.Error, "接口编码重复")));
}
return(Logic.EditInterfaceItem(model) ?
Task.FromResult(new ResponseModel(ResponseCode.Success, "操作成功"))
: Task.FromResult(new ResponseModel(ResponseCode.Error, "操作失败")));
}
/// <summary>
/// 新增、修改外部接口
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool EditInterfaceItem(InterfaceItem model)
{
try
{
using (var db = new DbContext())
{
if (string.IsNullOrEmpty(model.id))
{
return(db.Insert(model).Execute() > 0);
}
return(db.Update(model).Execute() > 0);
}
}
catch (Exception ex)
{
Logger.Instance.Error("编辑外部接口时发生异常：", ex);
return(false);
}
}
public static object Invoke(Type interfacetype, WrapBase wrapBase, MethodInfo methodInfo, List <Object> args)
{
// if (InternalConfig.EmitTestCode)
// {
// Console.WriteLine("InvokeProxy args:");
// args.ForEach(x=>{
// Console.WriteLine((x??new object()).ToString());
// });
// }
try
{
if (false == Lark.InterfaceWrapCache.ContainsKey(interfacetype))
{
throw new LarkException("RuntimeException：wrapcache is not exists！");
}
InterfaceItem interfaceItem = Lark.InterfaceWrapCache[interfacetype];
if (false == interfaceItem.WrapContext.MethodCache.ContainsKey(methodInfo))
{
throw new LarkException("RuntimeException：MethodCache is not exists！");
}
MethodItem methodItem = interfaceItem.WrapContext.MethodCache[methodInfo];
//todo need a pool of RequestCreContext
RequestCreContext requestCreContext = RequestCreContext.Create(interfaceItem.WrapContext, methodItem.WrapContext, wrapBase);
requestCreContext.ParameterValues.Value = args;
return(HttpCreater.Create(requestCreContext).DealResponse(methodInfo.ReturnType));
}
catch (System.Exception ex)
{
System.Console.WriteLine(ex.ToString());
throw ex;
}
}
//
public bool InventoryDesignInterfaces()
{
// Get all interfaces
// 'object_id' has to be included in select
string sql = $@"select object_id, name
from t_object
where object_type = 'Interface' AND
package_id in ( { _designPackagedIds} )
order by 2";
EA.Collection interfaceList = Rep.GetElementSet(sql, 2);
foreach (EA.Element el in interfaceList)
{
InterfaceItem ifItem = (InterfaceItem)_designFiles.Add($"{el.Name}.h");
ifItem.El = el;
foreach (EA.Method m in el.Methods)
{
// create function
FunctionItem functionItem = new FunctionItem(m.Name, m.ReturnType, m.IsStatic, new List <ParameterItem>(), ifItem, m);
if (_designFunctions.FunctionList.ContainsKey(m.Name))
{
var function = _designFunctions.FunctionList[m.Name];
MessageBox.Show($"Interface:\t{function.Interface?.Name}\r\nModule:\t{function.Module?.Name}",
$"Duplicated Function {m.Name}, skipped!");
}
else
{
_designFunctions.FunctionList.Add(m.Name, functionItem);
}
// update interface
ifItem.ProvidedFunctions.Add(functionItem);
}
}
// Show deleted Interface
var deletedInterfaces = from s in _designFiles.FileList
where !_files.FileList.Any(t => (s.Value.Name == t.Value.Name) &&
t.Value.GetType().Name.Equals(typeof(InterfaceItem).Name))
select s.Value.El;
var createdInterfaces = from s in _files.FileList
where !_designFiles.FileList.All(t => (s.Value.Name == t.Value.Name) &&
t.Value.GetType().Name.Equals(typeof(InterfaceItem).Name))
select s.Value.El;
_deletedInterfaces = 0;
string deleteMe = "DeleteMe";
foreach (var el in deletedInterfaces)
{
if (!el.Name.EndsWith(deleteMe))
{
el.Name = el.Name + deleteMe;
el.Update();
}
_deletedInterfaces++;
}
_createdInterfaces = createdInterfaces.Count();
return(true);
}
public FunctionItem(string name, string returnType, bool isStatic, List <ParameterItem> par, InterfaceItem interfaceItem, EA.Method method)
{
FunctionItemInit(name, returnType, isStatic, par, interfaceItem, method);
}
