Ejemplo n.º 1
0
        // it is caller's responsibility to call this method under lock(rcw)
        public ComEventsSink AddSink(ref Guid iid)
        {
            ComEventsSink sink = new ComEventsSink(_rcw, iid);

            _sinks = ComEventsSink.Add(_sinks, sink);

            return(_sinks);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Adds a handler to an event.
        /// </summary>
        /// <param name="handler">The handler to be added.</param>
        /// <returns>The original event with handler added.</returns>
        private object InPlaceAdd(object handler)
        {
            Requires.NotNull(handler, nameof(handler));
            VerifyHandler(handler);

            ComEventsSink comEventSink = ComEventsSink.FromRuntimeCallableWrapper(_rcw, _sourceIid, true);

            comEventSink.AddHandler(_dispid, handler);
            return(this);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Removes handler from the event.
        /// </summary>
        /// <param name="handler">The handler to be removed.</param>
        /// <returns>The original event with handler removed.</returns>
        private object InPlaceSubtract(object handler)
        {
            Requires.NotNull(handler, nameof(handler));
            VerifyHandler(handler);

            ComEventsSink comEventSink = ComEventsSink.FromRuntimeCallableWrapper(_rcw, _sourceIid, false);

            comEventSink?.RemoveHandler(_dispid, handler);

            return(this);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Adds a delegate to the invocation list of events originating from the COM object.
        /// </summary>
        /// <param name="rcw">COM object firing the events the caller would like to respond to</param>
        /// <param name="iid">identifier of the source interface used by COM object to fire events</param>
        /// <param name="dispid">dispatch identifier of the method on the source interface</param>
        /// <param name="d">delegate to invoke when specified COM event is fired</param>
        public static void Combine(object rcw, Guid iid, int dispid, Delegate d)
        {
            lock (rcw)
            {
                ComEventsInfo eventsInfo = ComEventsInfo.FromObject(rcw);

                ComEventsSink sink = eventsInfo.FindSink(ref iid) ?? eventsInfo.AddSink(ref iid);

                ComEventsMethod method = sink.FindMethod(dispid) ?? sink.AddMethod(dispid);

                method.AddDelegate(d);
            }
        }
Ejemplo n.º 5
0
 // it is caller's responsibility to call this method under lock(rcw)
 internal ComEventsSink RemoveSink(ComEventsSink sink)
 {
     _sinks = ComEventsSink.Remove(_sinks !, sink);
     return(_sinks !);
 }
Ejemplo n.º 6
0
 public ComEventsSink?FindSink(ref Guid iid)
 {
     return(ComEventsSink.Find(_sinks, ref iid));
 }