// Adds an EventKey -> Delegate mapping if it doesn't exist or 
 // combines a delegate to an existing EventKey
 public void Add(EventKey eventKey, Delegate handler) {
    Monitor.Enter(m_events);
    Delegate d;
    m_events.TryGetValue(eventKey, out d);
    m_events[eventKey] = Delegate.Combine(d, handler);
    Monitor.Exit(m_events);
 }

 /////////////////////////////////////////////////////
 // track methods
 /////////////////////////////////////////////////////
 public void addTrack(String name, Delegate onCompleteHandler=null)
 {
     if(_tracks.ContainsKey(name) == false){
         _tracks[name] = new SoundTrack( new Sound( name ), gameObject, onCompleteHandler );
         _tracks[name].volume = _trackVolume;
     }
 }

		protected override Delegate RemoveImpl(Delegate d)
		{
			MulticastDelegate ret = null, cur = null;

			for (MulticastDelegate del = this; del != null; del = (MulticastDelegate)del.mNext)
			{
				// Miss out the one we're removing
				if (!del.Equals(d))
				{
					if (ret == null)
					{
						ret = (MulticastDelegate)object.MemberwiseClone(del);
						cur = ret;
					}
					else
					{
						cur.mNext = (MulticastDelegate)object.MemberwiseClone(del);
						cur = (MulticastDelegate)cur.mNext;
					}
				}
			}
			if (cur != null)
			{
				cur.mNext = null;
			}

			return ret;
		}

 public DelegateData(Delegate del, Type delType, Type module, BuildingEvents[] ID)
 {
     delegateInstance = del;
     moduleType = module;
     eventID = ID;
     delegateType = delType;
 }

        public void registerDelegate(Delegate newOne)
        /* pre:  Have a list of delegates which could be empty. For the new delegate, have delegate identifier, name, topic 
         *       and whether presenting (true) or not (false).
         * post: Register a delegate by adding him/her to the top of the delegates stack. A delegate may only be a presenter
         *       if there is a presentation slot available (use availSlots), otherwise register the delegate and display an
         *       appropriate message. NO DUPLICATE DELEGATES ARE REGISTERED (on delegate identifier) - display an appropriate 
         *       message in such a case. 
         */
        {

            Stack temp = new Stack();
            Delegate cur;
            bool foundPos = false;
            while ((Delegates.Count > 0) && (!foundPos))
            {
                cur = (Delegate)Delegates.Pop();
                temp.Push(cur);
                if (cur.Equals(newOne))
                    foundPos = true;
            }
            while (temp.Count > 0)
                Delegates.Push(temp.Pop());
            if (foundPos)
                Console.WriteLine("Delegate " + newOne.DelID + " already registered.");
            else
            {
                if (newOne.Presenter)
                    if (availSlots() < 1)
                    {
                        Console.WriteLine("Delegate {0} registered but cannot present - not enough slots", newOne.DelID);
                        newOne.Presenter = false;
                    }
                Delegates.Push(newOne);
            }
        }

    private float _volumeRatio = 1; // sound volume ratio

    #endregion Fields

    #region Constructors

    /**
     * INIT soundTrack, hook up controls
     *  @param soundObject: Sound
     *  @param gameObject: GameObject
     * 	@param onCompleteHandler: Delegate
     **/
    public SoundTrack(Sound soundObject, GameObject gameObject, Delegate onCompleteHandler=null)
    {
        _soundObj = soundObject;
        _channel = gameObject.AddComponent("AudioSource") as AudioSource;
        _channel.clip = _soundObj.clip;
        _complete = onCompleteHandler;
    }

 public ContinuationTaskFromTask(Task antecedent, Delegate action, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions)
     : base(action, state, InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, antecedent.Scheduler)
 {
     Contract.Requires(action is Action<Task> || action is Action<Task, object>, "Invalid delegate type in ContinuationTaskFromTask");
     _antecedent = antecedent;
     CapturedContext = ExecutionContext.Capture();
 }

 /// <summary>
 /// Concatenates an invocation list of 2 delegates.
 /// </summary>
 public static Delegate Combine(Delegate a, Delegate b)
 {
     if (a == null) return b;
     if (b == null) return a;
     a.Add(b);
     return a;
 }

        /// <summary>
        ///     Gets the current value of the parameter given (optional) compiled query arguments.
        /// </summary>
        internal object EvaluateParameter(object[] arguments)
        {
            if (_cachedDelegate == null)
            {
                if (_funcletizedExpression.NodeType
                    == ExpressionType.Constant)
                {
                    return ((ConstantExpression)_funcletizedExpression).Value;
                }
                ConstantExpression ce;
                if (TryEvaluatePath(_funcletizedExpression, out ce))
                {
                    return ce.Value;
                }
            }

            try
            {
                if (_cachedDelegate == null)
                {
                    // Get the Func<> type for the property evaluator
                    var delegateType = TypeSystem.GetDelegateType(_compiledQueryParameters.Select(p => p.Type), _type);

                    // Now compile delegate for the funcletized expression
                    _cachedDelegate = Lambda(delegateType, _funcletizedExpression, _compiledQueryParameters).Compile();
                }
                return _cachedDelegate.DynamicInvoke(arguments);
            }
            catch (TargetInvocationException e)
            {
                throw e.InnerException;
            }
        }

 public sealed override void AddEventHandler(Object target, Delegate handler)
 {
     MethodInfo addMethod = this.AddMethod;
     if (!addMethod.IsPublic)
         throw new InvalidOperationException(SR.InvalidOperation_NoPublicAddMethod);
     addMethod.Invoke(target, new Object[] { handler });
 }

 public void RemoveEventHandler(object target, Delegate handler)
 {
     var removeMethod = GetRemoveMethod();
     if (removeMethod == null)
         throw new InvalidOperationException("no public remove method");
     removeMethod.Invoke(target, new object[] { handler });
 }

 public void AddEventHandler(object target, Delegate handler)
 {
     var addMethod = GetAddMethod();
     if (addMethod == null)
         throw new InvalidOperationException("no public add method");
     addMethod.Invoke(target, new object[] { handler });
 }

 /// <summary>
 /// Executes the specified delegate with the specified arguments
 /// asynchronously on a thread pool thread
 /// </summary>
 /// <param name="d"></param>
 /// <param name="args"></param>
 public static void FireAndForget(Delegate d, params object[] args)
 {
     // Invoke the wrapper asynchronously, which will then
     // execute the wrapped delegate synchronously (in the
     // thread pool thread)
     if (d != null) wrapperInstance.BeginInvoke(d, args, callback, null);
 }

 public InterestCalculator(decimal money, decimal interest, int years, Delegate del)
 {
     this.Money = money;
     this.Interest = interest;
     this.Years = years;
     this.PayOutValue = del(money, interest, years);
 }

        public static MethodInfo GetDelegateMethodInfo(Delegate del)
        {
            if (del == null)
                throw new ArgumentException();
            Delegate[] invokeList = del.GetInvocationList();
            del = invokeList[invokeList.Length - 1];
            RuntimeTypeHandle typeOfFirstParameterIfInstanceDelegate;
            bool isOpenResolver;
            IntPtr originalLdFtnResult = RuntimeAugments.GetDelegateLdFtnResult(del, out typeOfFirstParameterIfInstanceDelegate, out isOpenResolver);
            if (originalLdFtnResult == (IntPtr)0)
                return null;

            MethodHandle methodHandle = default(MethodHandle);
            RuntimeTypeHandle[] genericMethodTypeArgumentHandles = null;

            bool callTryGetMethod = true;

            unsafe
            {
                if (isOpenResolver)
                {
                    OpenMethodResolver* resolver = (OpenMethodResolver*)originalLdFtnResult;
                    if (resolver->ResolverType == OpenMethodResolver.OpenNonVirtualResolve)
                    {
                        originalLdFtnResult = resolver->CodePointer;
                        // And go on to do normal ldftn processing.
                    }
                    else if (resolver->ResolverType == OpenMethodResolver.DispatchResolve)
                    {
                        callTryGetMethod = false;
                        methodHandle = resolver->Handle.AsMethodHandle();
                        genericMethodTypeArgumentHandles = null;
                    }
                    else
                    {
                        System.Diagnostics.Debug.Assert(resolver->ResolverType == OpenMethodResolver.GVMResolve);

                        callTryGetMethod = false;
                        methodHandle = resolver->Handle.AsMethodHandle();

                        RuntimeTypeHandle declaringTypeHandleIgnored;
                        MethodNameAndSignature nameAndSignatureIgnored;
                        if (!TypeLoaderEnvironment.Instance.TryGetRuntimeMethodHandleComponents(resolver->GVMMethodHandle, out declaringTypeHandleIgnored, out nameAndSignatureIgnored, out genericMethodTypeArgumentHandles))
                            return null;
                    }
                }
            }

            if (callTryGetMethod)
            {
                if (!ReflectionExecution.ExecutionEnvironment.TryGetMethodForOriginalLdFtnResult(originalLdFtnResult, ref typeOfFirstParameterIfInstanceDelegate, out methodHandle, out genericMethodTypeArgumentHandles))
                    return null;
            }
            MethodBase methodBase = ReflectionCoreExecution.ExecutionDomain.GetMethod(typeOfFirstParameterIfInstanceDelegate, methodHandle, genericMethodTypeArgumentHandles);
            MethodInfo methodInfo = methodBase as MethodInfo;
            if (methodInfo != null)
                return methodInfo;
            return null; // GetMethod() returned a ConstructorInfo.
        }

	static void Main ()
	{
		Delegate [] d = new Delegate [] { new Function<int, int, bool> (f1) };
		Assert.AreEqual (1, d.Length, "#1");
		MethodInfo mi = d [0].Method;
		Assert.AreEqual (typeof (Program), mi.DeclaringType, "#2");
		Assert.AreEqual ("Boolean f1(Int32, Int32)", mi.ToString (), "#2");
	}

		protected virtual Delegate RemoveImpl(Delegate d)
		{
			if (d.Equals(this))
			{
				return null;
			}
			return this;
		}

 public static void DisplayDelegateInfo(Delegate del)
 {
     foreach (var item in del.GetInvocationList())
     {
         Console.WriteLine("Method Name {0}", del.Method);
         Console.WriteLine("Type Name {0}", del.Target);
     }
 }

		public static Delegate Remove(Delegate source, Delegate value)
		{
			if (source == null)
			{
				return null;
			}
			return source.RemoveImpl(value);
		}

        public virtual void RemoveEventHandler(Object target, Delegate handler)
        {
            MethodInfo removeMethod = RemoveMethod;
            if (!removeMethod.IsPublic)
                throw new InvalidOperationException(SR.InvalidOperation_NoPublicRemoveMethod);

            removeMethod.Invoke(target, new object[] { handler });
        }