博客园_Code For Future Life

变成百万富翁的二十五种方法

2012-02-09T14:26:00Z

1、做你真正感兴趣的事——你会花很多时间在上面，因此你一定要感兴趣才行，如果不是这样的话，你不会愿意把时间花在上面，就得不到成功。

　　2、自己当老板，为别人打工，你绝不会变成巨富，老板一心一意地缩减开支，他的目标不是使他的职员变成有钱人。

　　3、提供一种有实效的服务，或一种实际的产品，你要以写作、绘画或作曲变成百万富翁的机会可以说是无限小。而你要在营造业、房地产、制造业发大财的机会比较大。记住，出版商赚的钱比作家多得多。

　　4、如果你坚持要又自己的灵感来创业。最好选择娱乐业，在这方面，发财的速度相当快，流行歌曲和电视最理想。

　　5、不论你是演员或商人。尽量增加你的观众，在小咖啡馆唱歌的人，所赚的钱一定比不上替大唱片公司灌唱片的人，地方性的商人，不会比全国性的商人赚得的钱多。

　　6、找出一种需要，然后满足它，社会越变越复杂，人们所需要的产品和服务越来越多，最先发现这些需求而且满足他们的人，是改进现有产品和服务的人，也是最先成为富翁的人。

　　7、不要不敢采用不同的方式——新的方法和新产品，会造成新的财富。但必须确定你的新方法比旧方法更理想，你的新方法必须增进产品外观、效率、品质、方便或者减低成本。

　　8、如果你受过专业教育。或者特殊才能，充分利用它，如果你烧得一手好菜，而要去当泥水匠，那就太笨了。

　　9、在你着手任何事情之前，仔细地对周围的情形研究一番，政府机关和公共图书馆，可以提供不少资料，先做研究，可以节省你不少时间和金钱。

　　10、不要一直都想着发大财，不如你想想如何改进你的事业，您应该常常问自己的是：“我如何改良我的事业？”如何使事业进行顺利，财富就会跟着而来。

　　11、可能的话，进行一种家庭事业，这种方法可以减低费用，增进士气，利润的分配很简单，利润能够得到充分的利用，整个事业控制也较容易。

　　12、尽可能减低你的费用，但不能牺牲你的品质，否则的话，你等于是在慢性*，赚钱的机会不会大。

　　13、跟同行的分维持友谊——他们可能对你很有帮助。

　　14、尽量把时间花在你的事业上，一天十二小时，一星期六天。是最低的要求，一天十四小时到十八小时是很平常，一星期工作七天最好了。你必须先生家庭和社会上的娱乐，直到你事业站稳为止，也只有到那时候，你才能把责任分给别人。

　　15、不要不敢自己下决心，听听别人的赞美和批评，但你自己要下决心。

　　16、不要不敢说实话，拐弯抹角，只会浪费时间，心理想什么，就说什么，而且要尽可能地直截了当地、明确地说出来。

　　17、不要不敢承认自己的错误，犯了错误并不是一种罪行，犯错不改才是罪过。

　　18、不要因为失败就裹足不前，失败是难免的，也是有价值的，从失败中，你会学到正确的方法论。

　　19、不要在不可行的观念上打转，一发现其某种方法行不通，立即把它放弃，世界上有无数的方法，把时间浪费在那些不可行的方法上是无可弥补的损失。

　　20、不要冒你承担不起的风险，如果你损失十万元，若损失的起的话，就可以继续下去，但如果你赔不起五万元，而一旦失败的话，你就完蛋了。

　　21、一再投资，不要认你的利润空闲着，你的利润要继续投资下去，最好投资别的事业或你控制的事业上，那样，钱才能钱滚钱，替你增加好几倍的财富。

　　22、请一位高明的律师——他会替你节约更多的金钱和时间，比起你所给以的将要多得多。

　　23、请一位精明的会计师，最初的时候，你自己记账，但除非你本身是个会计师，你还是请一位精明的会计师，可能决定你的成功和失败——他是值得你花钱的。

　　24、请专家替你报税，一位机灵的税务专家，可又替你免很多的税。

　　25、好好维持你的健康和你的平静心灵——否则的话，拥有再多的钱也没有什么意思。

本文链接

今天终于测试解决了WCF传递大数据量的问题

2011-06-30T02:43:00Z

Web.config上的配置：

<system.serviceModel>
        <behaviors>
            <serviceBehaviors>
                <behavior name="MyDataService_Behavior">
                    <serviceMetadata httpGetEnabled="true" />
                    <serviceDebug includeExceptionDetailInFaults="false" />
                    <dataContractSerializer maxItemsInObjectGraph="2147483647"/>
                </behavior>
            </serviceBehaviors>
        </behaviors>

ServiceReferences.ClientConfig的配置：

<system.serviceModel>
    <bindings>
      <basicHttpBinding>
        <binding name="BasicHttpBinding_MyDataService" maxBufferSize="2147483647"
          maxReceivedMessageSize="2147483647">
          <security mode="None" />
        </binding>
      </basicHttpBinding>
    </bindings>
    <client>
      <endpoint address="http://localhost:1816/MyDataService.svc" binding="basicHttpBinding"
        bindingConfiguration="BasicHttpBinding_MyDataService" contract="MySerRef.MyDataService"
        name="BasicHttpBinding_MyDataService" />
    </client>
</system.serviceModel>

测试时查询了50000条记录，每条记录有不少于40个字段。

本文链接

关于工作流设计方面的一些经验总结

2011-06-28T06:38:00Z

企业的管理者要求:

业务流程的办理要高效透明,
政令的下达与意见的反馈要即时准确,
任何行为要在"制定者,行使者,监督者"相互制衡的环境下进行
管理者在制定新的流程时,可以参考以前流程的优点与不号
行使者在执行流程中,即可得到流程的约束,又可以得到流程的指道
监督者可即时的发现流程的不各种违纪行为,即时指正,并可事后考核

工作流系统特点：

这个系统以企业的组织结构与业务类型为基础数据,初始化了一个责权利相互制约的数学模型与业务模型
具体的管理业务人员,根据业务模型创建,调整具体的业务流程,制做在流程中需要填写的业务表单
其它的业务人员,依据自已在业务模型中的职能,启动,处理,管理,监督,查看业务流程
数据分析人员,,根据业务模型,自已创建所需要的报表.

本文链接

Telnet客户端

2011-06-21T05:01:00Z

今天早上根据网友夏春涛的代码，整理了一下，做了一个telnet客户端。利用Socket建立与服务器（cisco路由器）的管道，然后输入指令，接收回发的数据，并进行数据处理。

不过还是有一些bug，以后继续完善。

代码链接：http://files.cnblogs.com/futureflare/GaoTelnet.rar

主要的一些函数：

/// <summary>        
        /// 当接收完成后,执行的方法(供委托使用)       
        /// </summary>      
        /// <param name="ar"></param>       
        private void OnRecievedData(IAsyncResult ar)
        {
            try
            {
                //从参数中获得给的socket 对象           
                Socket sock = (Socket)ar.AsyncState;

                //EndReceive方法为结束挂起的异步读取         
                int nBytesRec = sock.EndReceive(ar);
                //如果有接收到数据的话            
                if (nBytesRec > 0)
                {
                    //声明一个字符串,用来存储解析过的字符串                
                    string m_strLine = "";
                    //遍历Socket接收到的字符                 
                    /*       
                     * 此循环用来调整linux 和 windows在换行上标记的区别       
                     * 最后将调整好的字符赋予给 m_strLine      
                     */
                    for (int i = 0; i < nBytesRec; i++)
                    {
                        Char ch = Convert.ToChar(m_byBuff[i]);
                        switch (ch)
                        {
                            case '\r':
                                m_strLine += Convert.ToString("\r\n");
                                break;
                            case '\n':
                                break;
                            default:
                                m_strLine += Convert.ToString(ch);
                                break;
                        }
                    }
                    try
                    {
                        //获得转义后的字符串的长度                  
                        int strLinelen = m_strLine.Length;
                        //如果长度为零                   
                        if (strLinelen == 0)
                        {
                            //则返回"\r\n" 即回车换行                    
                            m_strLine = Convert.ToString("\r\n");
                        }
                        //建立一个流,把接收的信息(转换后的)存进 mToProcess 中   
                        Byte[] mToProcess = new Byte[strLinelen];
                        for (int i = 0; i < strLinelen; i++)
                            mToProcess[i] = Convert.ToByte(m_strLine[i]);
                        //对接收的信息进行处理,包括对传输过来的信息的参数的存取和       
                        string mOutText = ProcessOptions(mToProcess);
                        
                        mOutText = ConvertToGB2312(mOutText);
                        strWorkingDataX = mOutText;
                        
                        //解析命令后返回 显示信息(即除掉了控制信息)                        
                        if (mOutText != "")
                        {                            
                            strWorkingData = mOutText;
                            strFullLog += mOutText;                            

                        }
                        //接收完数据,处理完字符串数据等一系列事物之后,开始回发数据          
                        RespondToOptions();
                    }
                    catch (Exception ex)
                    {
                        throw new Exception("接收数据的时候出错了! " + ex.Message);
                    }
                }
                else// 如果没有接收到任何数据的话           
                {
                    // 关闭连接            
                    // 关闭socket               
                    sock.Shutdown(SocketShutdown.Both);
                    sock.Close();
                }
            }
            catch { }
        }

       /// <summary>        
        /// 解析接收的数据,生成最终用户看到的有效文字,同时将附带的参数存储起来       
        ///</summary>       
        ///<param name="m_strLineToProcess">收到的处理后的数据</param>     
        /// <returns></returns>     
        private string ProcessOptions(byte[] m_strLineToProcess)
        {
            string m_DISPLAYTEXT = "";
            string m_strTemp = "";
            string m_strOption = "";
            string m_strNormalText = "";
            bool bScanDone = false;
            int ndx = 0;
            int ldx = 0;
            char ch;
            try
            {
                //把数据从byte[] 转化成string    
                for (int i = 0; i < m_strLineToProcess.Length; i++)
                {
                    Char ss = Convert.ToChar(m_strLineToProcess[i]);
                    m_strTemp = m_strTemp + Convert.ToString(ss);
                }

                //此处意义为,当没描完数据前,执行扫描      
                while (bScanDone != true)
                {
                    //获得长度                
                    int lensmk = m_strTemp.Length;
                    //之后开始分析指令,因为每条指令为255 开头,故可以用此来区分出每条指令 
                    ndx = m_strTemp.IndexOf(Convert.ToString(IAC));
                    //此处为出错判断,本无其他含义               
                    if (ndx > lensmk)
                        ndx = m_strTemp.Length;

                    //此处为,如果搜寻到IAC标记的telnet 指令,则执行以下步骤        
                    if (ndx != -1)
                    {
                        #region 如果存在IAC标志位
                        // 将 标志位IAC 的字符 赋值给最终显示文字           
                        m_DISPLAYTEXT += m_strTemp.Substring(0, ndx);
                        // 此处获得命令码              
                        ch = m_strTemp[ndx + 1];
                        //如果命令码是253(DO) 254(DONT)  521(WILL) 252(WONT) 的情况下 
                        if (ch == DO || ch == DONT || ch == WILL || ch == WONT)
                        {

                            //将以IAC 开头3个字符组成的整个命令存储起来          
                            m_strOption = m_strTemp.Substring(ndx, 3);
                            m_ListOptions.Add(m_strOption);
                            // 将 标志位IAC 的字符 赋值给最终显示文字                         
                            m_DISPLAYTEXT += m_strTemp.Substring(0, ndx);
                            //将处理过的字符串删去                          
                            string txt = m_strTemp.Substring(ndx + 3);
                            m_strTemp = txt;
                        }
                        //如果IAC后面又跟了个IAC (255)  
                        else if (ch == IAC)
                        {
                            //则显示从输入的字符串头开始,到之前的IAC 结束        
                            m_DISPLAYTEXT = m_strTemp.Substring(0, ndx);
                            //之后将处理过的字符串排除出去                  
                            m_strTemp = m_strTemp.Substring(ndx + 1);
                        }
                        //如果IAC后面跟的是SB(250)       
                        else if (ch == SB)
                        {
                            m_DISPLAYTEXT = m_strTemp.Substring(0, ndx);
                            ldx = m_strTemp.IndexOf(Convert.ToString(SE));
                            m_strOption = m_strTemp.Substring(ndx, ldx);
                            m_ListOptions.Add(m_strOption);
                            m_strTemp = m_strTemp.Substring(ldx);
                        }
                        #endregion
                    }
                    //若字符串里已经没有IAC标志位了  
                    else
                    {

                        //显示信息累加上m_strTemp存储的字段      
                        m_DISPLAYTEXT = m_DISPLAYTEXT + m_strTemp;
                        bScanDone = true;
                    }
                }
                //输出人看到的信息    
                m_strNormalText = m_DISPLAYTEXT;
            }
            catch (Exception eP)
            {
                throw new Exception("解析传入的字符串错误:" + eP.Message);
            }

            return m_strNormalText;
        }

本文链接

字符串表达式求值(转)

2011-06-21T04:54:00Z

最近要开发表单设计器，要用到公式处理方面的程序，以下是表达式计算的方法，网上Copy的，留给自己作为参考。

表达式表示法

算术表达式中最常见的表示法形式有 中缀、前缀和后缀表示法。中缀表示法是书写表达式的常见方式，而前缀和后缀表示法主要用于计算机科学领域。

中缀表示法
中缀表示法是算术表达式的常规表示法。称它为中缀表示法是因为每个操作符都位于其操作数的中间，这种表示法只适用于操作符恰好对应两个操作数的时候（在操作符是二元操作符如加、减、乘、除以及取模的情况下）。对以中缀表示法书写的表达式进行语法分析时，需要用括号和优先规则排除多义性。

Syntax: operand1 operator operand2Example: (A+B)*C-D/(E+F)

前缀表示法
前缀表示法中，操作符写在操作数的前面。这种表示法经常用于计算机科学，特别是编译器设计方面。为纪念其发明家 ― Jan Lukasiewicz（请参阅参考资料），这种表示法也称 波兰表示法。

Syntax  : operator operand1 operand2Example : -*+ABC/D+EF

后缀表示法
在后缀表示法中，操作符位于操作数后面。后缀表示法也称 逆波兰表示法（reverse Polish notation，RPN），因其使表达式求值变得轻松，所以被普遍使用。

Syntax  : operand1 operand2 operatorExample : AB+C*DEF+/-

前缀和后缀表示法有三项公共特征：

操作数的顺序与等价的中缀表达式中操作数的顺序一致
不需要括号
操作符的优先级不相关

中缀表达式到后缀表达式的转换

要把表达式从中缀表达式的形式转换成用后缀表示法表示的等价表达式，必须了解操作符的优先级和结合性。 优先级或者说操作符的强度决定求值顺序；优先级高的操作符比优先级低的操作符先求值。如果所有操作符优先级一样，那么求值顺序就取决于它们的 结合性。操作符的结合性定义了相同优先级操作符组合的顺序（从右至左或从左至右）。

Left associativity  : A+B+C = (A+B)+CRight associativity : A^B^C = A^(B^C)

转换过程包括用下面的算法读入中缀表达式的操作数、操作符和括号：

初始化一个空堆栈，将结果字符串变量置空。
从左到右读入中缀表达式，每次一个字符。
如果字符是操作数，将它添加到结果字符串。
如果字符是个操作符，弹出（pop）操作符，直至遇见开括号（opening parenthesis）、优先级较低的操作符或者同一优先级的右结合符号。把这个操作符压入（push）堆栈。
如果字符是个开括号，把它压入堆栈。
如果字符是个闭括号（closing parenthesis），在遇见开括号前，弹出所有操作符，然后把它们添加到结果字符串。
如果到达输入字符串的末尾，弹出所有操作符并添加到结果字符串。

后缀表达式求值

对后缀表达式求值比直接对中缀表达式求值简单。在后缀表达式中，不需要括号，而且操作符的优先级也不再起作用了。您可以用如下算法对后缀表达式求值：

初始化一个空堆栈
从左到右读入后缀表达式
如果字符是一个操作数，把它压入堆栈。
如果字符是个操作符，弹出两个操作数，执行恰当操作，然后把结果压入堆栈。如果您不能够弹出两个操作数，后缀表达式的语法就不正确。
到后缀表达式末尾，从堆栈中弹出结果。若后缀表达式格式正确，那么堆栈应该为空。

 #region 中缀转后缀
        /// <summary>
        /// 中缀表达式转换为后缀表达式
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        public static string InfixToPostfix(string expression)
        {
            Stack<char> operators = new Stack<char>();
            StringBuilder result = new StringBuilder();
            for (int i = 0; i < expression.Length; i++)
            {
                char ch = expression[i];
                if (char.IsWhiteSpace(ch)) continue;
                switch (ch)
                {
                    case '+':
                    case '-':
                        while (operators.Count > 0)
                        {
                            char c = operators.Pop();   //pop Operator
                            if (c == '(')
                            {
                                operators.Push(c);      //push Operator
                                break;
                            }
                            else
                            {
                                result.Append(c);
                            }
                        }
                        operators.Push(ch);
                        result.Append(" ");
                        break;
                    case '*':
                    case '/':
                        while (operators.Count > 0)
                        {
                            char c = operators.Pop();
                            if (c == '(')
                            {
                                operators.Push(c);
                                break;
                            }
                            else
                            {
                                if (c == '+' || c == '-')
                                {
                                    operators.Push(c);
                                    break;
                                }
                                else
                                {
                                    result.Append(c);
                                }
                            }
                        }
                        operators.Push(ch);
                        result.Append(" ");
                        break;
                    case '(':
                        operators.Push(ch);
                        break;
                    case ')':
                        while (operators.Count > 0)
                        {
                            char c = operators.Pop();
                            if (c == '(')
                            {
                                break;
                            }
                            else
                            {
                                result.Append(c);
                            }
                        }
                        break;
                    default:
                        result.Append(ch);
                        break;
                }
            }
            while (operators.Count > 0)
            {
                result.Append(operators.Pop()); //pop All Operator
            }
            return result.ToString();
        }
        #endregion
        #region 求值经典算法
        /// <summary>
        /// 求值的经典算法
        /// </summary>
        /// <param name="expression">字符串表达式</param>
        /// <returns></returns>
        public static double Parse(string expression)
        {
            string postfixExpression = InfixToPostfix(expression);
            Stack<double> results = new Stack<double>();
            double x, y;
            for (int i = 0; i < postfixExpression.Length; i++)
            {
                char ch = postfixExpression[i];
                if (char.IsWhiteSpace(ch)) continue;
                switch (ch)
                {
                    case '+':
                        y = results.Pop();
                        x = results.Pop();
                        results.Push(x + y);
                        break;
                    case '-':
                        y = results.Pop();
                        x = results.Pop();
                        results.Push(x - y);
                        break;
                    case '*':
                        y = results.Pop();
                        x = results.Pop();
                        results.Push(x * y);
                        break;
                    case '/':
                        y = results.Pop();
                        x = results.Pop();
                        results.Push(x / y);
                        break;
                    default:
                        int pos = i;
                        StringBuilder operand = new StringBuilder();
                        do
                        {
                            operand.Append(postfixExpression[pos]);
                            pos++;
                        } while (char.IsDigit(postfixExpression[pos]) || postfixExpression[pos] == '.');
                        i = --pos;
                        results.Push(double.Parse(operand.ToString()));
                        break;
                }
            }
            return results.Peek();
        }
        #endregion

本文链接

silverlight DataGrid模板列的动态生成

2011-06-20T09:44:00Z

string strXaml = @" <DataTemplate xmlns='http://schemas.microsoft.com/client/2007'>
            <Grid HorizontalAlignment='Center' VerticalAlignment='Center'>
                <Grid.RowDefinitions>
                    <RowDefinition Height='35'></RowDefinition>
                    <RowDefinition Height='35'></RowDefinition>
                </Grid.RowDefinitions>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width='150'></ColumnDefinition>
                    <ColumnDefinition Width='150'></ColumnDefinition>
                </Grid.ColumnDefinitions>
                    <TextBlock Text='Col1'></TextBlock>
                    <TextBlock Text='Col2' Grid.Column='1'></TextBlock>
                {0}
            </Grid>
                </DataTemplate>";

            StringBuilder sb = new StringBuilder();
            int k = 0;
            foreach (var item in this.objTableCaseTemplate.lstDBCaseItemTemplate)
            {
                if (k >= 2) break;
                string tbn = "DB_" + item.PhyTbName;
                string s = item.ItemName;
                sb.AppendLine("<TextBox Text='{Binding Path=" + tbn + "." + s + ",Mode=TwoWay }' Grid.Column='" + k + "' Grid.Row='1'/>");
                k++;
            }

strXaml = string.Format(strXaml, sb.ToString());

DataTemplate dtTemplate = (DataTemplate)XamlReader.Load(strXaml);

DataGridTemplateColumn tmpCol = new DataGridTemplateColumn();
            tmpCol.Header = "某个组";
            tmpCol.CellTemplate = dtTemplate;
            this.dataGridCaseList.Columns.Add(tmpCol);

本文链接

关于事件处理的完整框架Event，delegate，event args，无图有真相。

2011-06-20T02:57:00Z

public delegate void SelectItemsChangedEventHandler(ItemChangingEventArgs e);
    public class ItemChangingEventArgs : EventArgs
    {
        public List<string> lstSelItems { get; set; }  //这里存放用户选择的分类信息
    }

    public class Win子窗口
    {
        public event SelectItemsChangedEventHandler SelectItemsChangedEvent;


        public void Win子窗口_Closed()
        {
            ItemChangingEventArgs args = new ItemChangingEventArgs();
            args.lstSelItems = new List<string>();
            //获取用户选择的分类信息...

            //调用自定义事件通知主窗口
            this.SelectItemsChangedEvent(args);
        }

        public void 树形控件SelectIndexChanged事件处理函数()
        {
            ItemChangingEventArgs args = new ItemChangingEventArgs();
            args.lstSelItems = new List<string>();
            //获取用户选择的分类信息...

            //调用自定义事件通知主窗口
            this.SelectItemsChangedEvent(args);
        }
    }

    public class Win主窗口
    {
        Win子窗口 winChild;
        public Win主窗口()
        {
            //主窗口构造函数中初始化子窗口对象，但是不显示，需要的时候调用Show
            winChild = new Win子窗口();
            winChild.SelectItemsChangedEvent += new SelectItemsChangedEventHandler(winChild_SelectItemsChangedEvent);

        }

        //子窗口分类项选择事件处理
        void winChild_SelectItemsChangedEvent(ItemChangingEventArgs e)
        {
            List<string> lstRt = e.lstSelItems;
            //做需要的事情
            //...
        }
        
    }

本文链接

关于树形结构父类查子类，子类查父类的方法

2011-06-20T02:50:00Z

ID，Name， ParentID，Level，三个字段就可以描述树形结构了。其他业务信息可以额外添加。这四个是主要的。我看你的问题是想快速查询而已。

如果用Oracle，可以参考以下示例：

TB_ORGAN表定义：
ORG_ID       （节点ID）
ORG_NAME     （节点名称）
ORG_PARENTID （父节点ID）
ORG_LEVEL    （节点级别）

1.根据子类查其父类：

根据某个子节点的ID，选择其某个级别（例如Lev001）的父节点的SQL脚本：

SELECT ORG_NAME from TB_ORGAN WHERE ORG_LEVEL = 'Lev001' CONNECT BY ORG_ID = PRIOR ORG_PARENTID START WITH ORG_ID = '某个子节点的ID' AND ROWNUM = 1

2.根据父类查其子类：

SELECT ORG_ID, ORG_NAME, ORG_PARENTID from TB_ORGAN CONNECT BY ORG_PARENTID = PRIOR ORG_ID START WITH ORG_ID = '某个父节点ID'

上边这条语句，你也可以增加where条件，增加子节点级别，这样可以只查询某个级别的子节点。

好了，兄弟，这样的设计可以彻底解决树形结构的查询问题了吧。至于你想把Level如何定义，看你自己需求了，可以定义一些特征，这样加快查询速度。呵呵

本文链接

最近准备整理一下手头资料，开发一个工作流和表单管理系统

2011-06-20T01:22:00Z

一直以来，我都有个梦想，如果程序能够用人类的思考方式进行编写，那多好啊。不管什么编程语言，最直接的还是自然语言。但是自然语言实在太复杂，不是我辈能够解决，甚至有点狂想而已。

但是，工作流和表单这两个东西在解决业务流程方面的确向自然语言迈进了很大一步。如果我们能够定义一套表单生成语言，而不是仅仅图形化表单设计这种方式，那有多好啊。

工作流系统也太复杂了，所以自己平时也只是根据实际业务需求，开发一些简单的流程控制程序实现而已。

近几个月学习了WF4.0，觉得我应该好好利用一下这个平台，做一个对自己工作更加有帮助的，功能也更多的工作流系统。呵呵，只是为了以后工作不那么辛苦，可以利用现成的平台代码啦。

说起WF4.0，我觉得最大的改进就是Bookmark，这个是我最喜欢的一个功能。WF3.0是用事件驱动的，事件都要预先定义，很难做到动态。但是Bookmark就不同了，说白了，可以用一个字符串开启一个流程，

并切入某个状态进行。这样，我就可以利用这个特性来开发动态工作流了。

至于表单设计，想来，很多人应该都很熟悉了，也不是什么神秘的东西。不外乎物理表增删改，同时配合一组物理表信息管控表，用来实现各项功能罢了。只是，要做好一个既方便使用，又功能强大的表单设计器，

要考虑到很多问题，美工啊，可用性啊等等。接下来，自己要想很多大拿学习，开发一套这样的系统。

本文链接

今天装好了window 7

2010-01-31T13:49:00Z

今天装好了windows 7 旗舰版，试用了一个下午，感觉真是不错。把Vs2008装了，和以前XP上的安装过程没区别。系统兼容性非常好。尤其喜欢窗口拖放进行最大化和正常化的功能。还有华丽的主题，也是非常吸引我的。接下来要好好享受这个新系统啦。