protected override void OnDispose(bool inIsDisposing) { if (inIsDisposing) { DisposableBase.SafeDispose(_requestor); } }
protected override void OnDispose(bool inIsDisposing) { if (inIsDisposing) { DisposableBase.SafeDispose(ref _processingIntervalEvent); } }
protected override void OnDispose(bool inIsDisposing) { if (inIsDisposing) { DisposableBase.SafeDispose(ref _mutex); } }
public static void ClearAllWaitCursors() { for (int i = s_CurrentUseWaitCursors.Count - 1; i >= 0; --i) { DisposableBase.SafeDispose(s_CurrentUseWaitCursors[i]); } s_CurrentUseWaitCursors.Clear(); }
/// <summary> /// /// </summary> /// <param name="disposing"></param> protected override void Dispose(bool disposing) { if (disposing) { DisposableBase.SafeDispose(ref zipStream); DisposableBase.SafeDispose(ref fileStream); } base.Dispose(disposing); }
protected override void OnShutdown() { try { base.OnShutdown(); } finally { DisposableBase.SafeDispose(ref m_StartupMutex); } }
public INodeEndpointClient Make(string targetEndpointUrl, EndpointVersionType type, string username, string testPassword, string prodPassword) { ExceptionUtils.ThrowIfEmptyString(username); ExceptionUtils.ThrowIfEmptyString(testPassword); ExceptionUtils.ThrowIfEmptyString(prodPassword); INodeEndpointClient client = null; try { AuthenticationCredentials credentials = new AuthenticationCredentials(username, testPassword); client = Make(targetEndpointUrl, type, credentials); // First, check to ping the node to make sure it is up and running try { client.NodePing(); } catch (Exception pingEx) { throw new ArgumentException(string.Format("The node endpoint \"{0}\" cannot be contacted. NodePing returned the error: {1}", targetEndpointUrl, ExceptionUtils.GetDeepExceptionMessage(pingEx))); } client.Authenticate(); } catch (Exception) { DisposableBase.SafeDispose(ref client); } if (client == null) { try { AuthenticationCredentials credentials = new AuthenticationCredentials(username, prodPassword); client = Make(targetEndpointUrl, type, credentials); client.Authenticate(); } catch (Exception) { DisposableBase.SafeDispose(ref client); } } if (client == null) { throw new ArgumentException(string.Format("The NAAS user \"{0}\" failed to authenticate against the node endpoint \"{1}\". Please check that the NAAS user's username and password have been entered correctly.", username, targetEndpointUrl)); } return(client); }
protected virtual PluginDomainInstanceLoader GetPluginInstanceLoader(string pluginConfigFilePath, string pluginFilePath) { if (string.IsNullOrEmpty(pluginConfigFilePath) || (PluginInstanceLoadersCacheTimeInMinutes <= 0)) { // This is not an expensive case with string.IsNullOrEmpty(pluginConfigFilePath), since we are // not creating spring objects, so don't cache // // OR // // we've specified to turn off the cache with PluginInstanceLoadersCacheTimeInMinutes <= 0 return(new PluginDomainInstanceLoader(pluginConfigFilePath, pluginFilePath)); } const string CACHED_PLUGIN_INSTANCE_LOADERS = "_CACHED_PLUGIN_INSTANCE_LOADERS"; string cacheName = CACHED_PLUGIN_INSTANCE_LOADERS + "_" + pluginConfigFilePath + "_" + pluginFilePath; PluginDomainInstanceLoader loader; lock (s_CachedPluginInstanceLoadersLock) { loader = HttpRuntime.Cache[cacheName] as PluginDomainInstanceLoader; } if (loader != null) { return(loader); } string parentDirPath = Path.GetDirectoryName(Path.GetDirectoryName(pluginFilePath)); loader = new PluginDomainInstanceLoader(pluginConfigFilePath, pluginFilePath); PluginDomainInstanceLoader loaderAlreadyThere = null; lock (s_CachedPluginInstanceLoadersLock) { loaderAlreadyThere = HttpRuntime.Cache[cacheName] as PluginDomainInstanceLoader; if (loaderAlreadyThere == null) { loader.Acquire(); HttpRuntime.Cache.Add(cacheName, loader, new CacheDependency(parentDirPath), Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(PluginInstanceLoadersCacheTimeInMinutes), CacheItemPriority.AboveNormal, OnCachePluginDomainInstanceLoaderRemovedCallback); } } if (loaderAlreadyThere != null) { // Switch over to already cached instance DisposableBase.SafeDispose(ref loader); loader = loaderAlreadyThere; } return(loader); }
public virtual IPluginDisposer LoadPluginInterface <T>(DataService inDataService, out T plugin) where T : class { IPluginDisposer disposer = LoadPluginInterfaceInstance <T>(inDataService, true, out plugin); try { ConfigurePlugin <T>(inDataService, plugin); } catch (Exception) { DisposableBase.SafeDispose(ref disposer); throw; } return(disposer); }
private IDbConnection OpenDbConnection(string connectionString) { IDbConnection dbConnection = GetDbConnection(connectionString); try { LOG.Debug("OpenDbConnection: Attempting to open database connection: {0}", dbConnection.ConnectionString); dbConnection.Open(); return(dbConnection); } catch (Exception e) { LOG.Error("OpenDbConnection: Failed to open database connection: {0}", e, dbConnection.ConnectionString); DisposableBase.SafeDispose(dbConnection); throw; } }
/// <summary> /// Create a new <see cref="INodeEndpointClient"/> instance for accessing and communicating with a specific Exchange node. /// The input credentials are authenticated against the client node before this method returns. /// </summary> /// <param name="targetEndpointUrl">The url for the Exchange node endpoint.</param> /// <param name="type">The version of the Exchange node endpoint.</param> /// <param name="credentials">The credentials used to authenticate with the Exchange node endpoint.</param> /// <param name="tempDirectoryPath">A local directory path used for creating temporary files during INodeEndpointClient method /// execution. This value can be null, in which case the dafault system temp directory will be used.</param> /// <param name="proxy">Proxy information for accessing the Exchange node endpoint. This value can be null if /// no proxy is required.</param> /// <returns>A new <see cref="INodeEndpointClient"/> instance for accessing and communicating with a specific Exchange node. Dispose() /// should be called on the returned instance when the caller is finished using the instance.</returns> public static INodeEndpointClient CreateClientAndAuthenticate(string targetEndpointUrl, EndpointVersionType type, AuthenticationCredentials credentials, string tempDirectoryPath, IWebProxy proxy) { INodeEndpointClient client = new NodeEndpointClientFactory().Make(targetEndpointUrl, type, credentials, tempDirectoryPath, proxy); try { client.Authenticate(); } catch (Exception) { DisposableBase.SafeDispose(client); throw; } return(client); }
/// <summary> /// Create a new <see cref="INodeEndpointClient"/> instance for accessing and communicating with a specific Exchange node. /// The node is pinged after is it created to ensure it can be accessed. /// </summary> /// <param name="targetEndpointUrl">The url for the Exchange node endpoint.</param> /// <param name="type">The version of the Exchange node endpoint.</param> /// <param name="naasUserToken">A valid NAAS user token that will be used for validating this endpoint.</param> /// <param name="tempDirectoryPath">A local directory path used for creating temporary files during INodeEndpointClient method /// execution. This value can be null, in which case the dafault system temp directory will be used.</param> /// <param name="proxy">Proxy information for accessing the Exchange node endpoint. This value can be null if /// no proxy is required.</param> /// <returns>A new <see cref="INodeEndpointClient"/> instance for accessing and communicating with a specific Exchange node. Dispose() /// should be called on the returned instance when the caller is finished using the instance.</returns> public static INodeEndpointClient CreateClientAndPing(string targetEndpointUrl, EndpointVersionType type, string naasUserToken, string tempDirectoryPath, IWebProxy proxy) { INodeEndpointClient client = new NodeEndpointClientFactory().Make(targetEndpointUrl, type, naasUserToken, tempDirectoryPath, proxy); try { client.NodePing(); } catch (Exception) { DisposableBase.SafeDispose(client); throw; } return(client); }
public SingleInstanceApplication(string inUniqueId, bool inRunPerWindowsUser) { this.IsSingleInstance = true; this.EnableVisualStyles = true; this.ShutdownStyle = ShutdownMode.AfterMainFormCloses; string mutexName = inRunPerWindowsUser ? inUniqueId : cGlobalKernelObjectPrefix + inUniqueId; bool isMutexOwner = false; m_StartupMutex = new Mutex(true, mutexName, out isMutexOwner); m_IsRunningAlready = !isMutexOwner; if (m_IsRunningAlready) { // If there is already an instance running, set the m_IsRunningAlready flag so that // we will exit gracefully. The Mutex check is needed here since the base class does not check // for "global" single-instance apps, only per-user single-instance apps. DisposableBase.SafeDispose(ref m_StartupMutex); } }
protected virtual ICollection <SimpleDataService> GetDataServiceImplementersInDirectory(string inDirectoryPath, bool ignoreInstallingAssemblies) { OrderedSet <SimpleDataService> implementers = new OrderedSet <SimpleDataService>(); if (Directory.Exists(inDirectoryPath)) { OrderedSet <string> processedAssemblies = new OrderedSet <string>(); PluginDomainInstanceLoader loader = null; try { PluginInstanceFinder pluginFinder = null; foreach (string dllPath in Directory.GetFiles(inDirectoryPath, "*.dll", SearchOption.AllDirectories)) { if (!ignoreInstallingAssemblies || !IsInstallingPluginAssemblyPath(dllPath)) { string assemblyName = Path.GetFileName(dllPath); if (!processedAssemblies.Contains(assemblyName)) { string assemblyPath = GetPluginFilePathInDirectory(assemblyName, inDirectoryPath, ignoreInstallingAssemblies); if (assemblyPath != null) { if (loader == null) { // Don't need to load spring objects here loader = GetPluginInstanceLoader(null, assemblyPath); pluginFinder = loader.GetInstance <PluginInstanceFinder>(); } GetDataServiceImplementers(pluginFinder, assemblyPath, ref implementers); } processedAssemblies.Add(assemblyName); } } } } finally { DisposableBase.SafeDispose(ref loader); } } return(implementers); }
protected virtual IPluginDisposer LoadPluginInterfaceInstance <T>(DataService inDataService, bool ignoreInstallingAssemblies, string pluginConfigFilePath, out T plugin) where T : class { string pluginFilePath = GetPluginFilePath(inDataService, ignoreInstallingAssemblies); PluginDomainInstanceLoader loader = GetPluginInstanceLoader(pluginConfigFilePath, pluginFilePath); PluginDisposer disposer = new PluginDisposer(loader); try { plugin = loader.GetInstance <T>(pluginFilePath, inDataService.PluginInfo.ImplementingClassName); } catch (Exception) { DisposableBase.SafeDispose(ref disposer); throw; } return(disposer); }
protected override void DoStop() { try { foreach (INodeProcessor processor in Processors) { processor.RequestStop(); } foreach (INodeProcessor processor in Processors) { processor.Join(); } DisposableBase.SafeDispose(ThreadQueueServer); } catch (Exception e) { LOG.Error("DoStop() threw an exception.", e); throw; } }
public void Dispose() { DisposableBase.SafeDispose(ref m_StartupMutex); }
private static async Task DisposeAsyncTestCore(DisposableBase disp) { await using (disp.ConfigureAwait(false)) { } }