c#实例化继承类，必须对被继承类的程序集做引用 .net core Redis分布式缓存客户端实现逻辑分析及示例demo 数据库笔记之索引和事务 centos 7下安装python ...

阅读量：6236 次

发布时间：2019-06-22

本文共 18226 字，大约阅读时间需要 60 分钟。

0x00 问题

类型“Model.NewModel”在未被引用的程序集中定义。必须添加对程序集“Model, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null”的引用。 C:\LF\UsingInherit\UsingInherit\Program.cs 13 13 UsingInherit\

0x01 由来

程序的大致结构如下：

<p ">

BLL下的NewBll类继承 Model中的NewModel类

然后在UsingInherit中想要实例化类NewBLL，就发生了这样的情况

添加对Model的引用之后可以编译环境

0x02 总结

　　当实例化的继承类的类，实例化的继承类，被继承的类不在同一个程序集下的时候，除了要引用继承类所在的程序集还要引用被继承类所在的程序集！

　　其实这之中是否是因为实例化继承类的时候，因为没有引用被继承类，所以无法进行被继承类的属性访问，具体的原理不是很明白，找了一圈没找到，后面学习到再来补充原理，

　　希望有了解的博友可以指点一二；

由于是基于.net-core平台，所以，我们最好是基于IDistributedCache接口来实现。ASP.NET-CORE下的官方redis客户端实现是基于StackExchange的。但是官方提供的IDistributeCache接口中的方法只是增删改查，我们可以继续拓展，增加订阅/发布，消息队列，当然这些方法必须是基于底层的StackExchange相对应的方法来做的。

如果我们要实现自己的Redis客户端，同时不使用底层的StackExchange驱动，可以派生一个继承自IDistributedCache的接口，定义自己需要的方法，例如:

public interface IServiceStackRedisCache : IDistributedCache{    void Delete
          
           (T item); // 删除    void DeleteAll
           
            (T item);    T Get
            
             (string id);    IQueryable
             
               GetAll
              
               ();    IQueryable
               
                 GetAll
                
                 (string hash, string value); IQueryable
                 
                   GetAll
                  
                   (string hash, string value, Expression
                   
                    
                     > filter); long PublishMessage(string channel, object item); void Set
                     
                      (T item); void Set
                      
                       (T item, List
                       
                         hash, List
                        
                          value, string keyName); void Set
                         
                          (T item, string hash, string value, string keyName); void SetAll
                          
                           (List
                           
                             listItems); void SetAll
                            
                             (List
                             
                               list, List
                              
                                hash, List
                               
                                 value, string keyName); void SetAll
                                
                                 (List
                                 
                                   list, string hash, string value, string keyName);}

接口有了，接下来就是继承自接口的类，我们定义一个类来实现接口里的方法，例如:

using ServiceStack.Redis;namespace Microsoft.Extensions.Caching.Redis{    public class ServiceStackRedisCache : IServiceStackRedisCache    {        private readonly IRedisClientsManager _redisManager;        private readonly ServiceStackRedisCacheOptions _options;        public ServiceStackRedisCache(IOptions
          
            optionsAccessor)        {            if (optionsAccessor == null)            {                throw new ArgumentNullException(nameof(optionsAccessor));            }            _options = optionsAccessor.Value;            var host = $"{_options.Password}@{_options.Host}:{_options.Port}";            RedisConfig.VerifyMasterConnections = false;            _redisManager = new RedisManagerPool(host);        }        #region Base        public byte[] Get(string key)        {            if (key == null)            {                throw new ArgumentNullException(nameof(key));            }            using (var client = _redisManager.GetClient() as IRedisNativeClient)            {                if (client.Exists(key) == 1)                {                    return client.Get(key);                }            }            return null;        }        public async Task
           
             GetAsync(string key)        {            return Get(key);        }        public void Set(string key, byte[] value, DistributedCacheEntryOptions options)        {            if (key == null)            {                throw new ArgumentNullException(nameof(key));            }            if (value == null)            {                throw new ArgumentNullException(nameof(value));            }            if (options == null)            {                throw new ArgumentNullException(nameof(options));            }            using (var client = _redisManager.GetClient() as IRedisNativeClient)            {                var expireInSeconds = GetExpireInSeconds(options);                if (expireInSeconds > 0)                {                    client.SetEx(key, expireInSeconds, value);                    client.SetEx(GetExpirationKey(key), expireInSeconds, Encoding.UTF8.GetBytes(expireInSeconds.ToString()));                }                else                {                    client.Set(key, value);                }            }        }        public async Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)        {            Set(key, value, options);        }        public void Refresh(string key)        {            if (key == null)            {                throw new ArgumentNullException(nameof(key));            }            using (var client = _redisManager.GetClient() as IRedisNativeClient)            {                if (client.Exists(key) == 1)                {                    var value = client.Get(key);                    if (value != null)                    {                        var expirationValue = client.Get(GetExpirationKey(key));                        if (expirationValue != null)                        {                            client.Expire(key, int.Parse(Encoding.UTF8.GetString(expirationValue)));                        }                    }                }            }        }        public async Task RefreshAsync(string key)        {            if (key == null)            {                throw new ArgumentNullException(nameof(key));            }            Refresh(key);        }        public void Remove(string key)        {            if (key == null)            {                throw new ArgumentNullException(nameof(key));            }            using (var client = _redisManager.GetClient() as IRedisNativeClient)            {                client.Del(key);            }        }        public async Task RemoveAsync(string key)        {            Remove(key);        }        private int GetExpireInSeconds(DistributedCacheEntryOptions options)        {            if (options.SlidingExpiration.HasValue)            {                return (int)options.SlidingExpiration.Value.TotalSeconds;            }            else if (options.AbsoluteExpiration.HasValue)            {                return (int)options.AbsoluteExpirationRelativeToNow.Value.TotalSeconds;            }            else            {                return 0;            }        }        private string GetExpirationKey(string key)        {            return key + $"-{nameof(DistributedCacheEntryOptions)}";        }        #endregion        #region data        public T Get
            
             (string id)        {            using (var redisClient = _redisManager.GetClient())            {                var redis = redisClient.As
             
              ();                return redis.GetById(id.ToLower());            }        }        public IQueryable
              
                GetAll
               
                () { using (var redisClient = _redisManager.GetClient()) { var redis = redisClient.As
                
                 (); return redis.GetAll().AsQueryable(); } } public IQueryable
                 
                   GetAll
                  
                   (string hash, string value, Expression
                   
                    
                     > filter) { var filtered = _redisManager.GetClient().GetAllEntriesFromHash(hash).Where(c => c.Value.Equals(value, StringComparison.CurrentCultureIgnoreCase)); var ids = filtered.Select(c => c.Key); var ret = _redisManager.GetClient().As
                     
                      ().GetByIds(ids).AsQueryable() .Where(filter); return ret; } public IQueryable
                      
                        GetAll
                       
                        (string hash, string value) { var filtered = _redisManager.GetClient().GetAllEntriesFromHash(hash).Where(c => c.Value.Equals(value, StringComparison.CurrentCultureIgnoreCase)); var ids = filtered.Select(c => c.Key); var ret = _redisManager.GetClient().As
                        
                         ().GetByIds(ids).AsQueryable(); return ret; } public void Set
                         
                          (T item) { using (var redisClient = _redisManager.GetClient()) { var redis = redisClient.As
                          
                           (); redis.Store(item); } } public void Set
                           
                            (T item, string hash, string value, string keyName) { Type t = item.GetType(); PropertyInfo prop = t.GetProperty(keyName); _redisManager.GetClient().SetEntryInHash(hash, prop.GetValue(item).ToString(), value.ToLower()); _redisManager.GetClient().As
                            
                             ().Store(item); } public void Set
                             
                              (T item, List
                              
                                hash, List
                               
                                 value, string keyName) { Type t = item.GetType(); PropertyInfo prop = t.GetProperty(keyName); for (int i = 0; i < hash.Count; i++) { _redisManager.GetClient().SetEntryInHash(hash[i], prop.GetValue(item).ToString(), value[i].ToLower()); } _redisManager.GetClient().As
                                
                                 ().Store(item); } public void SetAll
                                 
                                  (List
                                  
                                    listItems) { using (var redisClient = _redisManager.GetClient()) { var redis = redisClient.As
                                   
                                    (); redis.StoreAll(listItems); } } public void SetAll
                                    
                                     (List
                                     
                                       list, string hash, string value, string keyName) { foreach (var item in list) { Type t = item.GetType(); PropertyInfo prop = t.GetProperty(keyName); _redisManager.GetClient().SetEntryInHash(hash, prop.GetValue(item).ToString(), value.ToLower()); _redisManager.GetClient().As
                                      
                                       ().StoreAll(list); } } public void SetAll
                                       
                                        (List
                                        
                                          list, List
                                         
                                           hash, List
                                          
                                            value, string keyName) { foreach (var item in list) { Type t = item.GetType(); PropertyInfo prop = t.GetProperty(keyName); for (int i = 0; i < hash.Count; i++) { _redisManager.GetClient().SetEntryInHash(hash[i], prop.GetValue(item).ToString(), value[i].ToLower()); } _redisManager.GetClient().As
                                           
                                            ().StoreAll(list); } } public void Delete
                                            
                                             (T item) { using (var redisClient = _redisManager.GetClient()) { var redis = redisClient.As
                                             
                                              (); redis.Delete(item); } } public void DeleteAll
                                              
                                               (T item) { using (var redisClient = _redisManager.GetClient()) { var redis = redisClient.As
                                               
                                                (); redis.DeleteAll(); } } public long PublishMessage(string channel, object item) { var ret = _redisManager.GetClient().PublishMessage(channel, JsonConvert.SerializeObject(item)); return ret; } #endregion }}

在这里我们使用ServiceStack来作为底层redis驱动。在构造函数中根据配置连接redis服务器。

aps.net-core给我们提供了强大的配置功能，使用强类型的Options，一般，我们实现一个继承自IOptions<TOptions>的类。定义一些字段用来表示主机，端口等常规redis配置选项。由于IOptions接口定义了一个Value属性，我们可以通过这个属性来获取配置类的实例。

然后我们在redis客户端类中(也就是上面的ServiceStackRedisCache类)，使用构造函数注入。这样就能获取到redis的配置了。

然后我们在控制器的构造函数中注入redis客户端类实例:

private readonly IServiceStackRedisCache _cache;public ValuesController(IServiceStackRedisCache cache){    _cache = cache;}

如此，我们才能使用redis客户端去操作redis服务器。

最后就是最重要的部分了。ASP.NET-CORE框架随处可见的都是依赖注入。上面所有的程序，都是一个接口对应着一个类。所谓的依赖注入，其实就是继承自接口的类的实例化过程，但是这个过程是解耦的！DI的作用主要就是用来解耦实例化的过程。

ASP.NET-CORE框架依赖注入部分是在ConfigureService中使用的。

从上面的过程中，我们看到有两个构造函数的注入过程，因此，我们需要实现两个DI，分别是配置类的DI和redis客户端类的DI。

services.Configure(setupAction);services.Add(ServiceDescriptor.Singleton
          
           ());

整个步骤就是:

1.定义接口，用于继承IDistributedCache的接口。该接口主要封装了基本的redis操作。

2.实现接口，实现redis的各个逻辑。

3.基于IOptions<TOptions>接口实现redis的常规配置。

4.在控制器的构造函数中注入。

5.依赖注入以上接口的实例。

完整demo下载: 链接：https://pan.baidu.com/s/17g3JQxdSBGJS2YoEaBxItw 密码：h60e

索引:

在未创建索引之前，数据库里的数据是按照堆来存储的，当我们使用index关键字创建索引时，其在内存中将会变为B树来存储。默认创建的索引类型是非聚焦索引，当使用关键字clustered创建聚焦索引。一个表只能有一个聚焦索引，可以有多个非聚焦索引。

聚集索引决定了表数据的物理存储顺序，也就是说表的物理存储是根据聚集索引结构进行顺序存储的，因此一个表只能有一个聚集索引。

除了聚集索引以外的其他索引，都称之为非聚集索引，非聚集索引一般都是为了优化特定的查询效率而创建的。

索引和主键的区别：1:主键是为了标识数据库记录唯一性,不允许记录重复,且键值不能为空,主键也是一个特殊索引.2:数据表中只允许有一个主键,但是可以有多个索引.3.使用主键，数据库会自动创建主键索引(默认下是聚焦索引),也可以在非主键上创建索引,方便查询效率.

可以在主键上设置为非聚集索引，在其余的列上设置为聚集索引。

唯一索引是指在该列中不能存储重复的值。

索引就一种特殊的查询表，数据库的搜索引擎可以利用它加速对数据的检索。索引很类似与现实生活中书的目录，不需要查询整本书内容就可以找到想要的数据。缺点是它减慢了数据录入的速度，同时也增加了数据库的尺寸大小。

事务

事务就是被绑定在一起作为一个逻辑工作单元的SQL语句分组，如果任何一个语句操作失败那么整个操作就被失败，以后操作就会回滚到操作前状态，或者是上个节点。事务的四个属性:ACID。即原子性，一致性，隔离性和持久性。

脏读: update table set X = X + 10 where col = A;

update table set X = X - 10 where col = B;

假设此时执行完了第一个sql语句，此时数据库里面做了更新。用户可以看到效果，但是由于某种原因，第二个sql语句执行失败了，事务回滚此时用户就会看到原来的效果，这就是脏读。

事务隔离级别中的READ COMMITED可以解决脏读现象(使用的是共享锁)，根据其名就可以看得出:提交完读

事务还有其余的三种隔离级别，在这里就不说了。

锁的粒度有哪些？

数据库锁：锁定整个数据库，这通常发生在整个数据库模式改变的时候。

表锁：锁定整个表，这包含了与该表相关联的所有数据相关的对象，包括实际的数据行(每一行)以及与该表相关联的所有索引中的键。

区段锁：锁定整个区段，因为一个区段由8页组成，所以区段锁定是指锁定控制了区段、控制了该区段内8个数据或索引页以及这8页中的所有数据行。

页锁：锁定该页中的所有数据或索引键。

行或行标识符：虽然从技术上将，锁是放在行标识符上的，但是本质上，它锁定了整个数据行。

每次在centos上安装python 3都需要重新查资料，这次索性自己记下笔记。

首先安装gcc

yum -y install gcc

yum install zlib-devel

./configure --prefix=/usr/local

make

make altinstall

建立软链接

cd/usr/bin

mv python python.backup

ln -s /usr/local/bin/python3.6 /usr/bin/python

ln -s /usr/local/bin/python3.6 /usr/bin/python3

其实到这里就安装完成了python 3，但是如果我们在使用pip安装框架的时候，可能会给我们安装到python 2.7的目录下、

更改yum脚本的python依赖(不知道Ubuntu下的apt工具是不是依赖于python，但是在centos下的yum的确是需要依赖Python)

# cd /usr/bin

# ls yum*

yum yum-config-manager yum-debug-restore yum-groups-manager

yum-builddep yum-debug-dump yumdownloader

更改以上文件头为

#!/usr/bin/python 改为 #!/usr/bin/python2

Json.NET

Json.Net 是一个读写Json效率比较高的.Net框架.Json.Net 使得在.Net环境下使用Json更加简单。通过Linq To JSON可以快速的读写Json，通过JsonSerializer可以序列化你的.Net对象。让你轻松实现.Net中所有类型(对象,基本数据类型等)和Json的转换。

Math.NET

Math.NET的目标是为提供一款自身包含清晰框架的符号运算和数学运算/科学运算，它是C#开发的开源类库。Math.NET含了一个支持线性代数的解析器，分析复杂微分，解方程等等功能。

Faker.Net

开发的时候是不是为测试数据烦恼？Faker.Net可以非常方便帮你生成大批量测试数据。例如人员表里面的姓名、性别什么的。

Html Agility Pack

Html Agility Pack 是CodePlex 上的一个开源项目。它提供了标准的DOM API 和XPath 导航--即使 HTML 不是适当的格式！HTML Agility Pack 搭配 ScrapySharp，彻底解除Html解析的痛苦。

NCrawler

NCrawler是一款国外的开源网络爬虫软件,遵循LGPL许可协议。其HTML处理使用的是htmlagilitypack开源库,采用xpath的方式处理定位网页元素,十分方便。

SuperWebSocket

SuperWebSocket是基于.NET开源Socket框架SuperSocket开发的, SuperSocket所支持的大部分功能在SuperWebSocket中得到了继承。用户可通过SuperWebSocket来快速的构建可靠的，高性能的websocket服务器端应用程序。

SuperSocket

SuperSocket 是一个轻量级的可扩展的 Socket 开发框架，可用来构建一个服务器端 Socket 程序，而无需了解如何使用 Socket，如何维护Socket连接，Socket是如何工作的。该项目使用纯 C# 开发，易于扩展和集成到已有的项目。只要你的已有系统是使用.NET开发的，你都能够使用 SuperSocket来轻易的开发出你需要的Socket应用程序来集成到你的现有系统之中。

Quartz.NET

Quartz.NET 是一个开源的作业调度框架，是 OpenSymphony 的 Quartz API的.NET移植，它用C#写成，可用于winform和asp.net应用中。它提供了巨大的灵活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，支持cron-like表达式等等。

Lucene.Net

Lucene.net是Lucene的.net移植版本，是一个开源的全文检索引擎开发包，即它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎。开发人员可以基于Lucene.net实现全文检索的功能。

HttpLib

一个基于C#语言的http协议的类库，Httplib让异步交互处理数据更容易了。类库的方法包括：上传文件到服务器，获取页面数据等等。

Smart Thread Pool

智能线程池，用SmartThreadPool可以简单就实现支持多线程的程序，由线程池来管理线程，可以减少死锁的出现。SmartThreadPool还支持简单的生产者-消费者模式，当不需要对任务进行持久化时，还是很好用的。

DocX

DocX是一个用来操作word的轻量级的类库。借助DocX，开发人员可以在不需要安装Microsoft Word的情况下操纵word2007/2010文件。

NPOI

NPOI 是 POI 项目的 .NET 版本。POI是一个开源的Java读写Excel、WORD等微软OLE2组件文档的项目。使用 NPOI 你就可以在没有安装 Office 或者相应环境的机器上对 WORD/EXCEL 文档进行读写。NPOI是构建在POI 3.x版本之上的，它可以在没有安装Office的情况下对Word/Excel文档进行读写操作。

PDFsharp

PDFsharp 是可以轻松地在 .NET 语言中创建PDF文档的开放源码库。它使用相同的绘制程序来创建 PDF 文档，在屏幕上显示，以及输出到打印机。可以修改、合并、拆分已经存在的 PDF 文件，支持透明图像。

Dapper

Dapper 是一个轻型的ORM类。代码就一个 SqlMapper.cs文件，编译后就40K的一个很小的Dll.Dapper很快。Dapper的速度接近与IDataReader，取列表的数据超过了DataTable。Dapper支持Mysql,SqlLite,Mssql2000,Mssql2005,Oracle等一系列的数据库，当然如果你知道原理也可以让它支持Mongo db。话说，这个ORM，博主自己也一直在使用，确实十分强悍，至少在性能方面，恐怕.NET里面的大多数ORM只能是望其项背了。

NHibernate

NHibernate是现在开发人员用的较多的一个ORM。NHibernate是一个面向.NET环境的对象/关系数据库映射工具。对象/关系数据库映射（object/relational mapping，ORM）这个术语表示一种技术，用来把对象模型表示的对象映射到基于SQL的关系模型数据结构中去。

log4net

log4net库是Apache log4j框架在Microsoft .NET平台的实现，是一个帮助程序员将日志信息输出到各种目标（控制台、文件、数据库等）的工具。

SharpSerializer

SharpSerializer是一个开源XML和二进制序列化器。SharpSerializer可以序列化Xml和自己的二进制格式,还可以序列化Json等其他文本格式或其他数据加密,压缩,优化等二进制流。

XProxy

XProxy是一个支持插件的基础代理程序集。通过编写简单的插件程序，你将能开发各种各样的代理程序。

XProxy是一个支持插件开发的数据交换机，可以编写插件对中转数据进行处理。内置有NAT插件、加解密插件、反向代理、直接代理、间接代理等插件。

nopCommerce

nopcommerce 是国外的一个高质量的开源b2c 网站系统，基于EntityFramework4.0和MVC3.0，使用Razor模板引擎，有很强的插件机制，包括支付配送功能都是通过插件来实现的，基于xml的多语言版本，非常灵活的语言切换功能，包括在后台都能同时编辑产品的中英文属性，非常适合做外贸，优秀超前的程序架构，性能也非常强大，自定义的产品名称和分类又有很好的seo优化。综合能力远远高于国内的一些程序架构糟糕的.net商城程序，是二次开发和大型b2c架构的首选。3.0开始支持多店。

Enterprise Library

Enterprise Library for .Net Framework 3.5 – EntLib v4.1 是patterns & practices 小组为.NET Framework 3.5 开发一套企业库，目前最新版本为v5.0，支持.NET Framework 4.0，共包括9个Application Block，包括数据访问（Data Access Application Block）、异常管理（Exception Handling Application Block）、数据验证（Validation Application Block）等等，对企业应用开发非常有帮助，也非常实用。

Autofac

Autofac是一款非常优秀的IOC框架，比较于其他的IOC框架，如Spring.NET，等等之类的，它非常的轻量级且性能上也很卓越。

AutoMapper

AutoMapper是一个.NET的对象映射工具。主要用于领域对象与DTO之间的转换、数据库查询结果映射至实体对象。

7-Zip

7-Zip 是一款号称有着现今最高压缩比的压缩软件，它不仅支持独有的 7z 文件格式，而且还支持各种其它压缩文件格式，其中包括 ZIP, RAR, CAB, GZIP, BZIP2和 TAR 等等。此软件压缩的压缩比要比普通 ZIP 文件高 30-50% ，因此，它可以把 Zip 格式的文件再压缩 2-10% 。

.Net PDF 类库

PDFsharp是一款可以让.NET框架支持的任何语言很容易的创建PDF文件的类库。

FO PDF 是一款C#编写类似于ASP.NET服务器控件的控件。它接受DataTable 和一些其它参数来创建XSL FO，并使用NFOP (Apache FOP Port in J#) PDF Formatter来绘制一个类似PDF Report 的DataGrid 。今后将会增加更多的标签来可以生成XSL FO 。

Report.NET 开源类库包含了生成精确PDF文档的类。它是.NET平台下的C#编写的，可以帮助你创建简单的灵活的PDF文件。你可以从任何ADO.NET的 DataSet取得数据来创建PDF文档。ASP.NET可以用Report.NET来创建动态的PDF响应页面。

SharpPDF是可以用来简单的创建PDF文件的C#类库。它创建的文件百分白兼容PDF格式。

iTextSharp是一款开源的PDF操作类库，使用它可以快速的创建PDF文件。是一个关于 iTextSharp的中文Blog。

工作流

Workflow.Net是使用微软.Net技术基于wmfc标准的创建工作流引擎。

NetBPM是JBpm移植到.net平台下的一款开源工作流软件。NetBpm可以很容易和.Net应用程序集成在一起,可以创建,执行和管理工作流程序。

Bpm Tool支持将业务模型转换成软件模型。业务开发人员可以使用模型驱动的方法设计，实现，执行和跟踪业务流程。因此开发人员能够更容易的关注业务逻辑的变化。

持久层框架

NHibernate是一个面向.NET环境的针对关系型数据库的对象持久化类库。

NHibernate来源于非常优秀的基于Java的Hibernate关系型持久化工具。 NHibernate从数据库底层来持久化你的.Net对象到关系型数据库。NHibernate为你处理这些，你不用自己写SQL去数据库存取对象。你的代码仅仅和对象关联，NHibernat自动产生SQL语句，并确保对象提交到正确的表和字段中去.大量减少开发时人工使用SQL和ADO.NET处理数据的时间. NHibernate可以帮助你消除或者包装那些针对特定数据库的SQL代码，并且帮你把结果集从表格式的表示形式转换到一系列的对象去。因此对于那些在基于.NET的中间层的应用中，它们实现面向对象的业务模型和商业逻辑的应用，NHibernate是最有用的。

FileHelpers Library是一款C#编写的开源 .NET 类库。它使用简单，很容易就可以从固定长度文件或界定记录(CSV)读/写数据。它也支持从不同的数据存储格式(Excel, Access, SqlServer)导入/导出数据。

Websharp是国人开源的一款开源持久层框架，它的目标是设计一个基于.Net的通用的应用软件系统的框架，以简化基于.Net平台的企业应用软件的开发。目前，Websharp关注于企业应用软件的以下几个方面：

1、数据库访问

2、 O/R 映射

3、 AOP

4、分布式访问

ObjectBroker是.NET平台下的一款开源O/R映射框架。它支持对象缓存，1:1, 1:n 和 m:n的关联映射等特性。

Gentle.NET是一款开源的与关系数据库（RDBMS）无关的对象持久层框架，可以自动生成SQL和对象结构。它拥有一个SQL工厂用来创建自定义查询、DataView构建助手和卓越的性能和完善的文档。

Ubik是C# 2.0下的ORM持久层框架,当前是WinForms应用程序开发提供的.它支持OPath的子集而可以进行面向对象查询,且包含一个网络事件系统.

NDal是一个数据提取层（DAL）框架，它可以运行在.NET和Mono环境下。

Persist.NET是C#编写的一款完整的持久层框架。

ObjectBroker是.NET平台下的数据库对象/关系映射(O/R Mapping)框架。