private static void InitProviders(ProfileSection config)
        {
            if (!s_InitializedProviders)
            {
                s_Providers = new ProfileProviderCollection();
                if (config.Providers != null)
                {
                    ProvidersHelper.InstantiateProviders(config.Providers, s_Providers, typeof(ProfileProvider));
                }
                s_InitializedProviders = true;
            }
            bool flag = !HostingEnvironment.IsHosted || (BuildManager.PreStartInitStage == PreStartInitStage.AfterPreStartInit);

            if (!s_InitializeDefaultProvider && flag)
            {
                s_Providers.SetReadOnly();
                if (config.DefaultProvider == null)
                {
                    throw new ProviderException(System.Web.SR.GetString("Profile_default_provider_not_specified"));
                }
                s_Provider = s_Providers[config.DefaultProvider];
                if (s_Provider == null)
                {
                    throw new ConfigurationErrorsException(System.Web.SR.GetString("Profile_default_provider_not_found"), config.ElementInformation.Properties["providers"].Source, config.ElementInformation.Properties["providers"].LineNumber);
                }
                s_InitializeDefaultProvider = true;
            }
        }
        ///<summary>
        ///Initializes the provider.
        ///</summary>
        ///
        ///<param name="config">A collection of the name/value pairs representing the provider-specific 
        /// attributes specified in the configuration for this provider.
        /// The <c>providerId</c> attribute may be used to override the name being used for looking up an object definition.
        /// </param>
        ///<param name="name">The friendly name of the provider.</param>
        ///<exception cref="T:System.ArgumentNullException">The <paramref name="name"/> or <paramref name="config"/> is null.</exception>
        ///<exception cref="T:System.InvalidOperationException">An attempt is made to call <see cref="M:System.Configuration.Provider.ProviderBase.Initialize(System.String,System.Collections.Specialized.NameValueCollection)"></see> on a provider after the provider has already been initialized.</exception>
        ///<exception cref="T:System.ArgumentException">The <paramref name="name"/> has a length of zero or providerId attribute is not set.</exception>      
        public override void Initialize(string name, NameValueCollection config)
        {
            lock (this)
            {
                if (config == null) throw new ArgumentNullException("config");

                string providerId = config["providerId"];
                if (String.IsNullOrEmpty(providerId))
                    providerId = name;
                config.Remove("providerId");

                this.wrappedProvider = (ProfileProvider)WebApplicationContext.GetRootContext().GetObject(providerId);
                this.wrappedProvider.Initialize(name, config);
            }
        }
Пример #3
0
 private ProfileProvider()
 {
     _Provider = ProfileManager.Providers["SqlProfileProvider"];
 }
 private static void InitProviders(ProfileSection config)
 {
     if (!s_InitializedProviders)
     {
         s_Providers = new ProfileProviderCollection();
         if (config.Providers != null)
         {
             ProvidersHelper.InstantiateProviders(config.Providers, s_Providers, typeof(ProfileProvider));
         }
         s_InitializedProviders = true;
     }
     bool flag = !HostingEnvironment.IsHosted || (BuildManager.PreStartInitStage == PreStartInitStage.AfterPreStartInit);
     if (!s_InitializeDefaultProvider && flag)
     {
         s_Providers.SetReadOnly();
         if (config.DefaultProvider == null)
         {
             throw new ProviderException(System.Web.SR.GetString("Profile_default_provider_not_specified"));
         }
         s_Provider = s_Providers[config.DefaultProvider];
         if (s_Provider == null)
         {
             throw new ConfigurationErrorsException(System.Web.SR.GetString("Profile_default_provider_not_found"), config.ElementInformation.Properties["providers"].Source, config.ElementInformation.Properties["providers"].LineNumber);
         }
         s_InitializeDefaultProvider = true;
     }
 }
Пример #5
0
        //////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////
        static private void InitializeStatic()
        {
            if (!ProfileManager.Enabled || s_Initialized)
            {
                if (s_InitializeException != null)
                {
                    throw s_InitializeException;
                }
                return;
            }
            lock (s_InitializeLock) {
                if (s_Initialized)
                {
                    if (s_InitializeException != null)
                    {
                        throw s_InitializeException;
                    }
                    return;
                }

                try {
                    ProfileSection config       = MTConfigUtil.GetProfileAppConfig();
                    bool           fAnonEnabled = (HostingEnvironment.IsHosted ? AnonymousIdentificationModule.Enabled : true);
                    Type           baseType     = ProfileBase.InheritsFromType;
                    bool           hasLowTrust  = HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Low);

                    s_Properties = new SettingsPropertyCollection();

                    // Step 0: Add all dynamic profile properties set programatically during PreAppStart
                    ProfileBase.AddPropertySettingsFromConfig(baseType, fAnonEnabled, hasLowTrust, ProfileManager.DynamicProfileProperties, null);

                    //////////////////////////////////////////////////////////////////////
                    // Step 1: Add Properties from the base class (if not ProfileBase)
                    if (baseType != typeof(ProfileBase))
                    {
                        //////////////////////////////////////////////////////////////////////
                        // Step 2: Construct a hashtable containing a list of all the property-names in the ProfileBase type
                        PropertyInfo[]      baseProps      = typeof(ProfileBase).GetProperties();
                        NameValueCollection baseProperties = new NameValueCollection(baseProps.Length);
                        foreach (PropertyInfo baseProp in baseProps)
                        {
                            baseProperties.Add(baseProp.Name, String.Empty);
                        }

                        //////////////////////////////////////////////////////////////////////
                        // Step 3: For each property in the derived class, add it to the s_Properties class.
                        PropertyInfo[] props = baseType.GetProperties();
                        foreach (PropertyInfo prop in props)
                        {
                            if (baseProperties[prop.Name] == null)   //not in the base class

                            {
                                ProfileProvider     prov           = hasLowTrust ? ProfileManager.Provider : null;
                                bool                readOnly       = false;
                                SettingsSerializeAs serializeAs    = SettingsSerializeAs.ProviderSpecific;
                                string              defaultValue   = String.Empty;
                                bool                allowAnonymous = false;
                                string              customData     = null;

                                //////////////////////////////////////////////////////////////////////
                                // Step 4: For the property, get the attributes
                                Attribute[] attribs = Attribute.GetCustomAttributes(prop, true);

                                foreach (Attribute attrib in attribs)
                                {
                                    if (attrib is SettingsSerializeAsAttribute)
                                    {
                                        serializeAs = ((SettingsSerializeAsAttribute)attrib).SerializeAs;
                                    }
                                    else if (attrib is SettingsAllowAnonymousAttribute)
                                    {
                                        allowAnonymous = ((SettingsAllowAnonymousAttribute)attrib).Allow;
                                        if (!fAnonEnabled && allowAnonymous)
                                        {
                                            throw new ConfigurationErrorsException(SR.GetString(SR.Annoymous_id_module_not_enabled, prop.Name), config.ElementInformation.Properties["inherits"].Source, config.ElementInformation.Properties["inherits"].LineNumber);
                                        }
                                    }
                                    else if (attrib is System.ComponentModel.ReadOnlyAttribute)
                                    {
                                        readOnly = ((System.ComponentModel.ReadOnlyAttribute)attrib).IsReadOnly;
                                    }
                                    else if (attrib is DefaultSettingValueAttribute)
                                    {
                                        defaultValue = ((DefaultSettingValueAttribute)attrib).Value;
                                    }
                                    else if (attrib is CustomProviderDataAttribute)
                                    {
                                        customData = ((CustomProviderDataAttribute)attrib).CustomProviderData;
                                    }
                                    else if (hasLowTrust && attrib is ProfileProviderAttribute)
                                    {
                                        prov = ProfileManager.Providers[((ProfileProviderAttribute)attrib).ProviderName];
                                        if (prov == null)
                                        {
                                            throw new ConfigurationErrorsException(SR.GetString(SR.Profile_provider_not_found, ((ProfileProviderAttribute)attrib).ProviderName), config.ElementInformation.Properties["inherits"].Source, config.ElementInformation.Properties["inherits"].LineNumber);
                                        }
                                    }
                                }
                                //////////////////////////////////////////////////////////////////////
                                // Step 5: Add the property to the s_Properties
                                SettingsAttributeDictionary settings = new SettingsAttributeDictionary();
                                settings.Add("AllowAnonymous", allowAnonymous);
                                if (!string.IsNullOrEmpty(customData))
                                {
                                    settings.Add("CustomProviderData", customData);
                                }
                                SettingsProperty sp = new SettingsProperty(prop.Name, prop.PropertyType, prov, readOnly, defaultValue, serializeAs, settings, false, true);
                                s_Properties.Add(sp);
                            }
                        }
                    }

                    //////////////////////////////////////////////////////////////////////
                    //////////////////////////////////////////////////////////////////////
                    // Step 6: Add all properties from config
                    if (config.PropertySettings != null)
                    {
                        AddPropertySettingsFromConfig(baseType, fAnonEnabled, hasLowTrust, config.PropertySettings, null);
                        foreach (ProfileGroupSettings pgs in config.PropertySettings.GroupSettings)
                        {
                            AddPropertySettingsFromConfig(baseType, fAnonEnabled, hasLowTrust, pgs.PropertySettings, pgs.Name);
                        }
                    }
                }
                catch (Exception e) {
                    if (s_InitializeException == null)
                    {
                        s_InitializeException = e;
                    }
                }
                // If there are no properties, create an empty collection.
                if (s_Properties == null)
                {
                    s_Properties = new SettingsPropertyCollection();
                }
                // Make the properties collection read-only
                s_Properties.SetReadOnly();
                s_Initialized = true;
            }

            // Throw an exception if there was an exception during initialization
            if (s_InitializeException != null)
            {
                throw s_InitializeException;
            }
        }
Пример #6
0
 private static void InitializeStatic()
 {
     if (!ProfileManager.Enabled || s_Initialized)
     {
         if (s_InitializeException != null)
         {
             throw s_InitializeException;
         }
     }
     else
     {
         lock (s_InitializeLock)
         {
             if (s_Initialized)
             {
                 if (s_InitializeException != null)
                 {
                     throw s_InitializeException;
                 }
                 return;
             }
             try
             {
                 ProfileSection profileAppConfig = MTConfigUtil.GetProfileAppConfig();
                 bool           fAnonEnabled     = HostingEnvironment.IsHosted ? AnonymousIdentificationModule.Enabled : true;
                 Type           inheritsFromType = InheritsFromType;
                 bool           hasLowTrust      = HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Low);
                 s_Properties = new SettingsPropertyCollection();
                 AddPropertySettingsFromConfig(inheritsFromType, fAnonEnabled, hasLowTrust, ProfileManager.DynamicProfileProperties, null);
                 if (inheritsFromType != typeof(ProfileBase))
                 {
                     PropertyInfo[]      properties = typeof(ProfileBase).GetProperties();
                     NameValueCollection values     = new NameValueCollection(properties.Length);
                     foreach (PropertyInfo info in properties)
                     {
                         values.Add(info.Name, string.Empty);
                     }
                     foreach (PropertyInfo info2 in inheritsFromType.GetProperties())
                     {
                         if (values[info2.Name] == null)
                         {
                             ProfileProvider     provider           = hasLowTrust ? ProfileManager.Provider : null;
                             bool                isReadOnly         = false;
                             SettingsSerializeAs providerSpecific   = SettingsSerializeAs.ProviderSpecific;
                             string              defaultValue       = string.Empty;
                             bool                allow              = false;
                             string              customProviderData = null;
                             foreach (Attribute attribute in Attribute.GetCustomAttributes(info2, true))
                             {
                                 if (attribute is SettingsSerializeAsAttribute)
                                 {
                                     providerSpecific = ((SettingsSerializeAsAttribute)attribute).SerializeAs;
                                 }
                                 else if (attribute is SettingsAllowAnonymousAttribute)
                                 {
                                     allow = ((SettingsAllowAnonymousAttribute)attribute).Allow;
                                     if (!fAnonEnabled && allow)
                                     {
                                         throw new ConfigurationErrorsException(System.Web.SR.GetString("Annoymous_id_module_not_enabled", new object[] { info2.Name }), profileAppConfig.ElementInformation.Properties["inherits"].Source, profileAppConfig.ElementInformation.Properties["inherits"].LineNumber);
                                     }
                                 }
                                 else if (attribute is ReadOnlyAttribute)
                                 {
                                     isReadOnly = ((ReadOnlyAttribute)attribute).IsReadOnly;
                                 }
                                 else if (attribute is DefaultSettingValueAttribute)
                                 {
                                     defaultValue = ((DefaultSettingValueAttribute)attribute).Value;
                                 }
                                 else if (attribute is CustomProviderDataAttribute)
                                 {
                                     customProviderData = ((CustomProviderDataAttribute)attribute).CustomProviderData;
                                 }
                                 else if (hasLowTrust && (attribute is ProfileProviderAttribute))
                                 {
                                     provider = ProfileManager.Providers[((ProfileProviderAttribute)attribute).ProviderName];
                                     if (provider == null)
                                     {
                                         throw new ConfigurationErrorsException(System.Web.SR.GetString("Profile_provider_not_found", new object[] { ((ProfileProviderAttribute)attribute).ProviderName }), profileAppConfig.ElementInformation.Properties["inherits"].Source, profileAppConfig.ElementInformation.Properties["inherits"].LineNumber);
                                     }
                                 }
                             }
                             SettingsAttributeDictionary attributes = new SettingsAttributeDictionary();
                             attributes.Add("AllowAnonymous", allow);
                             if (!string.IsNullOrEmpty(customProviderData))
                             {
                                 attributes.Add("CustomProviderData", customProviderData);
                             }
                             SettingsProperty property = new SettingsProperty(info2.Name, info2.PropertyType, provider, isReadOnly, defaultValue, providerSpecific, attributes, false, true);
                             s_Properties.Add(property);
                         }
                     }
                 }
                 if (profileAppConfig.PropertySettings != null)
                 {
                     AddPropertySettingsFromConfig(inheritsFromType, fAnonEnabled, hasLowTrust, profileAppConfig.PropertySettings, null);
                     foreach (ProfileGroupSettings settings in profileAppConfig.PropertySettings.GroupSettings)
                     {
                         AddPropertySettingsFromConfig(inheritsFromType, fAnonEnabled, hasLowTrust, settings.PropertySettings, settings.Name);
                     }
                 }
             }
             catch (Exception exception)
             {
                 if (s_InitializeException == null)
                 {
                     s_InitializeException = exception;
                 }
             }
             if (s_Properties == null)
             {
                 s_Properties = new SettingsPropertyCollection();
             }
             s_Properties.SetReadOnly();
             s_Initialized = true;
         }
         if (s_InitializeException != null)
         {
             throw s_InitializeException;
         }
     }
 }
        public void SetProvider(string ProviderName)
        {
            OnDebug(this, name + ".SetProvider()");

            try
            {
                if (String.IsNullOrWhiteSpace(ProviderName))
                {
                    InternalProvider = ProfileManager.Provider;
                }
                else
                {
                    InternalProvider = ProfileManager.Providers[ProviderName];
                }

                OnDebug(this, name + ": InternalProvider = " + InternalProvider.Name);
            }
            catch (Exception ex)
            {
                OnError(this, ex);
                InternalProvider = ProfileManager.Provider;
            }
        }
Пример #8
0
 public ProfileService(ProfileProvider profileProvider)
 {
     this.profileProvider = profileProvider;
 }