public AboutViewModel About()
{
var dbConfiguration = DatabaseExtensions.GetDatabaseConfiguration();
var storage = StartupSingleton.Instance;
var model = new AboutViewModel
{
FrameworkDescription = RuntimeInformation.FrameworkDescription,
OsArchitecture = RuntimeInformation.OSArchitecture.ToString(),
OsDescription = RuntimeInformation.OSDescription,
ProcessArchitecture = RuntimeInformation.ProcessArchitecture.ToString(),
ApplicationBasePath = Directory.GetCurrentDirectory(),
ExternalDatabaseType = dbConfiguration.ExternalDatabase.Type,
OmbiDatabaseType = dbConfiguration.OmbiDatabase.Type,
SettingsDatabaseType = dbConfiguration.SettingsDatabase.Type,
StoragePath = storage.StoragePath.HasValue() ? storage.StoragePath : "None Specified",
NotSupported = Directory.GetCurrentDirectory().Contains("qpkg")
};
var version = AssemblyHelper.GetRuntimeVersion();
var productArray = version.Split('-');
model.Version = productArray[0];
//model.Branch = productArray[1];
return(model);
}
/// <summary>
/// Получить соединение по имени
/// </summary>
/// <param name="name">Имя соединения</param>
/// <param name="defaultConnectionString"></param>
/// <returns>Содениение</returns>
public IDbConnection GetConnection(string name, string defaultConnectionString = null)
{
lock (Sync) {
Reload();
if (Registry.ContainsKey(name))
{
var component = Registry[name];
if (component.InstantiateWithContainer)
{
return(component.Container.Get <IDbConnection>(component.ContainerName));
}
else
{
return(Activator.CreateInstance(component.ConnectionType, component.ConnectionString) as IDbConnection);
}
}
else if (name.Contains(";"))
{
//full connection string
return(DatabaseExtensions.CreateDatabaseConnectionFromString(name));
}
if (defaultConnectionString.IsNotEmpty())
{
return(new SqlConnection(defaultConnectionString));
}
return(null);
}
}
private void PrepareEnvironment(IServiceProvider services)
{
var environment = services.GetRequiredService <IApplicationRuntime>().Environment;
DatabaseExtensions.PrepareDbEnvironment(services, environment);
BackgroundJobsExtensions.PrepareBgJobsEnvironment(services, environment);
}
/// <summary>
/// 获取新的数据库连接设置
/// </summary>
/// <returns>数据库连接设置</returns>
public ConnectionStringSettings GetNew()
{
using (var conn = DatabaseExtensions.CreateDbConnection(DataSource, ConnectString))
{
ConnectionStringSettings connectString = conn.MyQuery <ConnectionStringSettings>(QueryString).FirstOrDefault();
return(connectString);
}
}
public DatabaseContext CreateDbContext(string[] args)
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var appSettings = new AppSettings();
configuration.GetSection("AppSettings").Bind(appSettings);
var options = new DbContextOptionsBuilder <DatabaseContext>();
DatabaseExtensions.ConfigureDbContextOptions(configuration, appSettings, options);
return(new DatabaseContext(options.Options));
}
/// <summary>
/// Creates a new instance of a OSItemIndexDbContext.
/// </summary>
/// <returns>A new instance of OSItemIndexDbContext.</returns>
public OsItemIndexDbContext CreateDbContext(string[] args) // https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-3.1#evcp
{
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var configuration = new ConfigurationBuilder() // TODO Consider consting this somewhere, keep it all in once place, honestly prob not
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", true, true)
.AddJsonFile($"appsettings.{environment}.json", true)
.AddKeyPerFile("/run/secrets", true) // docker secrets dir
.AddEnvironmentVariables()
.Build();
var connStrBuilder = DatabaseExtensions.NpgsqlConnectionStringFromConfig(configuration);
var builder = new DbContextOptionsBuilder <OsItemIndexDbContext>()
.UseNpgsql(connStrBuilder.ConnectionString, o => o.CommandTimeout(15));
return(new OsItemIndexDbContext(builder.Options));
}
internal static User Login(User user)
{
string Command = "SELECT * FROM User WHERE Username = '******'";
var result = UserTableCreator.ReadData(Command);
if (result.Count == 0)
{
return(null);
}
if (DatabaseExtensions.CheckPasswordMatch(result[0].Password, user.Password))
{
return(result[0]);
}
else
{
return(null);
}
}
private static IEnumerable <XElement> InternalExecuteReader(string connection, string query, string elementName)
{
using (IDbConnection c = DatabaseExtensions.CreateDatabaseConnectionFromString(connection)){
c.Open();
IDbCommand cmd = c.CreateCommand();
cmd.CommandText = query;
using (IDataReader r = cmd.ExecuteReader()){
while (r.Read() || r.NextResult())
{
var e = new XElement(elementName);
for (int i = 0; i < r.FieldCount; i++)
{
string name = r.GetName(i);
e.SetAttr(name, r[i] is DBNull ? "" : r[i]);
}
yield return(e);
}
}
}
}
public static void Main(string[] args)
{
var host = CreateWebHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var services = scope.ServiceProvider;
try
{
var context = services.GetRequiredService <UklonSiteContext>();
DatabaseExtensions.Initialize(context);
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred while seeding the database.");
}
}
host.Run();
}
/// <summary>
/// 作为事务处理的一部分以指定的脚本类型和参数执行 <paramref name="command"/> 命令并根据执行结果返回一个新创建的 <see cref="IDataReader"/> 对象。
/// </summary>
/// <param name="transaction">用于包含脚本命令的 <see cref="DbTransaction"/> 对象。</param>
/// <param name="command">要被执行的 <see cref="DbCommand"/> 命令。</param>
/// <returns>表示脚本命令执行的结果的一个 <see cref="IDataReader"/> 对象。</returns>
public virtual IDataReader ExecuteReader(DbTransaction transaction, DbCommand command)
{
return(DatabaseExtensions.ExecuteReader(this.PrimitiveDatabase, transaction, command));
}
/// <summary>
/// 作为事务处理的一部分以指定的脚本类型执行一个 SQL 脚本并根据执行结果返回受影响的行数。
/// </summary>
/// <param name="transaction">用于包含脚本命令的 <see cref="DbTransaction"/> 对象。</param>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <returns>表示脚本命令执行受影响的行数。</returns>
public int ExecuteNonQuery(DbTransaction transaction, string commandText)
{
return(DatabaseExtensions.ExecuteNonQuery(this.PrimitiveDatabase, transaction, commandText));
}
/// <summary>
/// 以指定的脚本类型执行一个 SQL 脚本并根据执行结果返回一个新创建的 <see cref="IDataReader"/> 对象。
/// </summary>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="commandType">表示一个 <see cref="CommandType"/> 值用于指示 <paramref name="commandText"/> 的类型。</param>
/// <returns>表示脚本命令执行的结果的一个 <see cref="IDataReader"/> 对象。</returns>
public IDataReader ExecuteReader(string commandText, CommandType commandType)
{
return(DatabaseExtensions.ExecuteReader(this.PrimitiveDatabase, commandText, commandType));
}
/// <summary>
/// 以指定的脚本类型和参数执行一个 SQL 脚本并根据执行结果返回一个新创建的 <see cref="IDataReader"/> 对象。
/// </summary>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="commandType">表示一个 <see cref="CommandType"/> 值用于指示 <paramref name="commandText"/> 的类型。</param>
/// <param name="parameterValues">表示用于执行 <paramref name="commandText"/> 命令的参数列表。</param>
/// <returns>表示脚本命令执行的结果的一个 <see cref="IDataReader"/> 对象。</returns>
public IDataReader ExecuteReader(string commandText, CommandType commandType, params object[] parameterValues)
{
return(DatabaseExtensions.ExecuteReader(this.PrimitiveDatabase, commandText, commandType, parameterValues));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var provider = Configuration["Database:Provider"];
switch (provider)
{
case "InMemory":
services.AddDbContextPool <AlloyContext>((ServiceProvider, builder) => builder
.AddInterceptors(ServiceProvider.GetRequiredService <EventTransactionInterceptor>())
.UseInMemoryDatabase("api"));
break;
case "Sqlite":
case "SqlServer":
case "PostgreSQL":
services.AddDbContextPool <AlloyContext>((serviceProvider, builder) => builder
.AddInterceptors(serviceProvider.GetRequiredService <EventTransactionInterceptor>())
.UseConfiguredDatabase(Configuration));
break;
}
services.AddSingleton <StartupHealthCheck>();
services.AddSingleton <HostedServiceHealthCheck>();
services.AddHealthChecks()
.AddCheck <StartupHealthCheck>(
"startup",
failureStatus: HealthStatus.Degraded,
tags: new[] { "ready" })
.AddCheck <HostedServiceHealthCheck>(
"service_responsive",
failureStatus: HealthStatus.Unhealthy,
tags: new[] { "live" });
var connectionString = Configuration.GetConnectionString(DatabaseExtensions.DbProvider(Configuration));
switch (provider)
{
case "Sqlite":
services.AddHealthChecks().AddSqlite(connectionString, tags: new[] { "ready", "live" });
break;
case "SqlServer":
services.AddHealthChecks().AddSqlServer(connectionString, tags: new[] { "ready", "live" });
break;
case "PostgreSQL":
services.AddHealthChecks().AddNpgSql(connectionString, tags: new[] { "ready", "live" });
break;
}
services.AddOptions()
.Configure <DatabaseOptions>(Configuration.GetSection("Database"))
.AddScoped(config => config.GetService <IOptionsMonitor <DatabaseOptions> >().CurrentValue)
.Configure <ClaimsTransformationOptions>(Configuration.GetSection("ClaimsTransformation"))
.AddScoped(config => config.GetService <IOptionsMonitor <ClaimsTransformationOptions> >().CurrentValue);
services
.Configure <ClientOptions>(Configuration.GetSection("ClientSettings"))
.AddScoped(config => config.GetService <IOptionsMonitor <ClientOptions> >().CurrentValue);
services
.Configure <FilesOptions>(Configuration.GetSection("Files"))
.AddScoped(config => config.GetService <IOptionsMonitor <FilesOptions> >().CurrentValue);
services
.Configure <ResourceOwnerAuthorizationOptions>(Configuration.GetSection("ResourceOwnerAuthorization"))
.AddScoped(config => config.GetService <IOptionsMonitor <ResourceOwnerAuthorizationOptions> >().CurrentValue);
services
.Configure <ResourceOptions>(Configuration.GetSection("Resource"))
.AddScoped(config => config.GetService <IOptionsMonitor <ResourceOptions> >().CurrentValue);
services.AddCors(options => options.UseConfiguredCors(Configuration.GetSection("CorsPolicy")));
services.AddSignalR()
.AddJsonProtocol(options =>
{
options.PayloadSerializerOptions.PropertyNameCaseInsensitive = true;
options.PayloadSerializerOptions.Converters.Add(new JsonStringEnumConverter());
options.PayloadSerializerOptions.Converters.Add(new JsonDateTimeConverter());
});
services.AddMvc(options =>
{
options.Filters.Add(typeof(ValidateModelStateFilter));
options.Filters.Add(typeof(JsonExceptionFilter));
// Require all scopes in authOptions
var policyBuilder = new AuthorizationPolicyBuilder().RequireAuthenticatedUser();
Array.ForEach(_authOptions.AuthorizationScope.Split(' '), x => policyBuilder.RequireScope(x));
var policy = policyBuilder.Build();
options.Filters.Add(new AuthorizeFilter(policy));
})
.AddJsonOptions(options =>
{
options.JsonSerializerOptions.Converters.Add(new JsonNullableGuidConverter());
// options.JsonSerializerOptions.Converters.Add(new JsonIntegerConverter());
options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
options.JsonSerializerOptions.Converters.Add(new JsonDateTimeConverter());
});
services.AddSwagger(_authOptions);
JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.Authority = _authOptions.Authority;
options.RequireHttpsMetadata = _authOptions.RequireHttpsMetadata;
options.SaveToken = true;
options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters
{
ValidateIssuer = true,
ValidAudiences = _authOptions.AuthorizationScope.Split(' ')
};
options.Events = new JwtBearerEvents
{
OnMessageReceived = context =>
{
// If the request is for our hub...
var path = context.HttpContext.Request.Path;
var accessToken = context.Request.Query["access_token"];
if (!string.IsNullOrEmpty(accessToken) &&
(path.StartsWithSegments("/hubs")))
{
// Read the token out of the query string
context.Token = accessToken;
}
return(Task.CompletedTask);
}
};
});
services.AddRouting(options =>
{
options.LowercaseUrls = true;
});
services.AddMemoryCache();
services.AddScoped <IEventTemplateService, EventTemplateService>();
services.AddScoped <IEventService, EventService>();
services.AddScoped <ICasterService, CasterService>();
services.AddScoped <IPlayerService, PlayerService>();
services.AddScoped <ISteamfitterService, SteamfitterService>();
services.AddScoped <IUserClaimsService, UserClaimsService>();
services.AddTransient <EventTransactionInterceptor>();
// add the other API clients
services.AddPlayerApiClient();
services.AddCasterApiClient();
services.AddSteamfitterApiClient();
// add the background IHostedServices
services.AddAlloyBackgroundService();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped <IPrincipal>(p => p.GetService <IHttpContextAccessor>().HttpContext.User);
services.AddHttpClient();
ApplyPolicies(services);
services.AddAutoMapper(cfg =>
{
cfg.ForAllPropertyMaps(
pm => pm.SourceType != null && Nullable.GetUnderlyingType(pm.SourceType) == pm.DestinationType,
(pm, c) => c.MapFrom <object, object, object, object>(new IgnoreNullSourceValues(), pm.SourceMember.Name));
}, typeof(Startup));
services.AddMediatR(typeof(Startup).GetTypeInfo().Assembly);
services.AddScoped <IClaimsTransformation, AuthorizationClaimsTransformer>();
}
/// <summary>
/// 找出 <paramref name="command"/> 脚本中定义的参数列表，并将 <paramref name="parameterValues"/> 作为参数值分配给该参数列表。
/// </summary>
/// <param name="command">用于查找参数列表的 <see cref="DbCommand"/> 对象。</param>
/// <param name="parameterValues">用于作为参数值分配给 <paramref name="command"/> 参数列表的值集合。</param>
public virtual void AssignParameters(DbCommand command, params object[] parameterValues)
{
DatabaseExtensions.AssignParameters(this.PrimitiveDatabase, command, parameterValues);
}
/// <summary>
/// 以指定的脚本类型和参数执行一个 SQL 脚本并将返回结果数据填充至 <paramref name="dataTable"/> 中。
/// </summary>
/// <param name="dataTable">用于填充脚本命令返回结果数据的 <see cref="DataTable"/> 对象。</param>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="commandType">表示一个 <see cref="CommandType"/> 值用于指示 <paramref name="commandText"/> 的类型。</param>
/// <param name="parameterValues">表示用于执行 <paramref name="commandText"/> 命令的参数列表。</param>
public void LoadDataTable(DataTable dataTable, string commandText, CommandType commandType, params object[] parameterValues)
{
DatabaseExtensions.LoadDataTable(this.PrimitiveDatabase, dataTable, commandText, commandType, parameterValues);
}
/// <summary>
/// 以指定的脚本类型和参数执行一个 SQL 脚本并根据执行结果返回受影响的行数。
/// </summary>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="commandType">表示一个 <see cref="CommandType"/> 值用于指示 <paramref name="commandText"/> 的类型。</param>
/// <param name="parameterValues">表示用于执行 <paramref name="commandText"/> 命令的参数列表。</param>
/// <returns>表示脚本命令执行受影响的行数。</returns>
public int ExecuteNonQuery(string commandText, CommandType commandType, params object[] parameterValues)
{
return(DatabaseExtensions.ExecuteNonQuery(this.PrimitiveDatabase, commandText, commandType, parameterValues));
}
/// <summary>
/// 以指定的脚本参数执行一个 SQL 脚本并将返回结果数据填充至 <paramref name="dataTable"/> 中。
/// </summary>
/// <param name="dataTable">用于填充脚本命令返回结果数据的 <see cref="DataTable"/> 对象。</param>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="parameterValues">表示用于执行 <paramref name="commandText"/> 命令的参数列表。</param>
public void LoadDataTable(DataTable dataTable, string commandText, params DbParameter[] parameterValues)
{
DatabaseExtensions.LoadDataTable(this.PrimitiveDatabase, dataTable, commandText, parameterValues);
}
/// <summary>
/// 创建并返回与当前 <see cref="DbProviderFactory"/> 关联的 <see cref="DbConnection"/> 对象。
/// </summary>
/// <returns>与当前 <see cref="DbProviderFactory"/> 关联的 <see cref="DbConnection"/> 对象。</returns>
public virtual DbConnection CreateConnection()
{
return(DatabaseExtensions.CreateConnection(this.PrimitiveDatabase));
}
/// <summary>
/// 作为事务处理的一部分以指定的脚本类型和参数执行一个 SQL 脚本并将返回结果数据填充至 <paramref name="dataTable"/> 中。
/// </summary>
/// <param name="dataTable">用于填充脚本命令返回结果数据的 <see cref="DataTable"/> 对象。</param>
/// <param name="transaction">用于包含脚本命令的 <see cref="DbTransaction"/> 对象。</param>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="commandType">表示一个 <see cref="CommandType"/> 值用于指示 <paramref name="commandText"/> 的类型。</param>
/// <param name="parameterValues">表示用于执行 <paramref name="commandText"/> 命令的参数列表。</param>
public void LoadDataTable(DataTable dataTable, DbTransaction transaction, string commandText, CommandType commandType, params DbParameter[] parameterValues)
{
DatabaseExtensions.LoadDataTable(this.PrimitiveDatabase, dataTable, transaction, commandText, commandType, parameterValues);
}
/// <summary>
/// 作为事务处理的一部分执行一个 SQL 脚本并将返回结果数据填充至 <paramref name="dataTable"/> 中。
/// </summary>
/// <param name="dataTable">用于填充脚本命令返回结果数据的 <see cref="DataTable"/> 对象。</param>
/// <param name="transaction">用于包含脚本命令的 <see cref="DbTransaction"/> 对象。</param>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
public void LoadDataTable(DataTable dataTable, DbTransaction transaction, string commandText)
{
DatabaseExtensions.LoadDataTable(this.PrimitiveDatabase, dataTable, transaction, commandText);
}
internal HttpMessage CreateCreateOrUpdateRequest(string subscriptionId, string resourceGroupName, string serverName, string databaseName, string extensionName, DatabaseExtensions parameters)
{
var message = _pipeline.CreateMessage();
var request = message.Request;
request.Method = RequestMethod.Put;
var uri = new RawRequestUriBuilder();
uri.Reset(endpoint);
uri.AppendPath("/subscriptions/", false);
uri.AppendPath(subscriptionId, true);
uri.AppendPath("/resourceGroups/", false);
uri.AppendPath(resourceGroupName, true);
uri.AppendPath("/providers/Microsoft.Sql/servers/", false);
uri.AppendPath(serverName, true);
uri.AppendPath("/databases/", false);
uri.AppendPath(databaseName, true);
uri.AppendPath("/extensions/", false);
uri.AppendPath(extensionName, true);
uri.AppendQuery("api-version", "2021-02-01-preview", true);
request.Uri = uri;
request.Headers.Add("Accept", "application/json");
request.Headers.Add("Content-Type", "application/json");
var content = new Utf8JsonRequestContent();
content.JsonWriter.WriteObjectValue(parameters);
request.Content = content;
message.SetProperty("UserAgentOverride", _userAgent);
return(message);
}
/// <summary>
/// 作为事务处理的一部分以指定的脚本类型和参数执行一个 SQL 脚本并根据执行结果返回受影响的行数。
/// </summary>
/// <param name="transaction">用于包含脚本命令的 <see cref="DbTransaction"/> 对象。</param>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="commandType">表示一个 <see cref="CommandType"/> 值用于指示 <paramref name="commandText"/> 的类型。</param>
/// <param name="parameterValues">表示用于执行 <paramref name="commandText"/> 命令的参数列表。</param>
/// <returns>表示脚本命令执行受影响的行数。</returns>
public int ExecuteNonQuery(DbTransaction transaction, string commandText, CommandType commandType, params DbParameter[] parameterValues)
{
return(DatabaseExtensions.ExecuteNonQuery(this.PrimitiveDatabase, transaction, commandText, commandType, parameterValues));
}
/// <summary>
/// 作为事务处理的一部分执行 <paramref name="command"/> 命令并将返回结果数据填充至 <paramref name="dataTable"/> 中。
/// </summary>
/// <param name="dataTable">用于填充脚本命令返回结果数据的 <see cref="DataTable"/> 对象。</param>
/// <param name="transaction">用于包含脚本命令的 <see cref="DbTransaction"/> 对象。</param>
/// <param name="command"></param>
public virtual void LoadDataTable(DataTable dataTable, DbTransaction transaction, DbCommand command)
{
DatabaseExtensions.LoadDataTable(this.PrimitiveDatabase, dataTable, transaction, command);
}
/// <summary>
/// 以指定的脚本类型执行一个 SQL 脚本并根据执行结果返回受影响的行数。
/// </summary>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="commandType">表示一个 <see cref="CommandType"/> 值用于指示 <paramref name="commandText"/> 的类型。</param>
/// <returns>表示脚本命令执行受影响的行数。</returns>
public int ExecuteNonQuery(string commandText, CommandType commandType)
{
return(DatabaseExtensions.ExecuteNonQuery(this.PrimitiveDatabase, commandText, commandType));
}
/// <summary>
/// 作为事务处理的一部分以指定的脚本类型执行一个 SQL 脚本并根据执行结果返回一个新创建的 <see cref="IDataReader"/> 对象。
/// </summary>
/// <param name="transaction">用于包含脚本命令的 <see cref="DbTransaction"/> 对象。</param>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <returns>表示脚本命令执行的结果的一个 <see cref="IDataReader"/> 对象。</returns>
public IDataReader ExecuteReader(DbTransaction transaction, string commandText)
{
return(DatabaseExtensions.ExecuteReader(this.PrimitiveDatabase, transaction, commandText));
}
/// <summary>
/// 作为事务处理的一部分以指定的脚本类型和参数执行 <paramref name="command"/> 命令并根据执行结果返回受影响的行数。
/// </summary>
/// <param name="transaction">用于包含脚本命令的 <see cref="DbTransaction"/> 对象。</param>
/// <param name="command">要被执行的 <see cref="DbCommand"/> 命令。</param>
/// <returns>表示脚本命令执行受影响的行数。</returns>
public virtual int ExecuteNonQuery(DbTransaction transaction, DbCommand command)
{
return(DatabaseExtensions.ExecuteNonQuery(this.PrimitiveDatabase, transaction, command));
}
/// <summary>
/// 作为事务处理的一部分以指定的脚本参数执行一个 SQL 脚本并根据执行结果返回一个新创建的 <see cref="IDataReader"/> 对象。
/// </summary>
/// <param name="transaction">用于包含脚本命令的 <see cref="DbTransaction"/> 对象。</param>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="parameterValues">表示用于执行 <paramref name="commandText"/> 命令的参数列表。</param>
/// <returns>表示脚本命令执行的结果的一个 <see cref="IDataReader"/> 对象。</returns>
public IDataReader ExecuteReader(DbTransaction transaction, string commandText, params object[] parameterValues)
{
return(DatabaseExtensions.ExecuteReader(this.PrimitiveDatabase, transaction, commandText, parameterValues));
}
/// <summary>
/// 以指定的脚本类型执行一个 SQL 脚本并将返回结果数据填充至 <paramref name="dataTable"/> 中。
/// </summary>
/// <param name="dataTable">用于填充脚本命令返回结果数据的 <see cref="DataTable"/> 对象。</param>
/// <param name="commandText">表示要执行的 SQL 脚本文本内容。</param>
/// <param name="commandType">表示一个 <see cref="CommandType"/> 值用于指示 <paramref name="commandText"/> 的类型。</param>
public void LoadDataTable(DataTable dataTable, string commandText, CommandType commandType)
{
DatabaseExtensions.LoadDataTable(this.PrimitiveDatabase, dataTable, commandText, commandType);
}
public async Task <Response> CreateOrUpdateAsync(string subscriptionId, string resourceGroupName, string serverName, string databaseName, string extensionName, DatabaseExtensions parameters, CancellationToken cancellationToken = default)
{
if (subscriptionId == null)
{
throw new ArgumentNullException(nameof(subscriptionId));
}
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (serverName == null)
{
throw new ArgumentNullException(nameof(serverName));
}
if (databaseName == null)
{
throw new ArgumentNullException(nameof(databaseName));
}
if (extensionName == null)
{
throw new ArgumentNullException(nameof(extensionName));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var message = CreateCreateOrUpdateRequest(subscriptionId, resourceGroupName, serverName, databaseName, extensionName, parameters);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
case 202:
return(message.Response);
default:
throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false);
}
}
