一个简单的序列生成规则

　　RT，直接上代码，希望能够得到一些指点。

 

using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using System.IO;
using System.Threading;

namespace WebTest
{
    public partial class _Default : System.Web.UI.Page
    {
        //定义应用的字符集
        private static readonly char[] WORD = {
                                                  '0', '1', '2', '3', '4', '5', '6', '7', '8', 
                                                  '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 
                                                  'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 
                                                  'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
                                              };
        //private static readonly char[] WORD = {
        //                                          '0', '1', '2'
        //                                      };

        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                this.CreateIdentity();
            }
        }

        private void CreateIdentity()
        {
            try
            {
                // 获取排他锁
                Monitor.Enter(WORD);
                // 声明目标文件路径
                string strPath = Server.MapPath(@"Identity\" + DateTime.Now.ToString("yyyyMMdd") + ".txt");
                // 如果不存在则创建该文件
                if (!File.Exists(strPath))
                {
                    File.Create(strPath).Close();
                }
                // 打开文件
                FileStream fs = File.OpenRead(strPath);
                // 套接读取流
                StreamReader sr = new StreamReader(fs);
                // 读取数据
                string strTemp = sr.ReadToEnd();
                // 关闭打开的流
                sr.Close();
                fs.Close();

                if (string.IsNullOrEmpty(strTemp))
                {
                    strTemp = "00000";
                }
                else
                {
                    char[] chsTemp = strTemp.ToCharArray();

                    // 第五位的索引以及是否回归的标识
                    int index4 = 0;
                    bool flag4 = false;

                    // 第四位的索引以及是否回归的标识
                    int index3 = 0;
                    bool flag3 = false;

                    // 第三位的索引以及是否回归的标识
                    int index2 = 0;
                    bool flag2 = false;

                    // 第二位的索引以及是否回归的标识
                    int index1 = 0;
                    bool flag1 = false;

                    // 第一位的索引以及是否回归的标识
                    int index0 = 0;
                    bool flag0 = false;

                    // 开始检索序列
                    for (int i = 0; i < WORD.Length; i++)
                    {
                        // 检索第五位
                        if (chsTemp[4] == WORD[i])
                        {
                            // 如果当前索引已经是最大时，则回归并标记"已回归"；否则进一位
                            if (i == WORD.Length - 1)
                            {
                                index4 = 0;
                                flag4 = true;
                            }
                            else
                            {
                                index4 = i + 1;
                            }
                        }
                        // 检索第四位
                        if (chsTemp[3] == WORD[i])
                        {
                            // 如果当前索引已经是最大时，则回归并标记"已回归"；否则进一位
                            if (i == WORD.Length - 1)
                            {
                                index3 = 0;
                                flag3 = true;
                            }
                            else
                            {
                                index3 = i + 1;
                            }
                        }
                        // 检索第三位
                        if (chsTemp[2] == WORD[i])
                        {
                            // 如果当前索引已经是最大时，则回归并标记"已回归"；否则进一位
                            if (i == WORD.Length - 1)
                            {
                                index2 = 0;
                                flag2 = true;
                            }
                            else
                            {
                                index2 = i + 1;
                            }
                        }
                        // 检索第二位
                        if (chsTemp[1] == WORD[i])
                        {
                            // 如果当前索引已经是最大时，则回归并标记"已回归"；否则进一位
                            if (i == WORD.Length - 1)
                            {
                                index1 = 0;
                                flag1 = true;
                            }
                            else
                            {
                                index1 = i + 1;
                            }
                        }
                        // 检索第一位
                        if (chsTemp[0] == WORD[i])
                        {
                            // 如果当前索引已经是最大时，则回归并标记"已回归"；否则进一位
                            if (i == WORD.Length - 1)
                            {
                                index0 = 0;
                                flag0 = true;
                            }
                            else
                            {
                                index0 = i + 1;
                            }
                        }
                    }

                    // 如果所有位都回归则表示组合序列已达到极限
                    if (flag4 && flag3 && flag2 && flag1 && flag0)
                    {
                        Response.Write("已经达到最大限度！");
                    }
                    else
                    {
                        // 第一位
                        if (flag4 && flag3 && flag2 && flag1 && !flag0)
                        {
                            strTemp = WORD[index0].ToString();
                        }
                        else if (flag0)
                        {
                            if (!flag4 || !flag3 || !flag2 || !flag1)
                            {
                                strTemp = WORD[WORD.Length - 1].ToString();
                            }
                            else
                            {
                                strTemp = WORD[index0].ToString();
                            }
                        }
                        else
                        {
                            strTemp = WORD[index0 - 1].ToString();
                        }

                        // 第二位
                        if (flag4 && flag3 && flag2)
                        {
                            strTemp += WORD[index1].ToString();
                        }
                        else if (flag1)
                        {
                            if (!flag4 || !flag3 || !flag2)
                            {
                                strTemp += WORD[WORD.Length - 1].ToString();
                            }
                            else
                            {
                                strTemp += WORD[index1].ToString();
                            }
                        }
                        else
                        {
                            strTemp += WORD[index1 - 1].ToString();
                        }

                        // 第三位
                        if (flag4 && flag3)
                        {
                            strTemp += WORD[index2].ToString();
                        }
                        else if (flag2)
                        {
                            if (!flag4 || !flag3)
                            {
                                strTemp += WORD[WORD.Length - 1].ToString();
                            }
                            else
                            {
                                strTemp += WORD[index2].ToString();
                            }
                        }
                        else
                        {
                            strTemp += WORD[index2 - 1].ToString();
                        }

                        // 第四位
                        if (flag4)
                        {
                            strTemp += WORD[index3].ToString();
                        }
                        else if (!flag4 && flag3)
                        {
                            strTemp += WORD[WORD.Length - 1].ToString();
                        }
                        else
                        {
                            strTemp += WORD[index3 - 1].ToString();
                        }

                        // 第五位
                        strTemp += WORD[index4].ToString();
                    }
                }

                StreamWriter sw = new StreamWriter(strPath, false, System.Text.Encoding.Default);
                sw.Write(strTemp);
                sw.Flush();
                sw.Close();
                fs.Close();

                sr = null;
                sw = null;
                fs = null;

                Response.Write(DateTime.Now.ToString("yyMMdd") + strTemp);
            }
            catch (Exception ex)
            {
                Response.Write(ex.Message);
            }
            finally
            {
                Monitor.Exit(WORD);
                Response.Write(" Over!");
            }
        }

    }
}

 

运行效果的话，可以自己跑一下看看。

转载于:https://www.cnblogs.com/gexiaoliang/archive/2010/10/27/1863029.html