C# ITypesInfo.FindTypeInfo方法代码示例

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     if (Application != null) {
         typesInfo.FindTypeInfo(typeof(ShowInAnalysisPermission)).FindMember("ControllerType").AddAttribute(new VisibleInDetailViewAttribute(false));
         typesInfo.FindTypeInfo(typeof(PivotSettingsPermission)).FindMember("ControllerType").AddAttribute(new VisibleInDetailViewAttribute(false));
     }
 }

 public static IJobDetail StoreJob(this IScheduler scheduler, IXpandJobDetail xpandJobDetail,ITypesInfo typesInfo) {
     var jobDetail = (JobDetailImpl)(scheduler.GetJobDetail(xpandJobDetail) ?? xpandJobDetail.CreateQuartzJobDetail());
     jobDetail.AssignXpandJobDetail(xpandJobDetail);
     var typeInfo = typesInfo.FindTypeInfo(xpandJobDetail.JobDataMap.GetType());
     jobDetail.AssignDataMap(typeInfo, xpandJobDetail.JobDataMap);
     if (xpandJobDetail.Job.DataMap != null) {
         typeInfo = typesInfo.FindTypeInfo(xpandJobDetail.Job.DataMap.GetType());
         jobDetail.AssignDataMap(typeInfo, xpandJobDetail.Job.DataMap);
     }
     scheduler.StoreJobCore(jobDetail);
     return jobDetail;
 }

        public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
            base.CustomizeTypesInfo(typesInfo);
            OnApplicationInitialized(Application);
            var type = (BaseInfo)typesInfo.FindTypeInfo(typeof(IModelMember)).FindMember("Type");
            var attribute = type.FindAttribute<ModelReadOnlyAttribute>();
            if (attribute != null)
                type.RemoveAttribute(attribute);

            type = (BaseInfo)typesInfo.FindTypeInfo(typeof(IModelBOModelClassMembers));
            attribute = type.FindAttribute<ModelReadOnlyAttribute>();
            if (attribute != null)
                type.RemoveAttribute(attribute);
        }

 void CreateMembers(ITypesInfo typesInfo, Type optionsType, Type persistentType) {
     ITypeInfo typeInfo = typesInfo.FindTypeInfo(ReflectionHelper.GetType(persistentType.Name));
     IEnumerable<PropertyInfo> propertyInfos = optionsType.GetProperties().Where(info => info.GetSetMethod() != null).Where(propertyInfo => typeInfo.FindMember(propertyInfo.Name) == null);
     foreach (PropertyInfo propertyInfo in propertyInfos) {
         OnCreateMember(typeInfo, propertyInfo.Name, propertyInfo.PropertyType);
     }
 }

 void CreateMember(ITypesInfo typesInfo, IRoleTypeProvider roleTypeProvider, SecurityOperationsAttribute attribute) {
     var roleTypeInfo = typesInfo.FindTypeInfo(roleTypeProvider.RoleType);
     if (roleTypeInfo.FindMember(attribute.OperationProviderProperty) == null) {
         var memberInfo = roleTypeInfo.CreateMember(attribute.OperationProviderProperty, typeof(SecurityOperationsEnum));
         memberInfo.AddAttribute(new RuleRequiredFieldAttribute());
     }
 }

 void UpdateLayoutManager(ITypesInfo typesInfo) {
     if (!(LayoutManager is ILayoutManager)) {
         var typeInfo = ReflectionHelper.FindTypeDescendants(typesInfo.FindTypeInfo(typeof(ILayoutManager))).FirstOrDefault();
         if (typeInfo != null)
             this.SetPropertyInfoBackingFieldValue(view => view.LayoutManager, this, ReflectionHelper.CreateObject(typeInfo.Type));
     }
 }

 private void SetAdditionalExportedTypesProperties(ITypesInfo typesInfo)
 {
     foreach (var type in AdditionalExportedTypes)
     {
         var typeInfo = (TypeInfo)typesInfo.FindTypeInfo(type);
         typeInfo.IsDomainComponent = true;
     }
 }

        public void Init()
        {
            _TypesInfo = A.Fake<ITypesInfo>();
            _TypeInfo = A.Fake<ITypeInfo>();
            A.CallTo(() => _TypesInfo.FindTypeInfo(A<Type>.Ignored)).Returns(_TypeInfo);

            _Builder = ModelBuilder.Create<TargetClass>(_TypesInfo);
        }

 void AddNewObjectCreateGroup(ITypesInfo typesInfo, IEnumerable<Type> types) {
     foreach (var type in types) {
         var typeDescendants = ReflectionHelper.FindTypeDescendants(typesInfo.FindTypeInfo(type));
         foreach (var typeInfo in typeDescendants) {
             typeInfo.AddAttribute(new NewObjectCreateGroupAttribute("Logic"));
         }
     }
 }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     if (Debugger.IsAttached) {
         IEnumerable<XPClassInfo> collection = XafTypesInfo.XpoTypeInfoSource.XPDictionary.Classes.Cast<XPClassInfo>();
         foreach (var typeInfo in collection)
             if (typeInfo.HasAttribute(typeof(RuleCombinationOfPropertiesIsUniqueAttribute)))
                 if (typesInfo.FindTypeInfo(typeInfo.ClassType).DefaultMember == null)
                     throw new NullReferenceException("DefaultMember of " + typeInfo.FullName + " is null");
     }
 }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     if (Application == null)
         return;
     typesInfo.FindTypeInfo(TypesInfo.AnalysisType).AddAttribute(new DefaultPropertyAttribute("Name"));
     foreach (var keyValuePair in GetOptionsMapperDictionary()) {
         CreateMembers(typesInfo, keyValuePair.Key, keyValuePair.Value);
     }
 }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo) {
     base.CustomizeTypesInfo(typesInfo);
     var typeInfo = typesInfo.FindTypeInfo<XpoStateMachine>();
     typeInfo.CreateMember(EnableFilteredPropety, typeof (bool));
     if (!RuntimeMode) {
         CreateDesignTimeCollection(typesInfo, typeof(XpoStateMachine), AdminRoles);
     } else if (Application.CanBuildSecurityObjects()) {
         BuildSecuritySystemObjects();
     }
 }

 void HandleCustomAttribute(IMemberInfo memberInfo, ITypesInfo typesInfo) {
     var customAttributes = memberInfo.FindAttributes<Attribute>().OfType<ICustomAttribute>().ToList();
     foreach (var customAttribute in customAttributes) {
         for (int index = 0; index < customAttribute.Name.Split(';').Length; index++) {
             string s = customAttribute.Name.Split(';')[index];
             var theValue = customAttribute.Value.Split(';')[index];
             var typeInfo = typesInfo.FindTypeInfo(theValue);
             if (customAttribute is PropertyEditorAttribute && typeInfo.IsInterface) {
                 try {
                     theValue = typeInfo.Implementors.Single().FullName;
                 } catch (InvalidOperationException) {
                     if (Application != null)
                         throw new InvalidOperationException(typeInfo.FullName + " has no implementors");
                 }
             }
             memberInfo.AddAttribute(new ModelDefaultAttribute(s, theValue));
         }
     }
 }

 void ModifySequenceObjectWhenMySqlDatalayer(ITypesInfo typesInfo) {
     var typeInfo = typesInfo.FindTypeInfo(SequenceObjectType);
     if (IsMySql(typeInfo)) {
         var memberInfo = (XafMemberInfo)typeInfo.FindMember<ISequenceObject>(o => o.TypeName);
         memberInfo.RemoveAttributes<SizeAttribute>();
         memberInfo.AddAttribute(new SizeAttribute(255));
     }
 }

 public override void CustomizeTypesInfo(ITypesInfo typesInfo)
 {
     base.CustomizeTypesInfo(typesInfo);
     ITypeInfo info = typesInfo.FindTypeInfo(typeof(PersistentBase));
     if (FilterProviderManager.Providers != null)
         foreach (FilterProviderBase provider in FilterProviderManager.Providers)
         {
             if (info.FindMember(provider.FilterMemberName) == null)
                 CreateMember(info, provider);
         }
 }