private string GetTypeAttributes(TypeAttributes attr)
{
string result = "";
if (attr.HasFlag(TypeAttributes.Public))
{
result += "public ";
}
if (attr.HasFlag(TypeAttributes.Sealed))
{
result += "sealed ";
}
if (attr.HasFlag(TypeAttributes.Abstract))
{
if (attr.HasFlag(TypeAttributes.Interface))
{
result += "interface";
}
else
{
result += "abstract class";
}
}
else
{
result += "class";
}
return(result);
}
/// <summary>
/// 初始化环境，3.5 使用
/// </summary>
/// <param name="types">需要初始化调用的静态类</param>
public void Init(IEnumerable <Type> types)
{
if (_haveInit)
{
return;
}
container = new FrameworkContainer();
_modules = new FrameworkModules(this);
cyclePool = new RecyclableObjectPool();
if (types != null)
{
types.ForEach((type) =>
{
TypeAttributes ta = type.Attributes;
if (ta.HasFlag(TypeAttributes.Abstract) && ta.HasFlag(TypeAttributes.Sealed))
{
RuntimeHelpers.RunClassConstructor(type.TypeHandle);
}
});
}
if (onInit != null)
{
onInit();
}
deltaTime = TimeSpan.Zero;
_disposed = false;
_haveInit = true;
sw_delta = new Stopwatch();
sw_init = new Stopwatch();
sw_init.Start();
}
public void DefineNestedType(string name, TypeAttributes attributes, Type parent, PackingSize packingSize, int typesize, Type[] implementedInterfaces)
{
bool isDefaultImplementedInterfaces = implementedInterfaces?.Length == 0;
bool isDefaultPackingSize = packingSize == PackingSize.Unspecified;
bool isDefaultSize = typesize == 0;
bool isDefaultParent = parent == null;
bool isDefaultAttributes = attributes == TypeAttributes.NestedPrivate;
Action<TypeBuilder, TypeBuilder> verify = (type, declaringType) =>
{
bool allowsNullParent = attributes.HasFlag(TypeAttributes.Abstract) && attributes.HasFlag(TypeAttributes.ClassSemanticsMask);
Type baseType = allowsNullParent ? parent : (parent ?? typeof(object));
Helpers.VerifyType(type, declaringType.Module, declaringType, name, attributes, baseType, typesize, packingSize, implementedInterfaces);
};
if (isDefaultImplementedInterfaces)
{
if (isDefaultSize && isDefaultPackingSize)
{
if (isDefaultParent)
{
if (isDefaultAttributes)
{
// Use DefineNestedType(string)
TypeBuilder type1 = Helpers.DynamicType(TypeAttributes.Public);
verify(type1.DefineNestedType(name), type1);
}
// Use DefineNestedType(string, TypeAttributes)
TypeBuilder type2 = Helpers.DynamicType(TypeAttributes.Public);
verify(type2.DefineNestedType(name, attributes), type2);
}
// Use DefineNestedType(string, TypeAttributes, Type)
TypeBuilder type3 = Helpers.DynamicType(TypeAttributes.Public);
verify(type3.DefineNestedType(name, attributes, parent), type3);
}
else if (isDefaultSize)
{
// Use DefineNestedType(string, TypeAttributes, Type, PackingSize)
TypeBuilder type4 = Helpers.DynamicType(TypeAttributes.Public);
verify(type4.DefineNestedType(name, attributes, parent, packingSize), type4);
}
else if (isDefaultPackingSize)
{
// Use DefineNestedType(string, TypeAttributes, Type, int)
TypeBuilder type5 = Helpers.DynamicType(TypeAttributes.Public);
verify(type5.DefineNestedType(name, attributes, parent, typesize), type5);
}
// Use DefineNestedType(string, TypeAttributes, Type, PackingSize, int);
TypeBuilder type6 = Helpers.DynamicType(TypeAttributes.Public);
verify(type6.DefineNestedType(name, attributes, parent, packingSize, typesize), type6);
}
else
{
// Use DefineNestedType(string, TypeAttributes, Type, Type[])
Assert.True(isDefaultSize && isDefaultPackingSize); // Sanity check
TypeBuilder type7 = Helpers.DynamicType(TypeAttributes.Public);
verify(type7.DefineNestedType(name, attributes, parent, implementedInterfaces), type7);
}
}
private void OutputTypeAttributes(CodeTypeDeclaration e)
{
if ((e.Attributes & MemberAttributes.New) != 0)
{
output.Write("new ");
}
TypeAttributes attributes = e.TypeAttributes;
switch (attributes & TypeAttributes.VisibilityMask)
{
case TypeAttributes.Public:
case TypeAttributes.NestedPublic:
output.Write("public ");
break;
case TypeAttributes.NestedPrivate:
output.Write("private ");
break;
case TypeAttributes.NestedFamily:
output.Write("protected ");
break;
}
if (e.IsEnum)
{
output.Write("enum ");
}
else
{
switch (attributes & TypeAttributes.ClassSemanticsMask)
{
case TypeAttributes.Class:
if (attributes.HasFlag(TypeAttributes.Sealed))
{
if (attributes.HasFlag(TypeAttributes.Abstract))
{
output.Write("static ");
}
else
{
output.Write("final ");
}
}
else if (attributes.HasFlag(TypeAttributes.Abstract))
{
output.Write("abstract ");
}
output.Write("class ");
break;
case TypeAttributes.Interface:
output.Write("interface ");
break;
}
}
}
/// <summary>
/// Convert type attributes to string
/// </summary>
private static String Convert(NetTypeDefinition type, TypeAttributes source)
{
string result;
switch (source & TypeAttributes.VisibilityMask)
{
case TypeAttributes.NotPublic:
case TypeAttributes.NestedAssembly:
result = "internal ";
break;
case TypeAttributes.Public:
case TypeAttributes.NestedPublic:
result = "public ";
break;
case TypeAttributes.NestedPrivate:
result = "private ";
break;
case TypeAttributes.NestedFamily:
case TypeAttributes.NestedFamANDAssem:
result = "protected ";
break;
case TypeAttributes.NestedFamORAssem:
result = "protected internal ";
break;
default:
throw new ArgumentException(string.Format("Unknown visibility 0x{0:X4}", (int)(source & TypeAttributes.VisibilityMask)));
}
if (!(type.IsInterface || type.IsStruct || type.IsEnum || type.IsStatic))
{
if (source.HasFlag(TypeAttributes.Abstract))
{
result += "abstract ";
}
if (source.HasFlag(TypeAttributes.Sealed))
{
result += "sealed ";
}
}
if (type.IsStatic)
{
result += "static ";
}
if (type.IsEnum)
{
result += "sealed ";
}
if (!type.IsEnum)
{
result += "partial ";
}
return(result);
}
internal static string ProtectionModifierCSharp(this TypeAttributes typeAttributes)
{
//Must come before NestedFamANDAssem
if (typeAttributes.HasFlag(TypeAttributes.NestedFamORAssem))
{
return("protected internal");
}
if (typeAttributes.HasFlag(TypeAttributes.NestedFamANDAssem))
{
return("private protected");
}
if (typeAttributes.HasFlag(TypeAttributes.NestedFamily) && !typeAttributes.HasFlag(TypeAttributes.Public))
{
return("protected");
}
if (typeAttributes.HasFlag(TypeAttributes.NestedAssembly))
{
return("internal");
}
if (typeAttributes.HasFlag(TypeAttributes.Public) ^
typeAttributes.HasFlag(TypeAttributes.NestedPublic))
{
return("public");
}
if (typeAttributes.HasFlag(TypeAttributes.NestedPrivate)) //Must come after public
{
return("private");
}
return("internal");
}
public static bool IsVisible(MetadataReader metaReader, TypeDefinition currentType)
{
TypeDefinitionHandle typeDefHandle = currentType.GetDeclaringType();
// the visibility is not really a mask until you mask it with the VisibilityMask.
TypeAttributes visibility = currentType.Attributes & TypeAttributes.VisibilityMask;
if (typeDefHandle.IsNil)
{
return(visibility.HasFlag(TypeAttributes.Public));
}
return(visibility.HasFlag(TypeAttributes.Public) &
IsVisible(metaReader, metaReader.GetTypeDefinition(typeDefHandle)));
}
public void DefineNestedType(string name, TypeAttributes attributes, Type parent, PackingSize packingSize, int typesize, Type[] implementedInterfaces)
{
bool isDefaultImplementedInterfaces = implementedInterfaces?.Length == 0;
bool isDefaultPackingSize = packingSize == PackingSize.Unspecified;
bool isDefaultSize = typesize == 0;
bool isDefaultParent = parent == null;
bool isDefaultAttributes = attributes == TypeAttributes.NestedPrivate;
void Verify(TypeBuilder type, TypeBuilder declaringType)
{
bool allowsNullParent = attributes.HasFlag(TypeAttributes.Abstract) && attributes.HasFlag(TypeAttributes.ClassSemanticsMask);
Type baseType = allowsNullParent ? parent : (parent ?? typeof(object));
Helpers.VerifyType(type, declaringType.Module, declaringType, name, attributes, baseType, typesize, packingSize, implementedInterfaces);
}
if (isDefaultImplementedInterfaces)
{
if (isDefaultSize && isDefaultPackingSize)
{
if (isDefaultParent)
{
if (isDefaultAttributes)
{
// Use DefineNestedType(string)
TypeBuilder type1 = Helpers.DynamicType(TypeAttributes.Public);
Verify(type1.DefineNestedType(name), type1);
}
// Use DefineNestedType(string, TypeAttributes)
TypeBuilder type2 = Helpers.DynamicType(TypeAttributes.Public);
Verify(type2.DefineNestedType(name, attributes), type2);
}
// Use DefineNestedType(string, TypeAttributes, Type)
TypeBuilder type3 = Helpers.DynamicType(TypeAttributes.Public);
Verify(type3.DefineNestedType(name, attributes, parent), type3);
}
else if (isDefaultSize)
{
// Use DefineNestedType(string, TypeAttributes, Type, PackingSize)
TypeBuilder type4 = Helpers.DynamicType(TypeAttributes.Public);
Verify(type4.DefineNestedType(name, attributes, parent, packingSize), type4);
}
else if (isDefaultPackingSize)
{
// Use DefineNestedType(string, TypeAttributes, Type, int)
TypeBuilder type5 = Helpers.DynamicType(TypeAttributes.Public);
Verify(type5.DefineNestedType(name, attributes, parent, typesize), type5);
}
// Use DefineNestedType(string, TypeAttributes, Type, PackingSize, int);
TypeBuilder type6 = Helpers.DynamicType(TypeAttributes.Public);
Verify(type6.DefineNestedType(name, attributes, parent, packingSize, typesize), type6);
}
else
{
// Use DefineNestedType(string, TypeAttributes, Type, Type[])
Assert.True(isDefaultSize && isDefaultPackingSize); // Sanity check
TypeBuilder type7 = Helpers.DynamicType(TypeAttributes.Public);
Verify(type7.DefineNestedType(name, attributes, parent, implementedInterfaces), type7);
}
}
public void DefineType(string name, TypeAttributes attributes, Type parent, PackingSize packingSize, int typesize, Type[] implementedInterfaces)
{
bool isDefaultImplementedInterfaces = implementedInterfaces?.Length == 0;
bool isDefaultPackingSize = packingSize == PackingSize.Unspecified;
bool isDefaultSize = typesize == 0;
bool isDefaultParent = parent == null;
bool isDefaultAttributes = attributes == TypeAttributes.NotPublic;
void Verify(TypeBuilder type, Module module)
{
Type baseType = attributes.HasFlag(TypeAttributes.Abstract) && parent == null ? null : (parent ?? typeof(object));
Helpers.VerifyType(type, module, null, name, attributes, baseType, typesize, packingSize, implementedInterfaces);
}
if (isDefaultImplementedInterfaces)
{
if (isDefaultSize && isDefaultPackingSize)
{
if (isDefaultParent)
{
if (isDefaultAttributes)
{
// Use DefineType(string)
ModuleBuilder module1 = Helpers.DynamicModule();
Verify(module1.DefineType(name), module1);
}
// Use DefineType(string, TypeAttributes)
ModuleBuilder module2 = Helpers.DynamicModule();
Verify(module2.DefineType(name, attributes), module2);
}
// Use DefineType(string, TypeAttributes, Type)
ModuleBuilder module3 = Helpers.DynamicModule();
Verify(module3.DefineType(name, attributes, parent), module3);
}
else if (isDefaultSize)
{
// Use DefineType(string, TypeAttributes, Type, PackingSize)
ModuleBuilder module4 = Helpers.DynamicModule();
Verify(module4.DefineType(name, attributes, parent, packingSize), module4);
}
else if (isDefaultPackingSize)
{
// Use DefineType(string, TypeAttributes, Type, int)
ModuleBuilder module5 = Helpers.DynamicModule();
Verify(module5.DefineType(name, attributes, parent, typesize), module5);
}
// Use DefineType(string, TypeAttributes, Type, PackingSize, int)
ModuleBuilder module6 = Helpers.DynamicModule();
Verify(module6.DefineType(name, attributes, parent, packingSize, typesize), module6);
}
else
{
// Use DefineType(string, TypeAttributes, Type, Type[])
Assert.True(isDefaultSize && isDefaultPackingSize); // Sanity check
ModuleBuilder module7 = Helpers.DynamicModule();
Verify(module7.DefineType(name, attributes, parent, implementedInterfaces), module7);
}
}
public void DefineType(string name, TypeAttributes attributes, Type parent, PackingSize packingSize, int typesize, Type[] implementedInterfaces)
{
bool isDefaultImplementedInterfaces = implementedInterfaces?.Length == 0;
bool isDefaultPackingSize = packingSize == PackingSize.Unspecified;
bool isDefaultSize = typesize == 0;
bool isDefaultParent = parent == null;
bool isDefaultAttributes = attributes == TypeAttributes.NotPublic;
Action<TypeBuilder, Module> verify = (type, module) =>
{
Type baseType = attributes.HasFlag(TypeAttributes.Abstract) && parent == null ? null : (parent ?? typeof(object));
Helpers.VerifyType(type, module, null, name, attributes, baseType, typesize, packingSize, implementedInterfaces);
};
if (isDefaultImplementedInterfaces)
{
if (isDefaultSize && isDefaultPackingSize)
{
if (isDefaultParent)
{
if (isDefaultAttributes)
{
// Use DefineType(string)
ModuleBuilder module1 = Helpers.DynamicModule();
verify(module1.DefineType(name), module1);
}
// Use DefineType(string, TypeAttributes)
ModuleBuilder module2 = Helpers.DynamicModule();
verify(module2.DefineType(name, attributes), module2);
}
// Use DefineType(string, TypeAttributes, Type)
ModuleBuilder module3 = Helpers.DynamicModule();
verify(module3.DefineType(name, attributes, parent), module3);
}
else if (isDefaultSize)
{
// Use DefineType(string, TypeAttributes, Type, PackingSize)
ModuleBuilder module4 = Helpers.DynamicModule();
verify(module4.DefineType(name, attributes, parent, packingSize), module4);
}
else if (isDefaultPackingSize)
{
// Use DefineType(string, TypeAttributes, Type, int)
ModuleBuilder module5 = Helpers.DynamicModule();
verify(module5.DefineType(name, attributes, parent, typesize), module5);
}
// Use DefineType(string, TypeAttributes, Type, PackingSize, int)
ModuleBuilder module6 = Helpers.DynamicModule();
verify(module6.DefineType(name, attributes, parent, packingSize, typesize), module6);
}
else
{
// Use DefineType(string, TypeAttributes, Type, Type[])
Assert.True(isDefaultSize && isDefaultPackingSize); // Sanity check
ModuleBuilder module7 = Helpers.DynamicModule();
verify(module7.DefineType(name, attributes, parent, implementedInterfaces), module7);
}
}
private void AddModifiers(TypeAttributes attributes, MutableSymbol symbolToAdd)
{
SymbolModifier modifiers = symbolToAdd.Modifiers;
// Same as Roslyn PENamedTypeSymbol.DeclaredAccessibility
switch (attributes & TypeAttributes.VisibilityMask)
{
case TypeAttributes.NestedAssembly:
modifiers = SymbolModifier.Internal;
break;
case TypeAttributes.NestedFamORAssem:
case TypeAttributes.NestedFamANDAssem:
modifiers = SymbolModifier.Protected | SymbolModifier.Internal;
break;
case TypeAttributes.NestedPrivate:
modifiers = SymbolModifier.Private;
break;
case TypeAttributes.Public:
case TypeAttributes.NestedPublic:
modifiers = SymbolModifier.Public;
break;
case TypeAttributes.NestedFamily:
modifiers = SymbolModifier.Protected;
break;
case TypeAttributes.NotPublic:
modifiers = SymbolModifier.Internal;
break;
}
// Same as Roslyn PENamedTypeSymbol.IsStatic
if (attributes.HasFlag(TypeAttributes.Sealed) && attributes.HasFlag(TypeAttributes.Abstract))
{
modifiers |= SymbolModifier.Static;
}
symbolToAdd.Modifiers = modifiers;
}
public EnumCreator CreateEnum(string name, TypeAttributes typeAttributes = TypeAttributes.Public)
{
VerificationName(name);
if (typeAttributes.HasFlag(TypeAttributes.Interface))
{
throw new Exception("An enum cant have interface attribute");
}
EnumCreator @enum = new EnumCreator(name, moduleBuilder, typeAttributes);
enumCreators.Append(@enum);
return(@enum);
}
internal TypeCreator(string name, ModuleBuilder moduleBuilder, TypeAttributes typeAttributes)
{
if (typeAttributes.HasFlag(TypeAttributes.Interface))
{
throw new Exception("This class is made to created Class use interfacesCreator for interface");
}
this.Name = name;
this.moduleBuilder = moduleBuilder;
this.State = Metadata.State.NotDefined;
this.IsGenericParameter = false;
this.TypeAttributes = typeAttributes;
this.IsClass = true;
this.Assembly = moduleBuilder.Assembly;
}
public void Generate(string className, string namespacestr, List <string> namespaceList, string pathStr, TypeAttributes typeAttributes, string constructorStr, string interfaceName, string returnType)
{
try
{
CodeCompileUnit unit = new CodeCompileUnit();
CodeNamespace sampleNamespace = new CodeNamespace(namespacestr);
//导入命名空间
for (int i = 0; i < namespaceList.Count; i++)
{
sampleNamespace.Imports.Add(new CodeNamespaceImport(namespaceList[i]));
}
CodeTypeDeclaration Customerclass = new CodeTypeDeclaration(className);
Customerclass.TypeAttributes = typeAttributes;
if (typeAttributes.HasFlag(TypeAttributes.Class))
{
//添加构造
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "Create";
method.Attributes = MemberAttributes.Public;
method.ReturnType = new CodeTypeReference(returnType);
method.Statements.Add(new CodeSnippetExpression(constructorStr));
Customerclass.Members.Add(method);
//继承接口
if (!string.IsNullOrEmpty(interfaceName))
{
Customerclass.BaseTypes.Add(new CodeTypeReference(interfaceName));
}
}
sampleNamespace.Types.Add(Customerclass);
unit.Namespaces.Add(sampleNamespace);
string outputFile = pathStr + className + ".cs";
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CodeGeneratorOptions options
= new CodeGeneratorOptions();
options.BracingStyle = "C";
options.BlankLinesBetweenMembers = true;
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(outputFile))
{
provider.GenerateCodeFromCompileUnit(unit, sw, options);
}
}
catch (Exception ex)
{
throw ex;
}
}
public Class(Type type)
{
TypeAttributes attributes = type.Attributes;
if (attributes.HasFlag(TypeAttributes.Public))
{
Name = "public ";
}
else if (attributes.HasFlag(TypeAttributes.NotPublic))
{
Name = "private ";
}
else if (attributes.HasFlag(TypeAttributes.NestedFamily))
{
Name = "protected ";
}
else if (attributes.HasFlag(TypeAttributes.NestedAssembly))
{
Name = "internal ";
}
if (attributes.HasFlag(TypeAttributes.Interface))
{
Name = Name + "interface ";
}
else if (attributes.HasFlag(TypeAttributes.Class))
{
Name = Name + "class ";
}
Name = Name + type.Name;
Methods = new List <Method>();
BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
Methods = GetMethods(type, bindingFlags);
Fields = GetFields(type, bindingFlags);
Properties = GetProperties(type, bindingFlags);
Constructors = GetConstructors(type, bindingFlags);
}
private static TypeDefinition _Inject(ModuleDefinition mod, TypeDefinition type, Dictionary <MetadataToken, IMemberDefinition> mems)
{
TypeAttributes att = type.Attributes;
if (att.HasFlag(TypeAttributes.NotPublic))
{
att &= ~TypeAttributes.NotPublic;
}
att |= TypeAttributes.Public;
TypeDefinition definition = new TypeDefinition(type.Namespace, type.Name, att)
{
ClassSize = type.ClassSize,
PackingSize = type.PackingSize
};
if (type.BaseType != null)
{
definition.BaseType = mod.Import(type.BaseType);
}
mems.Add(type.MetadataToken, definition);
foreach (TypeDefinition definition2 in type.NestedTypes)
{
TypeDefinition item = _Inject(mod, definition2, mems);
definition.NestedTypes.Add(item);
}
foreach (FieldDefinition definition4 in type.Fields)
{
if (!definition4.IsLiteral)
{
FieldDefinition definition5 = new FieldDefinition(definition4.Name, definition4.Attributes, mod.TypeSystem.Void);
mems.Add(definition4.MetadataToken, definition5);
definition.Fields.Add(definition5);
}
}
foreach (MethodDefinition definition6 in type.Methods)
{
TransportAction visible = TransportAction.Public;
if (!TypeCheck.KeepMethod(type, definition6, out visible))
{
continue;
}
MethodAttributes methodAtt = definition6.Attributes;
if (visible == TransportAction.Public)
{
if (methodAtt.HasFlag(MethodAttributes.Private))
{
methodAtt &= ~MethodAttributes.Private;
}
if (visible == TransportAction.Public)
{
methodAtt |= MethodAttributes.Public;
}
}
MethodDefinition definition7 = new MethodDefinition(definition6.Name, methodAtt, definition6.ReturnType);
mems.Add(definition6.MetadataToken, definition7);
definition.Methods.Add(definition7);
}
return(definition);
}
void DealWithType(TypeDefinition type)
{
TypeAttributes att = type.Attributes;
if (att.HasFlag(TypeAttributes.NotPublic))
{
att &= ~TypeAttributes.NotPublic;
}
att |= TypeAttributes.Public;
TypeDefinition nTypeDef = CecilHelper.Inject(newModule.MainModule, type);
if (type.CustomAttributes.Where(x => x.AttributeType.FullName == "System.CodeDom.Compiler.GeneratedCodeAttribute").Count() != 0)//type.Namespace.EndsWith(".My")
{
// newModule.MainModule.Types.Add(.DeclaringType);
newModule.MainModule.Import(type);
return;
}
bool add = false;
List <MethodDefinition> RemoveMethods = new List <MethodDefinition>();
foreach (MethodDefinition method in type.Methods)
{
if (!method.HasBody)
{
continue;
}
if (!method.IsStatic)
{
continue;
}
TransportAction visibility = TransportAction.Public;
if (!TypeCheck.KeepMethod(type, method, out visibility))
{
continue;
}
if (!method.IsStatic)
{
MessageBox.Show("RemoteCall must be only used on static methods.\n: " + method.FullName);
throw new Exception("Not static");
}
add = true;
if (visibility == TransportAction.Move)
{
RemoveMethods.Add(method);
continue;
}
if (visibility == TransportAction.Copy)
{
continue;
}
method.Body.Instructions.Clear();
ILProcessor ilp = method.Body.GetILProcessor();
if (visibility == TransportAction.MoveClear)
{
ilp.Append(Instruction.Create(OpCodes.Ret));
continue;
}
ilp.Append(Instruction.Create(OpCodes.Ldstr, Hashing.SHA(string.Format("{0}.{1}", type.FullName, method.Name))));
if (method.Parameters.Count == 0)
{
ilp.Append(Instruction.Create(OpCodes.Ldc_I4_0));
ilp.Append(Instruction.Create(OpCodes.Newarr, objectReference));
}
else
{
ilp.Append(Instruction.Create(OpCodes.Ldc_I4, method.Parameters.Count));
ilp.Append(Instruction.Create(OpCodes.Newarr, objectReference));
for (int i = 0; i < method.Parameters.Count; i++)
{
ilp.Append(Instruction.Create(OpCodes.Dup));
ilp.Append(Instruction.Create(OpCodes.Ldc_I4, i));
ilp.Append(Instruction.Create(OpCodes.Ldarg, method.Parameters[i]));
ilp.Append(Instruction.Create(OpCodes.Box, method.Parameters[i].ParameterType));
ilp.Append(Instruction.Create(OpCodes.Stelem_Ref));
}
}
ilp.Append(Instruction.Create(OpCodes.Call, CreateRemoteCallRef));
ilp.Append(Instruction.Create(OpCodes.Unbox_Any, method.ReturnType));
ilp.Append(Instruction.Create(OpCodes.Ret));
}
foreach (MethodDefinition md in RemoveMethods)
{
type.Methods.Remove(md);
}
if (add)
{
newModule.MainModule.Types.Add(nTypeDef);
}
}
public void Generate(string className, string namespacestr, List <string> namespaceList, string pathStr, TypeAttributes typeAttributes, bool needConstructor = true, bool needcrmService = false, string interfaceName = null, string constructorParametTypeName = null, string constructorParametName = null, string PropertyParametName = null)
{
string outputFile = "";
try
{
CodeCompileUnit unit = new CodeCompileUnit();
CodeNamespace sampleNamespace = new CodeNamespace(namespacestr);
//导入命名空间
for (int i = 0; i < namespaceList.Count; i++)
{
sampleNamespace.Imports.Add(new CodeNamespaceImport(namespaceList[i]));
}
CodeTypeDeclaration Customerclass = new CodeTypeDeclaration(className);
Customerclass.TypeAttributes = typeAttributes;
if (typeAttributes.HasFlag(TypeAttributes.Class))
{
if (needConstructor)
{
if (needcrmService)
{
CodeMemberField crmfield = new CodeMemberField("ICrmService", "_crmService");
crmfield.Attributes = MemberAttributes.Private;
Customerclass.Members.Add(crmfield);
}
//添加字段
CodeMemberField field = new CodeMemberField(constructorParametTypeName, PropertyParametName);
field.Attributes = MemberAttributes.Public;
Customerclass.Members.Add(field);
//添加构造
CodeConstructor constructor = new CodeConstructor();
if (needcrmService)
{
constructor.Parameters.Add(new CodeParameterDeclarationExpression("ICrmService", "crmService"));
constructor.Statements.Add(new CodeSnippetExpression($@" _crmService = crmService;
{PropertyParametName}={constructorParametName}"));
}
else
{
constructor.Statements.Add(new CodeSnippetExpression($@"{PropertyParametName}={constructorParametName}"));
}
constructor.Attributes = MemberAttributes.Public;
constructor.Parameters.Add(new CodeParameterDeclarationExpression(constructorParametTypeName, constructorParametName));
Customerclass.Members.Add(constructor);
}
//继承接口
if (!string.IsNullOrEmpty(interfaceName))
{
Customerclass.BaseTypes.Add(new CodeTypeReference(interfaceName));
}
}
sampleNamespace.Types.Add(Customerclass);
unit.Namespaces.Add(sampleNamespace);
outputFile = pathStr + className + ".cs";
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BracingStyle = "C";
options.BlankLinesBetweenMembers = true;
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(outputFile))
{
provider.GenerateCodeFromCompileUnit(unit, sw, options);
}
}
catch (Exception ex)
{
var pathstr = outputFile;
throw ex;
}
}
