/// <summary>
        /// Initializes a new instance of the <see cref="PropertyEmitter"/> class.
        /// </summary>
        /// <param name="parent">The parent.</param>
        /// <param name="property">The property.</param>
        public PropertyEmitter(TypeEmitter parent, PropertyReference property, bool isStatic = false)
        {
            BackingField = property.GetBackingField();
            Parent       = parent;
            Target       = property as PropertyDefinition ?? property.Resolve();
            toStatic     = isStatic;

            if (Target.GetMethod != null)
            {
                getter = new MethodEmitter(parent, Target.GetMethod);
            }
            else
            {
                var existing = Parent.Target.GetMethod($"get_{Target.Name}", Target.PropertyType, new TypeReference[0], new GenericParameter[0]);
                if (existing != null)
                {
                    Target.GetMethod = existing.Resolve();
                    getter           = new MethodEmitter(parent, Target.GetMethod);
                }
            }

            if (Target.SetMethod != null)
            {
                setter = new MethodEmitter(parent, Target.SetMethod);
            }
            else
            {
                var existing = Parent.Target.GetMethod($"set_{Target.Name}", Target.Module.TypeSystem.Void, new[] { Target.PropertyType }, new GenericParameter[0]);
                if (existing != null)
                {
                    Target.SetMethod = existing.Resolve();
                    setter           = new MethodEmitter(parent, Target.SetMethod);
                }
            }
        }
        private static void LoadSet <T>(T[] items, PropertyReference collectionProperty)
        {
            object backingField = collectionProperty.GetBackingField().GetValue(collectionProperty.Owner);

            foreach (T item in items)
            {
                backingField.InvokeMethod("Add", item);
            }
        }
        private static void LoadList <T>(T[] items, PropertyReference listProperty)
        {
            var backingField = (IList)listProperty.GetBackingField().GetValue(listProperty.Owner);

            foreach (T item in items)
            {
                backingField.Add(item);
            }
        }
        public static void LoadCollectionBackingField <T>(object target, string propertyName, T[] items)
        {
            var collectionProperty = new PropertyReference(target, propertyName);

            if (!collectionProperty.HasBackingField())
            {
                return;
            }

            FieldInfo backingField = collectionProperty.GetBackingField();

            if (backingField.FieldType.Equals(typeof(IList)))
            {
                LoadList(items, collectionProperty);
            }
            else if (backingField.FieldType.FullName == "Iesi.Collections.ISet")
            {
                LoadSet(items, collectionProperty);
            }
        }