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);

未完待续...