private Cecil.FieldDefinition CreateFieldDefinition(AnalysisNet.Types.FieldDefinition fieldDefinition)
{
Cecil.FieldAttributes fieldAttribute = Cecil.FieldAttributes.Public;
if (fieldDefinition.IsStatic)
{
fieldAttribute |= Cecil.FieldAttributes.Static;
}
Cecil.TypeReference fieldType = ReferenceGenerator.TypeReference(fieldDefinition.Type);
Cecil.FieldDefinition cecilField = new Cecil.FieldDefinition(fieldDefinition.Name, fieldAttribute, fieldType);
if (fieldDefinition.Value != null)
{
cecilField.Constant = fieldDefinition.Value.Value;
cecilField.HasConstant = true;
}
byte[] newArray = new byte[fieldDefinition.InitialValue.Length];
Array.Copy(fieldDefinition.InitialValue, newArray, newArray.Length);
cecilField.InitialValue = newArray;
if (newArray.Length > 0)
{
cecilField.Attributes |= Cecil.FieldAttributes.HasFieldRVA;
}
return(cecilField);
}
/// <summary>
/// 生成代理类型的字段
/// </summary>
/// <param name="proxyType">代理类型</param>
/// <param name="fieldName">字段名称</param>
/// <param name="type">字段类型</param>
/// <returns></returns>
private FieldDefinition BuildField(TypeDefinition proxyType, string fieldName, TypeReference type)
{
const Mono.Cecil.FieldAttributes filedAttribute = Mono.Cecil.FieldAttributes.Private | Mono.Cecil.FieldAttributes.InitOnly;;
var filed = new FieldDefinition(fieldName, filedAttribute, type);
proxyType.Fields.Add(filed);
return(filed);
}
private static void AddField(TypeDefinition targetType, string fieldName, FieldAttributes fieldAttributes, TypeReference fieldType)
{
if (targetType.Fields.Any(f => f.Name == fieldName))
{
throw new InvalidOperationException(string.Format("Field '{0}' already exist in type {1}", fieldName, targetType.FullName));
}
targetType.Fields.Add(new FieldDefinition(fieldName, fieldAttributes, fieldType));
}
internal void AddOrReplaceIoc(ILProcessor il)
{
var mod = il.Body.Method.DeclaringType.Module;
var myNamespace = mod.Types.Select(t => t.Namespace)
.Where(n => !string.IsNullOrWhiteSpace(n)).OrderBy(n => n.Length).First();
const TAttr attr = TAttr.Class | TAttr.Public | TAttr.Sealed
| TAttr.Abstract | TAttr.BeforeFieldInit;
var objBase = mod.ImportReference(typeof(object));
var type = new TypeDefinition(myNamespace, IocName, attr, objBase);
var oldType = mod.Types.FirstOrDefault(t => t.FullName == type.FullName);
if (oldType != null)
{
mod.Types.Remove(oldType);
}
mod.Types.Add(type);
var vesselRef = mod.ImportReference(typeof(IVessel));
const FAttr fieldAttr = FAttr.Static | FAttr.Private;
var contField = new FieldDefinition(IocField, fieldAttr, vesselRef);
type.Fields.Add(contField);
const MAttr getAttrs = MAttr.Static | MAttr.Public
| MAttr.SpecialName | MAttr.HideBySig;
var getMethod = new MethodDefinition(IocMethod, getAttrs, vesselRef);
type.Methods.Add(getMethod);
ScopeMethod = getMethod;
IocType = type;
var gmil = getMethod.Body.GetILProcessor();
gmil.Append(gmil.Create(OpCodes.Ldsfld, contField));
gmil.Append(gmil.Create(OpCodes.Ret));
var voidRef = mod.ImportReference(typeof(void));
const MAttr constrAttrs = MAttr.Static | MAttr.SpecialName | MAttr.Private
| MAttr.RTSpecialName | MAttr.HideBySig;
var constr = new MethodDefinition(Defaults.StaticConstrName, constrAttrs, voidRef);
type.Methods.Add(constr);
var cil = constr.Body.GetILProcessor();
var multiMeth = typeof(DefaultVessel).GetConstructors().First();
var multiRef = mod.ImportReference(multiMeth);
cil.Append(cil.Create(OpCodes.Newobj, multiRef));
cil.Append(cil.Create(OpCodes.Stsfld, contField));
cil.Append(cil.Create(OpCodes.Ret));
il.Append(il.Create(OpCodes.Call, getMethod));
il.Append(il.Create(OpCodes.Pop));
il.Append(il.Create(OpCodes.Ret));
}
void AddVersionField(Assembly assembly, string name, TypeDefinition typeDefinition)
{
var weaverVersion = "0.0.0.0";
var attrs = assembly.GetCustomAttributes(typeof(AssemblyFileVersionAttribute));
var fileVersionAttribute = (AssemblyFileVersionAttribute)attrs.FirstOrDefault();
if (fileVersionAttribute != null)
{
weaverVersion = fileVersionAttribute.Version;
}
const FieldAttributes fieldAttributes = FieldAttributes.Assembly |
FieldAttributes.Literal |
FieldAttributes.Static |
FieldAttributes.HasDefault;
var field = new FieldDefinition(name, fieldAttributes, TypeSystem.StringReference)
{
Constant = weaverVersion
};
typeDefinition.Fields.Add(field);
}
public override void VisitFieldDefinition(FieldDefinition field)
{
if (!_includeFields)
{
return;
}
FieldElement fe = new FieldElement();
fe.Name = field.Name;
fe.Type = field.FieldType.FullName;
fe.IsStatic = field.IsStatic;
FieldAttributes fieldAccess = field.Attributes & FieldAttributes.FieldAccessMask;
fe.IsPrivate = fieldAccess == FieldAttributes.Private;
fe.IsPublic = fieldAccess == FieldAttributes.Public;
// Custom attributes
fe.Attributes.AddRange(ExtractCustomAttributes(field.CustomAttributes));
_currentType.Fields.Add(fe);
}
public static GenericFuncContainer <FieldDefinition, bool> FieldNegAttributeComparer(Mono.Cecil.FieldAttributes negAttrs)
{
return(new GenericFuncContainer <FieldDefinition, bool>(field => {
return (field.Attributes & negAttrs) == 0;
}));
}
public static FieldDefinition AddField(this TypeDefinition type, string name, FieldAttributes attributes, TypeReference fieldType)
{
FieldDefinition field = new FieldDefinition(name, attributes, fieldType);
type.Fields.Add(field);
return(field);
}
public static FieldDefinition AddField <T>(this TypeDefinition type, string name, FieldAttributes attributes)
{
return(type.AddField(name, attributes, type.Module.GetTypeReference <T>()));
}
public static FieldDefinition GetOrCreateField(this TypeDefinition self, string name, Mono.Cecil.FieldAttributes attributes, TypeReference fieldType)
{
var field = self.Fields.FirstOrDefault(a => a.Name == name);
if (null == field)
{
field = new FieldDefinition(name, attributes, fieldType);
self.Fields.Add(field);
}
return(field);
}