Beispiel #1
0
        public Work AddOrUpdate(IndirectionInfo info, Work method)
        {
            var holder = LooseCrossDomainAccessor.GetOrRegister <GenericHolder <TaggedBag <BodyOfNonPublicMethod, Dictionary <string, Work> > > >();

            if (holder.Source.Value == null)
            {
                holder.Source = TaggedBagFactory <BodyOfNonPublicMethod> .Make(new Dictionary <string, Work>());
            }

            var dict = holder.Source.Value;

            lock (dict)
            {
                using (InstanceGetters.DisableProcessing())
                {
                    var key = info + "";
                    holder.Source.Value[key] = method;

                    var wrapAndInvoke = CreateWrapAndInvokeMethod(IndirectionDelegate, key);
                    m_holder.AddOrUpdate(info, wrapAndInvoke);

                    dict[key] = method;
                    return(method);
                }
            }
        }
Beispiel #2
0
        protected void SetTargetInstanceBody <TBehaviorPreparableImpl, TBody>(
            object target, TBody value, Func <TBody> getBodyOfDefaultBehavior, Action <TBody, Dictionary <object, TargetSettingValue <TBody> > > setBodyExecutingDefaultOr)
            where TBehaviorPreparableImpl : BehaviorPreparableImpl
            where TBody : class
        {
            if (!typeof(Delegate).IsAssignableFrom(typeof(TBody)))
            {
                throw new ArgumentException("The generic parameter must be a delegate type.", "TBody");
            }

            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            RuntimeHelpers.PrepareDelegate(value as Delegate);

            var holder = LooseCrossDomainAccessor.GetOrRegister <GenericHolder <TaggedBag <TBehaviorPreparableImpl, Dictionary <object, TargetSettingValue <TBody> > > > >();

            if (holder.Source.Value == null)
            {
                holder.Source = TaggedBagFactory <TBehaviorPreparableImpl> .Make(new Dictionary <object, TargetSettingValue <TBody> >());
            }

            var dic = holder.Source.Value;

            if (!dic.ContainsKey(target))
            {
                var behavior = getBodyOfDefaultBehavior();
                RuntimeHelpers.PrepareDelegate(behavior as Delegate);
                dic[target] = new TargetSettingValue <TBody>(behavior, value);
                {
                    // Prepare JIT
                    var original    = dic[target].Original;
                    var indirection = dic[target].Indirection;
                }

                setBodyExecutingDefaultOr(behavior, dic);
            }
            else
            {
                var before = dic[target];
                dic[target] = new TargetSettingValue <TBody>(before.Original, value);
            }
        }