static Membership()
{
MembershipSection section = (MembershipSection)WebConfigurationManager.GetSection("system.web/membership");
providers = new MembershipProviderCollection();
ProvidersHelper.InstantiateProviders(section.Providers, providers, typeof(MembershipProvider));
provider = providers[section.DefaultProvider];
onlineTimeWindow = (int)section.UserIsOnlineTimeWindow.TotalMinutes;
hashAlgorithmType = section.HashAlgorithmType;
if (String.IsNullOrEmpty(hashAlgorithmType))
{
MachineKeySection mks = WebConfigurationManager.GetSection("system.web/machineKey") as MachineKeySection;
MachineKeyValidationConverter cvt = new MachineKeyValidationConverter();
hashAlgorithmType = cvt.ConvertTo(null, null, mks.Validation, typeof(string)) as string;
}
if (String.IsNullOrEmpty(hashAlgorithmType))
{
hashAlgorithmType = "SHA1";
}
}
private static void Initialize()
{
ProviderConfiguration configuration = (ProviderConfiguration)ConfigurationManager.GetSection("navigation-providers");
if (configuration == null)
{
throw new ConfigurationErrorsException
("The navigation-providers configuration section is not set correctly.");
}
providers = new NavigationProviderCollection();
ProvidersHelper.InstantiateProviders(configuration.Providers
, providers, typeof(NavigationProviderBase));
providers.SetReadOnly();
defaultProvider = providers[configuration.Default];
if (defaultProvider == null)
{
throw new Exception("No default navigation provider is defined for the navigation-providers section.");
}
}
static RoleManager()
{
//Get the feature's configuration info
var ac =
(RoleProviderConfiguration)ConfigurationManager.GetSection("roleManager");
if (ac == null || ac.DefaultProvider == null || ac.Providers == null || ac.Providers.Count < 1)
{
throw new ProviderException("You must specify a valid default provider for roleManager.");
}
//Instantiate the providers
providerCollection = new RoleProviderCollection();
ProvidersHelper.InstantiateProviders(ac.Providers, providerCollection, typeof(RoleProvider));
providerCollection.SetReadOnly();
defaultProvider = providerCollection[ac.DefaultProvider];
if (defaultProvider == null)
{
throw new ConfigurationErrorsException(
"You must specify a default provider for the roleManager.",
ac.ElementInformation.Properties["defaultProvider"].Source,
ac.ElementInformation.Properties["defaultProvider"].LineNumber);
}
}
private static void Initialize()
{
//try
//{
EditorConfiguration editorConfig = EditorConfiguration.GetConfig();
if (
(editorConfig.DefaultProvider == null) ||
(editorConfig.Providers == null) ||
(editorConfig.Providers.Count < 1)
)
{
throw new ProviderException("You must specify a valid default provider.");
}
providerCollection = new EditorProviderCollection();
ProvidersHelper.InstantiateProviders(
editorConfig.Providers,
providerCollection,
typeof(EditorProvider));
providerCollection.SetReadOnly();
defaultProvider = providerCollection[editorConfig.DefaultProvider];
//}
//catch (Exception ex)
//{
// initializationException = ex;
// isInitialized = true;
// throw ex;
//}
//isInitialized = true;
}
private static void Initialize()
{
FileSystemConfiguration config = FileSystemConfiguration.GetConfig();
if (
(config.DefaultProvider == null) ||
(config.Providers == null) ||
(config.Providers.Count < 1)
)
{
throw new ProviderException("You must specify a valid default provider.");
}
providerCollection = new FileSystemProviderCollection();
ProvidersHelper.InstantiateProviders(
config.Providers,
providerCollection,
typeof(FileSystemProvider));
providerCollection.SetReadOnly();
defaultProvider = providerCollection[config.DefaultProvider];
}
/// <summary>
/// Initializes this instance.
/// </summary>
private static void Initialize()
{
//Get the feature's configuration info
var qc = ConfigurationManager.GetSection("HtmlEditorProvider") as HtmlEditorConfiguration;
if (qc != null && (qc.DefaultProvider == null || qc.Providers == null || qc.Providers.Count < 1))
{
throw new ProviderException("You must specify a valid default provider.");
}
//Instantiate the providers
providerCollection = new HtmlEditorProviderCollection();
ProvidersHelper.InstantiateProviders(qc.Providers, providerCollection, typeof(HtmlEditorProvider));
providerCollection.SetReadOnly();
defaultProvider = providerCollection[qc.DefaultProvider];
if (defaultProvider == null)
{
throw new ConfigurationErrorsException(
"You must specify a default provider for the feature.",
qc.ElementInformation.Properties["defaultProvider"].Source,
qc.ElementInformation.Properties["defaultProvider"].LineNumber);
}
}
///<summary>
/// Configuration based provider loading, will load the providers on first call.
///</summary>
private static void LoadProviders()
{
// Avoid claiming lock if providers are already loaded
if (_provider == null)
{
lock (SyncRoot)
{
// Do this again to make sure _provider is still null
if (_provider == null)
{
// Load registered providers and point _provider to the default provider
_providers = new NetTiersProviderCollection();
ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
_provider = _providers[NetTiersSection.DefaultProvider];
if (_provider == null)
{
throw new ProviderException("Unable to load default NetTiersProvider");
}
}
}
}
}
private static void LoadProviders()
{
// Avoid claiming lock if providers are already loaded
if (_defaultProvider == null)
{
lock (_lock)
{
// Do this again to make sure _defaultProvider is still null
if (_defaultProvider == null)
{
PhotoAlbumSection section = (PhotoAlbumSection)
WebConfigurationManager.GetSection
("photoAlbumService");
// Only want one provider here
//_defaultProvider = (PhotoAlbumProvider)
// ProvidersHelper.InstantiateProvider
// (section.Providers[0], typeof(PhotoAlbumProvider));
_providers = new PhotoAlbumProviderCollection();
ProvidersHelper.InstantiateProviders(
section.Providers, _providers,
typeof(PhotoAlbumProvider));
_defaultProvider = _providers[section.DefaultProvider];
if (_defaultProvider == null)
{
throw new ProviderException
("Unable to load default PhotoAlbumProvider");
}
}
}
}
}
private static void Initialize()
{
if (s_Initialized)
{
if (s_InitializeException != null)
{
throw s_InitializeException;
}
}
else
{
if (s_InitializeException != null)
{
throw s_InitializeException;
}
lock (s_lock)
{
if (s_Initialized)
{
if (s_InitializeException != null)
{
throw s_InitializeException;
}
}
else
{
try
{
DBProviderSection section = GetSection <T>();
if (((section.DefaultProvider == null) || (section.Providers == null) || (section.Providers.Count < 1)))
{
throw new ProviderException("Default provider not specified");
}
s_Providers = new DBProviderCollection <T>();
if (HostingEnvironment.IsHosted)
{
ProvidersHelper.InstantiateProviders(section.Providers, s_Providers, typeof(T));
}
else
{
foreach (ProviderSettings settings in section.Providers)
{
Type c = Type.GetType(settings.Type, true, true);
if (!typeof(T).IsAssignableFrom(c))
{
throw new ArgumentException(string.Format("Provider must implement {0} type",
new object[] { typeof(T).ToString() }));
}
T provider = (T)Activator.CreateInstance(c);
NameValueCollection parameters = settings.Parameters;
NameValueCollection config = new NameValueCollection(parameters.Count, StringComparer.Ordinal);
foreach (string str2 in parameters)
{
config[str2] = parameters[str2];
}
provider.Initialize(settings.Name, config);
s_Providers.Add(provider);
}
}
s_Provider = (T)s_Providers[section.DefaultProvider];
if (s_Provider == null)
{
throw new ConfigurationErrorsException(string.Format("Default provider not found. {0}. Line number: {1}",
section.ElementInformation.Properties["defaultProvider"].Source,
section.ElementInformation.Properties["defaultProvider"].LineNumber));
}
s_Providers.SetReadOnly();
}
catch (Exception exception)
{
s_InitializeException = exception;
throw;
}
s_Initialized = true;
}
}
}
}
//============================================================
// PRIVATE METHODS
//============================================================
#region Initialize()
/// <summary>
/// Initializes the <see cref="SyndicationManager"/> using the declaratively configured application settings.
/// </summary>
/// <seealso cref="SyndicationResourceSection"/>
private static void Initialize()
{
//------------------------------------------------------------
// Verify manager has not already been initialized previously
//------------------------------------------------------------
if (syndicationManagerInitialized)
{
//------------------------------------------------------------
// Throw stored exception if initialization raised an exception
//------------------------------------------------------------
if (syndicationManagerInitializationException != null)
{
throw syndicationManagerInitializationException;
}
}
else
{
//------------------------------------------------------------
// Throw stored exception if initialization raised an exception
//------------------------------------------------------------
if (syndicationManagerInitializationException != null)
{
throw syndicationManagerInitializationException;
}
lock (syndicationManagerLock)
{
try
{
//------------------------------------------------------------
// Extract configuration section from application configuration
//------------------------------------------------------------
SyndicationResourceSection section = PrivilegedConfigurationManager.GetSyndicationResourceSection();
if (section != null)
{
//------------------------------------------------------------
// Raise exception if no providers were specified
//------------------------------------------------------------
if (((section.DefaultProvider == null) || (section.Providers == null)) || (section.Providers.Count < 1))
{
throw new ProviderException(String.Format(null, "The syndication resource providers were not specified. Source configuration file was {0}", section.ElementInformation.Source));
}
//------------------------------------------------------------
// Fill providers collection
//------------------------------------------------------------
syndicationManagerProviders = new SyndicationResourceProviderCollection();
if (HostingEnvironment.IsHosted)
{
ProvidersHelper.InstantiateProviders(section.Providers, syndicationManagerProviders, typeof(SyndicationResourceProvider));
}
else
{
foreach (ProviderSettings settings in section.Providers)
{
Type settingsType = Type.GetType(settings.Type, true, true);
if (!typeof(SyndicationResourceProvider).IsAssignableFrom(settingsType))
{
throw new ArgumentException(String.Format(null, "The provider must implement type of {0}. Source configuration file was {1}", typeof(SyndicationResourceProvider).FullName, section.ElementInformation.Source));
}
SyndicationResourceProvider provider = (SyndicationResourceProvider)Activator.CreateInstance(settingsType);
NameValueCollection parameters = settings.Parameters;
NameValueCollection configuration = new NameValueCollection(parameters.Count, StringComparer.Ordinal);
foreach (string parameter in parameters)
{
configuration[parameter] = parameters[parameter];
}
provider.Initialize(settings.Name, configuration);
syndicationManagerProviders.Add(provider);
}
}
//------------------------------------------------------------
// Set and validate default provider
//------------------------------------------------------------
syndicationManagerDefaultProvider = syndicationManagerProviders[section.DefaultProvider];
if (syndicationManagerDefaultProvider == null)
{
throw new ConfigurationErrorsException(String.Format(null, "The default syndication resource provider was not found. Source configuration file was {0}", section.ElementInformation.Source), section.ElementInformation.Properties["defaultProvider"].Source, section.ElementInformation.Properties["defaultProvider"].LineNumber);
}
//------------------------------------------------------------
// Prevent collection from being modified further
//------------------------------------------------------------
syndicationManagerProviders.SetReadOnly();
}
}
catch (Exception exception)
{
//------------------------------------------------------------
// Store exception locally and then throw
//------------------------------------------------------------
syndicationManagerInitializationException = exception;
throw;
}
//------------------------------------------------------------
// Set initialization indicator flag
//------------------------------------------------------------
syndicationManagerInitialized = true;
}
}
}
/// <summary>
/// Loads the providers.
/// </summary>
protected virtual void LoadProviders(
bool throwErrorIfUnableToLoadSection)
{
// Avoid claiming lock if providers are already loaded
if (_providers == null)
{
lock (_syncRoot)
{
// Do this again to make sure provider is still null
if (_providers == null)
{
// Get the providers
_providers = new ProviderCollection <T>();
// Get a reference to the section
ProvidersSection section = null;
try
{
section =
ConfigurationManager.GetSection(_sectionName) as ProvidersSection;
}
catch (Exception)
{
section = null;
}
if (section == null)
{
if (throwErrorIfUnableToLoadSection)
{
throw new ProviderException(
String.Format("Unable to load configuration section: '{0}'.",
_sectionName));
}
}
else
{
ProvidersHelper.InstantiateProviders(section.Providers, _providers, typeof(T));
if (_providers.Count > 0)
{
// If there is a default provider specified, then grab it,
// else grab the first provider in the collection
if (!String.IsNullOrEmpty(section.DefaultProvider))
{
_provider = (T)_providers[section.DefaultProvider];
}
else
{
_provider = _providers[0];
}
}
if (throwErrorIfUnableToLoadSection)
{
// If we have no provider, then throw an exception
if (_provider == null)
{
throw new ProviderException(
String.Format("Unable to load default provider for section: '{0}'.",
_sectionName));
}
}
}
}
}
}
}
/// <summary>
/// Before any of the index/search collections are accessed, the providers need to be loaded
/// </summary>
private void EnsureProviders()
{
if (!_providersInit)
{
lock (_lock)
{
// Do this again to make sure _provider is still null
if (!_providersInit)
{
// Load registered providers and point _provider to the default provider
_indexProviderCollection = new IndexProviderCollection();
ProvidersHelper.InstantiateProviders(ExamineSettings.Instance.IndexProviders.Providers, _indexProviderCollection, typeof(BaseIndexProvider));
_searchProviderCollection = new SearchProviderCollection();
ProvidersHelper.InstantiateProviders(ExamineSettings.Instance.SearchProviders.Providers, _searchProviderCollection, typeof(BaseSearchProvider));
//set the default
if (!string.IsNullOrEmpty(ExamineSettings.Instance.SearchProviders.DefaultProvider))
{
_defaultSearchProvider = _searchProviderCollection[ExamineSettings.Instance.SearchProviders.DefaultProvider];
}
if (_defaultSearchProvider == null)
{
throw new ProviderException("Unable to load default search provider");
}
_providersInit = true;
//check if we need to rebuild on startup
if (ExamineSettings.Instance.RebuildOnAppStart)
{
foreach (IIndexer index in _indexProviderCollection)
{
var rebuild = false;
var healthy = true;
Exception unhealthyEx = null;
var exists = index.IndexExists();
if (!exists)
{
rebuild = true;
}
if (!rebuild)
{
healthy = IsIndexHealthy(index, out unhealthyEx);
if (!healthy)
{
rebuild = true;
}
}
//if it doesn't exist ... or if it's unhealthy/corrupt
if (rebuild)
{
var args = new BuildingEmptyIndexOnStartupEventArgs(index, healthy, unhealthyEx);
OnBuildingEmptyIndexOnStartup(args);
if (!args.Cancel)
{
index.RebuildIndex();
}
}
}
}
}
}
}
}
/// <summary>
/// Initializes this instance.
/// </summary>
private static void Initialize()
{
//Check if we have been initialized before.
if (_isInitialized && _initializedDefaultProvider)
{
return;
}
//If we did initialize and there was an exception,
//rethrow the exception
if (_initializationException != null)
{
throw _initializationException;
}
lock (_initializationLock)
{
//Check if we have been initialized before.
if (_isInitialized && _initializedDefaultProvider)
{
return;
}
//If we did initialize and there was an exception,
//rethrow the exception
if (_initializationException != null)
{
throw _initializationException;
}
//Now actually do the initialization
try
{
//Get the feature's configuration info
SiteWideSearchConfiguration searchProviderConfig =
(SiteWideSearchConfiguration)ConfigurationManager.GetSection("SiteWideSearch");
if (searchProviderConfig == null)
{
throw new ProviderException("SiteWideSearchProviders section cannot be found in configuration file.");
}
//Instantiate the providers
_providerCollection = new SiteWideSearchProviderCollection();
//"InitializeSettings"
ProvidersHelper.InstantiateProviders(
searchProviderConfig.Providers,
_providerCollection,
typeof(SiteWideSearchProviderBase)
);
//Don't Allow this to be written to anymore now that it is loaded
_providerCollection.SetReadOnly();
if (searchProviderConfig.DefaultProvider == null || _providerCollection.Count < 1)
{
throw new ProviderException("Default SiteWideSearchProvider could not be found");
}
_defaultProvider = _providerCollection[searchProviderConfig.DefaultProvider];
if (_defaultProvider == null)
{
throw new ConfigurationErrorsException(
"SiteWideSearch Providers: Default provider could not be found.",
searchProviderConfig.ElementInformation.Properties["defaultProvider"].Source,
searchProviderConfig.ElementInformation.Properties["defaultProvider"].LineNumber);
}
}
catch (Exception ex)
{
_initializationException = ex;
throw;
}
//Set it as initialized
_isInitialized = true;
_initializedDefaultProvider = true;
}
}
