fastCSharp 1.5 代码生成实例 发布

fastCSharp是一个基于.NET元数据的 代码生成的 底层应用框架，目标是打造一个“ 开发+ 运行”效率双优的开源框架。
经过半年多的时间（ http://bbs.csdn.net/topics/390269709），除了与 web开发直接相关的部分，都已经在 fastCSharp part 1.5中完成了重写工作。
fastCSharp现在实现的 代码生成实例主要有 5个：

1、 基于缓存查询模式的 ORM代码生成实例（现在只支持 MSSQL），自定义配置类是fastCSharp.setup.cSharp.sqlTable，同时 支持反射模式fastCSharp.setup.cSharp.sqlTable.sqlTool<valueType>。
下面是ORM的model定义示例

    [fastCSharp.setup.cSharp.sqlTable(ConnectionName = "Connection1")]
    public partial class model1
    {
        /// <summary>
        /// 自增列，一个表格只允许一个，如果不配置IsIdentity = true，将自动匹配名称为 id 的成员
        /// </summary>
        [fastCSharp.setup.sqlMember(IsIdentity = true)]
        public int id;

        /// <summary>
        /// 关键字1，多个关键字成员按照成员定义顺序一致
        /// </summary>
        [fastCSharp.setup.sqlMember(IsPrimaryKey = true)]
        public int key1;
        /// <summary>
        /// 关键字2
        /// </summary>
        [fastCSharp.setup.sqlMember(IsPrimaryKey = true, IsAscii = true, MaxLength = 32)]

        public string key2;
        public enum EnumByte : byte
        {
             Enum1
        }
        /// <summary>
        /// 直接支持枚举类型转换，可以不指定SqlType = typeof(byte)
        /// </summary>
        [fastCSharp.setup.sqlMember(SqlType = typeof(byte))]
        public EnumByte key2;

        /// <summary>
        /// 指定隐式类型转换
        /// </summary>
        [fastCSharp.setup.sqlMember(SqlType = typeof(string))]
        public partial struct image
        {
            public string url;
            /// <summary>
            /// 如果不能隐式类型转换，必须实现互转函数
            /// </summary>
            public static implicit operator image(string url) { return new image { url = url }; }
            public static implicit operator string(image image) { return image.url; }
        }
        /// <summary>
        /// 支持隐式类型转换
        /// </summary>
        [fastCSharp.setup.sqlMember(IsAscii = true, MaxLength = 64)]
        public image icon = string.Empty;
    }

fastCSharp的配置文件是一个 纯数据的json格式文件，比如 Connection1 的配置定义

{
sql:	{
	checkConnection:["Connection1"],
	Connection1:
		{
		Diantou:{
			Type:"sql2008",
			Connection:"server=192.168.0.100;database=dbname;uid=username;pwd=password"
			}
		}
	}
}

下面是代码生成模式 示例，采用 派生类的模式

    public partial class bModel1 : model1.sqlTable<bModel1>
    {
        static bModel1()
        {
            if (SqlTool != null)
            {
                //定义缓存
                Cache = new fastCSharp.sql.cache.whole.identityArray<model1, model1.memberMap>(SqlTool);
                //定义缓存同步个性化处理事件
                Cache.OnInserted += XXX;
                Cache.OnUpdated += XXX;
            }
        }
    }

有时候 多个表格结构相同，那么只需要定义一个model，比如可以

    public abstract class bModelBase<tableType> : model1.sqlTable<tableType>
        where tableType : bModelBase<tableType>
    {
    }
    public partial class bModel1_1 : bModelBase<bModel1_1>
    {
    }
    public partial class bModel1_N : bModelBase<bModel1_N>
    {
    }

下面是 反射模式示例

    public class bModel1 : model1
    {
        private static readonly fastCSharp.setup.cSharp.sqlTable.sqlTool<bModel1> sqlTool = fastCSharp.setup.cSharp.sqlTable.sqlTool<bModel1>.Default;
        static bModel1()
        {
            if (sqlTool != null)
            {
                //缓存定义与事件定义 和 代码生成模式示例一样
            }
        }   
    }

有人说ORM不适应于 复杂的综合查询。真的吗？我现在展示一段查询代码

                return diantou.dataProxy.questionTopic.getTopicCache(id)
                    .getArray(value => diantou.dataProxy.question.get(value.linkId))
                    .getHash(value => value.bestAnswerId)
                    .getArray(value => diantou.dataProxy.answer.get(value))
                    .getFind(value => value != null)
                    .group(value => value.userId)
                    .getArray(value => new keyValue<diantou.dataProxy.user, int>(diantou.dataProxy.user.get(value.Key), value.Value.Count))
                    .group(value => value.Key.grade0)
                    .getArray(value => new userStat
                    {
                        grade0 = value.Key,
                        count = value.Value.Count,
                        path = topic.path.bestAnswer,
                        users = value.Value.rangeSort((left, right) => right.Value - left.Value, 0, 6)
                            .getArray(user => diantou.dataProxy.user.get(user.Key, userId))
                    });

这个查询需求是，先根据话题(topic)ID查找相关联的问题(question)ID集合，然后找到这些问题的最佳答案(answer)ID集合，然后根据这些答案的用户(user)ID分组统计答案数量，最后将这些用户根据用户等级分组，每个分组根据答案数量取前6个用户。
我个人认为基于ORM的查询更 简单流畅。如果用SQL实现这个需求，该是一个多么 复杂的SQL语句？如果需求有一点点变化，修改这个SQL语句该是多麻烦的事？

2、 数据类快速序列化代码生成实例，自定义配置类是fastCSharp.setup.cSharp.serialize，同时 支持反射模式。

    /// <summary>
    /// 仅仅选择字段成员，反射模式可以不必配置
    /// </summary>
    [fastCSharp.setup.cSharp.serialize(Filter = fastCSharp.setup.memberFilter.InstanceField)]
    public partial class model1
    {
    }

代码生成模式将实现接口fastCSharp.setup.cSharp.serialize.ISerialize

        /// <summary>
        /// 序列化接口
        /// </summary>
        public interface ISerialize
        {
            /// <summary>
            /// 对象序列化
            /// </summary>
            /// <returns>序列化数据</returns>
            byte[] Serialize();
            /// <summary>
            /// 对象序列化
            /// </summary>
            /// <param name="stream">数据流</param>
            void Serialize(memoryStream stream);
            /// <summary>
            /// 对象序列化
            /// </summary>
            /// <param name="serializer">对象序列化器</param>
            void Serialize(dataSerializer serializer);
            /// <summary>
            /// 反序列化
            /// </summary>
            /// <param name="data">序列化数据</param>
            bool DeSerialize(byte[] data);
            /// <summary>
            /// 反序列化
            /// </summary>
            /// <param name="data">序列化数据</param>
            /// <param name="startIndex">起始位置</param>
            /// <param name="endIndex">结束位置</param>
            bool DeSerialize(byte[] data, int startIndex, out int endIndex);
            /// <summary>
            /// 反序列化
            /// </summary>
            /// <param name="deSerializer">对象反序列化器</param>
            void DeSerialize(deSerializer deSerializer);
        }

如果自定义配置IsStreamSerialize = true,将实现接口fastCSharp.setup.cSharp.serialize.IStreamSerialize

        /// <summary>
        /// 序列化流接口
        /// </summary>
        public interface IStreamSerialize : ISerialize
        {
            /// <summary>
            /// 对象序列化
            /// </summary>
            /// <param name="stream">数据流</param>
            void Serialize(Stream stream);
            /// <summary>
            /// 对象序列化
            /// </summary>
            /// <param name="serializer">对象序列化器</param>
            void Serialize(streamSerializer serializer);
        }

反射模式的话， 直接调用反射函数

fastCSharp.setup.cSharp.serialize.dataSerialize.Get<model1>(value);
fastCSharp.setup.cSharp.serialize.streamSerialize.Get<model1>(value);
fastCSharp.setup.cSharp.serialize.deSerialize.Get<model1>(data);

未完待续...

56 个解决方案

#1

3、 TCP（静态方法）调用代码生成实例，自定义配置类是fastCSharp.setup.cSharp.tcpCall， 支持泛型，支持跨类（只能支持单例）， 不支持反射模式。下面是示例：

    [fastCSharp.setup.cSharp.tcpCall(Service = "tcpCallVerifyAsynchronous", VerifyType = typeof(tcpVerifyAsynchronous))]
    public partial class tcpCallVerifyAsynchronous
    {
        [fastCSharp.setup.cSharp.tcpCall(IsClientAsynchronous = false)]
        protected static void action()
        {
            isServer = true;
        }
        [fastCSharp.setup.cSharp.tcpCall(IsClientAsynchronous = true)]
        protected static void actionAsynchronous()
        {
            isServer = true;
        }
        [fastCSharp.setup.testCase]
        internal static bool Test()
        {
            using (fastCSharp.testCase.tcpServer.tcpCallVerifyAsynchronous server = new fastCSharp.testCase.tcpServer.tcpCallVerifyAsynchronous())
            {
                if (!server.Start()) throw new Exception("tcpCallVerifyAsynchronous");
                if (fastCSharp.testCase.tcpClient.tcpCallVerifyAsynchronous.defaultTcpServer.IsServer) throw new Exception("IsServer");

                isServer = false;
                tcpCall.tcpCallVerifyAsynchronous.action();
                checkServer("action");

                isServer = false;
                isReturn = null;
                tcpCall.tcpCallVerifyAsynchronous.actionAsynchronous(actionAsynchronousReturn);
                checkIsReturn("actionAsynchronous");
            }
            return true;
        }
    }

4、 TCP（动态方法）服务代码生成实例，自定义配置类是fastCSharp.setup.cSharp.tcpServer， 支持泛型， 不支持跨类， 不支持反射模式。下面是示例：

    [fastCSharp.setup.cSharp.tcpServer(Service = "tcpServerVerifyAsynchronous", VerifyType = typeof(tcpVerifyAsynchronous))]
    public partial class tcpServerVerifyAsynchronous
    {
        [fastCSharp.setup.cSharp.tcpServer(IsClientAsynchronous = false)]
        protected void action()
        {
            isServer = true;
        }
        [fastCSharp.setup.cSharp.tcpServer(IsClientAsynchronous = true)]
        protected void actionAsynchronous()
        {
            isServer = true;
        }
        [fastCSharp.setup.testCase]
        internal static bool Test()
        {
            using (fastCSharp.testCase.tcpServer.tcpServerVerifyAsynchronous server = new fastCSharp.testCase.tcpServer.tcpServerVerifyAsynchronous())
            {
                if (!server.Start()) throw new Exception("tcpServerVerifyAsynchronous");
                using (fastCSharp.testCase.tcpClient.tcpServerVerifyAsynchronous client = new fastCSharp.testCase.tcpClient.tcpServerVerifyAsynchronous())
                {
                    isServer = false;
                    client.action();
                    checkServer("action");

                    isServer = false;
                    isReturn = null;
                    client.actionAsynchronous(actionAsynchronousReturn);
                    checkIsReturn("actionAsynchronous");
                }
            }
            return true;
        }
    }

与TCP（静态方法）调用代码生成实例相似，也可以参考一下fastCSharp.setup.tcpRegister。

5、 快速json处理代码生成实例，自定义配置类是fastCSharp.setup.cSharp.ajax，同时 支持反射模式。

    /// <summary>
    /// 可以选择只生成 序列化 或者 反序列化 的代码，反射模式可以不必配置
    /// </summary>
    [fastCSharp.setup.cSharp.ajax(IsToJson = true, IsParseJson = true)]
    public partial class model1
    {
    }

代码生成模式将实现接口fastCSharp.setup.cSharp.ajax.IToJson与fastCSharp.setup.cSharp.ajax.IParseJson

        /// <summary>
        /// 对象转换成JSON字符串接口
        /// </summary>
        public interface IToJson
        {
            /// <summary>
            /// 对象转换成JSON字符串
            /// </summary>
            /// <returns>JSON字符串</returns>
            string ToJson();
            /// <summary>
            /// 对象转换成JSON字符串
            /// </summary>
            /// <param name="toJsoner">对象转换JSON字符串</param>
            void ToJson(toJsoner toJsoner);
        }
        /// <summary>
        /// JSON字符串转换成对象接口
        /// </summary>
        public interface IParseJson
        {
            /// <summary>
            /// JSON字符串转换成对象
            /// </summary>
            /// <param name="json">JSON字符串</param>
            void FromJson(string json);
            /// <summary>
            /// JSON字符串解析节点换成对象
            /// </summary>
            /// <param name="node">JSON字符串解析节点</param>
            void FromJson(jsonNode node);
        }

反射模式的话，直接调用反射函数

fastCSharp.setup.cSharp.ajax.toJson.Get<model1>(value);
fastCSharp.setup.cSharp.ajax.parseJson.Get<model1>(json);

由于很多人不需要代码生成那么好的运行效率，也 不想配置初始环境，所以某些代码生成实例提供了 基于反射的实例实现。有的代码生成实例需要生成代理实例（比如TCP调用），没有办法使用反射实现相同的效果。
今天是我在现在这个公司工作的最后一天了，感谢 李陶冶大牛这几年对我的照顾，感谢你对于这个项目开源发展的支持。也许过几天我就回老家“休息”了，在这里默默的祝福你和 51nod能够一切顺利。
最后欢迎对 算法有兴趣的朋友到基于 fastCSharp开发的 51nod OJ上去 AC问题（ 支持C#）或者讨论算法问题。

#2

#3

三花聚顶，支持肖老大

#4

支持+1    

#5

#6

顶，楼主好强大.

#7

支持一个

#8

支持一下!

#9

特意上来支持楼主的开源行动！

#10

支持

#11

禽兽到此一游

#12

支持

#13

该回复于2015-02-28 22:02:26被版主删除

#14

支持一下，我们这儿已经用上了。

#15

折腾了半天，终于发布到github了 https://github.com/fastCSharp/fastCSharp

#16

支持一下，以后能用上

#17

这个厉害啊,收藏了

#18

这个厉害啊,收藏了

#19

不错不错不错。

#20

感谢分享，正好有用 

#21

该回复于2013-05-30 08:40:32被管理员删除

#22

好东西啊，学习了

#23

厉害厉害 顶LZ,但是你发的github目录有点乱,还有最好有一个demo，好让我们这些码农体验轻松体验一下

建议这么分文件夹比较好：demo,libs（你生成的dll或者第三方的库）,src（就你现在的源码）

#24

51nod   不错 
 
支持开源

#25

#26

#27

支持一个~   赞~           

#28

看不懂也来看看

#29

该回复于2017-05-01 00:00:56被版主删除

#30

好辛苦，顶一个哦。

#31

该回复于2013-05-30 09:38:56被管理员删除

#32

好 顶一个哦。

#33

#34

#35

看不懂  我太菜了

#36

不错~~~

#37

看不太懂e~

#38

引用 23 楼 yyl8781697 的回复:

厉害厉害 顶LZ,但是你发的github目录有点乱,还有最好有一个demo，好让我们这些码农体验轻松体验一下

建议这么分文件夹比较好：demo,libs（你生成的dll或者第三方的库）,src（就你现在的源码）

谢谢你的建议，github还不会用。
demo现在没有，不过有个简单的测试用例项目，（现在只有TCP调用与序列化的测试用例）。
那我就把这个测试用例项目(testCase)也同步上去吧。

#39

直接动软代码生成器

#40

好厉害啊！直接动软代码生成器

#41

该回复于2013-06-23 12:27:51被版主删除

#42

表示看不懂.还在学习中...支持下。

#43

做个标记，方便以后学习

#44

mark 学习，读代码

#45

mark 学习，读代码 mark 学习，读代码 

#46

技术贴，绝对顶！

#47

不错，学了不少知识

#48

技术贴，绝对顶！

#49

不错，学了不少知识

#50

假期归来，顶一下