C# IFrameworkContext类代码示例

 public EnsureCoreDataTask(IFrameworkContext context, IHiveManager coreManager, IEnumerable<Lazy<Permission, PermissionMetadata>> permissions,
     ISecurityService securityService)
     : base(context, coreManager)
 {
     _permissions = permissions;
     _securityService = securityService;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProviderBootstrapper"/> class if sufficient configuration information has been supplied by the user.
        /// </summary>
        /// <param name="existingConfig">The existing config.</param>
        /// <param name="frameworkContext"></param>
        /// <remarks></remarks>
        public ProviderBootstrapper(ProviderConfigurationSection existingConfig, IFrameworkContext frameworkContext)
        {
            _existingConfig = existingConfig;
            _frameworkContext = frameworkContext;

        
        }

        /// <summary>
        /// Creates the test data types
        /// </summary>
        public List<DataType> InitDataTypes(IFrameworkContext frameworkContext)
        {
            // much neater :)
            _dataTypes = CoreFakeCmsData.RequiredCoreUserAttributeTypes()
                            .Select(x => frameworkContext.TypeMappers.Map<DataType>(x))
                            .ToList();

            //_dataTypes = new List<DataType>();
            //foreach (var v in CoreCmsData.RequiredCoreUserAttributeTypes())
            //{
            //    var a = frameworkContext.TypeMappers.Map<DataType>(v);
            //    _dataTypes.Add(a);
            //}

            //get the data types from the CoreCmsData
            //var dataTypes = new List<DataType>()
            //        {
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("rte-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("sltb-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("csp-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("tag-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("mltb-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("media-picker-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("integer-pe".EncodeAsGuid()))),
            //            frameworkContext.TypeMappers.Map<DataType>(CoreCmsData.RequiredCoreUserAttributeTypes().Single(x => x.Id == new HiveId("uploader-pe".EncodeAsGuid())))
            //        };

            //_dataTypes = dataTypes;
            LogHelper.Error<UmbracoXmlImportHelper>(String.Format("There were {0} data types found", _dataTypes.Count), new Exception());
            return _dataTypes;
        }

        //public EntityRepositoryFactory(ProviderMetadata providerMetadata, 
        //    ProviderRevisionSessionFactory<TypedEntity> revisionRepositoryFactory, 
        //    ProviderSchemaSessionFactory schemaRepositoryFactory,
        //    IFrameworkContext frameworkContext, global::NHibernate.Cfg.Configuration nhConfig)
        //    : base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext)
        //{
        //    Helper = new NhFactoryHelper(nhConfig, null, false, false, frameworkContext);
        //}

        public EntityRepositoryFactory(ProviderMetadata providerMetadata,
            AbstractRevisionRepositoryFactory<TypedEntity> revisionRepositoryFactory,
            AbstractSchemaRepositoryFactory schemaRepositoryFactory,
            IFrameworkContext frameworkContext, ProviderDependencyHelper dependencyHelper)
            : base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, dependencyHelper)
        {
        }

        public ProviderSetup(ProviderUnitFactory unitFactory, ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
            : base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
        {
            Mandate.ParameterNotNull(unitFactory, "unitFactory");

            UnitFactory = unitFactory;
        }

 protected ReadonlyProviderSetup(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal) 
     : base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
 {
     Mandate.ParameterNotNull(frameworkContext, "frameworkContext");
     Mandate.ParameterNotNull(bootstrapper, "bootstrapper");
     Mandate.ParameterNotNull(providerMetadata, "providerMetadata");
 }

 public IndexController(IndexConfiguration configuration, IFrameworkContext frameworkContext)
 {
     Configuration = configuration;
     FrameworkContext = frameworkContext;
     _manualResetter = new ManualResetEvent(false);
     Queue = new IndexModificationQueue();
 }

 internal EntityRepositoryFactory(ProviderMetadata providerMetadata,
     AbstractRevisionRepositoryFactory<TypedEntity> revisionRepositoryFactory,
     AbstractSchemaRepositoryFactory schemaRepositoryFactory, Settings settings,
     IFrameworkContext frameworkContext)
     : base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, new DependencyHelper(settings, providerMetadata))
 {
 }

 public AbstractProviderSetup(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
 {
     ProviderMetadata = providerMetadata;
     FrameworkContext = frameworkContext;
     Bootstrapper = bootstrapper;
     PriorityOrdinal = priorityOrdinal;
 }

 /// <summary>
 /// Constructor used for testing
 /// </summary>
 /// <param name="providerMetadata"></param>
 /// <param name="revisionRepositoryFactory"></param>
 /// <param name="frameworkContext"></param>
 /// <param name="helper"></param>
 internal SchemaRepositoryFactory(
     ProviderMetadata providerMetadata,
     AbstractRevisionRepositoryFactory<EntitySchema> revisionRepositoryFactory,
     IFrameworkContext frameworkContext,
     ExamineHelper helper)
     : base(providerMetadata, revisionRepositoryFactory, frameworkContext, new DependencyHelper(helper, providerMetadata))
 {
 }

 public NhFactoryHelper(Configuration config, ISession singleProvidedSession, bool leaveSessionOpenOnDispose, bool isSingleSessionFinalized, IFrameworkContext frameworkContext)
 {
     Config = config;
     SingleProvidedSession = singleProvidedSession;
     LeaveSessionOpenOnDispose = leaveSessionOpenOnDispose;
     IsSingleSessionFinalized = isSingleSessionFinalized;
     FrameworkContext = frameworkContext;
 }

 public DevDatasetInstallTask(
     IFrameworkContext frameworkContext,
     IPropertyEditorFactory propertyEditorFactory,
     IHiveManager hiveManager,
     IAttributeTypeRegistry attributeTypeRegistry)
     : base(frameworkContext, hiveManager)
 {
     _devDataSet = new DevDataset(propertyEditorFactory, frameworkContext, attributeTypeRegistry);
 }

        protected AbstractProviderRepository(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext)
        {
            CanRead = true;
            ProviderMetadata = providerMetadata;
            FrameworkContext = frameworkContext;
            RepositoryScopedCache = new DictionaryScopedCache();

            //HiveContext = new RepositoryContext(RuntimeCacheProvider.Default, PerHttpRequestCacheProvider.Default, frameworkContext);
        }

        public PublicAccessService(IHiveManager hive, IMembershipService<Member> membersMembershipService,
            IFrameworkContext framework)
        {
            Mandate.That<NullReferenceException>(hive != null);
            Mandate.That<NullReferenceException>(membersMembershipService != null);

            _hive = hive;
            _members = membersMembershipService;
            _framework = framework;
        }

 public ProviderMappingGroup(string key,
     WildcardUriMatch singleMatch,
     ReadonlyProviderSetup singleReader,
     ProviderSetup singleWriter,
     IFrameworkContext frameworkContext)
     : this(key, Enumerable.Repeat(singleMatch, 1), Enumerable.Repeat(singleReader, 1), Enumerable.Repeat(singleWriter, 1), frameworkContext)
 {
     Mandate.ParameterNotNull(singleReader, "singleReader");
     Mandate.ParameterNotNull(singleWriter, "singleWriter");
 }