fireasy 3.0

　　fireasy 3.0 在 2.0 的基础上进行了重构，抛弃了 .Net Framework 时代的一些思想和模式，使之完全与 .Net Core 相匹配。

　　目前 3.0 还处于开发阶段，到正式发布还需要一段时间，感谢你的关注与支持。

一、目标框架

　　目前目标框架为 net462、netstandard2.0、netstandard2.1 和 net6.0。

二、部分程序集

程序集	说明
Fireasy.Common	公共类库，提供依赖注入、动态代理、代码编译、静态编译、反射缓存等等，以及各类基础接口的定义
Fireasy.Composition	提供 MEF 的集成
Fireasy.Common.Analyzers	Fireasy.Common 的语法分析类库，提供动态代理(AOP)生成、依赖服务发现与注入
Fireasy.CodeCompiler.VisualBasic	提供代码编译对 VB.NET 语言支持
Fireasy.Configuration	配置相关类库，提供配置的解析和配置
Fireasy.Data.Abstractions	数据库抽象类库，定义数据库层面的各类接口、适配器接口(语法、架构、批量插入、记录包装等等)
Fireasy.Data	数据库实现类库，对抽象类库的实现，提供SqlServer、MySql、SQLite、Firebird、PostgreSql、Oracle、达梦、人大金仓和神通数据库的适配
Fireasy.Data.Configuration	数据库配置相关类库，提供数据库适配器及连接字符串的配置解析
Fireasy.Data.OleDb	OleDb 适配
Fireasy.Data.Analyzers	Fireasy.Data 的语法分析类库，提供 BulkCopy 适配器的生成
Fireasy.Data.Entity.Abstractions	实体框架的抽象类库，定义 EntityContext、实体仓储等等
Fireasy.Data.Entity	实体框架的具体实现，提供SqlServer、MySql、SQLite、Firebird、PostgreSql、Oracle、达梦、人大金仓和神通数据库的 linq 查询解析
Fireasy.ObjectMapping.Abstractions	对象映射抽象类库，定义对象映射的接口
Fireasy.AutoMapper	对象映射之 AutoMapper 适配
Fireasy.Mapster	对象映射之 Mapster 适配

三、开始使用

　　要使用 Fireasy 相关的组件，必须在 IServiceCollection 对象上使用扩展方法 AddFireasy()。

1、Winform

static class Program
{
    public static IServiceProvider ServiceProvider { get; set; }

    [STAThread]
    static void Main(params string[] args)
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
            
        var services = new ServiceCollection();

        //必不可少
        services.AddFireasy();

        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
            .Build();

        services.AddSingleton<IConfiguration>(configuration);
        ServiceProvider = services.BuildServiceProvider();

        Application.Run(new frmMain());
    }
}

2、Console

static class Program
{
    public static IServiceProvider ServiceProvider { get; set; }

    static void Main(params string[] args)
    {
        var services = new ServiceCollection();

        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
            .Build();

        //必不可少
        services.AddFireasy();

        services.AddSingleton<IConfiguration>(configuration);
        ServiceProvider = services.BuildServiceProvider();

        Console.ReadKey();
    }
}

3、ASP.NET Core

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        //必不可少
        services.AddFireasy();
    }
}

四、公共类库

1、服务发现

使用 Predicate 对程序集进行过滤

private void Test()
{
    var services = new ServiceCollection();

    //只遍列 Fireasy.Common.Tests
    services.AddFireasy(opt => opt.DiscoverOptions.AssemblyFilterPredicates.Add(s => !s.FullName!.StartsWith("Fireasy.Common.Tests")));
}

使用 IAssemblyFilter 对程序集进行过滤

private void Test()
{
    var services = new ServiceCollection();
    services.AddFireasy(opt => opt.DiscoverOptions.AssemblyFilters.Add(new MyAssemblyFilter()));

    private class MyAssemblyFilter : IAssemblyFilter
    {
        public bool IsFilter(Assembly assembly)
        {
            //只遍列 Fireasy.Common.Tests
            return !assembly.FullName!.StartsWith("Fireasy.Common.Tests");
        }
    }
}

列出遍列过的程序集

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    var discoverer = serviceProvider.GetRequiredService<IServiceDiscoverer>();

    foreach (var assembly in discoverer.Assemblies)
    {
        Console.WriteLine(assembly.FullName);
    }
}

列出注册的所有服务描述

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    var discoverer = serviceProvider.GetRequiredService<IServiceDiscoverer>();

    foreach (var desc in discoverer.Descriptors)
    {
        Console.WriteLine($"{desc.ServiceType} -> {desc.ImplementationType}");
    }
}

发现 ISingletonService、ITransientService 或 IScopedService 三种生命周期的服务

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    var service1 = serviceProvider.GetService<ITestSingletonService>();
    var service2 = serviceProvider.GetService<ITestSingletonService>();

    Assert.IsNotNull(service1);
    Assert.IsNotNull(service2);

    //两对象的id应相等
    Assert.AreEqual(service1.Id, service2.Id);

    Guid id1, id2;

    //作用域1
    using (var scope1 = serviceProvider.CreateScope())
    {
        var service1 = scope1.ServiceProvider.GetService<ITestScopedService>();
        var service2 = scope1.ServiceProvider.GetService<ITestScopedService>();

        Assert.IsNotNull(service1);
        Assert.IsNotNull(service2);

        //两对象的id应相等
        Assert.AreEqual(service1.Id, service2.Id);

        id1 = service1.Id;
    }

    //作用域2
    using (var scope2 = serviceProvider.CreateScope())
    {
        var service1 = scope2.ServiceProvider.GetService<ITestScopedService>();
        var service2 = scope2.ServiceProvider.GetService<ITestScopedService>();

        Assert.IsNotNull(service1);
        Assert.IsNotNull(service2);

        //两对象的id应相等
        Assert.AreEqual(service1.Id, service2.Id);

        id2 = service1.Id;
    }

    //两次scoped的id应不相等
    Assert.AreNotEqual(id1, id2);
}

public interface ITestSingletonService
{
    Guid Id { get; }

    void Test();
}

public class TestSingletonServiceImpl : ITestSingletonService, ISingletonService
{
    public TestSingletonServiceImpl()
    {
        Id = Guid.NewGuid();
    }

    public Guid Id { get; }

    public void Test() => Console.WriteLine("Hello TestSingletonService!");
}

public interface ITestScopedService
{
    Guid Id { get; }

    void Test();
}

public class TestScopedServiceImpl : ITestScopedService, IScopedService
{
    public TestScopedServiceImpl()
    {
        Id = Guid.NewGuid();
    }

    public Guid Id { get; }

    public void Test() => Console.WriteLine("Hello TestScopedService!");
}

使用服务部署器，自动注册服务

[assembly: ServicesDeploy(typeof(DataServicesDeployer))]

public class DataServicesDeployer : IServicesDeployer
{
    void IServicesDeployer.Configure(IServiceCollection services)
    {
        services.AddSingleton<IProviderManager, DefaultProviderManager>();
        services.AddSingleton<IDatabaseFactory, DefaultDatabaseFactory>();
        services.AddSingleton<IRowMapperFactory, DefaultRowMapperFactory>();
        services.AddSingleton<IValueConvertManager, DefaultValueConvertManager>();
        services.AddScoped<IDatabase>(sp => sp.GetRequiredService<IDatabaseFactory>().CreateDatabase());
    }
}

2、动态代理

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    var proxyFactory = serviceProvider.GetService<IDynamicProxyFactory>();
    var proxyObj = proxyFactory!.BuildProxy<TestProxy>();

    var value = await proxyObj!.GetStringAsync();
    Assert.AreEqual("hello world", value);
}

public class TestProxy
{
    [Intercept(typeof(GetStringAsyncInterceptor))]
    public virtual Task<string> GetStringAsync()
    {
        return Task.FromResult(string.Empty);
    }
}

public class GetStringAsyncInterceptor : IAsyncInterceptor
{
    public ValueTask InitializeAsync(InterceptContext context)
    {
        return ValueTask.CompletedTask;
    }

    public ValueTask InterceptAsync(InterceptCallInfo info)
    {
        info.ReturnValue = "hello world";

        return ValueTask.CompletedTask;
    }
}

3、反射缓存

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    var reflectionFactory = serviceProvider.GetService<IReflectionFactory>();

    var obj = new OneObject();
    var property = typeof(OneObject).GetTypeInfo().GetDeclaredProperty(nameof(OneObject.Value));
    var accessor = reflectionFactory!.GetAccessor<int>(property!);

    accessor.SetValue(obj, 100);
    var value = accessor.GetValue(obj);

    Assert.AreEqual(100, value);
}

private class OneObject
{
    public int Value { get; set; }
}

4、动态编译

private void Test()
{
    /*
    public class MyClass<T, TS> where T : MyBaseClass
    {
        public MyClass(TS ts)
        {
        }
        public T Hello<TV>(T t, TV tv)
        {
            Console.WriteLine(tv);
            return t;
        }
    }
    */

    var gt = new GtpType("T").SetBaseTypeConstraint(typeof(MyBaseClass));

    var assemblyBuilder = new DynamicAssemblyBuilder("MyAssembly");
    var typeBuilder = assemblyBuilder.DefineType("MyClass");

    //定义泛型类型参数
    typeBuilder.DefineGenericParameters(gt, new GtpType("TS"));

    //定义构造函数
    typeBuilder.DefineConstructor(new Type[] { new GtpType("TS") });

    //定义一个泛型方法，TV不在类中定义，所以属于方法的泛型类型参数
    var methodBuilder = typeBuilder.DefineMethod("Hello", gt, new Type[] { gt, new GtpType("TV") }, ilCoding: c =>
    {
        c.Emitter
        .ldarg_2.call(typeof(Console).GetMethod("WriteLine", new[] { typeof(object) }))
        .ldarg_1.ret();
    });

    var type = typeBuilder.CreateType().MakeGenericType(typeof(MyBaseClass), typeof(int));
    var obj = Activator.CreateInstance(type, 100);

    var method = type.GetMethod("Hello").MakeGenericMethod(typeof(string));
    var value = method.Invoke(obj, new object[] { new MyBaseClass(), "world" });

    Assert.IsInstanceOfType(value, typeof(MyBaseClass));
}

5、代码编译

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    var source = @"
public class TestClass
{
    public string Hello(string str)
    {
        return str;
    }
}";

    var codeCompilerManager = serviceProvider.GetService<ICodeCompilerManager>();
    var codeCompiler = codeCompilerManager!.CreateCompiler("csharp");

    var opt = new ConfigureOptions();
    opt.Assemblies.Add("System.Core.dll");

    var assembly = codeCompiler!.CompileAssembly(source, opt);

    var type = assembly!.GetType("TestClass");

    Assert.IsNotNull(type);
}

　　要使用 VB.NET 语言只需要在项目中引用 Fireasy.CodeCompiler.VisualBasic 即可。

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    var source = @"
Public Class A
    Public Function Hello(ByVal str As String) As String
        Return str
    End Function
End Class";

    var codeCompilerManager = serviceProvider.GetService<ICodeCompilerManager>();
    var codeCompiler = codeCompilerManager!.CreateCompiler("vb");

    var assembly = codeCompiler!.CompileAssembly(source);

    var type = assembly!.GetType("A");

    Assert.IsNotNull(type);
}

6、对象序列化

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    var obj = new TestObject { Name = "fireasy", Address = "kunming", Age = 30 };

    var serializer = serviceProvider.GetRequiredService<IJsonSerializer>();

    //在明确提供方的情况下，可以指定 JsonSerializerOptions，但是更换提供方后，相应的也要切换
    var json = serializer.Serialize(obj, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase, WriteIndented = true });

    Console.WriteLine(json);
}

　　除了 Json 序列化，还提供了二进制序列化 IBinarySerializer，但目前还没有适配。

7、MEF 服务导出

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();

    var configuration = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
        .Build();

    services.AddSingleton<IConfiguration>(configuration);

    var serviceProvider = services.BuildServiceProvider();

    //这是一个扩展方法 GetExportedServices
    var exportedServices = serviceProvider.GetExportedServices<IExportService>();
    Assert.AreEqual(2, exportedServices.Count());
}

public interface IExportService
{
}

[Export(typeof(IExportService))]
public class ExportService1 : IExportService
{
}

[Export(typeof(IExportService))]
public class ExportService2 : IExportService
{
}

　　使用配置进行匹配，assembly 匹配程序集名称，pattern 匹配文件名称。

{
  "fireasy": {
    "imports": {
      "settings": {
        "usePattern": {
          "pattern": "Fireasy.*.dll"
        },
        "useAssembly": {
          "assembly": "Fireasy.Composition.Tests"
        }
      }
    }
  }
}

8、动态扩展对象

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    //如果不获取 DynamicDescriptionSupporter 则该测试将失败
    var supporter = serviceProvider.GetService<DynamicDescriptionSupporter>();

    var obj = (IDictionary<string, object>)new DynamicExpandoObject();
    obj.Add("Name", "fireasy");

    var property = TypeDescriptor.GetProperties(obj).Find("Name", false);

    Assert.IsNotNull(property);

    var value = property.GetValue(obj);

    Assert.AreEqual("fireasy", value);
}

五、数据库类库

　　IProvider 定义了一套标准，不同的数据库类型有不同的实现。另外，每种数据库还应实现以下插件服务接口：

ISyntaxProvider 语法插件服务
ISchemaProvider 架构插件服务
IBatcherProvider 批量插入插件服务
IRecordWrapper 记录包装器插件服务
IGeneratorProvider 标识生成器插件服务

　　目前已经提供了 SqlServer、MySql、SQLite、Firebird、PostgreSql、Oracle、Dameng(达梦)、Kingbase(人大金仓)和ShenTong(神通)数据库，以及 OleDb 驱动。

　　Fireasy.Data 中未引用相关的 Nuget 包，只要在项目中直接安装 Nuget 包即可。

数据库类型	Nuget 包
SqlServer	Microsoft.Data.SqlClient、System.Data.SqlClient
MySql	MySql.Data、MySqlConnector
SQLite	System.Data.SQLite、Microsoft.Data.Sqlite
Firebird	FirebirdSql.Data.FirebirdClient
PostgreSql	Npgsql
Oracle	Oracle.ManagedDataAccess
Dameng	DmProvider
Kingbase	Kdbndp
ShenTong	Oscar.Data.SqlClient
OleDb	System.Data.OleDb

1、列举数据库提供者(比如SqlServer、MySql等等)

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();
    var serviceProvider = services.BuildServiceProvider();

    var manager = serviceProvider.GetRequiredService<IProviderManager>();

    var descriptors = manager.GetSupportedProviders();

    foreach (var item in descriptors)
    {
        Console.WriteLine($"{item.Alais} {item.Description}");
    }
}

2、更换提供者或插件服务

private void Test()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();

    //用于替换 SqlServerProvider 中的 DbProviderFactory
    builder.ConfigureData(s => s.AddProivderFactory<SqlServerProvider>(System.Data.SqlClient.SqlClientFactory.Instance));

    //用于替换数据库提供者，SqlServer 不再使用 SqlServerProvider，而是使用自定义的 TestProvider
    //sqlserver使用2012以下版本的语法
    builder.ConfigureData(s => s.AddProvider<TestProvider>("SqlServer").AddProivderService<SqlServerProvider, SqlServerSyntaxLessThan2012>());

    var serviceProvider = services.BuildServiceProvider();
}

3、使用配置文件配置连接字符串

{
  "fireasy": {
    "dataInstances": {
      "default": "sqlserver",
      "settings": {
        "sqlite": {
          "providerType": "SQLite",
          "connectionString": "Data source=|appdir|..\\..\\..\\..\\..\\..\\db\\Northwind.db3;Pooling=True"
        },
        "sqlserver": {
          "providerType": "SqlServer",
          "connectionString": "Data Source=(LocalDB)\\MSSQLLocalDB;AttachDbFilename=|appdir|..\\..\\..\\..\\..\\..\\db\\Northwind.mdf;Integrated Security=True;Connect Timeout=30"
        },
        "oracle": {
          "providerType": "Oracle",
          "connectionString": "Data Source=localhost/orcl;User ID=c##test;Password=Faib1234"
        },
        "mysql": {
          "providerType": "MySql",
          "connectionString": "Data Source=localhost;database=northwind;User Id=root;password=faib;pooling=true;charset=utf8"
        },
        "oledb_access": {
          "providerType": "OleDb",
          "connectionString": "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=|appdir|..\\..\\..\\..\\..\\..\\db\\Northwind.accdb;Persist Security Info=False;"
        },
        "testdb": {
          "providerType": "myprovider",
          "connectionString": "Data Source=localhost;database=northwind;User Id=root;password=faib;pooling=true;charset=utf8"
        }
      }
    },
    "dataProviders": {
      "settings": {
        "myprovider": {
          "type": "Fireasy.Data.Tests.TestProvider, Fireasy.Data.Tests"
        }
      }
    }
  }
}

4、创建数据库实例

private async Task TestAsync()
{
    var services = new ServiceCollection();
    var builder = services.AddFireasy();

    var configuration = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
        .Build();

    services.AddSingleton<IConfiguration>(configuration);

    var serviceProvider = services.BuildServiceProvider();

    var factory = serviceProvider.GetRequiredService<IDatabaseFactory>();

    //指定提供者及连接串
    await using var database = factory.CreateDatabase<MySqlProvider>("Data Source=localhost;database=northwind;User Id=root;password=faib;pooling=true;charset=utf8");
    Assert.IsNotNull(database);

    //指定数据库配置名称
    await using var database = factory.CreateDatabase("oledb_access");
    Assert.IsNotNull(database);
}

5、数据库增删改查

private async Task TestAsync()
{
    //略去 serviceProvider 的创建，见第4节

    var factory = serviceProvider.GetRequiredService<IDatabaseFactory>();

    await using var database = factory.CreateDatabase("mysql");

    //查询列表，带分页
    var pager = new DataPager(10, 1);
    var list = await database.ExecuteEnumerableAsync<Customers>($"select * from customers order by CustomerID", pager);

    //单一字段
    var value = await database.ExecuteScalarAsync<byte[]>($"select Picture from categories where CategoryID=1");

    //更新字段，参数化
    var parameters = new ParameterCollection();
    parameters.Add("customerId", "ALFKI");
    parameters.Add("country", "Germany");
    var ret = await database.ExecuteNonQueryAsync($"update customers set Country=@country where CustomerID=@customerId", parameters: parameters);
}

6、使用事务

private async Task TestAsync()
{
    //略去 serviceProvider 的创建，见第4节

    var factory = serviceProvider.GetRequiredService<IDatabaseFactory>();

    await using var database = factory.CreateDatabase("mysql");
    await database.BeginTransactionAsync();

    try
    {
        await database.ExecuteNonQueryAsync($"delete from customers");
        //表不存在，将抛错
        await database.ExecuteNonQueryAsync($"delete from testtable");

        await database.CommitTransactionAsync();
    }
    catch (Exception)
    {
        await database.RollbackTransactionAsync();
    }
}

7、获取数据库架构

private async Task TestAsync()
{
    //略去 serviceProvider 的创建，见第4节

    var factory = ServiceProvider.GetRequiredService<IDatabaseFactory>();

    await using var database = factory.CreateDatabase("mysql");
    var schema = database.GetService<ISchemaProvider>();
    var syntax = database.GetService<ISyntaxProvider>();

    //获取表
    var tables = await schema!.GetSchemasAsync<Data.Schema.Table>(database).ToListAsync();

    var names = new[]
    {
        syntax!.ToggleCase("products"),
        syntax!.ToggleCase("customers"),
        syntax!.ToggleCase("orders")
    };

    //多表匹配
    tables = await schema!.GetSchemasAsync<Data.Schema.Table>(database, s => names.Contains(s.Name)).ToListAsync();

    //获取字段
    var columns = await schema!.GetSchemasAsync<Data.Schema.Column>(database, s => s.TableName == syntax!.ToggleCase("products") && s.Name == "ProductID").ToListAsync();

    //获取外键
    var foreignKeys = await schema!.GetSchemasAsync<Data.Schema.ForeignKey>(database, s => s.TableName.Equals(syntax!.ToggleCase("orders"))).ToListAsync();
}

8、批量插入

private async Task TestAsync()
{
    //略去 serviceProvider 的创建，见第4节

    var factory = ServiceProvider.GetRequiredService<IDatabaseFactory>();

    await using var database = factory.CreateDatabase("mysql");
    var batcher = database.GetService<IBatcherProvider>();

    var list = new List<BatcherData>();

    for (var i = 0; i < 100000; i++)
    {
        list.Add(new BatcherData(i + 1, "Name" + i, "Address" + i));
    }

    await batcher.InsertAsync(database, list, "batchers");
}

private class BatcherData
{
    public BatcherData(int id, string name, string address)
    {
        Id = id;
        Name = name;
        Address = address;
    }

    public int Id { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
}

技术揭秘系列文章

Fireasy3 揭秘 -- 依赖注入与服务发现
Fireasy3 揭秘 -- 自动服务部署
Fireasy3 揭秘 -- 使用 SourceGeneraor 改进服务发现
Fireasy3 揭秘 -- 使用 SourceGeneraor 实现动态代理(AOP)
Fireasy3 揭秘 -- 使用 Emit 构建程序集
Fireasy3 揭秘 -- 代码编译器及适配器
Fireasy3 揭秘 -- 使用缓存提高反射性能
Fireasy3 揭秘 -- 动态类型及扩展支持
Fireasy3 揭秘 -- 线程数据共享的实现
Fireasy3 揭秘 -- 配置管理及解析处理
Fireasy3 揭秘 -- 数据库适配器
Fireasy3 揭秘 -- 解决数据库之间的语法差异
Fireasy3 揭秘 -- 获取数据库的架构信息
Fireasy3 揭秘 -- 数据批量插入的实现
Fireasy3 揭秘 -- 使用包装器对数据读取进行兼容
Fireasy3 揭秘 -- 数据行映射器
Fireasy3 揭秘 -- 数据转换器的实现
Fireasy3 揭秘 -- 通用序列生成器和雪花生成器的实现
Fireasy3 揭秘 -- 命令拦截器的实现
Fireasy3 揭秘 -- 数据库主从同步的实现
Fireasy3 揭秘 -- 大数据分页的策略
Fireasy3 揭秘 -- 数据按需更新及生成实体代理类
Fireasy3 揭秘 -- 用对象池技术管理上下文
Fireasy3 揭秘 -- Lambda 表达式解析的原理
Fireasy3 揭秘 -- 扩展选择的实现
Fireasy3 揭秘 -- 按需加载与惰性加载的区别与实现
Fireasy3 揭秘 -- 自定义函数的解析与绑定
Fireasy3 揭秘 -- 与 MongoDB 进行适配
Fireasy3 揭秘 -- 模块化的实现原理

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

README.md

README.md

fireasy 3.0

一、目标框架

二、部分程序集

三、开始使用

1、Winform

2、Console

3、ASP.NET Core

四、公共类库

1、服务发现

2、动态代理

3、反射缓存

4、动态编译

5、代码编译

6、对象序列化

7、MEF 服务导出

8、动态扩展对象

五、数据库类库

1、列举数据库提供者(比如SqlServer、MySql等等)

2、更换提供者或插件服务

3、使用配置文件配置连接字符串

4、创建数据库实例

5、数据库增删改查

6、使用事务

7、获取数据库架构

8、批量插入

技术揭秘系列文章

Files

README.md

Latest commit

History

README.md

File metadata and controls

fireasy 3.0

一、目标框架

二、部分程序集

三、开始使用

1、Winform

2、Console

3、ASP.NET Core

四、公共类库

1、服务发现

2、动态代理

3、反射缓存

4、动态编译

5、代码编译

6、对象序列化

7、MEF 服务导出

8、动态扩展对象

五、数据库类库

1、列举数据库提供者(比如SqlServer、MySql等等)

2、更换提供者或插件服务

3、使用配置文件配置连接字符串

4、创建数据库实例

5、数据库增删改查

6、使用事务

7、获取数据库架构

8、批量插入

技术揭秘系列文章