using System;
using System.Data;
using System.Data.SqlClient;
using System.Web;
using System.IO;
using System.Collections;
using System.Text.RegularExpressions;

namespace UUN
{
    /// <summary>
    /// 模板编译扩展
    /// </summary>
    public class 编译扩展
    {
        private SqlConnection 连接;
        private HttpContext HC;
        private 编译器 编译器;
        private String 编译类型;
        private bool 是否手机号变量;

        public 编译扩展(SqlConnection 连接, HttpContext HC,编译器 编译器,String 编译类型)
        {
            this.连接 = 连接;
            this.HC = HC;
            this.编译器 = 编译器;
            this.编译类型 = 编译类型;
        }
        public String 开始执行代码()
        {
            String 返回值 = "";
            switch (编译类型)
            {
                case "Club/ShouGongZhuCe2":
                    返回值 = 开始执行代码_Club_ShouGongZhuCe2();
                    break;
                case "Club/ShouGongZhuCe":
                    返回值 = 开始执行代码_Club_ShouGongZhuCe();
                    break;
                case "Club/DenLu2":
                    返回值 = 开始执行代码_Club_DenLu2();
                    break;
                case "Club/DuanXinZhuCe":
                    返回值 = 开始执行代码_Club_DuanXinZhuCe();
                    break;
                case "Club/GeRenZhongXin":
                    返回值 = 开始执行代码_Club_GeRenZhongXin();
                    break;
                case "Club/YongHu_ChaKan":
                    返回值 = 开始执行代码_Club_YongHu_ChaKan();
                    break;
                case "Club/XiuGaiZiLiao":
                    返回值 = 开始执行代码_Club_XiuGaiZiLiao();
                    break;
                case "Club/ZaiXianHuiYuan":
                    返回值 = 开始执行代码_Club_ZaiXianHuiYuan();
                    break;
                case "Club/XiuGaiTouXiang":
                    返回值 = 开始执行代码_Club_XiuGaiTouXiang();
                    break;
                case "Club/XiuGaiTouXiang2":
                    返回值 = 开始执行代码_Club_XiuGaiTouXiang2();
                    break;
                case "Club/MiMaBaoHu":
                    返回值 = 开始执行代码_Club_MiMaBaoHu();
                    break;
                case "Club/ZhaoHuiMiMa2":
                    返回值 = 开始执行代码_Club_ZhaoHuiMiMa2();
                    break;
                case "Club/ZhaoHuiMiMa3":
                    返回值 = 开始执行代码_Club_ZhaoHuiMiMa3();
                    break;
                default:
                    返回值 = "";
                    break;
            }
            return 返回值;
        }
        public String 编译公共标签(String 代码)
        {
            switch (编译类型)
            {
                case "Club/DenLu":
                    return 编译公共标签_Club_DenLu(代码);
                case "Club/DuanXinZhuCe":
                    return 编译公共标签_Club_DuanXinZhuCe(代码);
                case "Club/ShouGongZhuCe":
                    return 编译公共标签_Club_ShouGongZhuCe(代码);
                case "Club/ShouGongZhuCe2":
                    return 编译公共标签_Club_ShouGongZhuCe2(代码);
                case "Club/YongHu_ChaKan":
                    return 编译公共标签_Club_YongHu_ChaKan(代码);
                case "Club/XiuGaiZiLiao":
                    return 编译公共标签_Club_XiuGaiZiLiao(代码);
                case "Club/ZaiXianHuiYuan":
                    return 编译公共标签_Club_ZaiXianHuiYuan(代码);
                case "Club/XiuGaiTouXiang":
                    return 编译公共标签_Club_XiuGaiTouXiang(代码);
                case "Club/ZhaoHuiMiMa2":
                    return 编译公共标签_Club_ZhaoHuiMiMa2(代码);
                default:
                    return "";
            }
        }
        public String 编译模板方法(String 方法名称, Hashtable 属性列表)
        {
            switch (编译类型)
            {
                case "Club/DenLu":
                    return 编译模板方法_Club_DenLu(方法名称, 属性列表);
                case "Club/DuanXinZhuCe":
                    return 编译模板方法_Club_DuanXinZhuCe(方法名称, 属性列表);
                case "Club/ShouGongZhuCe":
                    return 编译模板方法_Club_ShouGongZhuCe(方法名称, 属性列表);
                case "Club/ZaiXianHuiYuan":
                    return 编译模板方法_Club_ZaiXianHuiYuan(方法名称, 属性列表);
                case "Club/XiuGaiTouXiang":
                    return 编译模板方法_Club_XiuGaiTouXiang(方法名称, 属性列表);
                default:
                    return "";
            }
        }
        public String 结束执行代码()
        {
            String 返回值 = "";
            switch (编译类型)
            {
                case "Club/YongHu_ChaKan":
                    返回值 = 结束执行代码_Club_YongHu_ChaKan();
                    break;
            }
            return 返回值;
        }

        private String 开始执行代码_Club_ZhaoHuiMiMa3()
        {
            return @"		String Club_ZhaoHuiMiMa3_密码保护答案1=Request.Form[""MB_DaAn1""];
		String Club_ZhaoHuiMiMa3_密码保护答案2=Request.Form[""MB_DaAn2""];
		String Club_ZhaoHuiMiMa3_密码保护答案3=Request.Form[""MB_DaAn3""];
		int Club_ZhaoHuiMiMa3_ID=Convert.ToInt32(Request.QueryString[""ID""]);

		if(Club_ZhaoHuiMiMa3_密码保护答案1.Length<1||Club_ZhaoHuiMiMa3_密码保护答案1.Length>50)
			throw new Exception(""密码保护答案1不正确"");
		if(Club_ZhaoHuiMiMa3_密码保护答案2.Length<1||Club_ZhaoHuiMiMa3_密码保护答案2.Length>50)
			throw new Exception(""密码保护答案2不正确"");
		if(Club_ZhaoHuiMiMa3_密码保护答案3.Length<1||Club_ZhaoHuiMiMa3_密码保护答案3.Length>50)
			throw new Exception(""密码保护答案3不正确"");

		SqlCommand Club_ZhaoHuiMiMa3_语句=new SqlCommand(""SELECT [ID] FROM [""+程序.数据表前缀+""社区_密码保护] WHERE [密码保护答案1]=@密码保护答案1 AND [密码保护答案2]=@密码保护答案2 AND [密码保护答案3]=@密码保护答案3 AND [会员ID]=@会员ID"",访问.连接);
		Club_ZhaoHuiMiMa3_语句.Parameters.Add(""@密码保护答案1"",SqlDbType.NVarChar).Value=Club_ZhaoHuiMiMa3_密码保护答案1;
		Club_ZhaoHuiMiMa3_语句.Parameters.Add(""@密码保护答案2"",SqlDbType.NVarChar).Value=Club_ZhaoHuiMiMa3_密码保护答案2;
		Club_ZhaoHuiMiMa3_语句.Parameters.Add(""@密码保护答案3"",SqlDbType.NVarChar).Value=Club_ZhaoHuiMiMa3_密码保护答案3;
		Club_ZhaoHuiMiMa3_语句.Parameters.Add(""@会员ID"",SqlDbType.NVarChar).Value=Club_ZhaoHuiMiMa3_ID;
		SqlDataReader Club_ZhaoHuiMiMa3_读取=Club_ZhaoHuiMiMa3_语句.ExecuteReader();
		bool Club_ZhaoHuiMiMa3_是否存在=Club_ZhaoHuiMiMa3_读取.HasRows;
		Club_ZhaoHuiMiMa3_读取.Close();

		if(Club_ZhaoHuiMiMa3_是否存在)
		{
			Club_ZhaoHuiMiMa3_语句=new SqlCommand(""SELECT [手机号] FROM [""+程序.数据表前缀+""社区_用户_用户] WHERE [ID]=@ID"",访问.连接);
			Club_ZhaoHuiMiMa3_语句.Parameters.Add(""@ID"",SqlDbType.Int).Value=Club_ZhaoHuiMiMa3_ID;
			String Club_ZhaoHuiMiMa3_手机号;
			Club_ZhaoHuiMiMa3_读取=Club_ZhaoHuiMiMa3_语句.ExecuteReader();
			if(Club_ZhaoHuiMiMa3_读取.Read())
				Club_ZhaoHuiMiMa3_手机号=Convert.ToString(Club_ZhaoHuiMiMa3_读取[""手机号""]);
			else
			{
				Club_ZhaoHuiMiMa3_读取.Close();
				throw new Exception(""用户不存在"");
			}
			Club_ZhaoHuiMiMa3_读取.Close();

			Club_ZhaoHuiMiMa3_语句=new SqlCommand(""UPDATE [""+程序.数据表前缀+""社区_用户_用户] SET [密码]=@密码 WHERE [ID]=@ID"",访问.连接);
			Club_ZhaoHuiMiMa3_语句.Parameters.Add(""@密码"",SqlDbType.NVarChar).Value=常用.MD5加密(常用.MD5加密(Club_ZhaoHuiMiMa3_手机号.Substring(5)));
			Club_ZhaoHuiMiMa3_语句.Parameters.Add(""@ID"",SqlDbType.Int).Value=Club_ZhaoHuiMiMa3_ID;
			Club_ZhaoHuiMiMa3_语句.ExecuteNonQuery();
		}
		else
			throw new Exception(""密码保护答案错误"");
";
        }
        private String 开始执行代码_Club_ZhaoHuiMiMa2()
        {
            return @"		String Club_ZhaoHuiMiMa_SQL=""SELECT [ID] FROM [""+程序.数据表前缀+""社区_用户_用户] WHERE [用户类型]='会员' AND "";
		SqlParameter Club_ZhaoHuiMiMa_参数;
		String Club_ZhaoHuiMiMa_用户=Request.Form[""YongHu""];
		switch(Convert.ToInt32(Request.Form[""LeiXing""]))
		{
			case 0:
				Club_ZhaoHuiMiMa_SQL+=""[ID]=@ID"";
				Club_ZhaoHuiMiMa_参数=new SqlParameter(""@ID"",SqlDbType.Int);
				Club_ZhaoHuiMiMa_参数.Value=Convert.ToInt32(Club_ZhaoHuiMiMa_用户);
				break;
			case 1:
			    {
			    	Club_ZhaoHuiMiMa_SQL+=""[手机号]=@手机号"";
					Club_ZhaoHuiMiMa_参数=new SqlParameter(""@ID"",SqlDbType.NVarChar);
					Club_ZhaoHuiMiMa_参数.Value=Club_ZhaoHuiMiMa_用户;
			    }
				break;
			default:
				{
					Club_ZhaoHuiMiMa_SQL+=""[昵称]=@昵称"";
					Club_ZhaoHuiMiMa_参数=new SqlParameter(""@昵称"",SqlDbType.NVarChar);
					Club_ZhaoHuiMiMa_参数.Value=Club_ZhaoHuiMiMa_用户;
				}
				break;
		}
		SqlCommand Club_ZhaoHuiMiMa_语句=new SqlCommand(Club_ZhaoHuiMiMa_SQL,访问.连接);
		Club_ZhaoHuiMiMa_语句.Parameters.Add(Club_ZhaoHuiMiMa_参数);
		int Club_ZhaoHuiMiMa_ID;
		SqlDataReader Club_ZhaoHuiMiMa_读取=Club_ZhaoHuiMiMa_语句.ExecuteReader();
		if(Club_ZhaoHuiMiMa_读取.Read())
			Club_ZhaoHuiMiMa_ID=Convert.ToInt32(Club_ZhaoHuiMiMa_读取[""ID""]);
		else
		{
			Club_ZhaoHuiMiMa_读取.Close();
			throw new Exception(""用户不存在"");
		}
		Club_ZhaoHuiMiMa_读取.Close();
		
		Club_ZhaoHuiMiMa_语句=new SqlCommand(""SELECT [密码保护问题1],[密码保护问题2],[密码保护问题3] FROM [""+程序.数据表前缀+""社区_密码保护] WHERE [会员ID]=@会员ID"",访问.连接);
		Club_ZhaoHuiMiMa_语句.Parameters.Add(""@会员ID"",SqlDbType.Int).Value=Club_ZhaoHuiMiMa_ID;
		Hashtable Club_ZhaoHuiMiMa_密码保护=常用.SQL_获取(Club_ZhaoHuiMiMa_语句);
		if(Club_ZhaoHuiMiMa_密码保护==null)
			throw new Exception(""该用户未设置密码保护"");
";
        }
        private String 编译公共标签_Club_ZhaoHuiMiMa2(String 代码)
        {
            String 返回值 = "";
            switch (代码)
            {
                case "密码保护问题1":
                    返回值 += "\t\t返回值.Append(Server.HtmlEncode(Club_ZhaoHuiMiMa_密码保护[\"密码保护问题1\"].ToString()));\r\n";
                    break;
                case "密码保护问题2":
                    返回值 += "\t\t返回值.Append(Server.HtmlEncode(Club_ZhaoHuiMiMa_密码保护[\"密码保护问题2\"].ToString()));\r\n";
                    break;
                case "密码保护问题3":
                    返回值 += "\t\t返回值.Append(Server.HtmlEncode(Club_ZhaoHuiMiMa_密码保护[\"密码保护问题3\"].ToString()));\r\n";
                    break;
                case "会员ID":
                    返回值 += "\t\t返回值.Append(Club_ZhaoHuiMiMa_ID.ToString());\r\n";
                    break;
            }
            return 返回值;
        }
        private String 开始执行代码_Club_MiMaBaoHu()
        {
            编译器.方法库 += @"	private void Club_MiMaBaoHu_保存设置()
	{
		String 密码保护问题1=Request.Form[""MB_WenTi1""];
		String 密码保护答案1=Request.Form[""MB_DaAn1""];
		String 密码保护问题2=Request.Form[""MB_WenTi2""];
		String 密码保护答案2=Request.Form[""MB_DaAn2""];
		String 密码保护问题3=Request.Form[""MB_WenTi3""];
		String 密码保护答案3=Request.Form[""MB_DaAn3""];

		if(密码保护问题1.Length<1||密码保护问题1.Length>50)
			throw new Exception(""密码保护问题1的长度只能在1-50之间"");
		if(密码保护答案1.Length<1||密码保护答案1.Length>50)
			throw new Exception(""密码保护答案1的长度只能在1-50之间"");
		if(密码保护问题2.Length<1||密码保护问题2.Length>50)
			throw new Exception(""密码保护问题2的长度只能在1-50之间"");
		if(密码保护答案2.Length<1||密码保护答案2.Length>50)
			throw new Exception(""密码保护答案2的长度只能在1-50之间"");
		if(密码保护问题3.Length<1||密码保护问题3.Length>50)
			throw new Exception(""密码保护问题3的长度只能在1-50之间"");
		if(密码保护答案3.Length<1||密码保护答案3.Length>50)
			throw new Exception(""密码保护答案3的长度只能在1-50之间"");

		int ZGID=常用.SQL_最高ID(访问.连接,""密码保护"");
		SqlCommand 语句=new SqlCommand(""INSERT INTO [""+程序.数据表前缀+""社区_密码保护]([ID],[密码保护问题1],[密码保护答案1],[密码保护问题2],[密码保护答案2],[密码保护问题3],[密码保护答案3],[会员ID])""+
			""VALUES(@ID,@密码保护问题1,@密码保护答案1,@密码保护问题2,@密码保护答案2,@密码保护问题3,@密码保护答案3,@会员ID)"",访问.连接);
		语句.Parameters.Add(""@ID"",SqlDbType.Int).Value=ZGID;
		语句.Parameters.Add(""@密码保护问题1"",SqlDbType.NVarChar).Value=密码保护问题1;
		语句.Parameters.Add(""@密码保护答案1"",SqlDbType.NVarChar).Value=密码保护答案1;
		语句.Parameters.Add(""@密码保护问题2"",SqlDbType.NVarChar).Value=密码保护问题2;
		语句.Parameters.Add(""@密码保护答案2"",SqlDbType.NVarChar).Value=密码保护答案2;
		语句.Parameters.Add(""@密码保护问题3"",SqlDbType.NVarChar).Value=密码保护问题3;
		语句.Parameters.Add(""@密码保护答案3"",SqlDbType.NVarChar).Value=密码保护答案3;
		语句.Parameters.Add(""@会员ID"",SqlDbType.Int).Value=Convert.ToInt32(访问.用户[""ID""]);
		语句.ExecuteNonQuery();

		Response.Redirect(常用.处理地址(""GeRenZhongXin.aspx"",访问.用户[""标识""].ToString()));
	}";
            return @"		访问.验证会员();
		SqlCommand Club_MiMaBaoHu_语句=new SqlCommand(""SELECT [ID] FROM [""+程序.数据表前缀+""社区_密码保护] WHERE [会员ID]=@会员ID"",访问.连接);
		Club_MiMaBaoHu_语句.Parameters.Add(""@会员ID"",SqlDbType.Int).Value=Convert.ToInt32(访问.用户[""ID""]);
		SqlDataReader Club_MiMaBaoHu_读取=Club_MiMaBaoHu_语句.ExecuteReader();
		bool Club_MiMaBaoHu_是否存在=Club_MiMaBaoHu_读取.HasRows;
		Club_MiMaBaoHu_读取.Close();
		if(Club_MiMaBaoHu_是否存在)
			throw new Exception(""您已设置密码保护"");
		if(Request.QueryString[""l""]==""en"")
			Club_MiMaBaoHu_保存设置();
";
        }
        private String 开始执行代码_Club_XiuGaiTouXiang2()
        {
            编译器.方法库 += @"	private void Club_XiuGaiTouXiang2_修改头像()
	{
		int ID=Convert.ToInt32(Request.QueryString[""ID""]);
		String 头像地址;
		int 需要积分;
		SqlCommand 语句=new SqlCommand(""SELECT [头像地址],[需要积分] FROM [""+程序.数据表前缀+""社区_头像] WHERE [ID]=@ID"",访问.连接);
		语句.Parameters.Add(""@ID"",SqlDbType.Int).Value=ID;
		SqlDataReader 读取=语句.ExecuteReader();
		if(读取.Read())
		{
			头像地址=Convert.ToString(读取[""头像地址""]);
			需要积分=Convert.ToInt32(读取[""需要积分""]);
		}
		else
		{
			读取.Close();
			throw new Exception(""头像不存在"");
		}
		读取.Close();

		new 用户(this.Context,访问.连接).扣除积分(Convert.ToInt32(访问.用户[""ID""]),需要积分,false,"""");

		语句=new SqlCommand(""UPDATE [用户] SET [头像]=@头像 WHERE [ID]=@ID"",访问.连接);
		语句.Parameters.Add(""@头像"",SqlDbType.NVarChar).Value=头像地址;
		语句.Parameters.Add(""@ID"",SqlDbType.Int).Value=Convert.ToInt32(访问.用户[""ID""]);
		语句.ExecuteNonQuery();

		new 会员活动信息(this.Context,访问.连接).记录(Convert.ToInt32(访问.用户[""ID""]),
			Convert.ToString(访问.用户[""昵称""]),
			""更换了新头像"",
			程序.安装位置+""Club/YongHu_ChaKan.aspx?ID=""+访问.用户[""ID""]);
	}
";
            return "\t\t访问.验证会员();\r\n\t\tClub_XiuGaiTouXiang2_修改头像();\r\n";
        }
        private String 开始执行代码_Club_XiuGaiTouXiang()
        {
            编译器.方法库 += "\tprivate String Club_XiuGaiTouXiang_分页跳转;\r\n";
            return "\t\t访问.验证会员();\r\n";
        }
        private String 编译公共标签_Club_XiuGaiTouXiang(String 代码)
        {
            String 返回值 = "";
            switch (代码)
            {
                case "分页跳转":
                    返回值 += "\t\t返回值.Append(Club_XiuGaiTouXiang_分页跳转);\r\n";
                    break;
            }
            return 返回值;
        }
        private String 编译模板方法_Club_XiuGaiTouXiang(String 方法名称,Hashtable 属性列表)
        {
            String 返回值 = "";
            switch (方法名称)
            {
                case "头像列表":
                    返回值 += 编译模板方法_Club_XiuGaiTouXiang_头像列表(属性列表);
                    break;
            }
            return 返回值;
        }
        private String 编译模板方法_Club_XiuGaiTouXiang_头像列表(Hashtable 属性列表)
        {
            String 随机值 = 常用.随机字符(8);

            Hashtable 必须字段 = new Hashtable();
            必须字段.Add("序号", "");
            必须字段.Add("更换地址", "ID");
            Hashtable 字段代码 = new Hashtable();
            字段代码.Add("序号", "(分页.当前页-1)*一页显示记录数+i+1");
            字段代码.Add("头像性别", @"Convert.ToBoolean(行[""头像性别""])?程序.设置[""单位名词_男性名词""].ToString():程序.设置[""单位名词_女性名词""].ToString()");
            字段代码.Add("更换地址", "\"XiuGaiTouXiang2.aspx?ID=\"+行[\"ID\"]");
            字段代码.Add("需要积分", "行[\"需要积分\"].ToString()+程序.设置[\"单位名词_积分名词\"]+程序.设置[\"单位名词_积分名称\"]");

            String 查询字段, 行代码;
            查询字段 = 编译器.生成查询字段(Convert.ToString(属性列表["格式"]), Convert.ToString(属性列表["交替格式"]), 必须字段, 字段代码, out 行代码);

            编译器.方法库 += "\tprivate String 头像列表" + 随机值 + "()\r\n";
            编译器.方法库 += "\t{\r\n";
            编译器.方法库 += "\t\tStringBuilder 返回值=new StringBuilder();\r\n";

            String 查询参数 = "";

            编译器.方法库 += "\t\tSqlCommand 语句=new SqlCommand(\"SELECT COUNT(ID) FROM [\"+程序.数据表前缀+\"社区_头像] WHERE [头像性别]='0' OR [头像性别]=@头像性别\",访问.连接);\r\n";
            编译器.方法库 += "\t\t语句.Parameters.Add(\"@头像性别\",SqlDbType.Int).Value=Convert.ToBoolean(访问.用户[\"性别\"])?1:2;\r\n";
            编译器.方法库 += "\t\t前台分页 分页=new 前台分页(Convert.ToInt32(语句.ExecuteScalar())," +
                "Convert.ToInt32(Request.QueryString[\"page\"])," +
                "Convert.ToInt32(访问.获取一页显示记录数())," +
                "\"XiuGaiTouXiang.aspx\",访问.用户[\"标识\"].ToString());\r\n";

            编译器.方法库 += "\t\t语句=new SqlCommand(\"SELECT " + 查询字段 + " FROM [\"+程序.数据表前缀+\"社区_头像] WHERE [头像性别]='0' OR [头像性别]=@头像性别";
            查询参数 += "\t\t语句.Parameters.Add(\"@头像性别\",SqlDbType.Int).Value=Convert.ToBoolean(访问.用户[\"性别\"])?1:2;\r\n";
            编译器.方法库 += " ORDER BY [ID] DESC";
            编译器.方法库 += "\",访问.连接);\r\n";
            编译器.方法库 += 查询参数;
            生成查询结果分页代码("Club_XiuGaiTouXiang", 行代码);

            return "\t\t返回值.Append(头像列表" + 随机值 + "());\r\n";
        }
        private String 开始执行代码_Club_ZaiXianHuiYuan()
        {
            编译器.方法库+= "\tprivate String Club_ZaiXianHuiYuan_分页跳转;\r\n";
            return "";
        }
        private String 编译公共标签_Club_ZaiXianHuiYuan(String 代码)
        {
            String 返回值 = "";
            switch (代码)
            {
                case "分页跳转":
                    返回值 += "\t\t返回值.Append(Club_ZaiXianHuiYuan_分页跳转);\r\n";
                    break;
                case "来源地址":
                    返回值 += "\t\t返回值.Append(Request.QueryString[\"rurl\"]);\r\n";
                    break;
            }
            return 返回值;
        }
        private String 编译模板方法_Club_ZaiXianHuiYuan(String 方法名称, Hashtable 属性列表)
        {
            String 返回值 = "";
            switch (方法名称)
            {
                case "在线用户列表":
                    返回值 += 编译模板方法_Club_ZaiXianHuiYuan_在线用户列表(属性列表);
                    break;
            }
            return 返回值;
        }
        private String 编译模板方法_Club_ZaiXianHuiYuan_在线用户列表(Hashtable 属性列表)
        {
            String 随机值=常用.随机字符(8);

            Hashtable 必须字段 = new Hashtable();
            必须字段.Add("序号", "");
            必须字段.Add("用户资料地址", "ID");
            Hashtable 字段代码 = new Hashtable();
            字段代码.Add("序号", "(分页.当前页-1)*一页显示记录数+i+1");
            字段代码.Add("用户资料地址", @"程序.安装位置+""Club/YongHu_ChaKan.aspx?ID=""+行[""ID""]+""&Rurl=""+Server.UrlEncode(Request.Url.ToString())");
            字段代码.Add("最后访问时间", @"Convert.ToDateTime(行[""最后访问时间""]).ToString(""" + 属性列表["时间格式"] + "\")");
            字段代码.Add("最后登录时间", @"Convert.ToDateTime(行[""最后登录时间""]).ToString(""" + 属性列表["时间格式"] + "\")");
            字段代码.Add("创建时间", @"Convert.ToDateTime(行[""创建时间""]).ToString(""" + 属性列表["时间格式"] + "\")");
            字段代码.Add("性别", @"Convert.ToBoolean(行[""性别""])?程序.设置[""单位名词_男性名词""].ToString():程序.设置[""单位名词_女性名词""].ToString()");

            String 查询字段, 行代码;
            查询字段 = 编译器.生成查询字段(Convert.ToString(属性列表["格式"]),Convert.ToString(属性列表["交替格式"]), 必须字段, 字段代码, out 行代码);

            编译器.方法库 += "\tprivate String 在线用户列表" + 随机值 + "()\r\n";
            编译器.方法库 += "\t{\r\n";
            编译器.方法库 += "\t\tStringBuilder 返回值=new StringBuilder();\r\n";

            String 查询参数 = "";

            编译器.方法库 += "\t\tSqlCommand 语句=new SqlCommand(\"SELECT COUNT(ID) FROM [\"+程序.数据表前缀+\"社区_用户_用户] WHERE [用户类型]='会员' AND [最后访问时间]>@最后访问时间\",访问.连接);";
            编译器.方法库 += "\t\t语句.Parameters.Add(\"@最后访问时间\",SqlDbType.DateTime).Value=DateTime.Now-new TimeSpan(0,Convert.ToInt32(程序.设置[\"离线时间\"]),0);\r\n";
            编译器.方法库 += "\t\t前台分页 分页=new 前台分页(Convert.ToInt32(语句.ExecuteScalar())," +
                "Convert.ToInt32(Request.QueryString[\"page\"])," +
                "Convert.ToInt32(访问.获取一页显示记录数())," +
                "\"ZaiXianHuiYuan.aspx?rurl=\"+Server.UrlEncode(Request.QueryString[\"rurl\"]),访问.用户[\"标识\"].ToString());\r\n";

            编译器.方法库 += "\t\t语句=new SqlCommand(\"SELECT " + 查询字段 + " FROM [\"+程序.数据表前缀+\"社区_用户] WHERE [用户类型]='会员' AND [最后访问时间]>@最后访问时间";
            查询参数 = "\t\t语句.Parameters.Add(\"@最后访问时间\",SqlDbType.DateTime).Value=DateTime.Now-new TimeSpan(0,Convert.ToInt32(程序.设置[\"离线时间\"]),0);\r\n";
            编译器.方法库 += " ORDER BY ";
            switch (Convert.ToInt32(属性列表["排序"]))
            {
                case 0:
                    编译器.方法库 += "[ID] DESC";
                    break;
                case 1:
                    编译器.方法库 += "[积分] DESC";
                    break;
                case 2:
                    编译器.方法库 += "[最后访问时间] DESC";
                    break;
                case 3:
                    编译器.方法库 += "[最后登录时间] DESC";
                    break;
                case 4:
                    编译器.方法库 += "[等级] DESC";
                    break;
                case 5:
                    编译器.方法库 += "[今日访问次数] DESC";
                    break;
            }
            编译器.方法库 += "\",访问.连接);\r\n";
            编译器.方法库 += 查询参数;
            生成查询结果分页代码("Club_ZaiXianHuiYuan", 行代码);
            return "\t\t返回值.Append(在线用户列表" + 随机值 + "());\r\n";
        }
        private String 开始执行代码_Club_XiuGaiZiLiao()
        {
            return @"		访问.验证会员();
		if(Request.QueryString[""l""]==""en"")
			new 用户(this.Context,访问.连接).修改用户资料(访问.用户);
		Hashtable Club_XiuGaiZiLiao_用户=常用.SQL_获取(new SqlCommand(""SELECT [昵称],[性别],[个人资料] FROM [""+程序.数据表前缀+""社区_用户] WHERE [用户类型]='会员' AND [ID]=""+访问.用户[""ID""],访问.连接));
		String Club_XiuGaiZiLiao_随机值=常用.随机字符(4);
		设置 Club_XiuGaiZiLiao_其它资料=new 设置(Club_XiuGaiZiLiao_用户[""个人资料""].ToString());
";
        }
        private DataSet 修改资料结构数据;
        private String 编译公共标签_Club_XiuGaiZiLiao(String 代码)
        {
            String 返回值 = "";
            switch (代码)
            {
                case "昵称":
                    返回值 += "\t\t返回值.Append(Server.HtmlEncode(Club_XiuGaiZiLiao_用户[\"昵称\"].ToString()));\r\n";
                    break;
                case "性别":
                    返回值 += "\t\t返回值.Append(Club_XiuGaiZiLiao_用户[\"性别\"]);\r\n";
                    break;
                case "随机值":
                    返回值 += "\t\t返回值.Append(Club_XiuGaiZiLiao_随机值);\r\n";
                    break;
                case "其它资料数据项":
                    {
                        if (修改资料结构数据 == null)
                            修改资料结构数据 = 获取修改资料结构数据();
                        for (int i = 0; i < 修改资料结构数据.Tables[0].Rows.Count; i++)
                        {
                            DataRow 行 = 修改资料结构数据.Tables[0].Rows[i];
                            String 数据代码 = "";
                            switch (Convert.ToInt32(行["数据类型"]))
                            {
                                case 0:
                                    数据代码 = "<input type=\"\"text\"\" name=\"\"" + 行["表单名称"] + "\"+Club_XiuGaiZiLiao_随机值+@\"\"\" maxlength=\"\"" + 行["最大大小(长度)"] + "\"\" value=\"\"\"+Server.HtmlEncode(Club_XiuGaiZiLiao_其它资料[\""+行["数据名称"]+"\"].ToString())+@\"\"\" />";
                                    break;
                                case 1:
                                    数据代码 = "<input type=\"\"text\"\" name=\"\"" + 行["表单名称"] + "\"+Club_XiuGaiZiLiao_随机值+@\"\"\" format=\"\"*N\"\" value=\"\"\"+Server.HtmlEncode(Club_XiuGaiZiLiao_其它资料[\""+行["数据名称"]+"\"].ToString())+@\"\"\" size=\"\"4\"\" />";
                                    break;
                                default:
                                    {
                                        String[] 值数组 = 行["值列表"].ToString().Split(new String[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                                        数据代码 = "<select name=\"\"" + 行["表单名称"] + "\"+Club_XiuGaiZiLiao_随机值+@\"\"\" value=\"\"\"+Server.HtmlEncode(Club_XiuGaiZiLiao_其它资料[\""+行["数据名称"]+"\"].ToString())+@\"\"\">";
                                        for (int i1 = 0; i1 < 值数组.Length; i1++)
                                            数据代码 += "<option value=\"\"" + HC.Server.HtmlEncode(值数组[i1]) + "\"\">" + HC.Server.HtmlEncode(值数组[i1]) + "</option>";
                                        数据代码 += "</select>";
                                    }
                                    break;
                            }
                            返回值 += "\t\t" + @"返回值.Append(@""" +
                                行["表单代码"].ToString()
                                .Replace("$项名称$", HC.Server.HtmlEncode(行["数据名称"].ToString()))
                                .Replace("$项代码$", 数据代码)
                                + "\");\r\n";
                        }
                    }
                    break;
                case "其它资料表单项":
                    {
                        if (修改资料结构数据 == null)
                            修改资料结构数据 = 获取修改资料结构数据();
                        for (int i = 0; i < 修改资料结构数据.Tables[0].Rows.Count; i++)
                        {
                            DataRow 行 = 修改资料结构数据.Tables[0].Rows[i];
                            返回值 += "\t\t返回值.Append(@\"<postfield name=\"\"" +
                                HC.Server.HtmlEncode(行["表单名称"].ToString()) +
                                "\"\" value=\"\"$(" +
                                HC.Server.HtmlEncode(行["表单名称"].ToString()) +
                                "\"+Club_XiuGaiZiLiao_随机值+@\")\"\" />\");\r\n";
                        }
                    }
                    break;
            }
            return 返回值;
        }
        private String Club_YongHu_ChaKan_字段变量 = "[ID]";
        private bool Club_YongHu_ChaKan_是否勋章;
        private bool Club_YongHu_ChaKan_是否个人资料;
        private String 结束执行代码_Club_YongHu_ChaKan()
        {
            String 方法库 = "";
            方法库 += @"	private Hashtable 获取用户()
	{
		int ID=Convert.ToInt32(Request.QueryString[""ID""]);
		return 常用.SQL_获取(new SqlCommand(""SELECT " + Club_YongHu_ChaKan_字段变量 + @" FROM [""+程序.数据表前缀+""社区_用户] WHERE [用户类型]='会员' AND [ID]=""+ID,访问.连接));
	}
";
            编译器.方法库 += 方法库;
            return "";
        }
        private String 开始执行代码_Club_YongHu_ChaKan()
        {
            return @"		Hashtable ___用户=获取用户();
		if(___用户==null)
			throw new Exception(""用户不存在"");
";
        }
        private String 编译公共标签_Club_YongHu_ChaKan(String 代码)
        {
            String 返回值 = "";
            switch (代码)
            {
                case "ID":
                    返回值+="\t\t返回值.Append(___用户[\"ID\"]);\r\n";
                    break;
                case "昵称":
                    返回值 += "\t\t返回值.Append(Server.HtmlEncode(___用户[\"昵称\"].ToString()));\r\n";
                    Club_YongHu_ChaKan_字段变量=常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "昵称");
                    break;
                case "手机号":
                    返回值 += "\t\t返回值.Append(___用户[\"手机号\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "手机号");
                    break;
                case "性别":
                    返回值 += "\t\t返回值.Append(Convert.ToBoolean(___用户[\"性别\"])?程序.设置[\"单位名词_男性名词\"]:程序.设置[\"单位名词_女性名词\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "性别");
                    break;
                case "积分":
                    返回值 += "\t\t返回值.Append(___用户[\"积分\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "积分");
                    break;
                case "最后访问时间":
                    返回值 += "\t\t返回值.Append(___用户[\"最后访问时间\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "最后访问时间");
                    break;
                case "最后登录时间":
                    返回值 += "\t\t返回值.Append(___用户[\"最后登录时间\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "最后登录时间");
                    break;
                case "最后登录IP":
                    返回值 += "\t\t返回值.Append(___用户[\"最后登录IP\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "最后登录IP");
                    break;
                case "最后登录地区":
                    返回值 += "\t\t返回值.Append(___用户[\"最后登录地区\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "最后登录地区");
                    break;
                case "等级":
                    返回值 += "\t\t返回值.Append(___用户[\"等级\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "等级");
                    break;
                case "所在位置":
                    返回值 += "\t\t返回值.Append(Server.HtmlEncode(___用户[\"所在位置\"].ToString()));\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "所在位置");
                    break;
                case "今日访问次数":
                    返回值 += "\t\t返回值.Append(___用户[\"今日访问次数\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "今日访问次数");
                    break;
                case "头像":
                    返回值 += "\t\t返回值.Append(\"<img src=\\\"\"+Server.HtmlEncode(___用户[\"头像\"].ToString())+\"\\\" alt=\\\"\\\" />\");\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "头像");
                    break;
                case "勋章":
                    if (!Club_YongHu_ChaKan_是否勋章)
                    {
                        返回值 += "\t\tString[] 勋章数组=___用户[\"勋章\"].ToString().Split(new Char[]{','}, StringSplitOptions.RemoveEmptyEntries);\r\n";
                        Club_YongHu_ChaKan_是否勋章 = true;
                    }
                    返回值 += @"		for(int i=0;i<勋章数组.Length;i++)
			返回值.Append(""<img src=\""""+Server.HtmlEncode(勋章数组[i])+""\"" alt=\""\"" />"");
";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "勋章");
                    break;
                case "创建时间":
                    返回值 += "\t\t返回值.Append(___用户[\"创建时间\"]);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "创建时间");
                    break;
                case "其它资料":
                    if (!Club_YongHu_ChaKan_是否个人资料)
                    {
                        返回值 += "\t\tString ___其它资料数据=new 用户(this.Context,访问.连接).获取用户其它资料(___用户[\"个人资料\"].ToString());\r\n";
                        Club_YongHu_ChaKan_是否个人资料 = true;
                    }
                    返回值 += "\t\t返回值.Append(___其它资料数据);\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "个人资料");
                    break;
                case "等级称呼":
                    返回值 += "\t\t返回值.Append(用户.获取等级称呼(Convert.ToInt32(___用户[\"等级\"])));\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "等级");
                    break;
                case "在线状态":
                    返回值 += "\t\t返回值.Append(Convert.ToDateTime(___用户[\"最后访问时间\"])>(DateTime.Now-new TimeSpan(0,Convert.ToInt32(程序.设置[\"离线时间\"]),0))?\"在线\":\"离线\");\r\n";
                    Club_YongHu_ChaKan_字段变量 = 常用.SQL_增加非重复字段(Club_YongHu_ChaKan_字段变量, "最后访问时间");
                    break;
                case "来源地址":
                    返回值 += "\t\t返回值.Append(Request.QueryString[\"rurl\"]);\r\n";
                    break;
            }
            return 返回值;
        }
        private String 编译公共标签_Club_ShouGongZhuCe2(String 代码)
        {
            String 返回值 = "";
            switch (代码)
            {
                case "手机号":
                    if (!是否手机号变量)
                    {
                        返回值 = "\t\t" + @"String ___手机号=new 用户(this.Context,访问.连接).获取手机号(Convert.ToInt32(访问.用户[""ID""]));
";
                        是否手机号变量 = true;
                    }
                    返回值 += "\t\t" + @"返回值.Append(___手机号);
";
                    break;
            }
            return 返回值;
        }
        private String 开始执行代码_Club_GeRenZhongXin()
        {
            return @"		访问.验证会员();
";
        }
        private String 开始执行代码_Club_DuanXinZhuCe()
        {
            return @"		if(!Convert.ToBoolean(程序.设置[""注册用户_是否开启注册""]))
			throw new Exception(Convert.ToString(程序.设置[""注册用户_暂停注册提示""]));
		if(!Convert.ToBoolean(程序.设置[""注册用户_是否启用短信注册""]))
			throw new Exception(""短信注册尚未启用"");
";
        }
        private String 开始执行代码_Club_DenLu2()
        {
            return @"
		if(!Convert.ToBoolean(Request.QueryString[""c""]))
		{
			String 标识=new 用户(this.Context,访问.连接).会员登录(
				Convert.ToInt32(Request.Form[""LeiXing""]),
				Request.Form[""YongHu""],
				Request.Form[""MiMa""]);
			Response.Redirect(常用.处理地址(""DenLu2.aspx?c=true"",标识));
		}
		访问.验证会员();
		new 会员活动信息(this.Context,访问.连接).记录(Convert.ToInt32(访问.用户[""ID""]),
			Convert.ToString(访问.用户[""昵称""]),
			""登录社区"",
			程序.安装位置+""Club/YongHu_ChaKan.aspx?ID=""+访问.用户[""ID""]);
";
        }
        private String 开始执行代码_Club_ShouGongZhuCe2()
        {
            return @"		if(!Convert.ToBoolean(程序.设置[""注册用户_是否开启注册""]))
			throw new Exception(Convert.ToString(程序.设置[""注册用户_暂停注册提示""]));
		if(!Convert.ToBoolean(程序.设置[""注册用户_是否启用手工注册""]))
			throw new Exception(""手工注册尚未启用"");
		if(!Convert.ToBoolean(Request.QueryString[""c""]))
		{
		if(Convert.ToBoolean(程序.设置[""是否防止恶意手工注册""]))
		{
			SqlCommand Club_ShouGongZhuCe2_语句=new SqlCommand(""SELECT [ID] FROM [""+程序.数据表前缀+""社区_用户] WHERE [最后登录IP]=@最后登录IP AND [创建时间]>@创建时间"",访问.连接);
			Club_ShouGongZhuCe2_语句.Parameters.Add(""@最后登录IP"",SqlDbType.NVarChar).Value=Request.UserHostAddress;
			Club_ShouGongZhuCe2_语句.Parameters.Add(""@创建时间"",SqlDbType.DateTime).Value=DateTime.Now-new TimeSpan(0,30,0);
			SqlDataReader Club_ShouGongZhuCe2_读取=Club_ShouGongZhuCe2_语句.ExecuteReader();
			bool Club_ShouGongZhuCe2_是否存在=Club_ShouGongZhuCe2_读取.HasRows;
			Club_ShouGongZhuCe2_读取.Close();
			if(Club_ShouGongZhuCe2_是否存在)
				throw new Exception(""您刚才已经注册了一个账号，不能重复注册。"");
		}
			用户 Club_ShouGongZhuCe2_用户=new 用户(this.Context,访问.连接);
			String 标识=Club_ShouGongZhuCe2_用户.增加用户();
			Club_ShouGongZhuCe2_用户.奖励积分(Convert.ToInt32(访问.用户[""ID""]),
				Convert.ToInt32(程序.设置[""注册用户_注册后赠送积分""]),
				Convert.ToBoolean(程序.设置[""注册用户_注册成功后消息提醒""]),
				Convert.ToString(程序.设置[""注册用户_注册成功消息内容""]));
			Response.Redirect(常用.处理地址(""ShouGongZhuCe2.aspx?c=true"",标识));
		}
		访问.验证会员();
";
        }
        private DataSet 结构数据;
        private String 开始执行代码_Club_ShouGongZhuCe()
        {
            return @"		if(!Convert.ToBoolean(程序.设置[""注册用户_是否开启注册""]))
			throw new Exception(Convert.ToString(程序.设置[""注册用户_暂停注册提示""]));
		if(!Convert.ToBoolean(程序.设置[""注册用户_是否启用手工注册""]))
			throw new Exception(""手工注册尚未启用"");
";
        }
        private String 编译公共标签_Club_ShouGongZhuCe(String 代码)
        {
            String 返回值 = "";
            switch (代码)
            {
                case "注册数据项":
                    {
                        if (结构数据 == null)
                            结构数据 = 获取资料结构数据();
                        for (int i = 0; i < 结构数据.Tables[0].Rows.Count; i++)
                        {
                            DataRow 行 = 结构数据.Tables[0].Rows[i];
                            String 数据代码 = "";
                            switch (Convert.ToInt32(行["数据类型"]))
                            {
                                case 0:
                                    数据代码 = "<input type=\"text\" name=\"" + 行["表单名称"] + "\" maxlength=\"" + 行["最大大小(长度)"] + "\" value=\""+HC.Server.HtmlEncode(行["默认值"].ToString())+"\" />";
                                    break;
                                case 1:
                                    数据代码 = "<input type=\"text\" name=\"" + 行["表单名称"] + "\" format=\"*N\" value=\"" + Convert.ToInt32(行["默认值"]) + "\" size=\"4\" />";
                                    break;
                                default:
                                    {
                                        String[] 值数组 = 行["值列表"].ToString().Split(new String[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
                                        数据代码 = "<select name=\"" + 行["表单名称"] + "\" value=\""+HC.Server.HtmlEncode(行["默认值"].ToString())+"\">";
                                        for (int i1 = 0; i1 < 值数组.Length; i1++)
                                            数据代码 += "<option value=\"" + HC.Server.HtmlEncode(值数组[i1]) + "\">" + HC.Server.HtmlEncode(值数组[i1]) + "</option>";
                                        数据代码 += "</select>";
                                    }
                                    break;
                            }
                            返回值 += "\t\t" + @"返回值.Append(@""" + 
                                行["表单代码"].ToString()
                                .Replace("$项名称$",HC.Server.HtmlEncode(行["数据名称"].ToString()))
                                .Replace("$项代码$",数据代码)
                                .Replace("\"", "\"\"") + "\");\r\n";
                        }
                    }
                    break;
                case "注册表单项":
                    {
                        if (结构数据 == null)
                            结构数据 = 获取资料结构数据();
                        for (int i = 0; i < 结构数据.Tables[0].Rows.Count; i++)
                        {
                            DataRow 行 = 结构数据.Tables[0].Rows[i];
                            返回值 += "\t\t返回值.Append(@\"<postfield name=\"\"" +
                                HC.Server.HtmlEncode(行["表单名称"].ToString()) +
                                "\"\" value=\"\"$(" +
                                HC.Server.HtmlEncode(行["表单名称"].ToString()) +
                                ")\"\" />\");\r\n";
                        }
                    }
                    break;
            }
            return 返回值;
        }
        private DataSet 获取修改资料结构数据()
        {
            DataSet 数据 = new DataSet();
            SqlCommand 语句 = new SqlCommand("SELECT [ID],[数据名称],[数据类型],[最小大小(长度)],[最大大小(长度)],[值列表],[是否允许重复],[默认值],[表单代码],[备注],[表单名称] FROM ["+程序.数据表前缀+"社区_用户_资料结构] WHERE [是否修改资料项]=@是否修改资料项 ORDER BY [ID]", 连接);
            语句.Parameters.Add("@是否修改资料项", SqlDbType.Bit).Value = true;
            SqlDataAdapter 填充 = new SqlDataAdapter(语句);
            填充.Fill(数据, "用户资料结构");
            return 数据;
        }
        private DataSet 获取资料结构数据()
        {
            DataSet 数据 = new DataSet();
            SqlCommand 语句 = new SqlCommand("SELECT [ID],[数据名称],[数据类型],[最小大小(长度)],[最大大小(长度)],[值列表],[是否允许重复],[默认值],[表单代码],[备注],[表单名称] FROM [" + 程序.数据表前缀 + "社区_用户_资料结构] WHERE [是否注册项]=@是否注册项 ORDER BY [ID]", 连接);
            语句.Parameters.Add("@是否注册项", SqlDbType.Bit).Value = true;
            SqlDataAdapter 填充 = new SqlDataAdapter(语句);
            填充.Fill(数据, "用户资料结构");
            return 数据;
        }
        private String 编译模板方法_Club_ShouGongZhuCe(String 方法名称, Hashtable 属性列表)
        {
            return "";
        }
        private String 编译公共标签_Club_DuanXinZhuCe(String 代码)
        {
            String 返回值 = "";
            switch (代码)
            {
                case "短信接收号码":
                    返回值 += "\t\t" + @"返回值.Append(程序.设置[""注册用户_短信接收号码""]);
";
                    break;
                case "注册用户指令":
                    返回值 += "\t\t" + @"返回值.Append(程序.设置[""注册用户_注册用户指令""]);
";
                    break;
                case "取回密码指令":
                    返回值 += "\t\t" + @"返回值.Append(程序.设置[""注册用户_取回密码指令""]);
";
                    break;
                default:
                    返回值= "";
                    break;
            }
            return 返回值;
        }
        private String 编译模板方法_Club_DuanXinZhuCe(String 方法名称, Hashtable 属性列表)
        {
            return "";
        }
        private String 编译公共标签_Club_DenLu(String 代码)
        {
            return "";
        }
        private String 编译模板方法_Club_DenLu(String 方法名称, Hashtable 属性列表)
        {
            return "";
        }
        private void 生成查询结果分页代码(String 分页代码变量, String 行代码)
        {
            编译器.方法库 += "\t\tDataSet 数据=new DataSet();\r\n";
            编译器.方法库 += "\t\tint 一页显示记录数=访问.获取一页显示记录数();\r\n";
            编译器.方法库 += "\t\tSqlDataAdapter 填充=new SqlDataAdapter(语句);\r\n";
            编译器.方法库 += "\t\t填充.Fill(数据,(分页.当前页-1)*一页显示记录数,一页显示记录数,\"数据\");\r\n\r\n";
            编译器.方法库 += "\t\tfor(int i=0;i<数据.Tables[0].Rows.Count;i++)\r\n";
            编译器.方法库 += "\t\t{\r\n";
            编译器.方法库 += 行代码;
            编译器.方法库 += "\t\t}\r\n";
            编译器.方法库 += "\t\t"+分页代码变量+"_分页跳转=分页.生成代码(false);\r\n";
            编译器.方法库 += "\t\treturn 返回值.ToString();\r\n";
            编译器.方法库 += "\t}\r\n";
        }
    }
}