/// <summary> /// Initializes a new instance of the <see cref="SqlLocalDbInstance"/> class. /// </summary> /// <param name="instanceName">The name of the SQL Server LocalDB instance.</param> /// <param name="localDB">The <see cref="ISqlLocalDbApi"/> instance to use.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="instanceName"/> is <see langword="null"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// The LocalDB instance specified by <paramref name="instanceName"/> does not exist. /// </exception> /// <exception cref="SqlLocalDbException"> /// The LocalDB instance specified by <paramref name="instanceName"/> could not be obtained. /// </exception> internal SqlLocalDbInstance(string instanceName, ISqlLocalDbApi localDB) { if (instanceName == null) { throw new ArgumentNullException(nameof(instanceName)); } Debug.Assert(localDB != null, "localDB cannot be null."); ISqlLocalDbInstanceInfo info = localDB.GetInstanceInfo(instanceName); if (info == null || !info.Exists) { string message = SRHelper.Format( SR.SqlLocalDbInstance_InstanceNotFoundFormat, instanceName); Logger.Error(Logger.TraceEvent.General, message); throw new InvalidOperationException(message); } _instanceName = instanceName; _namedPipe = info.NamedPipe; }
/// <summary> /// Sets the physical database file name in the specified <see cref="DbConnectionStringBuilder"/>. /// </summary> /// <param name="value">The <see cref="DbConnectionStringBuilder"/> to set the physical database file name for.</param> /// <param name="fileName">The physical file name to set.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="value"/> is <see langword="null"/> or invalid. /// </exception> /// <exception cref="NotSupportedException"> /// <paramref name="fileName"/> references the Data Directory for the current <see cref="AppDomain"/> but /// the Data Directory for the current <see cref="AppDomain"/> has no value set. /// </exception> public static void SetPhysicalFileName(this DbConnectionStringBuilder value, string fileName) { string fullPath = null; if (fileName != null) { fullPath = ExpandDataDirectoryIfPresent(fileName); try { // Only full file paths are supported, so ensure that the path is fully qualified before it is set fullPath = Path.GetFullPath(fullPath); } catch (ArgumentException ex) { throw new ArgumentException(SRHelper.Format(SR.Extensions_InvalidPathFormat, ex.Message), nameof(fileName), ex); } catch (NotSupportedException ex) { throw new ArgumentException(SRHelper.Format(SR.Extensions_InvalidPathFormat, ex.Message), nameof(fileName), ex); } } value.SetKeywordValueAsString(AttachDBFilenameKeywordName, fullPath); }
public async Task SRHelper_Format_Formats_Parameters() { // Arrange await Task.Factory.StartNew( () => { // Use a non-default culture var culture = CultureInfo.GetCultureInfo("en-GB"); Thread.CurrentThread.CurrentCulture = culture; Thread.CurrentThread.CurrentUICulture = culture; // Use a date where the result is valid with the day and month either way around // i.e. US format dates vs. UK format dates DateTime value = new DateTime(2012, 2, 3, 12, 34, 56); // Act string result = SRHelper.Format( "{0}", value); // Assert Assert.AreEqual( value.ToString(culture), result, "Format() returned incorrect result."); }); }
/// <summary> /// Shares the LocalDB instance using the specified name. /// </summary> /// <param name="sharedName">The name to use to share the instance.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="sharedName"/> is <see langword="null"/>. /// </exception> /// <exception cref="SqlLocalDbException"> /// The LocalDB instance could not be shared. /// </exception> public virtual void Share(string sharedName) { if (sharedName == null) { throw new ArgumentNullException(nameof(sharedName)); } try { SqlLocalDbApi.ShareInstance(_instanceName, sharedName); } catch (SqlLocalDbException e) { string message = SRHelper.Format( SR.SqlLocalDbInstance_ShareFailedFormat, _instanceName); Logger.Error(Logger.TraceEvent.ShareInstance, message); throw new SqlLocalDbException( message, e.ErrorCode, e.InstanceName, e); } }
/// <summary> /// Deletes the specified <see cref="ISqlLocalDbInstance"/> instance. /// </summary> /// <param name="instance">The LocalDB instance to delete.</param> /// <param name="throwIfNotFound"> /// Whether to throw an exception if the SQL LocalDB instance /// associated with <paramref name="instance"/> cannot be found. /// </param> /// <param name="deleteFiles"> /// Whether to delete the file(s) associated with the SQL LocalDB instance. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="instance"/> is <see langword="null"/>. /// </exception> /// <exception cref="SqlLocalDbException"> /// The SQL Server LocalDB instance specified by <paramref name="instance"/> could not be deleted. /// </exception> internal static void Delete(ISqlLocalDbInstance instance, bool throwIfNotFound, bool deleteFiles) { if (instance == null) { throw new ArgumentNullException(nameof(instance)); } try { SqlLocalDbApi.DeleteInstanceInternal(instance.Name, throwIfNotFound, deleteFiles); } catch (SqlLocalDbException ex) { string message = SRHelper.Format( SR.SqlLocalDbInstance_DeleteFailedFormat, instance.Name); Logger.Error(Logger.TraceEvent.DeleteFailed, message); throw new SqlLocalDbException( message, ex.ErrorCode, ex.InstanceName, ex); } }
public void SRHelper_Format_Throws_If_Args_Is_Null() { // Arrange string format = string.Empty; object[] args = null; throw ErrorAssert.Throws <ArgumentNullException>( () => SRHelper.Format(format, args), "args"); }
public void SRHelper_Format_Throws_If_Format_Is_Null() { // Arrange string format = null; object[] args = new object[0]; // Act and Assert throw ErrorAssert.Throws <ArgumentNullException>( () => SRHelper.Format(format, args), "format"); }
/// <summary> /// Creates an instance of <see cref="SqlConnectionStringBuilder"/> containing /// the default SQL connection string to connect to the LocalDB instance. /// </summary> /// <returns> /// An instance of <see cref="SqlConnectionStringBuilder"/> containing /// the default SQL connection string to connect to the LocalDB instance. /// </returns> /// <exception cref="InvalidOperationException"> /// The value of <see cref="SqlLocalDbInstance.IsRunning"/> is <see langword="false"/>. /// </exception> public virtual SqlConnectionStringBuilder CreateConnectionStringBuilder() { if (!this.IsRunning) { string message = SRHelper.Format( SR.SqlLocalDbInstance_NotRunningFormat, _instanceName); throw new InvalidOperationException(message); } SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(); builder.DataSource = _namedPipe; return(builder); }
/// <summary> /// Creates an instance of <see cref="DbConnectionStringBuilder"/> that can be used to connect to the SQL LocalDB instance. /// </summary> /// <param name="instance">The <see cref="ISqlLocalDbInstance"/> to get the connection string builder for.</param> /// <param name="modelConnectionStringName">The name of the connection string for the model in the application configuration file.</param> /// <param name="initialCatalog">The optional name to use for the Initial Catalog in the provider connection string to override the default, if present.</param> /// <returns> /// The created instance of <see cref="DbConnectionStringBuilder"/>. /// </returns> /// <exception cref="ArgumentException"> /// No connection string with the name specified by <paramref name="modelConnectionStringName"/> can be found in the application configuration file. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="instance"/> is <see langword="null"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// The value of the <see cref="ISqlLocalDbInstance.NamedPipe"/> property of <paramref name="instance"/> is <see langword="null"/> or the empty string. /// </exception> public static DbConnectionStringBuilder GetConnectionStringForModel(this ISqlLocalDbInstance instance, string modelConnectionStringName, string initialCatalog) { if (instance == null) { throw new ArgumentNullException(nameof(instance)); } var connectionStringSettings = ConfigurationManager.ConnectionStrings .OfType <ConnectionStringSettings>() .Where((p) => string.Equals(p.Name, modelConnectionStringName, StringComparison.Ordinal)) .FirstOrDefault(); if (connectionStringSettings == null) { throw new ArgumentException(SRHelper.Format(SR.Extensions_NoConnectionStringFormat, modelConnectionStringName), nameof(modelConnectionStringName)); } return(CreateBuilder(connectionStringSettings, instance.NamedPipe, initialCatalog)); }
/// <summary> /// Stops sharing the LocalDB instance. /// </summary> /// <exception cref="SqlLocalDbException"> /// The LocalDB instance could not be unshared. /// </exception> public virtual void Unshare() { try { SqlLocalDbApi.UnshareInstance(_instanceName); } catch (SqlLocalDbException e) { string message = SRHelper.Format( SR.SqlLocalDbInstance_UnshareFailedFormat, _instanceName); Logger.Error(Logger.TraceEvent.UnshareInstance, message); throw new SqlLocalDbException( message, e.ErrorCode, e.InstanceName, e); } }
/// <summary> /// Stops the SQL Server LocalDB instance. /// </summary> /// <exception cref="SqlLocalDbException"> /// The LocalDB instance could not be stopped. /// </exception> public void Stop() { try { SqlLocalDbApi.StopInstance(_instanceName); _namedPipe = string.Empty; } catch (SqlLocalDbException e) { string message = SRHelper.Format( SR.SqlLocalDbInstance_StopFailedFormat, _instanceName); Logger.Error(Logger.TraceEvent.StopInstance, message); throw new SqlLocalDbException( message, e.ErrorCode, e.InstanceName, e); } }
/// <summary> /// Starts the SQL Server LocalDB instance. /// </summary> /// <exception cref="SqlLocalDbException"> /// The LocalDB instance could not be started. /// </exception> public void Start() { try { // The pipe name changes per instance lifetime _namedPipe = SqlLocalDbApi.StartInstance(_instanceName); } catch (SqlLocalDbException e) { string message = SRHelper.Format( SR.SqlLocalDbInstance_StartFailedFormat, _instanceName); Logger.Error(Logger.TraceEvent.StartInstance, message); throw new SqlLocalDbException( message, e.ErrorCode, e.InstanceName, e); } }
/// <summary> /// Creates a new instance of <see cref="ISqlLocalDbInstance"/>. /// </summary> /// <param name="instanceName">The name of the SQL Server LocalDB instance to create.</param> /// <returns> /// The created instance of <see cref="ISqlLocalDbInstance"/>. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="instanceName"/> is <see langword="null"/>. /// </exception> /// <exception cref="InvalidOperationException"> /// The LocalDB instance specified by <paramref name="instanceName"/> already exists or /// no LocalDB instance information was returned by the underlying SQL LocalDB API. /// </exception> /// <exception cref="SqlLocalDbException"> /// The LocalDB instance specified by <paramref name="instanceName"/> could not be created. /// </exception> public virtual SqlLocalDbInstance CreateInstance(string instanceName) { ISqlLocalDbInstanceInfo info = _localDB.GetInstanceInfo(instanceName); if (info == null) { throw new InvalidOperationException(SR.SqlLocalDbProvider_NoInstance); } if (info.Exists) { string message = SRHelper.Format( SR.SqlLocalDbFactory_InstanceExistsFormat, instanceName); Logger.Error(Logger.TraceEvent.CreateInstance, message); throw new InvalidOperationException(message); } string version; // If creating the default instance, the version number must not be specified if (SqlLocalDbApi.IsDefaultInstanceName(instanceName)) { version = string.Empty; } else { version = _version ?? _localDB.LatestVersion; } _localDB.CreateInstance(instanceName, version); return(GetInstance(instanceName)); }