文章图片
没有人喜欢样板代码。我们通常通过使用常见的面向对象编程模式来减少它，但通常使用模式的代码开销与我们首先使用样板代码几乎相同——如果不是更大的话。以某种方式标记应该实现某些行为的代码的一部分，并在其他地方解决实现，这将是非常好的。
例如，如果我们有一个StudentRepository，我们可以使用Dapper从关系数据库中获取所有学生：

public class StudentRepository { public Task< IEnumerable< Student>> GetAllAsync(IDbConnection connection) { return connection.GetAllAsync< Student>(); } }

.NET如何缓存和连接？这是关系数据库存储库的一个非常简单的实现。如果学生列表变化不大并且经常被调用，我们可以缓存这些项目以优化系统的响应时间。由于我们的代码中通常有很多存储库（无论它们是否相关），因此最好将缓存的这种横切关注放在一边并很容易地使用它，例如：

public class StudentRepository { [ Cache] public Task< IEnumerable< Student>> GetAllAsync(IDbConnection connection) { return connection.GetAllAsync< Student>(); } }

一个好处是不用担心数据库连接。把这个横切关注放在一边，只需标记一个使用外部连接管理器的方法，例如：

public class StudentRepository { [ Cache] [ DbConnection] public Task< IEnumerable< Student>> GetAllAsync(IDbConnection connection = null) { return connection.GetAllAsync< Student>(); } }

在本.NET缓存和连接处理教程中，我们将考虑使用面向方面的模式而不是常用的 OOP。尽管 AOP 已经存在一段时间了，但开发人员通常更喜欢 OOP 而不是 AOP。虽然你用 AOP 做的一切都可以用 OOP 来完成，就像过程编程与 OOP 一样，AOP 为开发人员提供了他们可以使用的范式的更多选择。AOP 代码的组织方式与 OOP 不同，在某些方面（双关语），有些人可能会争论得更好。最后，选择使用哪种范式是个人喜好。
.NET面向方面编程教程：我们如何做在 .NET 中，AOP 模式可以使用中间语言编织来实现，更好地称为IL 编织。这是一个在代码编译后启动的过程，它改变编译器产生的IL代码，使代码达到预期的行为。所以，看已经提到的例子，即使我们没有在这个类中编写缓存代码，我们编写的方法也会被改变（或替换）以调用缓存代码。.NET缓存和连接处理示例：为了说明起见，最终结果应如下所示：

// Weaved by PostSharppublic class StudentRepository { [ DebuggerTargetMethod(100663306)] [ DebuggerBindingMethod(100663329)] [ DebuggerBindingMethod(100663335)] public async Task< IEnumerable< Student>> GetAllAsync( IDbConnection connection = null) { AsyncMethodInterceptionArgsImpl< IEnumerable< Student>> interceptionArgsImpl; try { // ISSUE: reference to a compiler-generated field await < >z__a_1.a2.OnInvokeAsync((MethodInterceptionArgs) interceptionArgsImpl); // ISSUE: reference to a compiler-generated field this.< >1__state = -2; } finally { } return (IEnumerable< Student>) interceptionArgsImpl.TypedReturnValue; }[ DebuggerSourceMethod(100663300)] private Task< IEnumerable< Student>> < GetAllAsync>z__OriginalMethod( [ Optional] IDbConnection connection) { return (Task< IEnumerable< Student>>) SqlMapperExtensions.GetAllAsync< Student>(connection, (IDbTransaction) null, new int?()); } }

所需工具本文中的所有代码，包括方面和集成测试，都可以在notmarkopadjen/dot-net-aspects-postsharpGitHub 存储库中找到。对于 IL 编织，我们将使用Visual Studio 市场中的PostSharp。它是一种商业工具，用于商业目的需要许可证。为了进行试验，你可以选择免费的 PostSharp Essentials 许可证。
如果你希望运行集成测试，你将需要 MySQL 和 Redis 服务器。在上面的代码中，我使用 MariaDB 10.4 和 Redis 5.0 使用 Docker Compose 做了一个实验。为了使用它，你需要安装Docker并启动 Compose 配置：

docker-compose up -d

当然，你可以使用其他服务器并更改appsettings.json.
.NET缓存和连接处理教程：面向方面的基本编码【.NET中的缓存和连接处理（面向方面的编程教程）】我们来试试AOP的拦截模式。要在 PostSharp 中做到这一点，我们需要实现一个新属性，继承该MethodInterceptionAspect属性并覆盖所需的方法。

[ PSerializable] [ AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)] public class CacheAttribute : MethodInterceptionAspect { // ...public override void OnInvoke(MethodInterceptionArgs args) { // ... var redisValue = https://www.lsbin.com/db.StringGet(key); // ... }public override async Task OnInvokeAsync(MethodInterceptionArgs args) { // ... var redisValue = await db.StringGetAsync(key); // ... } }

.NET如何缓存和连接？我们看到我们有两种不同的同步和异步调用方法。正确实现这些以充分利用 .NET 异步功能非常重要。当使用StackExchange.Redis库从 Redis 读取时，我们使用StringGet或StringGetAsync方法调用，这取决于我们是同步还是异步代码分支。
代码执行流程受调用MethodInterceptionArgs、args对象的方法以及为对象的属性设置值的影响。最重要的成员：

• Proceed(  ProceedAsync) 方法 - 调用原始方法执行。
• ReturnValue属性 - 包含方法调用的返回值。原始方法执行前为空，执行后包含原始返回值。它可以随时更换。
• Method属性 -  System.Reflection.MethodBase（通常System.Reflection.MethodInfo）包含目标方法反射信息。
• Instance  属性 - 目标对象（方法父实例）。
• Arguments属性 - 包含参数值。它可以随时更换。

.NET面向方面编程教程：DbConnection 方面我们希望能够在没有 实例的情况下调用存储库方法IDbConnection，并让方面创建这些连接并将其提供给方法调用。有时，你可能希望无论如何都提供连接（例如，由于事务），并且在这些情况下，方面不应该做任何事情。
在下面的实现中，我们将只有用于数据库连接管理的代码，就像我们在任何数据库实体存储库中一样。在这种特殊情况下， 的实例MySqlConnection被解析为方法执行并在方法执行完成后处理。

using Microsoft.Extensions.Configuration; using MySql.Data.MySqlClient; using PostSharp.Aspects; using PostSharp.Aspects.Dependencies; using PostSharp.Serialization; using System; using System.Data; using System.Threading.Tasks; namespace Paden.Aspects.Storage.MySQL { [ PSerializable] [ ProvideAspectRole(StandardRoles.TransactionHandling)] [ AspectRoleDependency(AspectDependencyAction.Order, AspectDependencyPosition.After, StandardRoles.Caching)] [ AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)] public class DbConnectionAttribute : MethodInterceptionAspect { const string DefaultConnectionStringName = "DefaultConnection"; static Lazy< IConfigurationRoot> config; static string connectionString; public static string ConnectionString { get { return connectionString ?? config.Value.GetConnectionString(DefaultConnectionStringName); } set { connectionString = value; } }static DbConnectionAttribute() { config = new Lazy< IConfigurationRoot>(() => new ConfigurationBuilder().AddJsonFile("appsettings.json", false, false).Build()); }public override void OnInvoke(MethodInterceptionArgs args) { var i = GetArgumentIndex(args); if (!i.HasValue) { args.Proceed(); return; }using (IDbConnection db = new MySqlConnection(ConnectionString)) { args.Arguments.SetArgument(i.Value, db); args.Proceed(); } }public override async Task OnInvokeAsync(MethodInterceptionArgs args) { var i = GetArgumentIndex(args); if (!i.HasValue) { await args.ProceedAsync(); return; }using (IDbConnection db = new MySqlConnection(ConnectionString)) { args.Arguments.SetArgument(i.Value, db); await args.ProceedAsync(); } }private int? GetArgumentIndex(MethodInterceptionArgs args) { var parameters = args.Method.GetParameters(); for (int i = 0; i < parameters.Length; i++) { var parameter = parameters[ i]; if (parameter.ParameterType == typeof(IDbConnection) & & parameter.IsOptional & & args.Arguments[ i] == null) { return i; } } return null; } } }

这里重要的是指定方面的执行顺序。在这里，它是通过分配方面角色和排序角色执行来完成的。IDbConnection如果无论如何都不会使用它（例如，从缓存中读取的值），我们不希望被创建。它由以下属性定义：

[ ProvideAspectRole(StandardRoles.TransactionHandling)] [ AspectRoleDependency(AspectDependencyAction.Order, AspectDependencyPosition.After, StandardRoles.Caching)]

PostSharp 还可以在类级别和程序集级别实现所有方面，因此定义属性范围很重要：

[ AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]

正在读取连接字符串appsettings.json，但可以使用静态属性覆盖ConnectionString。
执行流程如下：

1. Aspect 标识IDbConnection没有提供值的可选参数索引。如果没有找到，我们跳过。
2. MySqlConnection 是基于提供的ConnectionString.
3. IDbConnection  设置参数值。
4. 调用原始方法。

所以，如果我们想使用这个方面，我们可以在不提供连接的情况下调用存储库方法：

await studentRepository.InsertAsync(new Student { Name = "Not Marko Padjen" }, connection: null);

.NET缓存和连接处理教程：缓存方面在这里，我们要识别唯一的方法调用并缓存它们。如果使用相同参数调用了来自同一类的相同方法，则方法调用被认为是唯一的。
.NET如何缓存和连接？在下面的实现中，在每个方法上，都会为调用创建拦截键。这随后用于检查缓存服务器上是否存在返回值。如果是，则在不调用原始方法的情况下返回它。如果不是，则调用原始方法，并将返回值保存到缓存服务器以供进一步使用。

using Microsoft.Extensions.Configuration; using Newtonsoft.Json; using PostSharp.Aspects; using PostSharp.Aspects.Dependencies; using PostSharp.Serialization; using StackExchange.Redis; using System; using System.Collections.Generic; using System.Data; using System.Linq; using System.Linq.Expressions; using System.Reflection; using System.Text; using System.Threading.Tasks; namespace Paden.Aspects.Caching.Redis { [ PSerializable] [ ProvideAspectRole(StandardRoles.Caching)] [ AspectRoleDependency(AspectDependencyAction.Order, AspectDependencyPosition.Before, StandardRoles.TransactionHandling)] [ AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)] public class CacheAttribute : MethodInterceptionAspect { const int DefaultExpirySeconds = 5 * 60; static Lazy< string> redisServer; public int ExpirySeconds = DefaultExpirySeconds; private TimeSpan? Expiry => ExpirySeconds == -1 ? (TimeSpan?)null : TimeSpan.FromSeconds(ExpirySeconds); static CacheAttribute() { redisServer = new Lazy< string>(() => new ConfigurationBuilder().AddJsonFile("appsettings.json", false, false).Build()[ "Redis:Server"]); }public override void OnInvoke(MethodInterceptionArgs args) { if (args.Instance is ICacheAware cacheAware & & !cacheAware.CacheEnabled) { args.Proceed(); return; }var key = GetKey(args.Method as MethodInfo, args.Arguments); using (var connection = ConnectionMultiplexer.Connect(redisServer.Value)) { var db = connection.GetDatabase(); var redisValue = https://www.lsbin.com/db.StringGet(key); if (redisValue.IsNullOrEmpty) { args.Proceed(); db.StringSet(key, JsonConvert.SerializeObject(args.ReturnValue), Expiry); } else { args.ReturnValue = JsonConvert.DeserializeObject(redisValue.ToString(), (args.Method as MethodInfo).ReturnType); } } }public override async Task OnInvokeAsync(MethodInterceptionArgs args) { if (args.Instance is ICacheAware cacheAware & & !cacheAware.CacheEnabled) { await args.ProceedAsync(); return; }var key = GetKey(args.Method as MethodInfo, args.Arguments); using (var connection = ConnectionMultiplexer.Connect(redisServer.Value)) { var db = connection.GetDatabase(); var redisValue = await db.StringGetAsync(key); if (redisValue.IsNullOrEmpty) { await args.ProceedAsync(); db.StringSet(key, JsonConvert.SerializeObject(args.ReturnValue), Expiry); } else { args.ReturnValue = JsonConvert.DeserializeObject(redisValue.ToString(), (args.Method as MethodInfo).ReturnType.GenericTypeArguments[ 0]); } } }private string GetKey(MethodInfo method, IList< object> values) { var parameters = method.GetParameters(); var keyBuilder = GetKeyBuilder(method); keyBuilder.Append("("); foreach (var parameter in parameters) { AppendParameterValue(keyBuilder, parameter, values[ parameter.Position]); } if (parameters.Any()) { keyBuilder.Remove(keyBuilder.Length - 2, 2); } keyBuilder.Append(")"); return keyBuilder.ToString(); }public static void InvalidateCache< T, TResult>(Expression< Func< T, TResult>> expression) { var methodCallExpression = expression.Body as MethodCallExpression; var keyBuilder = GetKeyBuilder(methodCallExpression.Method); var parameters = methodCallExpression.Method.GetParameters(); var anyMethod = typeof(CacheExtensions).GetMethod(nameof(CacheExtensions.Any)); keyBuilder.Append("("); for (int i = 0; i < parameters.Length; i++) { var parameter = parameters[ i]; var argument = methodCallExpression.Arguments[ i]; object value = https://www.lsbin.com/null; if (argument is ConstantExpression constantArgument) { value = constantArgument.Value; } else if (argument is MemberExpression memberArgument) { value = Expression.Lambda(memberArgument).Compile().DynamicInvoke(); } else if (argument is MethodCallExpression methodCallArgument) { if (methodCallArgument.Method == anyMethod.MakeGenericMethod(methodCallArgument.Method.GetGenericArguments())) { value ="*"; } }AppendParameterValue(keyBuilder, parameter, value); } if (methodCallExpression.Arguments.Any()) { keyBuilder.Remove(keyBuilder.Length - 2, 2); } keyBuilder.Append(")"); using (var connection = ConnectionMultiplexer.Connect(redisServer.Value)) { connection.GetDatabase().ScriptEvaluate(@" local keys = redis.call('keys', ARGV[ 1]) for i=1, #keys, 5000 do redis.call('del', unpack(keys, i, math.min(i + 4999, #keys))) end", values: new RedisValue[ ] { CacheExtensions.EscapeRedisString(keyBuilder.ToString()) }); } }private static StringBuilder GetKeyBuilder(MethodInfo method) { var keyBuilder = new StringBuilder(); keyBuilder.Append(method.ReturnType.FullName); keyBuilder.Append(" {"); keyBuilder.Append(method.ReflectedType.AssemblyQualifiedName); keyBuilder.Append("}."); keyBuilder.Append(method.ReflectedType.FullName); keyBuilder.Append("."); keyBuilder.Append(method.Name); return keyBuilder; }private static void AppendParameterValue(StringBuilder keyBuilder, ParameterInfo parameter, object value) { keyBuilder.Append(parameter.ParameterType.FullName); keyBuilder.Append(" "); if (parameter.ParameterType == typeof(IDbConnection)) { keyBuilder.Append("< IGNORED>"); } else { keyBuilder.Append(value =https://www.lsbin.com/= null ?"< NULL>" : value.ToString()); } keyBuilder.Append(", "); } } }

在这里，我们也尊重方面的顺序。方面的作用是Caching，它被定义为追求TransactionHandling：

[ ProvideAspectRole(StandardRoles.Caching)] [ AspectRoleDependency(AspectDependencyAction.Order, AspectDependencyPosition.Before, StandardRoles.TransactionHandling)]

属性范围与 DbConnection 方面相同：

[ AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]

通过定义公共字段ExpirySeconds（默认为 5 分钟），可以在每个方法上设置缓存项目的过期时间，例如：

[ Cache(ExpirySeconds = 2 * 60 /* 2 minutes */)] [ DbConnection] public Task< IEnumerable< Student>> GetAllAsync(IDbConnection connection = null) { return connection.GetAllAsync< Student>(); }

执行流程如下：

1. 方面检查该实例是否ICacheAware可以提供一个标志以跳过在此特定对象实例上使用缓存。
2. Aspect 为方法调用生成一个键。
3. Aspect 打开 Redis 连接。
4. 如果 value 与生成的键一起存在，则返回 value 并跳过原始方法执行。
5. 如果值不存在，则调用原始方法并将返回值与生成的键一起保存在缓存中。

对于密钥生成，这里有一些限制：

1. IDbConnection作为参数始终被忽略，无论是否为空。这是故意完成的，以适应先前方面的使用。
2. 作为字符串值的特殊值可能会导致从缓存中错误读取，例如< IGNORED> 和< NULL> 值。这可以通过值编码来避免。
3. 不考虑引用类型，只考虑它们的类型（.ToString()用于值评估）。对于大多数情况，这很好，并且不会增加额外的复杂性。

.NET缓存和连接处理示例：为了正确使用缓存，可能需要在缓存过期之前使缓存失效，例如实体更新或实体删除。

public class StudentRepository : ICacheAware { // ...[ Cache] [ DbConnection] public Task< IEnumerable< Student>> GetAllAsync(IDbConnection connection = null) { return connection.GetAllAsync< Student>(); }[ Cache] [ DbConnection] public Task< Student> GetAsync(int id, IDbConnection connection = null) { return connection.GetAsync< Student>(id); }[ DbConnection] public async Task< int> InsertAsync(Student student, IDbConnection connection = null) { var result = await connection.InsertAsync(student); this.InvalidateCache(r => r.GetAllAsync(Any< IDbConnection>())); return result; }[ DbConnection] public async Task< bool> UpdateAsync(Student student, IDbConnection connection = null) { var result = await connection.UpdateAsync(student); this.InvalidateCache(r => r.GetAllAsync(Any< IDbConnection>())); this.InvalidateCache(r => r.GetAsync(student.Id, Any< IDbConnection>())); return result; }[ DbConnection] public async Task< bool> DeleteAsync(Student student, IDbConnection connection = null) { var result = await connection.DeleteAsync(student); this.InvalidateCache(r => r.GetAllAsync(Any< IDbConnection>())); this.InvalidateCache(r => r.GetAsync(student.Id, Any< IDbConnection>())); return result; } }

InvalidateCachehelper 方法接受表达式，因此可以使用通配符（类似于Moq框架）：

this.InvalidateCache(r => r.GetAsync(student.Id, Any< IDbConnection>()));

这方面的使用没有特殊参数，因此开发人员应该只知道代码限制。
.NET面向方面编程教程：把它放在一起最好的方法是试用和调试是使用项目中提供的集成测试Paden.Aspects.DAL.Tests。
.NET如何缓存和连接？以下集成测试方法使用真实服务器（关系数据库和缓存）。连接外观仅用于跟踪方法调用。

[ Fact] public async Task Get_Should_Call_Database_If_Entity_Not_Dirty_Otherwise_Read_From_Cache() { var student = new Student { Id = studentId, Name = "Not Marko Padjen" }; var studentUpdated = new Student { Id = studentId, Name = "Not Marko Padjen UPDATED" }; await systemUnderTest.InsertAsync(student); // Gets entity by id, should save in cache Assert.Equal(student.Name, (await systemUnderTest.GetAsync(studentId)).Name); // Updates entity by id, should invalidate cache await systemUnderTest.UpdateAsync(studentUpdated); var connectionMock = fixture.GetConnectionFacade(); // Gets entity by id, ensures that it is the expected one Assert.Equal(studentUpdated.Name, (await systemUnderTest.GetAsync(studentId, connectionMock)).Name); // Ensures that database was used for the call Mock.Get(connectionMock).Verify(m => m.CreateCommand(), Times.Once); var connectionMockUnused = fixture.GetConnectionFacade(); // Calls again, should read from cache Assert.Equal(studentUpdated.Name, (await systemUnderTest.GetAsync(studentId, connectionMockUnused)).Name); // Ensures that database was not used Mock.Get(connectionMockUnused).Verify(m => m.CreateCommand(), Times.Never); }

使用类夹具自动创建和处理数据库：

using Microsoft.Extensions.Configuration; using Moq; using MySql.Data.MySqlClient; using Paden.Aspects.DAL.Entities; using Paden.Aspects.Storage.MySQL; using System; using System.Data; namespace Paden.Aspects.DAL.Tests { public class DatabaseFixture : IDisposable { public MySqlConnection Connection { get; private set; } public readonly string DatabaseName = $"integration_test_{Guid.NewGuid():N}"; public DatabaseFixture() { var config = new ConfigurationBuilder().AddJsonFile("appsettings.json", false, false).Build(); var connectionString = config.GetConnectionString("DefaultConnection"); Connection = new MySqlConnection(connectionString); Connection.Open(); new MySqlCommand($"CREATE DATABASE `{DatabaseName}`; ", Connection).ExecuteNonQuery(); Connection.ChangeDatabase(DatabaseName); DbConnectionAttribute.ConnectionString = $"{connectionString}; Database={DatabaseName}"; }public void RecreateTables() { new MySqlCommand(Student.ReCreateStatement, Connection).ExecuteNonQuery(); }public IDbConnection GetConnectionFacade() { var connectionMock = Mock.Of< IDbConnection>(); Mock.Get(connectionMock).Setup(m => m.CreateCommand()).Returns(Connection.CreateCommand()).Verifiable(); Mock.Get(connectionMock).SetupGet(m => m.State).Returns(ConnectionState.Open).Verifiable(); return connectionMock; }public void Dispose() { try { new MySqlCommand($"DROP DATABASE IF EXISTS `{DatabaseName}`; ", Connection).ExecuteNonQuery(); } catch (Exception) { // ignored } Connection.Close(); } } }

只能在调试时手动检查，因为测试执行后，数据库被删除，缓存被手动失效。
.NET缓存和连接处理示例：例如，在Get_Should_Call_Database_If_Entity_Not_Dirty_Otherwise_Read_From_Cache测试执行过程中，我们可以在Redis数据库中找到以下值：

127.0.0.1:6379> KEYS * 1) "System.Threading.Tasks.Task`1[ [ Paden.Aspects.DAL.Entities.Student, Paden.Aspects.DAL, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] {Paden.Aspects.DAL.StudentRepository, Paden.Aspects.DAL, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null}.Paden.Aspects.DAL.StudentRepository.GetAsync(System.Int32 1, System.Data.IDbConnection < IGNORED>)"127.0.0.1:6379> GET "System.Threading.Tasks.Task`1[ [ Paden.Aspects.DAL.Entities.Student, Paden.Aspects.DAL, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] {Paden.Aspects.DAL.StudentRepository, Paden.Aspects.DAL, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null}.Paden.Aspects.DAL.StudentRepository.GetAsync(System.Int32 1, System.Data.IDbConnection < IGNORED>)" "{\"Id\":1,\"Name\":\"Not Marko Padjen\"}"

集成测试GetAllAsync_Should_Not_Call_Database_On_Second_Call还确保缓存的调用比原始数据源调用的性能更高。它们还生成跟踪，告诉我们执行每个调用花费了多少时间：

Database run time (ms): 73 Cache run time (ms): 9

.NET面向方面编程教程：在生产中使用前的改进此处提供的代码用于教育目的。在实际系统中使用它之前，可能会做一些改进：

• 数据库连接方面：
  • 如果需要，可以实现连接池。
  • 可以实现多个连接字符串。对此的常见用法是关系数据库集群，其中我们区分只读和读写连接类型。
• 缓存方面：
  • 如果需要，可以实现连接池。
  • 根据用例，引用类型值也可以被视为生成键的一部分。在大多数情况下，它们可能只会提供性能缺陷。

这些功能在此处没有实现，因为它们与它们所使用的系统的特定要求相关，如果没有正确实现，则不会对系统性能做出贡献。
.NET缓存和连接处理教程结论有人可能会争辩说，来自SOLID 原则的“单一职责”、“开闭”和“依赖倒置”可能用 AOP 比用 OOP 更好地实现。事实上，.NET 开发人员的目标应该是良好的代码组织，这可以通过适用于特定情况的许多工具、框架和模式来实现。
重申一下：本文中的所有代码，包括方面和集成测试，都可以在notmarkopadjen/dot-net-aspects-postsharpGitHub 存储库上找到。对于 IL 编织，我们使用了 Visual Studio 市场中的PostSharp。该代码包括使用 docker compose 使用 MariaDB 10.4 和 Redis 5.0 制作的实验室。

推荐阅读

• 

  八图H5邀请函兴起的原因
• 

  中考志愿怎么填第一批第二批 中考志愿怎么填
• 

  打完新冠疫苗要检查抗体吗
• 

  汽车发动机怠速不稳定是什么原因 发动机怠速不稳定是什么原因有哪些
• 

  笔记本|ROG Zephyrus M16 性能全面升级，兼具台式机级性能
• 

  难忘的父亲节初中作文精选3篇
• 

  酷我音
• 

  广州陶瓷餐具价格怎么样 广州陶瓷餐具哪里有卖
• 

  宜昌一次性吸纳就业补贴对象+电话 宜昌市应届毕业生补贴
• 

  2022世界杯沙特阿拉伯队阵容名单 世界杯沙特阿拉伯队首发阵容
• 

  高三优秀议论文 优秀议论文
• 

  excel如何插入word文档
• 

  志高空调遥控器怎么调制热,注意这些控制技巧
• 

  步步惊心是什么意思 步步惊心的含义
• 

  深圳北站在哪里打的 深圳北站是哪里
• 

  信用卡欠了钱5万实在没钱还会坐牢吗
• 

  真后悔养了博美 养博美犬的好处和坏处
• 

  大学期末考试试卷分析,试卷分析失分原因和改进措施
• 

  住房风水禁忌100例 房屋后面风水禁忌
• 

  美的空调不同产地,每个人都应该了解这些

• Web最佳流行布局有哪些（分析12个永恒的UI模式）
• 如何构建一个无法关闭的Android POS应用程序（）
• 如何使用Express.js路由进行基于Promise的错误处理
• Python NetworkX图形数据科学使用指南（图论）
• 如何使用Redux Toolkit和RTK查询创建React项目（）
• Win8系统中Word 2013办公软件的详细运用介绍
• win8.1专业版中如何对常用软件进行安装与删除
• Win8.1系统下安装运用0ffice 2013软件的详细办法
• 雨林木风Win8系统下如何删除电脑中的软件