internal DataItemEventDescriptor(
      DataItemTypeDescriptor owner,
      EventDescriptor parent,
      Type componentType,
      Type eventType,
      Action<object, object> addHandler,
      Action<object, object> removeHandler )
      : base( owner, parent )
    {
      if( componentType == null )
        throw new ArgumentNullException( "componentType" );

      if( eventType == null )
        throw new ArgumentNullException( "eventType" );

      if( addHandler == null )
        throw new ArgumentNullException( "addHandler" );

      if( removeHandler == null )
        throw new ArgumentNullException( "removeHandler" );

      m_componentType = componentType;
      m_eventType = eventType;
      m_addHandler = addHandler;
      m_removeHandler = removeHandler;
    }

    public int Add(EventDescriptor value)
    {
      Contract.Ensures(0 <= Contract.Result<int>());
      Contract.Ensures(Contract.Result<int>() <= 2147483646);

      return default(int);
    }

		protected override ICollection GetCompatibleMethods(EventDescriptor e)
		{
			ITypeDefinition definition = loader.GetPrimaryTypeDefinition();
			ArrayList compatibleMethods = new ArrayList();
			MethodInfo methodInfo = e.EventType.GetMethod("Invoke");
			var methodInfoParameters = methodInfo.GetParameters();
			
			foreach (IMethod method in definition.Methods) {
				if (method.Parameters.Count == methodInfoParameters.Length) {
					bool found = true;
					for (int i = 0; i < methodInfoParameters.Length; ++i) {
						ParameterInfo pInfo = methodInfoParameters[i];
						IParameter p = method.Parameters[i];
						if (p.Type.ReflectionName != pInfo.ParameterType.ToString()) {
							found = false;
							break;
						}
					}
					if (found) {
						compatibleMethods.Add(method.Name);
					}
				}
			}
			
			return compatibleMethods;
		}

 ICollection IEventBindingService.GetCompatibleMethods(EventDescriptor e)
 {
     if (e == null)
     {
         throw new ArgumentNullException("e");
     }
     return this.GetCompatibleMethods(e);
 }

		protected override bool ShowCode(IComponent component, EventDescriptor edesc, string methodName)
		{
			if (formDesigner != null) {
				formDesigner.ShowSourceCode(component, edesc, methodName);
				return true;
			}
			return false;
		}

    protected DataItemEventDescriptorBase( DataItemTypeDescriptor owner, EventDescriptor parent )
      : base( parent )
    {
      if( owner == null )
        throw new ArgumentNullException( "owner" );

      m_owner = owner;
    }

		string IEventBindingService.CreateUniqueMethodName (IComponent component, EventDescriptor eventDescriptor)
		{
			if (eventDescriptor == null)
				throw new ArgumentNullException ("eventDescriptor");
			if (component == null)
				throw new ArgumentNullException ("component");

			return this.CreateUniqueMethodName (component, eventDescriptor);
		}

		public ReflectionEventDescriptor (Type componentType, EventDescriptor oldEventDescriptor, Attribute[] attrs) : base (oldEventDescriptor, attrs)
		{
			_componentType = componentType;
			_eventType = oldEventDescriptor.EventType;

			EventInfo event_info = componentType.GetEvent (oldEventDescriptor.Name);
			add_method = event_info.GetAddMethod ();
			remove_method = event_info.GetRemoveMethod ();
		}

		EventDescriptorCollection (EventDescriptor[] events, bool readOnly) 
		{
			this.isReadOnly = readOnly;
			if (events == null)
				return;

			for (int i = 0; i < events.Length; i++)
				this.Add (events[i]);
		}

		public string CreateUniqueMethodName (IComponent component, EventDescriptor e)
		{
			if (component.Site == null || component.Site.Name == null)
				throw new ArgumentException ("IComponent must be sited and named");
			
			//TODO: check component.Site.Name is valid as start of method name
			string trialPrefix = component.Site.Name + "_" + e.Name;
			
			return proxy.GenerateIdentifierUniqueInCodeBehind (trialPrefix);
		}

 public int Add(EventDescriptor value)
 {
     if (this.readOnly)
     {
         throw new NotSupportedException();
     }
     this.EnsureSize(this.eventCount + 1);
     this.events[this.eventCount++] = value;
     return (this.eventCount - 1);
 }

 private string GetEventDescriptorHashCode(EventDescriptor eventDesc)
 {
     StringBuilder builder = new StringBuilder(eventDesc.Name);
     builder.Append(eventDesc.EventType.GetHashCode().ToString(CultureInfo.InvariantCulture));
     foreach (Attribute attribute in eventDesc.Attributes)
     {
         builder.Append(attribute.GetHashCode().ToString(CultureInfo.InvariantCulture));
     }
     return builder.ToString();
 }

	// Constructors.
	public EventDescriptorCollection(EventDescriptor[] events)
			{
				list = new ArrayList();
				if(events != null)
				{
					foreach(EventDescriptor descr in events)
					{
						list.Add(descr);
					}
				}
			}

 /// <devdoc>
 ///    <para>
 ///       Initializes a new instance of the <see cref='System.ComponentModel.EventDescriptorCollection'/> class.
 ///    </para>
 /// </devdoc>
 public EventDescriptorCollection(EventDescriptor[] events) {
     this.events = events;
     if (events == null) {
         this.events = new EventDescriptor[0];
         this.eventCount = 0;
     }
     else {
         this.eventCount = this.events.Length;
     }
     this.eventsOwned = true;
 }

        public EventPropertyDescriptor(EventDescriptor eventDesc, IServiceProvider serviceProvider)
            : base(eventDesc)
        {
            _eventDescriptor = eventDesc;
            _serviceProvider = serviceProvider;

            FieldInfo eventFieldInfo = _eventDescriptor.ComponentType.GetField(_eventDescriptor.Name + "Event");
            if (eventFieldInfo != null)
            {
                _eventProperty = eventFieldInfo.GetValue(_eventDescriptor.ComponentType) as DependencyProperty;
            }
        }

 private EventDescriptorCollection(EventDescriptor[] events, int eventCount, string[] namedSort, IComparer comparer)
 {
     _eventsOwned = false;
     if (namedSort != null)
     {
         _namedSort = (string[])namedSort.Clone();
     }
     _comparer = comparer;
     _events = events;
     _eventCount = eventCount;
     _needSort = true;
 }

 public ReflectEventDescriptor(Type componentType, EventDescriptor oldReflectEventDescriptor, Attribute[] attributes) : base(oldReflectEventDescriptor, attributes)
 {
     this.componentClass = componentType;
     this.type = oldReflectEventDescriptor.EventType;
     ReflectEventDescriptor descriptor = oldReflectEventDescriptor as ReflectEventDescriptor;
     if (descriptor != null)
     {
         this.addMethod = descriptor.addMethod;
         this.removeMethod = descriptor.removeMethod;
         this.filledMethods = true;
     }
 }

		protected override bool ShowCode(IComponent component, EventDescriptor edesc, string methodName)
		{
			// There were reports of an ArgumentNullException caused by edesc==null.
			// Looking at the .NET code calling this method, this can happen when there are two calls to ShowCode() before the Application.Idle
			// event gets raised. In that case, ShowCode() already was called for the second set of arguments, and we can safely ignore
			// the call with edesc==null.
			if (formDesigner != null && edesc != null) {
				formDesigner.ShowSourceCode(component, edesc, methodName);
				return true;
			}
			return false;
		}

        public override EventDescriptorCollection GetEvents()
        {
            var coll = base.GetEvents();
            var list = new EventDescriptor[coll.Count];

            for (int i = 0; i < coll.Count; i++)
                if (coll[i].Name == "TextChanged")//instead of TextChanged slip BindingTextChanged for binding
                    list[i] = new FooTextChangedDescriptor(coll[i]);
                else
                    list[i] = coll[i];

            return new EventDescriptorCollection(list);
        }

 /// <summary>
 ///    <para>
 ///       Initializes a new instance of the <see cref='System.ComponentModel.EventDescriptorCollection'/> class.
 ///    </para>
 /// </summary>
 public EventDescriptorCollection(EventDescriptor[] events)
 {
     if (events == null)
     {
         _events = Array.Empty<EventDescriptor>();
     }
     else
     {
         _events = events;
         Count = events.Length;
     }
     _eventsOwned = true;
 }