C# IActor.GetType方法代码示例

        private static DynamicMethod BuildDispatchingMethod(IActor handler, IStructSizeCounter counter,
            Func<Type, int> messageIdGetter)
        {
            var handlerType = handler.GetType();
            var handleMethods = ActorRegistry.GetHandleMethods(handlerType)
                .ToDictionary(m => messageIdGetter(m.GetParameters()[1].ParameterType.GetElementType()), m => m)
                .OrderBy(kvp => kvp.Key)
                .ToArray();

            var dm = new DynamicMethod("ReadMessagesFor_" + handlerType.Namespace.Replace(".", "_") + handlerType.Name,
                typeof (void), new[] {typeof (MessageReader), typeof (int), typeof (ByteChunk)},
                handlerType.Assembly.Modules.First(), true);

            var actorField = typeof (MessageReader).GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
                .Single(fi => fi.FieldType == typeof (IActor));

            var il = dm.GetILGenerator();

            // push handler
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldfld, actorField);
            il.Emit(OpCodes.Castclass, handlerType);

            var endLbl = il.DefineLabel();

            // dispatch
            foreach (var method in handleMethods)
            {
                var lbl = il.DefineLabel();
                il.Emit(OpCodes.Ldarg_1); // messageTypeId
                il.Emit(OpCodes.Ldc_I4, method.Key);
                il.Emit(OpCodes.Ceq);
                il.Emit(OpCodes.Brfalse_S, lbl);

                // push envelope
                il.Emit(OpCodes.Ldarg_2);
                il.Emit(OpCodes.Ldfld, typeof (ByteChunk).GetField("Pointer"));

                //var messageType = method.Value.GetParameters()[1].ParameterType.GetElementType();
                //il.Emit(OpCodes.Ldc_I4, (int)Marshal.OffsetOf(messageType, Envelope.FieldName));
                //il.Emit(OpCodes.Add);

                // push message
                il.Emit(OpCodes.Ldarg_2);
                il.Emit(OpCodes.Ldfld, typeof (ByteChunk).GetField("Pointer"));

                il.EmitCall(OpCodes.Callvirt, method.Value, null);
                il.Emit(OpCodes.Br_S, endLbl);
                il.MarkLabel(lbl);
            }

            // nothing was called, pop
            il.Emit(OpCodes.Pop);

            // end label
            il.MarkLabel(endLbl);
            il.Emit(OpCodes.Ret);
            return dm;
        }

        public static EventPlug[] Enumerate(IActor actor)
        {
            List<EventPlug> list = new List<EventPlug>();

            foreach (EventInfo e in actor.GetType().GetEvents())
            {
                EventPlug plug = Create(e,actor);
                if (plug != null)
                {
                    list.Add(plug);
                }
            }

            return list.ToArray();
        }

        private void Initialize(IActor actor)
        {
            // First get all public methods.
            MethodInfo[] allMethods = actor.GetType().GetMethods( BindingFlags.Public | BindingFlags.NonPublic );

            foreach (MethodInfo m in allMethods)
            {
                // Check if its a method handler.
                MessageHandlerAttribute messageAttribute = Attribute.GetCustomAttribute( m,typeof(MessageHandlerAttribute)) as MessageHandlerAttribute;

                if (messageAttribute != null)
                {
                    string messageName = messageAttribute.Name;

                    if (messageName == string.Empty)
                    {
                        messageName = m.Name;
                    }

                    // Store it.
                    if (!methods.ContainsKey(messageName))
                    {
                        MessagePrototype newPrototype = MessagePrototype.Create( messageName,m );

                        methods.Add( messageName,m );
                        prototypes.Add( messageName,newPrototype );
                    }
                }
            }

            returnArray = new MessagePrototype[ prototypes.Count ];
            prototypes.Values.CopyTo( returnArray,0 );

            // Handle the dispatch
            realCall = new MessageDebugger.DebugMessageDelegate( this.CallMethod );
        }

        public static IProperty[] Enumerate(IActor actor)
        {
            PropertyInfo[] properties = actor.GetType().GetProperties();
            List<IProperty> propertyList = new List<IProperty>();

            foreach (PropertyInfo p in properties)
            {
                Property currentProperty = Create(p,actor);
                if (currentProperty != null)
                    propertyList.Add(currentProperty);
            }

            return propertyList.ToArray();
        }

 public static string GetBaseType(IActor actor)
 {
     return GetBaseType( actor.GetType() );
 }

 public static string GetDocumentation(IActor actor)
 {
     return GetDocumentation( actor.GetType() );
 }

 public static string GetDescription(IActor actor)
 {
     return GetDescription( actor.GetType() );
 }

 /// <summary>
 /// Builds the description on the actor instance basis.
 /// </summary>
 /// <param name="actor"></param>
 public ActorDescriptor(IActor actor)
 {
     HandledMessageTypes = GetHandledMessageTypes(actor.GetType());
 }

        public Object ResolveArgumentGroup(IActor resolvedActor, String[] parameters)
        {
            if (resolvedActor == null)
            {
                if (parameters.Length != 1)
                    throw new SystemException("argument group expects exactly one parameter instead of " + parameters.Length);

                String groupId = parameters[0];
                IGroup group = null;
                try
                {
                    group = organizationService.FindGroupById(groupId);
                }
                catch (OrganisationRuntimeException e)
                {
                    throw new SystemException("can't resolve group-argument with parameter " + groupId + " : " + e.Message);
                }

                return group;
            }
            else
            {
                if (parameters.Length != 1)
                    throw new SystemException("argument group expects exactly one parameter (membership-type) instead of " + parameters.Length);

                IUser user = null;
                IGroup group = null;
                String membershipType = parameters[0];

                try
                {
                    group = organizationService.FindGroupByMembership(resolvedActor.Id, membershipType);
                }
                catch (InvalidCastException e)
                {
                    throw new SystemException("can't resolve group-argument : a group must be calculated from a User, not a " + resolvedActor.GetType().FullName, e);
                }
                catch (OrganisationRuntimeException e)
                {
                    throw new SystemException("can't resolve group-argument : can't find the hierarchy-memberschip of User " + user.Id + " and membership-type " + membershipType + " : " + e.Message, e);
                }

                return group;
            }
        }

        public Object ResolveArgumentRole(IActor resolvedActor, String[] parameters)
        {
            if (parameters.Length != 1)
                throw new SystemException("argument role expects exactly one parameter (role-name) instead of " + parameters.Length);

            IActor actor = null;

            if (resolvedActor == null)
            {
                try
                {
                    var attributeInstance = attributeRepository.FindAttributeInstanceInScope(parameters[0], CurrentScope, DbSession);
                    actor = (IActor)attributeInstance.GetValue();
                    throw new NotImplementedException();
                }
                catch (InvalidCastException e)
                {
                    //throw new SystemException("argument attribute(" + parameters[0] + ") does not contain an actor : " + executionContext.GetAttribute(parameters[0]).GetType().FullName, e);
                }
            }
            else
            {
                String roleName = parameters[0].Trim();

                try
                {
                    IList users = organizationService.FindUsersByGroupAndRole(resolvedActor.Id, roleName);
                    if (users.Count < 1)
                        throw new SystemException("no users have role " + roleName + " for group " + resolvedActor.Id);
                    actor = (IUser)users[0];

                    // TODO : create a new group if more then one user is returned on the query...
                }
                catch (InvalidCastException e)
                {
                    throw new SystemException("can't resolve role-argument : a role must be calculated from a Group, not a " + resolvedActor.GetType().FullName, e);
                }
                catch (OrganisationRuntimeException e)
                {
                    throw new SystemException("can't resolve role-argument : can't find the users that perform role " + roleName + " for group " + resolvedActor.Id + " : " + e.Message);
                }
            }

            return actor;
        }

        public Object ResolveArgumentParentGroup(IActor resolvedActor, String[] parameters)
        {
            if (parameters.Length != 0)
                throw new SystemException("argument parentGroup expects exactly zero parameters instead of " + parameters.Length);

            IGroup group = null;

            try
            {
                group = (IGroup)resolvedActor;
                group = group.Parent;
            }
            catch (InvalidCastException e)
            {
                throw new SystemException("can't resolve parentGroup-argument : a role must be calculated from a Group, not a " + resolvedActor.GetType().FullName, e);
            }

            return group;
        }

 public IActor OnError(IRuntime runtime, int actorId, IActor actor, Exception ex)
 {
     string message = String.Format("ActorId={0} of type={1}", actorId, actor.GetType().Name);
     runtime.Log.Error(message, ex);
     return null;
 }