c#实例化继承类，必须对被继承类的程序集做引用 .net core Redis分布式缓存客户端实现逻辑分析及示例demo 数据库笔记之索引和事务 centos 7下安装python 3.6笔记 你大波哥~ C#开源框架（转载） JSON C＃ Class Generator ---由json字符串生成C＃实体类的工具

c#实例化继承类，必须对被继承类的程序集做引用

 

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 总结

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

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

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

 

 

22.net core Redis分布式缓存客户端实现逻辑分析及示例demo

 

由于是基于.net-core平台，所以，我们最好是基于IDistributedCache接口来实现。ASP.NET-CORE下的官方redis客户端实现是基于StackExchange的。但是官方提供的IDistributeCache接口中的方法只是增删改查，我们可以继续拓展，增加订阅/发布，消息队列，当然这些方法必须是基于底层的StackExchange相对应的方法来做的。
如果我们要实现自己的Redis客户端，同时不使用底层的StackExchange驱动，可以派生一个继承自IDistributedCache的接口，定义自己需要的方法，例如:

public interface IServiceStackRedisCache : IDistributedCache
{
    void Delete<T>(T item); // 删除
    void DeleteAll<T>(T item);
    T Get<T>(string id);
    IQueryable<T> GetAll<T>();
    IQueryable<T> GetAll<T>(string hash, string value);
    IQueryable<T> GetAll<T>(string hash, string value, Expression<Func<T, bool>> filter);
    long PublishMessage(string channel, object item);
    void Set<T>(T item);
    void Set<T>(T item, List<string> hash, List<string> value, string keyName);
    void Set<T>(T item, string hash, string value, string keyName);
    void SetAll<T>(List<T> listItems);
    void SetAll<T>(List<T> list, List<string> hash, List<string> value, string keyName);
    void SetAll<T>(List<T> 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<ServiceStackRedisCacheOptions> 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<byte[]> 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<T>(string id)
        {
            using (var redisClient = _redisManager.GetClient())
            {
                var redis = redisClient.As<T>();
                return redis.GetById(id.ToLower());
            }
        }

        public IQueryable<T> GetAll<T>()
        {
            using (var redisClient = _redisManager.GetClient())
            {
                var redis = redisClient.As<T>();
                return redis.GetAll().AsQueryable();
            }
        }

        public IQueryable<T> GetAll<T>(string hash, string value, Expression<Func<T, bool>> 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<T>().GetByIds(ids).AsQueryable()
                                .Where(filter);

            return ret;
        }

        public IQueryable<T> GetAll<T>(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<T>().GetByIds(ids).AsQueryable();
            return ret;
        }

        public void Set<T>(T item)
        {
            using (var redisClient = _redisManager.GetClient())
            {
                var redis = redisClient.As<T>();
                redis.Store(item);
            }
        }

        public void Set<T>(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<T>().Store(item);
        }

        public void Set<T>(T item, List<string> hash, List<string> 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<T>().Store(item);
        }

        public void SetAll<T>(List<T> listItems)
        {
            using (var redisClient = _redisManager.GetClient())
            {
                var redis = redisClient.As<T>();
                redis.StoreAll(listItems);
            }
        }

        public void SetAll<T>(List<T> 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<T>().StoreAll(list);
            }
        }

        public void SetAll<T>(List<T> list, List<string> hash, List<string> 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<T>().StoreAll(list);
            }
        }

        public void Delete<T>(T item)
        {
            using (var redisClient = _redisManager.GetClient())
            {
                var redis = redisClient.As<T>();
                redis.Delete(item);
            }
        }

        public void DeleteAll<T>(T item)
        {
            using (var redisClient = _redisManager.GetClient())
            {
                var redis = redisClient.As<T>();
                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<IServiceStackRedisCache, ServiceStackRedisCache>());

整个步骤就是:
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 7下安装python 3.6笔记

 

每次在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

你大波哥~

 

C#开源框架（转载）

Json.NET

http://json.codeplex.com/

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

Math.NET

http://www.mathdotnet.com/

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

Faker.Net

https://github.com/jonwingfield/Faker.Net

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

Html Agility Pack

http://htmlagilitypack.codeplex.com/

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

NCrawler

http://ncrawler.codeplex.com/

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

SuperWebSocket

http://superwebsocket.codeplex.com/

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

SuperSocket

http://supersocket.codeplex.com/

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

Quartz.NET

http://www.quartz-scheduler.net/

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

Lucene.Net

http://lucenenet.apache.org/

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

HttpLib

http://httplib.codeplex.com/

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

Smart Thread Pool

http://www.codeproject.com/Articles/7933/Smart-Thread-Pool

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

DocX

https://docx.codeplex.com/

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

NPOI

http://npoi.codeplex.com/

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

PDFsharp

https://pdfsharp.codeplex.com/

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

Dapper

https://github.com/SamSaffron/dapper-dot-net

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

NHibernate

https://github.com/nhibernate

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

log4net

http://logging.apache.org/log4net/

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

SharpSerializer

http://sharpserializer.codeplex.com/

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

XProxy

http://xproxy.codeplex.com/

XProxy是一个支持插件的基础代理程序集。通过编写简单的插件程序，你将能开发各种各样的代理程序。
XProxy是一个支持插件开发的数据交换机，可以编写插件对中转数据进行处理。内置有NAT插件、加解密插件、反向代理、直接代理、间接代理等插件。

nopCommerce

http://nopcommerce.codeplex.com/releases/view/106146

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

Enterprise Library

https://entlib.codeplex.com/

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

http://autofac.org/

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

AutoMapper

https://github.com/AutoMapper/AutoMapper

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

7-Zip

http://www.7-zip.org/

http://sourceforge.net/projects/sevenzip/postdownload?source=dlp

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

.Net PDF 类库

PDFsharp

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

ASP.NET FO PDF

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

Report.NET

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

SharpPDF

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

iTextSharp

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

工作流 

Workflow.Net

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

netBPM

NetBPM是JBpm移植到.net平台下的一款开源工作流软件。NetBpm可以很容易和.Net应用程序集成在一起,可以创建,执行和管理工作流程序。
     Bpm Tool支持将业务模型转换成软件模型。业务开发人员可以使用模型驱动的方法设计，实现，执行和跟踪业务流程。因此开发人员能够更容易的关注业务逻辑的变化。

持久层框架

NHibernate

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

FileHelpers Library

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

Websharp

Websharp是国人开源的一款开源持久层框架，它的目标是设计一个基于.Net的通用的应用软件系统的框架，以简化基于.Net平台的企业应用软件的开发。目前，Websharp关注于企业应用软件的以下几个方面：
1、  数据库访问
2、  O/R 映射
3、  AOP
4、  分布式访问

ObjectBroker

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

Gentle.NET

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

Ubik

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

NDal

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

Persist.NET

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

ObjectBroker

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

iBATIS.NET

iBATIS.NET帮助你的应用系统创建更好的持久层框架。

Advanced Data Provider

Advanced Data Provider是为ADO.NET提供的动态数据提供者 。可以让应用程序透明的访问不同的ADO.NET 数据提供者。

OJB.NET

OJB.NET是一款.NET平台下的对象/关系映射(O/R Mapping)工具。

图表制作

ZedGraph

ZedGraph是C#编写的.NET类库，提供了用户控件和web控件。它可以创建2D的线性图、条形图和饼图。它功能完整且有详细的功能自定义，不过使用默认的选项就足够好用了。

.NET Charts

一款类似 PieChart, StackBar, LineChart的C#开源图表组件。

NPlot

NPlot是一款.NET下的开源图表类库.它值得称道的地方是优雅且灵活的API设计.NPlot包含了Windows Form控件, ASP.NET控件和一个创建Bitmap图片的类。还有一个可用的GTK#控件。

XSCharting

XSCharting是C#开发的图表组件，提供了多种多样的图表选项。

DaveChart

DaveChart是一个免费的DotNet类库。

NChart

NChart 提供了很多值得应用在商业，教育等多个领域的2 D图表。

WebGis

SharpMap

SharpMap是一款易于使用的地图渲染器，它可以为Web和Windows应用程序渲染GIS数据。SharpMap是使用C#编写，基于.NET 2.0框架上开发的开源项目。

monoGIS

monoGIS将成为Mono平台下的开源完整GIS。已经发布了internet mapserver，OGC WMS实现和一些工具像空间格式转换。

NASA World Wind

NASA World Wind 是C#开发的个人电脑上的开源的3D图形虚拟地球系统。它结合了美国国家航空航天局(NASA)从卫星拍摄的图像，这些图像应用于Blue Marble, Landsat 7, SRTM, MODIS 以及其它更多的地方。

JSON C＃ Class Generator ---由json字符串生成C＃实体类的工具

 

json作为互联网上轻量便捷的数据传输格式，越来越受到重视。但在服务器端编程过程中，我们常常希望能通过智能提示来提高编码效率。JSON C＃ Class Generator 能将json格式所表示的Javascript对象转化成强类型的C＃实体类，来实现减少代码输入的效果。

http://jsonclassgenerator.codeplex.com/ ----开源的winform工具。

http://json2csharp.com/---一款在线转化工具，大家看名字就知道了。
另外一个在线转换工具：
Jsons
quicktype.io

from:http://www.byywee.com/page/M0/S574/574576.html
参考文章

1. NET平台开源项目速览(18)C#平台JSON实体类生成器JSON C# Class Generator