C# TypeDefinition.GetConstructors方法代码示例

    private void WeaveType(TypeDefinition type, Dictionary<string, Tuple<MethodReference, MethodReference>> methodTable)
    {
        Debug.WriteLine("Weaving " + type.Name);

        var persistedProperties = new List<WeaveResult>();
        foreach (var prop in type.Properties.Where(x => x.HasThis && !x.CustomAttributes.Any(a => a.AttributeType.Name == "IgnoredAttribute")))
        {
            try
            {
                var weaveResult = WeaveProperty(prop, type, methodTable);
                if (weaveResult.Woven)
                {
                    persistedProperties.Add(weaveResult);
                }
                else
                {
                    var sequencePoint = prop.GetMethod.Body.Instructions.First().SequencePoint;
                    if (!string.IsNullOrEmpty(weaveResult.ErrorMessage))
                    {
                        // We only want one error point, so even though there may be more problems, we only log the first one.
                        LogErrorPoint(weaveResult.ErrorMessage, sequencePoint);
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(weaveResult.WarningMessage))
                        {
                            LogWarningPoint(weaveResult.WarningMessage, sequencePoint);
                        }

                        var realmAttributeNames = prop.CustomAttributes
                                                      .Select(a => a.AttributeType.Name)
                                                      .Intersect(RealmPropertyAttributes)
                                                      .Select(a => $"[{a.Replace("Attribute", string.Empty)}]");
                        
                        if (realmAttributeNames.Any())
                        {
                            LogErrorPoint($"{type.Name}.{prop.Name} has {string.Join(", ", realmAttributeNames)} applied, but it's not persisted, so those attributes will be ignored.", sequencePoint);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                var sequencePoint = prop.GetMethod.Body.Instructions.First().SequencePoint;
                LogErrorPoint(
                    $"Unexpected error caught weaving property '{type.Name}.{prop.Name}': {e.Message}.\r\nCallstack:\r\n{e.StackTrace}",
                    sequencePoint);
            }
        }

        if (!persistedProperties.Any())
        {
            LogError($"Class {type.Name} is a RealmObject but has no persisted properties.");
            return;
        }

        if (persistedProperties.Count(p => p.IsPrimaryKey) > 1)
        {
            LogError($"Class {type.Name} has more than one property marked with [PrimaryKey].");
            return;
        }

        var objectConstructor = type.GetConstructors()
            .SingleOrDefault(c => c.Parameters.Count == 0 && !c.IsStatic);
        if (objectConstructor == null)
        {
            var nonDefaultConstructor = type.GetConstructors().First();
            var sequencePoint = nonDefaultConstructor.Body.Instructions.First().SequencePoint;
            LogErrorPoint($"Class {type.Name} must have a public constructor that takes no parameters.", sequencePoint);
            return;
        }

        var preserveAttribute = new CustomAttribute(_references.PreserveAttribute_Constructor);
        objectConstructor.CustomAttributes.Add(preserveAttribute);
        preserveAttribute = new CustomAttribute(_references.PreserveAttribute_ConstructorWithParams); // recreate so has new instance
        preserveAttribute.ConstructorArguments.Add(new CustomAttributeArgument(ModuleDefinition.TypeSystem.Boolean, true)); // AllMembers
        preserveAttribute.ConstructorArguments.Add(new CustomAttributeArgument(ModuleDefinition.TypeSystem.Boolean, false)); // Conditional
        type.CustomAttributes.Add(preserveAttribute);
        LogDebug($"Added [Preserve] to {type.Name} and its constructor.");

        var wovenAttribute = new CustomAttribute(_references.WovenAttribute_Constructor);
        TypeReference helperType = WeaveRealmObjectHelper(type, objectConstructor, persistedProperties);
        wovenAttribute.ConstructorArguments.Add(new CustomAttributeArgument(_references.System_Type, helperType));
        type.CustomAttributes.Add(wovenAttribute);
        Debug.WriteLine(string.Empty);
    }

    private MethodDefinition CreateParameterlessConstructor(TypeDefinition type, MethodReference parentConstructor)
    {
        var constructor = new MethodDefinition(".ctor", MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, TypeSystem.Void);
          var processor = constructor.Body.GetILProcessor();

          // Select referencedConstructor whose field initializer code we're cloning
          // Note: Field initializers aren't optimized away, even if the field is overwritten by ctor!
          var referencedConstructor = type.GetConstructors().FirstOrDefault();
          if (referencedConstructor != null) {
         // Copy all instructions to last field initializer set-field.
         // If we don't run into a .ctor somehow, all instructions are copied.
         var referencedBody = referencedConstructor.Body;
         var referencedInstructions = referencedBody.Instructions;
         int copiedInstructionCount = referencedInstructions.Count;
         var superCall = referencedInstructions.FirstOrDefault(
            i => i.OpCode == OpCodes.Call && ((MethodReference)i.Operand).Name == ".ctor");
         if (superCall != null) {
            copiedInstructionCount = referencedInstructions.IndexOf(superCall);
            while (copiedInstructionCount > 0 &&
                   referencedInstructions[copiedInstructionCount - 1].OpCode != OpCodes.Stfld) {
               copiedInstructionCount--;
            }
         }
         for (var i = 0; i < copiedInstructionCount; i++) {
            processor.Append(referencedInstructions[i]);
         }
          }

          // Call parent constructor
          processor.Emit(OpCodes.Ldarg_0);
          processor.Emit(OpCodes.Call, parentConstructor);
          processor.Emit(OpCodes.Ret);
          return constructor;
    }