public virtual DialogResult ShowDialog(CustomAttribute attribute, CustomAttributeNamedArgument? argument, bool usefields) { m_selectedargument = argument; m_selectedattribute = attribute; m_usefields = usefields; return base.ShowDialog(); }
private CecilCustomAttribute CreateCecilCustomAttribute(ModuleDefinition module) { var ctorRef = Constructor.Import(module); var cca = new CecilCustomAttribute(ctorRef); foreach (var value in Arguments) { cca.ConstructorArguments.Add(CreateCecilTypedArgument( module, value)); } for (var i = 0; i < PropertiesInitialized.Length; ++i) { var clrProp = PropertiesInitialized[i]; var value = PropertyValues[i]; cca.Properties.Add(CreateCecilNamedArgument( clrProp.Name, module, value)); } for (var i = 0; i < FieldsInitialized.Length; ++i) { var clrField = FieldsInitialized[i]; var value = FieldValues[i]; cca.Fields.Add(CreateCecilNamedArgument( clrField.Name, module, value)); } return(cca); }
/*CustomAttribute customAttribute; public CustomAttribute CustomAttribute { get { return customAttribute; } }*/ public DomCecilAttribute (CustomAttribute customAttribute) { //this.customAttribute = customAttribute; base.AttributeType = DomCecilMethod.GetReturnType (customAttribute.Constructor); base.Name = customAttribute.Constructor.DeclaringType.FullName; try { foreach (var argument in customAttribute.ConstructorArguments) AddPositionalArgument (CreateExpressionFor (argument)); } catch (Exception e) { LoggingService.LogError ("Error reading attributes", e); } try { foreach (var namedArgument in customAttribute.Properties) AddNamedArgument (namedArgument.Name, CreateExpressionFor (namedArgument.Argument)); } catch (Exception e) { LoggingService.LogError ("Error reading attributes", e); } try { foreach (var namedArgument in customAttribute.Fields) AddNamedArgument (namedArgument.Name, CreateExpressionFor (namedArgument.Argument)); } catch (Exception e) { LoggingService.LogError ("Error reading attributes", e); } }
public void Run() { // Retrieve the target method onto which we want to add the attribute var targetType = _module.Types.Single(t => t.Name == "Target"); var targetMethod = targetType.Methods.Single(m => m.Name == "TargetMethod"); // Retrieve the type of the attribute var decorationAttributeType = _module.Types.Single(t => t.Name == "DecorationAttribute"); // Create the equivalent of [Decoration("WOW")] // All custom attributes are created from a constructor var decorationAttributeConstructor = decorationAttributeType .Methods .Single(m => m.IsConstructor && m.Parameters.Count == 1 && m.Parameters[0].ParameterType.MetadataType == MetadataType.String); var decorationAttribute = new CustomAttribute(decorationAttributeConstructor); decorationAttribute.ConstructorArguments.Add( new CustomAttributeArgument( type: _module.TypeSystem.String, value: "WOW")); // Add the custom attribute to the method targetMethod.CustomAttributes.Add(decorationAttribute); // Write the module with default parameters _module.Write(_targetFileName); }
public void Visit(IBehaviorDefinition method, CustomAttribute attribute) { ILProcessor processor = method.Body.GetILProcessor(); string description = attribute.Properties.Where(argument => (argument.Name == "Description")).First().Argument.Value as string; Instruction exitInstruction = processor.Create(OpCodes.Callvirt, method.Module.Import(broadcastType.GetMethod("Run", new[] {typeof(object), typeof(string)}))); var returnValue = new VariableDefinition("retVal", method.Module.Import(typeof(object))); var enclosingObject = new VariableDefinition("enclosing", method.Module.Import(typeof(object))); method.Body.Variables.Add(enclosingObject); method.Body.Variables.Add(returnValue); Instruction store = processor.Create(OpCodes.Stloc, returnValue); Instruction reload = processor.Create(OpCodes.Ldloc, returnValue); var instructions = new List<Instruction>(); if (!ReturnsVoid(method)) { instructions.Add(store); } instructions.Add(processor.Create(OpCodes.Newobj, method.Module.Import(broadcastType.GetConstructor(new Type[] { })))); instructions.Add(processor.Create(OpCodes.Ldarg_0)); instructions.Add(processor.Create(OpCodes.Ldstr, description)); instructions.Add(exitInstruction); if (!ReturnsVoid(method)) { instructions.Add(reload); } new InsertionAtEnd(processor, method).Run(instructions); }
/// <summary> /// Runs the specified cloaking task. /// </summary> /// <param name="context">The running context of this cloak job.</param> public void RunTask(ICloakContext context) { Dictionary<string, AssemblyDefinition> assemblyCache = context.GetAssemblyDefinitions(); foreach (string assembly in assemblyCache.Keys) { AssemblyDefinition def = assemblyCache[assembly]; Type si = typeof (SuppressIldasmAttribute); CustomAttribute found = null; foreach (CustomAttribute attr in def.CustomAttributes) { if (attr.Constructor.DeclaringType.FullName == si.FullName) { found = attr; break; } } //Only add if it's not there already if (found == null) { //Add one MethodReference constructor = def.MainModule.Import(typeof (SuppressIldasmAttribute).GetConstructor(Type.EmptyTypes)); CustomAttribute attr = new CustomAttribute(constructor); def.CustomAttributes.Add(attr); } } }
protected override bool IsRemovedAttribute(CustomAttribute attribute) { // note: this also avoid calling FullName (which allocates a string) var attr_type = attribute.Constructor.DeclaringType; switch (attr_type.Name) { case "AdviceAttribute": case "FieldAttribute": case "PreserveAttribute": // the ApplyPreserveAttribute substep is executed before this case "LinkerSafeAttribute": return attr_type.Namespace == Namespaces.Foundation; // used for documentation, not at runtime case "AvailabilityAttribute": case "AvailabilityBaseAttribute": case "DeprecatedAttribute": case "IntroducedAttribute": case "iOSAttribute": case "MacAttribute": case "LionAttribute": case "MountainLionAttribute": case "MavericksAttribute": case "ObsoletedAttribute": case "SinceAttribute": case "ThreadSafeAttribute": case "UnavailableAttribute": case "LinkWithAttribute": case "DesignatedInitializerAttribute": return attr_type.Namespace == Namespaces.ObjCRuntime; default: return base.IsRemovedAttribute (attribute); } }
protected override void WillRemoveAttribute(ICustomAttributeProvider provider, CustomAttribute attribute) { var attr_type = attribute.Constructor.DeclaringType; if (attr_type.Namespace == Namespaces.ObjCRuntime) { switch (attr_type.Name) { case "AvailabilityAttribute": case "AvailabilityBaseAttribute": case "DeprecatedAttribute": case "IntroducedAttribute": var dict = context.Annotations.GetCustomAnnotations ("Availability"); List<CustomAttribute> attribs; object attribObjects; if (!dict.TryGetValue (provider, out attribObjects)) { attribs = new List<CustomAttribute> (); dict [provider] = attribs; } else { attribs = (List<CustomAttribute>) attribObjects; } // Make sure the attribute is resolved, since after removing the attribute // it won't be able to do it. The 'CustomAttribute.Resolve' method is private, but fetching // any property will cause it to be called. var dummy = attribute.HasConstructorArguments; attribs.Add (attribute); break; } } base.WillRemoveAttribute (provider, attribute); }
private bool AddXmlSchemaProviderAttribute(CatelType catelType) { var catelTypeDefinition = catelType.TypeDefinition; var methodName = GetXmlSchemaMethodName(catelType); var existingCustomAttribute = (from attribute in catelTypeDefinition.CustomAttributes where string.Equals(attribute.AttributeType.Name, "XmlSchemaProviderAttribute") select attribute).FirstOrDefault(); if (existingCustomAttribute != null) { var constructorArgument = existingCustomAttribute.ConstructorArguments[0]; if (string.Equals(constructorArgument.Value, methodName)) { return false; } } var xmlSchemaProviderAttribute = catelTypeDefinition.Module.FindType("System.Xml", "System.Xml.Serialization.XmlSchemaProviderAttribute"); var attributeConstructor = catelTypeDefinition.Module.Import(xmlSchemaProviderAttribute.Resolve().Constructor(false)); var customAttribute = new CustomAttribute(attributeConstructor); customAttribute.ConstructorArguments.Add(new CustomAttributeArgument(catelTypeDefinition.Module.TypeSystem.String, methodName)); catelTypeDefinition.CustomAttributes.Add(customAttribute); return true; }
public static CustomAttribute Clone(CustomAttribute custattr, ModuleDefinition context, IImportMapper mapper) { var ca = new CustomAttribute(context.Import(custattr.Constructor, mapper)); custattr.CopyTo(ca, context, mapper); return ca; }
public void Visit(IBehaviorDefinition behaviorDefinition, CustomAttribute attribute) { ILProcessor processor = behaviorDefinition.Body.GetILProcessor(); var pingerDefinition = new VariableDefinition("pinger", behaviorDefinition.Module.Import(breakpointType)); behaviorDefinition.Body.Variables.Add(pingerDefinition); var sequencedInstructions = behaviorDefinition.Body.Instructions.Where(instruction => instruction.SequencePoint != null).ToList(); Console.Out.WriteLine(sequencedInstructions.Count); // var extractedInstructions = Specific(sequencedInstructions, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 20, 21); var extractedInstructions = Filtered(sequencedInstructions); foreach (var instruction in extractedInstructions) { Type intType = typeof(int); var breakPointInstructions = new List<Instruction> { processor.Create(OpCodes.Newobj, behaviorDefinition.Module.Import( breakpointType.GetConstructor(new Type[]{}))), processor.Create(OpCodes.Ldc_I4, instruction.SequencePoint.StartLine), processor.Create(OpCodes.Ldc_I4, instruction.SequencePoint.StartColumn), processor.Create(OpCodes.Ldc_I4, instruction.SequencePoint.EndLine), processor.Create(OpCodes.Ldc_I4, instruction.SequencePoint.EndColumn), processor.Create(OpCodes.Ldstr, instruction.SequencePoint.Document.Url), processor.Create(OpCodes.Call, behaviorDefinition.Module.Import(breakpointType.GetMethod("Activate", new[] {intType, intType, intType, intType, typeof(string)}))) }; breakPointInstructions.ForEach(bpr => processor.InsertBefore(instruction, bpr)); foreach (var i in behaviorDefinition.Body.Instructions) { Console.Out.WriteLine("{0}/[{1}]: {2} {3}", i.Offset, Sequence(i.SequencePoint), i.OpCode, i.Operand); } } }
public void Visit(IBehaviorDefinition method, CustomAttribute attribute) { ILProcessor processor = method.Body.GetILProcessor(); string description = attribute.Properties.Where(argument => (argument.Name == "Description")).First().Argument.Value as string; var listType = typeof(List<object>); var listVariable = new VariableDefinition("argumentz", method.Module.Import(listType)); method.Body.Variables.Add(listVariable); var instructions = new List<Instruction>(); instructions.Add(processor.Create(OpCodes.Newobj, method.Module.Import(listType.GetConstructor(new Type[] { })))); instructions.Add(processor.Create(OpCodes.Stloc, listVariable)); int parameterIndex = 1; foreach (var parameter in method.Parameters) { instructions.Add(processor.Create(OpCodes.Ldloc, listVariable)); instructions.Add(processor.Create(OpCodes.Ldarg, parameterIndex)); if (parameter.ParameterType.IsPrimitive || parameter.ParameterType.IsValueType) instructions.Add(processor.Create(OpCodes.Box, parameter.ParameterType)); instructions.Add(processor.Create(OpCodes.Callvirt, method.Module.Import(listType.GetMethod("Add", new[] { typeof(object) })))); ++parameterIndex; } instructions.Add(processor.Create(OpCodes.Newobj, method.Module.Import(broadcastType.GetConstructor(new Type[] {})))); instructions.Add(processor.Create(OpCodes.Ldloc, listVariable)); instructions.Add(processor.Create(OpCodes.Ldstr, description)); instructions.Add(processor.Create(OpCodes.Callvirt, method.Module.Import(broadcastType.GetMethod("Run", new[] {listType, typeof(string)})))); new InsertionAtStart(processor, method).Run(instructions); }
MethodReference FindConstructor(CustomAttribute att) { // The constructor provided by CustomAttribute.Constructor is lacking some information, such as the parameter // name and custom attributes. Since we need the full info, we have to look it up in the declaring type. TypeDefinition atd = FindTypeDefinition(att.Constructor.DeclaringType.Module.Assembly, att.Constructor.DeclaringType); foreach (MethodReference met in atd.Methods) { if (met.Name != ".ctor") { continue; } if (met.Parameters.Count == att.Constructor.Parameters.Count) { for (int n = met.Parameters.Count - 1; n >= 0; n--) { if (met.Parameters[n].ParameterType.FullName != att.Constructor.Parameters[n].ParameterType.FullName) { break; } if (n == 0) { return(met); } } } } return(null); }
public static CustomAttribute InjectCustomAttribute(this ICustomAttributeProvider provider, CustomAttribute attribute, ReferenceResolver resolver) { if (attribute == null) throw new ArgumentNullException("attribute"); if (resolver == null) throw new ArgumentNullException("resolver"); TypeReference attributeType = resolver.ReferenceType(attribute.AttributeType); // no context required as attributes cannot be generic MethodReference constructor = resolver.ReferenceMethod(attribute.Constructor); CustomAttribute newAttribute; if ((newAttribute = Helper.GetCustomAttribute(provider.CustomAttributes, attribute)) != null) return newAttribute; newAttribute = new CustomAttribute(constructor);//, attr.GetBlob()); provider.CustomAttributes.Add(newAttribute); MetadataBuilderHelper.CopyCustomAttributeArguments(attribute.ConstructorArguments, newAttribute.ConstructorArguments, resolver); MetadataBuilderHelper.CopyCustomAttributeNamedArguments(attribute.Fields, newAttribute.Fields, resolver); MetadataBuilderHelper.CopyCustomAttributeNamedArguments(attribute.Properties, newAttribute.Properties, resolver); return newAttribute; }
public AppliedPatchInfo(CustomAttribute cecilCustomAttribute) { _cecilCustomAttribute = cecilCustomAttribute; Name = cecilCustomAttribute.Fields.Single(f => f.Name == "Name").Argument.Value.ToString(); Version = int.Parse( cecilCustomAttribute.Fields.Single(f => f.Name == "Version").Argument.Value.ToString() ); var catStr = PatchCategory.Unknown.ToString(); var catField = cecilCustomAttribute.Fields.SingleOrDefault(f => f.Name == "Category"); if (catField.Name == "Category") { catStr = catField.Argument.Value.ToString(); } PatchCategory catTemp = PatchCategory.Unknown; Enum.TryParse(catStr, true, out catTemp); Category = catTemp; var codeBlocksObj = cecilCustomAttribute.Fields.SingleOrDefault(f => f.Name == "CodeBlocks"); if (codeBlocksObj.Name == "CodeBlocks") { AppliedCodeBlocks = AppliedCodeBlock.Deserialise(codeBlocksObj.Argument.Value.ToString()); } else { AppliedCodeBlocks = new List<AppliedCodeBlock>(); } }
/// <summary> /// Public translation interface. /// Translates the given method to GLSL /// </summary> /// <param name="s">Shader type definition.</param> /// <param name="m">A method representing a shader to translate.</param> /// <param name="attr">The shader type as attribute (either FragmentShaderAttribute or VertexShaderAttribute</param> /// <param name="type">The shader type as ShaderType</param> /// <returns>The translated GLSL shader source</returns> public FunctionDescription Transform(TypeDefinition s, MethodDefinition m, CustomAttribute attr, ShaderType type) { if (s == null) throw new ArgumentNullException("s"); if (m == null) throw new ArgumentNullException("m"); if (attr == null) throw new ArgumentNullException("attr"); var ctx = new DecompilerContext(s.Module) { CurrentType = s, CurrentMethod = m, CancellationToken = CancellationToken.None }; var d = AstMethodBodyBuilder.CreateMethodBody(m, ctx); var glsl = new GlslVisitor(d, attr, ctx); _functions.UnionWith(glsl.Functions); var entry = (bool)attr.ConstructorArguments.FirstOrDefault().Value; var sig = entry ? "void main()" : GlslVisitor.GetSignature(m); var code = glsl.Result; var desc = new FunctionDescription(entry ? "main" : Shader.GetMethodName(m), sig + code, entry, type); _dependencies.UnionWith(glsl.Dependencies); return desc; }
public void Visit(IBehaviorDefinition behaviorDefinition, CustomAttribute attribute) { ILProcessor processor = behaviorDefinition.Body.GetILProcessor(); var pingerDefinition = new VariableDefinition("pinger", behaviorDefinition.Module.Import(pingType)); behaviorDefinition.Body.Variables.Add(pingerDefinition); var start = new List<Instruction> { processor.Create(OpCodes.Ldstr, behaviorDefinition.Name), processor.Create(OpCodes.Newobj, behaviorDefinition.Module.Import( pingType.GetConstructor(new[]{typeof(string)}))), processor.Create(OpCodes.Stloc, pingerDefinition), processor.Create(OpCodes.Ldloc, pingerDefinition), processor.Create(OpCodes.Callvirt, behaviorDefinition.Module.Import(pingType.GetMethod("Start", new Type[] {}))), }; var end = new List<Instruction> { processor.Create(OpCodes.Ldloc, pingerDefinition), processor.Create(OpCodes.Callvirt, behaviorDefinition.Module.Import(pingType.GetMethod("End", new Type[] {}))) }; new InsertionAtStart(processor, behaviorDefinition).Run(start); new InsertionAtEnd(processor, behaviorDefinition).Run(end); foreach (var instruction in behaviorDefinition.Body.Instructions) { Console.Out.WriteLine("{0}/[{1}]: {2} {3}", instruction.Offset, Sequence(instruction.SequencePoint), instruction.OpCode, instruction.Operand); } }
public CustomAttribute InjectCustomAttribute(Mono.Cecil.ICustomAttributeProvider target, CustomAttribute attribute) { if(module == null) throw new ArgumentNullException("module"); if(target == null) throw new ArgumentNullException("target"); if(attribute == null) throw new ArgumentNullException("attribute"); TypeReference attributeType = ReferenceOrInjectType(attribute.AttributeType); // no context required as attributes cannot be generic MethodReference constructor = ReferenceOrInjectMethod(attribute.Constructor); CustomAttribute newAttribute; if((newAttribute = Helper.GetCustomAttribute(target.CustomAttributes, attribute)) != null) return newAttribute; newAttribute = new CustomAttribute(constructor);//, attr.GetBlob()); target.CustomAttributes.Add(newAttribute); CopyCustomAttributeArguments(attribute.ConstructorArguments, newAttribute.ConstructorArguments); CopyCustomAttributeNamedArguments(attribute.Fields, newAttribute.Fields); CopyCustomAttributeNamedArguments(attribute.Properties, newAttribute.Properties); return newAttribute; }
protected override bool IsRemovedAttribute(CustomAttribute attribute) { // note: this also avoid calling FullName (which allocates a string) var attr_type = attribute.Constructor.DeclaringType; switch (attr_type.Name) { case "ObsoleteAttribute": // System.Mono*Attribute from mono/mcs/build/common/MonoTODOAttribute.cs case "MonoDocumentationNoteAttribute": case "MonoExtensionAttribute": case "MonoInternalNoteAttribute": case "MonoLimitationAttribute": case "MonoNotSupportedAttribute": case "MonoTODOAttribute": return attr_type.Namespace == "System"; case "MonoFIXAttribute": return attr_type.Namespace == "System.Xml"; // remove debugging-related attributes if we're not linking symbols (i.e. we're building release builds) case "DebuggableAttribute": case "DebuggerBrowsableAttribute": case "DebuggerDisplayAttribute": case "DebuggerHiddenAttribute": case "DebuggerNonUserCodeAttribute": case "DebuggerStepperBoundaryAttribute": case "DebuggerStepThroughAttribute": case "DebuggerTypeProxyAttribute": case "DebuggerVisualizerAttribute": return !DebugBuild && attr_type.Namespace == "System.Diagnostics"; default: return false; } }
/// <summary> /// Default ctor /// </summary> internal DexImport(string className, TypeDefinition firstType, CustomAttribute attr, string scope) { this.className = className; this.attr = attr; this.scope = scope; types = new List<TypeDefinition> { firstType }; }
/// <summary> /// Create app widget provider xml file. /// </summary> private void CreateAppWidgetProviderFile(string tempFolder, int index, CustomAttribute attr) { var resourceName = AppWidgetProviderResource.GetResourceName(index); var path = Path.Combine(Path.Combine(tempFolder, @"res\xml"), resourceName + ".xml"); var doc = new XDocument(); var root = new XElement("appwidget-provider"); doc.Add(root); root.AddAttrIfNotEmpty("minWidth", Namespace, attr.GetValue<string>("MinWidth")); root.AddAttrIfNotEmpty("minHeight", Namespace, attr.GetValue<string>("MinHeight")); root.AddAttrIfNotDefault("updatePeriodMillis", Namespace, attr.GetValue<long>("UpdatePeriod"), 0L); root.AddAttrIfNotEmpty("previewImage", Namespace, attr.GetValue<string>("PreviewImage"), FormatDrawable); root.AddAttrIfNotEmpty("initialLayout", Namespace, attr.GetValue<string>("InitialLayout"), FormatLayout); var configureActivityType = attr.GetValue<TypeReference>("ConfigureActivity"); if (configureActivityType != null) { var configureActivityTypeDef = configureActivityType.Resolve(); if (configureActivityTypeDef == null) throw new ArgumentException("Cannot resolve " + configureActivityType.FullName); root.AddAttr("configure", Namespace, FormatClassName(XBuilder.AsTypeDefinition(module, configureActivityTypeDef))); } root.AddAttrIfNotDefault("resizeMode", Namespace, attr.GetValue<int>("ResizeMode"), 0, widgetResizeModesOptions.Format); root.AddAttrIfNotDefault("widgetCategory", Namespace, attr.GetValue<int>("Category"), 0, widgetCategoriesOptions.Format); root.AddAttrIfNotEmpty("initialKeyguardLayout", Namespace, attr.GetValue<string>("InitialKeyguardLayout"), FormatLayout); Directory.CreateDirectory(Path.GetDirectoryName(path)); doc.Save(path); }
private void AddDataAttr(List<Tuple<string, string>> data, CustomAttribute attr, string attrName) { string propertyName = "Data" + char.ToUpperInvariant(attrName[0]) + attrName.Substring(1); string value = attr.GetValue<string>(-1, propertyName); if (value == null) return; data.Add(Tuple.Create(attrName, value)); }
public virtual DialogResult ShowDialog(CustomAttribute attribute, CustomAttributeNamedArgument? argument, bool usefields) { SelectedArgument = argument; SelectedAttribute = attribute; _useFields = usefields; return ShowDialog(); }
void MarkMethod (MethodDefinition method, CustomAttribute preserve_attribute) { if (method == null) return; Mark (method, preserve_attribute); Annotations.SetAction (method, MethodAction.Parse); }
protected virtual bool IsPreservedAttribute (CustomAttribute attribute) { // [assembly: Preserve (type)] does not preserve all the code in the assembly, in fact it might // not preserve anything in _this_ assembly, but something in a separate assembly (reference) if (attribute.HasConstructorArguments) return false; return (attribute.AttributeType.Name == "PreserveAttribute"); }
public static void VisibileInReport(this TypeDefinition t, bool visible) { var mod = t.Module; var ctor = mod.ImportReference(typeof(VisibleInReportsAttribute).GetConstructor(new[] { typeof(bool) })); var cb = new Mono.Cecil.CustomAttribute(ctor); cb.ConstructorArguments.Add(new CustomAttributeArgument(mod.ImportReference(typeof(bool)), visible)); t.CustomAttributes.Add(cb); }
void Mark (IMetadataTokenProvider provider, CustomAttribute preserve_attribute) { if (IsConditionalAttribute (preserve_attribute)) { PreserveConditional (provider); return; } PreserveUnconditional (provider); }
public static object GetLeadingConstructorArgument(CustomAttribute customAttribute) { if (customAttribute.ConstructorParameters.Count < 1) { throw new CompilerException("Expected custom attribute to have at least 1 constructor parameter: " + customAttribute); } return customAttribute.ConstructorParameters[0]; }
/// <summary> /// Adds the specified attribute to the specified field. /// </summary> /// <param name="field">The field to add the attribute to.</param> /// <param name="attribute">The attribute to add.</param> /// <param name="module">The module the field is defined in.</param> public static CustomAttribute AddAttribute(FieldDefinition field, Type attribute, ModuleDefinition module) { TypeDefinition tr = module.Import(attribute).Resolve(); MethodDefinition mr = tr.Methods.First(value => value.IsConstructor); MethodReference rf = module.Import(mr); var customAttribute = new CustomAttribute(rf); field.CustomAttributes.Add(customAttribute); return customAttribute; }
/// <summary> /// Contracts for <see cref="IWeave.Weave"/> /// </summary> /// <param name="weavingContext">Context data for weaving.</param> /// <param name="target">The type to which the weave will be applied/</param> /// <param name="weaveAttribute">Attribute that may contain arguments for the weave invocation.</param> public void Weave(IWeavingContext weavingContext, TypeDefinition target, CustomAttribute weaveAttribute) { Contract.Requires(weavingContext != null); Contract.Requires(target != null); Contract.Requires(weaveAttribute != null); Contract.Requires(this.IsInitialized); throw new NotSupportedException(); }
/// <summary> /// CopyMethod copies a method definition into a new copy which can be added /// to another module. /// </summary> /// <param name="method">The MethodDefinition to copy</param> /// <returns>A copy of the MethodDefinition</returns> public static MethodDefinition CopyMethod(MethodDefinition method) { MethodDefinition newMethod = new MethodDefinition(method.Name, method.Attributes, method.ReturnType); foreach (ParameterDefinition param in method.Parameters) { ParameterDefinition newParam = new ParameterDefinition(param.Name, param.Attributes, param.ParameterType); newMethod.Parameters.Add(newParam); } foreach (CustomAttribute attr in method.CustomAttributes) { CustomAttribute newAttr = new CustomAttribute(attr.Constructor); foreach (CustomAttributeArgument arg in attr.ConstructorArguments) { CustomAttributeArgument newArg = new CustomAttributeArgument(arg.Type, arg.Value); newAttr.ConstructorArguments.Add(newArg); } foreach (CustomAttributeNamedArgument arg in attr.Fields) { CustomAttributeNamedArgument newArg = new CustomAttributeNamedArgument(arg.Name, new CustomAttributeArgument(arg.Argument.Type, arg.Argument.Value)); newAttr.Fields.Add(newArg); } newMethod.CustomAttributes.Add(newAttr); } if (method.Body != null) { if (newMethod.Body == null) newMethod.Body = new MethodBody(newMethod); foreach (Instruction inst in method.Body.Instructions) { newMethod.Body.Instructions.Add(inst); } foreach (VariableDefinition var in method.Body.Variables) { VariableDefinition newVar = new VariableDefinition(var.Name, var.VariableType); newMethod.Body.Variables.Add(newVar); } foreach (ExceptionHandler handler in method.Body.ExceptionHandlers) { ExceptionHandler newHandler = new ExceptionHandler(handler.HandlerType); newHandler.HandlerStart = handler.HandlerStart; newHandler.HandlerEnd = handler.HandlerEnd; newHandler.TryStart = handler.TryStart; newHandler.TryEnd = handler.TryEnd; newHandler.FilterStart = handler.FilterStart; newHandler.CatchType = handler.CatchType; newMethod.Body.ExceptionHandlers.Add(newHandler); } newMethod.Body.InitLocals = method.Body.InitLocals; } return newMethod; }
/// <summary> /// Compile the given XML file to a binary XML file in the given output folder. /// </summary> private void CreateUsesSdk(XElement manifest, CustomAttribute packageAttribute) { // Create uses-sdk var usesSdk = new XElement("uses-sdk", new XAttribute(XName.Get("minSdkVersion", Namespace), FindMinSdkLevel().ToString())); if (!string.IsNullOrEmpty(targetSdkVersion)) { usesSdk.Add(new XAttribute(XName.Get("targetSdkVersion", Namespace), FormatTargetSdkVersion(targetSdkVersion))); } manifest.Add(usesSdk); }
private static void AddCustomAttributeArgument(Collection<CustomAttribute> customAttributes) { var version = typeof (ModuleWeaver).Assembly.GetName().Version.ToString(); var name = typeof (ModuleWeaver).Assembly.GetName().Name; var generatedAttribute = new CustomAttribute(ReferenceFinder.GeneratedCodeAttribute.ConstructorStringString); generatedAttribute.ConstructorArguments.Add(new CustomAttributeArgument(ReferenceFinder.String.TypeReference, name)); generatedAttribute.ConstructorArguments.Add(new CustomAttributeArgument(ReferenceFinder.String.TypeReference, version)); customAttributes.Add(generatedAttribute); }
protected static IList GetArgumentsToBaseConstructor(MC.CustomAttribute att, MC.TypeReference baseType) { if (att.AttributeType.FullName == baseType.FullName) { return(att.ConstructorArguments.Select(arg => arg.Value).ToList()); } else { //FIXME: Implement throw new NotImplementedException(); } }
protected static IList GetArgumentsToBaseConstructor(MC.CustomAttribute att, MC.TypeReference baseType) { if (att.Constructor.DeclaringType.FullName == baseType.FullName) { return(att.ConstructorParameters); } else { //FIXME: Implement throw new NotImplementedException(); } }
private static Mono.Cecil.CustomAttribute GetModelDefaultCustomAttribute(string name, string value, ModuleDefinition mod) { var ctor = mod.ImportReference( typeof(ModelDefaultAttribute).GetConstructor(new[] { typeof(string), typeof(string) })); var cb = new Mono.Cecil.CustomAttribute(ctor); var tr = mod.ImportReference(typeof(string)); cb.ConstructorArguments.Add(new CustomAttributeArgument(tr, name)); cb.ConstructorArguments.Add(new CustomAttributeArgument(tr, value)); return(cb); }
public static void AddNonPersistentDc(this TypeDefinition type) { var modf = type.Module; var ctor = modf.ImportReference(typeof(NonPersistentAttribute).GetConstructor(Type.EmptyTypes)); if (ctor == null) { throw new Exception("没有找到合适的构造函数!"); } var att = new Mono.Cecil.CustomAttribute(ctor); type.CustomAttributes.Add(att); }
public static void Size(this PropertyDefinition p, int size) { var modf = p.PropertyType.Module; var ctor = modf.ImportReference(typeof(SizeAttribute).GetConstructor(new[] { typeof(int) })); if (ctor == null) { throw new Exception("没有找到合适的构造函数!"); } var att = new Mono.Cecil.CustomAttribute(ctor); att.ConstructorArguments.Add(new CustomAttributeArgument(modf.ImportReference(typeof(int)), size)); p.CustomAttributes.Add(att); }
public static void Aggregate(this PropertyDefinition self) { var mod = self.DeclaringType.Module; var clrctor = typeof(AggregatedAttribute).GetConstructor(Type.EmptyTypes); var ctor = self.DeclaringType.Module.ImportReference(clrctor); if (ctor == null) { throw new Exception("没有找到合适的构造函数!"); } var att = new Mono.Cecil.CustomAttribute(ctor); self.CustomAttributes.Add(att); }
public static void Assocication(this PropertyDefinition self, string name) { var mod = self.DeclaringType.Module; var clrctor = typeof(AssociationAttribute).GetConstructor(new Type[] { typeof(string) }); var ctor = self.DeclaringType.Module.ImportReference(clrctor); if (ctor == null) { throw new Exception("没有找到合适的构造函数!"); } var att = new Mono.Cecil.CustomAttribute(ctor); att.ConstructorArguments.Add(new CustomAttributeArgument(mod.ImportReference(typeof(string)), name)); self.CustomAttributes.Add(att); }
protected virtual void Visit(Mono.Cecil.CustomAttribute customAttribute, Context context) { if (customAttribute.Constructor != null) { this.Visit(customAttribute.Constructor, context.AttributeConstructor(customAttribute)); } if (customAttribute.AttributeType != null) { this.VisitTypeReference(customAttribute.AttributeType, context.AttributeType(customAttribute)); } foreach (CustomAttributeArgument argument in customAttribute.ConstructorArguments) { this.Visit(argument, context.AttributeArgument(customAttribute)); } foreach (Mono.Cecil.CustomAttributeNamedArgument argument2 in customAttribute.Fields) { this.Visit(argument2, context.AttributeArgument(customAttribute)); } foreach (Mono.Cecil.CustomAttributeNamedArgument argument3 in customAttribute.Properties) { this.Visit(argument3, context.AttributeArgument(customAttribute)); } }
protected void SetCustomAttributes(ICollection <AnalysisNet.Types.CustomAttribute> ourAttributes, ICollection <Cecil.CustomAttribute> cecilAttributes) { foreach (AnalysisNet.Types.CustomAttribute analysisNetAttr in ourAttributes) { Cecil.MethodReference ctor = ReferenceGenerator.MethodReference(analysisNetAttr.Constructor); Cecil.TypeReference type = ReferenceGenerator.TypeReference(analysisNetAttr.Type); Cecil.CustomAttribute cecilAttr = new Cecil.CustomAttribute(ctor); foreach (AnalysisNet.ThreeAddressCode.Values.Constant constant in analysisNetAttr.Arguments) { // todo: cci is not working correctly if (constant == null) { continue; } Cecil.CustomAttributeArgument cecilArg = new Cecil.CustomAttributeArgument(ReferenceGenerator.TypeReference(constant.Type), constant.Value); cecilAttr.ConstructorArguments.Add(cecilArg); } cecilAttributes.Add(cecilAttr); } }
object ConvertAttribute(CustomAttribute att, Type expectedType) { Type attype = typeof(IAssemblyReflector).Assembly.GetType(att.Constructor.DeclaringType.FullName); if (attype == null || !expectedType.IsAssignableFrom(attype)) { return(null); } object ob; if (att.ConstructorArguments.Count > 0) { object[] cargs = new object [att.ConstructorArguments.Count]; List <int> typeParameters = null; // Constructor parameters of type System.Type can't be set because types from the assembly // can't be loaded. The parameter value will be set later using a type name property. for (int n = 0; n < cargs.Length; n++) { var atype = Type.GetType(att.Constructor.Parameters[n].ParameterType.FullName); if (atype == null) { atype = typeof(IAssemblyReflector).Assembly.GetType(att.Constructor.Parameters[n].ParameterType.FullName); } if (atype.IsEnum) { cargs [n] = Enum.ToObject(atype, att.ConstructorArguments [n].Value); } else { cargs [n] = att.ConstructorArguments [n].Value; } if (typeof(System.Type).IsAssignableFrom(atype)) { if (typeParameters == null) { typeParameters = new List <int> (); } cargs [n] = typeof(object); typeParameters.Add(n); } } ob = Activator.CreateInstance(attype, cargs); // If there are arguments of type System.Type, set them using the property if (typeParameters != null) { Type[] ptypes = new Type [cargs.Length]; for (int n = 0; n < cargs.Length; n++) { ptypes [n] = cargs [n].GetType(); } ConstructorInfo ci = attype.GetConstructor(ptypes); ParameterInfo[] ciParams = ci.GetParameters(); for (int n = 0; n < typeParameters.Count; n++) { int ip = typeParameters [n]; string propName = ciParams[ip].Name; propName = char.ToUpper(propName [0]) + propName.Substring(1); SetTypeNameAndAssemblyName(propName, attype, ob, (TypeReference)att.ConstructorArguments[ip].Value); } } } else { ob = Activator.CreateInstance(attype); } foreach (Mono.Cecil.CustomAttributeNamedArgument namedArgument in att.Properties) { string pname = namedArgument.Name; PropertyInfo prop = attype.GetProperty(pname); if (prop != null) { if (prop.PropertyType == typeof(System.Type)) { SetTypeNameAndAssemblyName(pname, attype, ob, (TypeReference)namedArgument.Argument.Value); } else { prop.SetValue(ob, namedArgument.Argument.Value, null); } } } return(ob); }
internal static MethodDefinition Clone(MethodDefinition meth, ImportContext context) { MethodDefinition nm = new MethodDefinition( meth.Name, RVA.Zero, meth.Attributes, meth.ImplAttributes, meth.HasThis, meth.ExplicitThis, meth.CallingConvention); MethodReference contextMethod = context.GenericContext.Method; context.GenericContext.Method = nm; GenericParameter.CloneInto(meth, nm, context); nm.ReturnType.ReturnType = context.Import(meth.ReturnType.ReturnType); if (meth.ReturnType.Parameter != null) { nm.ReturnType.Parameter = ParameterDefinition.Clone(meth.ReturnType.Parameter, context); nm.ReturnType.Parameter.Method = nm; } if (meth.PInvokeInfo != null) { nm.PInvokeInfo = meth.PInvokeInfo; // TODO: import module ? } if (meth.HasParameters) { foreach (ParameterDefinition param in meth.Parameters) { nm.Parameters.Add(ParameterDefinition.Clone(param, context)); } } if (meth.HasOverrides) { foreach (MethodReference ov in meth.Overrides) { nm.Overrides.Add(context.Import(ov)); } } if (meth.HasCustomAttributes) { foreach (CustomAttribute ca in meth.CustomAttributes) { nm.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } } if (meth.HasSecurityDeclarations) { foreach (SecurityDeclaration sec in meth.SecurityDeclarations) { nm.SecurityDeclarations.Add(SecurityDeclaration.Clone(sec)); } } if (meth.Body != null) { nm.Body = MethodBody.Clone(meth.Body, nm, context); } context.GenericContext.Method = contextMethod; return(nm); }
void ReadCustomAttributes() { if (!m_tHeap.HasTable(CustomAttributeTable.RId)) { return; } CustomAttributeTable caTable = m_tableReader.GetCustomAttributeTable(); for (int i = 0; i < caTable.Rows.Count; i++) { CustomAttributeRow caRow = caTable [i]; MethodReference ctor; if (caRow.Type.TokenType == TokenType.Method) { ctor = GetMethodDefAt(caRow.Type.RID); } else { ctor = GetMemberRefAt(caRow.Type.RID, new GenericContext()) as MethodReference; } CustomAttrib ca = m_sigReader.GetCustomAttrib(caRow.Value, ctor); CustomAttribute cattr; if (!ca.Read) { cattr = new CustomAttribute(ctor); cattr.IsReadable = false; cattr.Blob = m_root.Streams.BlobHeap.Read(caRow.Value); } else { cattr = BuildCustomAttribute(ctor, ca); } ICustomAttributeProvider owner = null; switch (caRow.Parent.TokenType) { case TokenType.Assembly: owner = this.Module.Assembly; break; case TokenType.Module: owner = this.Module; break; case TokenType.TypeDef: owner = GetTypeDefAt(caRow.Parent.RID); break; case TokenType.TypeRef: owner = GetTypeRefAt(caRow.Parent.RID); break; case TokenType.Field: owner = GetFieldDefAt(caRow.Parent.RID); break; case TokenType.Method: owner = GetMethodDefAt(caRow.Parent.RID); break; case TokenType.Property: owner = GetPropertyDefAt(caRow.Parent.RID); break; case TokenType.Event: owner = GetEventDefAt(caRow.Parent.RID); break; case TokenType.Param: owner = GetParamDefAt(caRow.Parent.RID); break; case TokenType.GenericParam: owner = GetGenericParameterAt(caRow.Parent.RID); break; default: //TODO: support other ? break; } if (owner != null) { owner.CustomAttributes.Add(cattr); } } }
public void Add(CustomAttribute value) { List.Add(value); }
public CustomAttributeEventArgs(CustomAttribute item) { m_item = item; }
public void Insert(int index, CustomAttribute value) { List.Insert(index, value); }
public void Remove(CustomAttribute value) { List.Remove(value); }
public virtual void VisitCustomAttribute(CustomAttribute customAttr) { }
private void GenerateModuleAssembly() { #region GetVersion Version ver = BusinessBuilder.GetVersion(AdmiralEnvironment.UserDefineBusinessFile); if (ver != null) { ver = new Version(ver.Major + 1, ver.Minor, ver.Build, ver.Revision); } else { ver = new Version(1, 0, 0, 0); } #endregion var assemblyName = "AdmiralDynamicDC"; var newFileName = AdmiralEnvironment.UserDefineBusinessTempFile.FullName; #region 定义程序集 var asmName = new AssemblyNameDefinition(assemblyName, ver); //[assembly: AssemblyFileVersionAttribute("1.0.0.12")] var assembly = AssemblyDefinition.CreateAssembly( asmName, "MainModule", ModuleKind.Dll ); //AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Save, AdmiralEnvironment.UserDefineBusinessDirectoryInfo.FullName); #region 定义模块 var module = assembly.MainModule; #endregion #endregion #region 设置文件版本 var asmFileVerCtor = typeof(SR.AssemblyFileVersionAttribute).GetConstructor(new[] { typeof(string) }); var asmFileVerCtorRef = assembly.MainModule.ImportReference(asmFileVerCtor); var ca = new Mono.Cecil.CustomAttribute(asmFileVerCtorRef); ca.ConstructorArguments.Add(new CustomAttributeArgument( assembly.MainModule.ImportReference(typeof(string)), ver.ToString())); assembly.CustomAttributes.Add(ca); #endregion #region XafModule var xafModule = new TypeDefinition("", "RuntimeModule", TypeAttributes.Public | TypeAttributes.Class, assembly.MainModule.ImportReference(typeof(RuntimeModuleBase))); //module.DefineType("RuntimeModule", TypeAttributes.Public | TypeAttributes.Class, typeof(RuntimeModuleBase)); var ctor = new MethodDefinition(".ctor", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, module.ImportReference(typeof(void)) ); //.method public hidebysig specialname rtspecialname instance void .ctor() cil managed //xafModule.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard | CallingConventions.HasThis, Type.EmptyTypes); var baseCtor = typeof(RuntimeModuleBase).GetConstructor(Type.EmptyTypes); var il = ctor.Body.Instructions; //.maxstack 8 //L_0000: ldarg.0 //L_0001: call instance void Admiral.ERP.Module.RuntimeModuleBase::.ctor() //L_0006: ret il.Add(Instruction.Create(OpCodes.Ldarg_0)); il.Add(Instruction.Create(OpCodes.Call, module.ImportReference(baseCtor))); il.Add(Instruction.Create(OpCodes.Ret)); xafModule.Methods.Add(ctor); module.Types.Add(xafModule); #endregion #region 创建业务对象 var ObjectSpace = this.Application.CreateObjectSpace(); var allTypes = ObjectSpace.GetObjects <BusinessObjectBase>(); var userDefinedBos = allTypes.OfType <BusinessObject>().Where(x => x.IsRuntimeDefine).ToList(); //ObjectSpace.GetObjects<BusinessObject>(new BinaryOperator("IsRuntimeDefine", true)).OrderBy(x => x.CreateIndex).ToArray(); var dllTypes = allTypes.Except(userDefinedBos); //ObjectSpace.GetObjects<BusinessObject>(new BinaryOperator("IsRuntimeDefine", false)); module.InitializeTypeReferences(dllTypes); //第一步只生成类型定义,是因为可能有交叉使用类型,如,基类是未定义的类型,则无法使用 #region 定义类型生成的代码,包含属性修饰:-->[NonPersistent]pubic class { } foreach (var bo in userDefinedBos) { var typeAtt = TypeAttributes.Class | TypeAttributes.Public; if (bo.IsAbstract) { typeAtt |= TypeAttributes.Abstract; } else if (!bo.CanInherits) { typeAtt |= TypeAttributes.Sealed; } var type = new TypeDefinition(bo.Category.FullName, bo.称, typeAtt); module.Types.Add(type); if (!bo.IsPersistent) { type.AddNonPersistentDc(); } if (bo.IsCloneable.HasValue) { type.ModelDefault("IsCloneable", bo.IsCloneable.Value.ToString().ToLower()); } if (bo.IsCreatableItem.HasValue) { type.ModelDefault("IsCreatableItem", bo.IsCreatableItem.Value.ToString().ToLower()); } if (bo.IsVisibileInReports.HasValue) { type.VisibileInReport(bo.IsVisibileInReports.Value); } type.AddToTypeReferences(bo); } #endregion #region 生成剩下的内容 foreach (var bo in userDefinedBos) { var type = bo.GetTypeDefintion(); if (type == null) { throw new Exception("错误!"); } #region 处理基类 var boBaseType = bo.Base.GetTypeReference() ?? module.ImportReference(typeof(SimpleObject)); MethodReference boBaseCtor; if (boBaseType.HasGenericParameters) { type.BaseType = boBaseType.MakeGenericType(bo.GenericParameters.Select(gp => gp.ParameterValue.GetTypeReference()).ToArray()); //var tb = boBaseType.Resolve().MakeGenericType(bo.GenericParameters.Select(gp => gp.ParameterValue.FindType(typeReferences)).ToArray()); boBaseCtor = //(tb as TypeDefinition).Methods.Single(x => x.Name == ".ctor" && x.Parameters.First().ParameterType.FullName == typeof(Session).FullName); module.ImportReference( type.BaseType.Resolve() .Methods.Single( x => x.Name == ".ctor" && x.Parameters.First().ParameterType.FullName == typeof(Session).FullName) ); boBaseCtor = boBaseCtor.MakeGeneric(bo.GenericParameters.Select(gp => gp.ParameterValue.GetTypeReference()).ToArray()); } else { type.BaseType = boBaseType; boBaseCtor = module.ImportReference( boBaseType.Resolve().Methods.Single(x => x.Name == ".ctor" && x.Parameters.Count == 1 && x.Parameters.Single().ParameterType.FullName == typeof(Session).FullName) ); } if (boBaseCtor != null) { var boctor = new MethodDefinition(".ctor", MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.RTSpecialName, //CallingConventions.Standard | CallingConventions.HasThis, module.ImportReference(typeof(void)) ); // type.DefineConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.RTSpecialName, CallingConventions.Standard | CallingConventions.HasThis, new Type[] { typeof(Session) }); var p = new ParameterDefinition("session", ParameterAttributes.None, module.ImportReference(typeof(Session))); boctor.Parameters.Add(p); var boil = boctor.Body.GetILProcessor(); //.GetILGenerator(); boil.Emit(OpCodes.Ldarg_0); boil.Emit(OpCodes.Ldarg_1); boil.Emit(OpCodes.Call, boBaseCtor); boil.Emit(OpCodes.Nop); boil.Emit(OpCodes.Nop); boil.Emit(OpCodes.Ret); //L_0000: ldarg.0 //L_0001: ldarg.1 //L_0002: call instance void IMatrix.ERP.Module.BusinessObjects.订单`1 <class IMatrix.ERP.Module.BusinessObjects.PMS.采购订单明细>::.ctor(class [DevExpress.Xpo.v15.2] //DevExpress.Xpo.Session) //L_0007: nop //L_0008: nop //L_0009: ret //.method public hidebysig specialname rtspecialname //instance void .ctor(class ['DevExpress.Xpo.v15.2']DevExpress.Xpo.Session session) cil managed //{ //// 代码大小 10 (0xa) //.maxstack 8 //IL_0000: ldarg.0 //IL_0001: ldarg.1 //IL_0002: call instance void [IMatrix.ERP.Module]IMatrix.ERP.Module.BusinessObjects.'订单`1'::.ctor<class '业务'.'采购计划明细'>(class ['DevExpress.Xpo.v15.2']DevExpress.Xpo.Session) //IL_0007: nop //IL_0008: nop //IL_0009: ret //} // end of method '采购计划'::.ctor type.Methods.Add(boctor); } #endregion #region 填加属性 foreach (var p in bo.Properties) { BuildPropertyCore(p, type); } #endregion #region 填加集合属性 foreach (var item in bo.CollectionProperties) { BuildCollectionProperty(item, type); } #endregion } #endregion #endregion #region 保存生成的程序集 assembly.Write(newFileName); #endregion #region 除模块信息,让系统执行更新表结构动作 var moduleInfo = ObjectSpace.FindObject <ModuleInfo>(new BinaryOperator("Name", "RuntimeModule")); if (moduleInfo != null) { ObjectSpace.Delete(moduleInfo); ObjectSpace.CommitChanges(); } var restart = Application as IRestartApplication; if (restart != null) { restart.RestartApplication(); } #endregion }
public static void SetConstructorArgumentValue(Mono.Cecil.CustomAttribute ca, int index, object value) { Mono.Cecil.CustomAttributeArgument[] items = GetCaaItems(ca.ConstructorArguments); items[index].Value = value; }
public static void SetPropertyName(Mono.Cecil.CustomAttribute ca, int index, string name) { Mono.Cecil.CustomAttributeNamedArgument[] items = GetCanaItems(ca.Properties); items[index].Name = name; }
MA.CustomAttribute ConvertToRawAttribute(CustomAttribute att, string expectedType) { TypeDefinition attType = FindTypeDefinition(att.Constructor.DeclaringType.Module.Assembly, att.Constructor.DeclaringType); if (attType == null || !TypeIsAssignableFrom(expectedType, attType)) { return(null); } MA.CustomAttribute mat = new MA.CustomAttribute(); mat.TypeName = att.Constructor.DeclaringType.FullName; if (att.ConstructorArguments.Count > 0) { var arguments = att.ConstructorArguments; MethodReference constructor = FindConstructor(att); if (constructor == null) { throw new InvalidOperationException("Custom attribute constructor not found"); } for (int n = 0; n < arguments.Count; n++) { ParameterDefinition par = constructor.Parameters[n]; object val = arguments [n].Value; if (val != null) { string name = par.Name; NodeAttributeAttribute bat = (NodeAttributeAttribute)GetCustomAttribute(par, typeof(NodeAttributeAttribute), false); if (bat != null) { name = bat.Name; } mat.Add(name, Convert.ToString(val, System.Globalization.CultureInfo.InvariantCulture)); } } } foreach (Mono.Cecil.CustomAttributeNamedArgument namedArgument in att.Properties) { string pname = namedArgument.Name; object val = namedArgument.Argument.Value; if (val == null) { continue; } foreach (TypeDefinition td in GetInheritanceChain(attType)) { PropertyDefinition prop = GetMember(td.Properties, pname); if (prop == null) { continue; } NodeAttributeAttribute bat = (NodeAttributeAttribute)GetCustomAttribute(prop, typeof(NodeAttributeAttribute), false); if (bat != null) { string name = string.IsNullOrEmpty(bat.Name) ? prop.Name : bat.Name; mat.Add(name, Convert.ToString(val, System.Globalization.CultureInfo.InvariantCulture)); } } } foreach (Mono.Cecil.CustomAttributeNamedArgument namedArgument in att.Fields) { string pname = namedArgument.Name; object val = namedArgument.Argument.Value; if (val == null) { continue; } foreach (TypeDefinition td in GetInheritanceChain(attType)) { FieldDefinition field = GetMember(td.Fields, pname); if (field != null) { NodeAttributeAttribute bat = (NodeAttributeAttribute)GetCustomAttribute(field, typeof(NodeAttributeAttribute), false); if (bat != null) { string name = string.IsNullOrEmpty(bat.Name) ? field.Name : bat.Name; mat.Add(name, Convert.ToString(val, System.Globalization.CultureInfo.InvariantCulture)); } } } } return(mat); }
public int IndexOf(CustomAttribute value) { return(List.IndexOf(value)); }
object ConvertAttribute(CustomAttribute att, Type expectedType) { Type attype = typeof(IAssemblyReflector).Assembly.GetType(att.Constructor.DeclaringType.FullName); if (attype == null || !expectedType.IsAssignableFrom(attype)) { return(null); } object ob; if (att.ConstructorArguments.Count > 0) { object[] cargs = new object [att.ConstructorArguments.Count]; ArrayList typeParameters = null; // Constructor parameters of type System.Type can't be set because types from the assembly // can't be loaded. The parameter value will be set later using a type name property. for (int n = 0; n < cargs.Length; n++) { cargs [n] = att.ConstructorArguments [n].Value; string atype = att.Constructor.Parameters[n].ParameterType.FullName; if (atype == "System.Type") { if (typeParameters == null) { typeParameters = new ArrayList(); } cargs [n] = typeof(object); typeParameters.Add(n); } } ob = Activator.CreateInstance(attype, cargs); // If there are arguments of type System.Type, set them using the property if (typeParameters != null) { Type[] ptypes = new Type [cargs.Length]; for (int n = 0; n < cargs.Length; n++) { ptypes [n] = cargs [n].GetType(); } ConstructorInfo ci = attype.GetConstructor(ptypes); ParameterInfo[] ciParams = ci.GetParameters(); for (int n = 0; n < typeParameters.Count; n++) { int ip = (int)typeParameters [n]; string propName = ciParams[ip].Name; propName = char.ToUpper(propName [0]) + propName.Substring(1) + "Name"; PropertyInfo pi = attype.GetProperty(propName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); if (pi == null) { throw new InvalidOperationException("Property '" + propName + "' not found in type '" + attype + "'."); } pi.SetValue(ob, ((TypeReference)att.ConstructorArguments [ip].Value).FullName, null); } } } else { ob = Activator.CreateInstance(attype); } foreach (Mono.Cecil.CustomAttributeNamedArgument namedArgument in att.Properties) { string pname = namedArgument.Name; PropertyInfo prop = attype.GetProperty(pname); if (prop != null) { if (prop.PropertyType == typeof(System.Type)) { // We can't load the type. We have to use the typeName property instead. pname += "Name"; prop = attype.GetProperty(pname, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); if (prop == null) { throw new InvalidOperationException("Property '" + pname + "' not found in type '" + attype + "'."); } prop.SetValue(ob, ((TypeReference)namedArgument.Argument.Value).FullName, null); } else { prop.SetValue(ob, namedArgument.Argument.Value, null); } } } return(ob); }
public bool Contains(CustomAttribute value) { return(List.Contains(value)); }