隔了很久没写东西了,主要是最近比较忙,更主要的是最近比较懒......

其实这篇很早就想写了

工作和生活中经常可以看到一些程序猿,写代码的时候只关注代码的逻辑性,而不考虑运行效率

其实这对大多数程序猿来说都是没有问题的

不过作为一只有理想的CodeMonkey,我还是希望给大家分享一些性能优化心得

曾经在网上听过这样一句话

程序的可读性和性能是成反比的

我非常赞同这句话,所以对于那些极度影响阅读的性能优化我就不在这里赘述了

今天主要说的就是一些举手之劳即可完成的性能优化

减少重复代码

这是最基本的优化方案,尽可能减少那些重复做的事,让他们只做一次

比较常见是这种代码,同样的Math.Cos(angle) 和Math.Sin(angle)都做了2次

  1. private Point RotatePt(double angle, Point pt)
  2. {
  3.      Point pRet = new Point();
  4.      angle = -angle;
  5.      pRet.X = (int)((double)pt.X * Math.Cos(angle) - (double)pt.Y * Math.Sin(angle));
  6.      pRet.Y = (int)((double)pt.X * Math.Sin(angle) + (double)pt.Y * Math.Cos(angle));
  7.      return pRet;
  8. }

优化后

  1. private Point RotatePt3(double angle, Point pt)
  2. {
  3.     Point pRet = new Point();
  4.     angle = -angle;
  5.     double SIN_ANGLE = Math.Sin(angle);
  6.     double COS_ANGLE = Math.Cos(angle);
  7.     pRet.X =(int)(pt.X * COS_ANGLE - pt.Y * SIN_ANGLE);
  8.     pRet.Y = (int)(pt.X * SIN_ANGLE + pt.Y * COS_ANGLE);
  9.     return pRet;
  10. }

还有另一种 ,在方法中实例化一个对象, 但是这个对象其实是可以复用的

  1. public static string ConvertQuot(string html)
  2. {
  3.     Regex regex = new Regex("&(quot|#34);", RegexOptions.IgnoreCase);
  4.     return regex.Replace(html, "\"");
  5. }

优化后

  1. readonly static Regex ReplaceQuot = new Regex("&(quot|#34);", RegexOptions.IgnoreCase | RegexOptions.Compiled);
  2. public static string ConvertQuot(string html)
  3. {
  4.     return ReplaceQuot.Replace(html, "\"");
  5. }

还有一种是不必要的初始化,比如调用out参数之前,是不需要初始化的

  1. public bool Check(int userid)
  2. {
  3.     var user = new User();
  4.     if(GetUser(userid,out user))
  5.     {
  6.         return user.Level > ;
  7.     }
  8.     return false;
  9. }

这里的new User()就是不必要的操作,

优化后

  1. public bool Check(int userid)
  2. {
  3.     User user;
  4.     if(GetUser(userid,out user))
  5.     {
  6.         return user.Level > ;
  7.     }
  8.     return false;
  9. }

不要迷信正则表达式

正好在第一个栗子里说到了正在表达式(Regex)对象就顺便一起说了

很多人以为正则表达式很快,非常快,超级的快

虽然正则表达式是挺快的,不过千万不要迷信他,不信你看下面的栗子

  1. //方法1
  2. public static string ConvertQuot1(string html)
  3. {
  4.     return html.Replace(""", "\"").Replace(""", "\"");
  5. }
  6.  
  7. readonly static Regex ReplaceQuot = new Regex("&(quot|#34);", RegexOptions.IgnoreCase | RegexOptions.Compiled);
  8. //方法2
  9. public static string ConvertQuot2(string html)
  10. {
  11.     return ReplaceQuot.Replace(html, "\"");
  12. }

有多少人认为正则表达式比较快的,举个手??

结果为10w次循环的时间 ,即使是10个Replace连用,也比Regex好,所以不要迷信他

  1. //方法1
  2. public static string ConvertQuot1(string html)
  3. {
  4.     return html.Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "");
  5. }
  6.  
  7. readonly static Regex ReplaceQuot = new Regex("[1234567890]", RegexOptions.IgnoreCase | RegexOptions.Compiled);
  8. //方法2
  9. public static string ConvertQuot2(string html)
  10. {
  11.     return ReplaceQuot.Replace(html, "");
  12. }

ConvertQuot1:3518
ConvertQuot2:12479

最后给你们看一个真实的,杯具的栗子

  1. Htmlstring = Regex.Replace(Htmlstring, @"<(.[^>]*)>", "", RegexOptions.IgnoreCase);
  2. Htmlstring = Regex.Replace(Htmlstring, @"([\r\n])[\s]+", "", RegexOptions.IgnoreCase);
  3. Htmlstring = Regex.Replace(Htmlstring, @"-->", "", RegexOptions.IgnoreCase);
  4. Htmlstring = Regex.Replace(Htmlstring, @"<!--.*", "", RegexOptions.IgnoreCase);
  5.  
  6. Htmlstring = Regex.Replace(Htmlstring, @"&(quot|#34);", "\"", RegexOptions.IgnoreCase);
  7. Htmlstring = Regex.Replace(Htmlstring, @"&(amp|#38);", "&", RegexOptions.IgnoreCase);
  8. Htmlstring = Regex.Replace(Htmlstring, @"&(lt|#60);", "<", RegexOptions.IgnoreCase);
  9. Htmlstring = Regex.Replace(Htmlstring, @"&(gt|#62);", ">", RegexOptions.IgnoreCase);
  10. Htmlstring = Regex.Replace(Htmlstring, @"&(nbsp|#160);", " ", RegexOptions.IgnoreCase);
  11. Htmlstring = Regex.Replace(Htmlstring, @"&(iexcl|#161);", "\xa1", RegexOptions.IgnoreCase);
  12. Htmlstring = Regex.Replace(Htmlstring, @"&(cent|#162);", "\xa2", RegexOptions.IgnoreCase);
  13. Htmlstring = Regex.Replace(Htmlstring, @"&(pound|#163);", "\xa3", RegexOptions.IgnoreCase);
  14. Htmlstring = Regex.Replace(Htmlstring, @"&(copy|#169);", "\xa9", RegexOptions.IgnoreCase);
  15. Htmlstring = Regex.Replace(Htmlstring, @"&#(\d+);", "", RegexOptions.IgnoreCase);

合理使用正则表达式

上面说了正则表达式的效率不高,并不是说就不要用他了,至少正则表达式的作用不仅仅如此而已

如果一定要用正则表达式的话也需要注意,能静态全局公用的尽量全局公用

  1. readonly static Regex regex = new Regex("[1234567890]", RegexOptions.Compiled);

注意他的第二个参数RegexOptions.Compiled 注释是  指定将正则表达式编译为程序集。这会产生更快的执行速度，但会增加启动时间。

通俗的说就是加了这个枚举,会使得初始化Regex对象变慢,但是执行字符串查找的时候更快, 不使用的话,初始化很多,查询比较慢

之前测过相差蛮大的 ,代码就不比较了,有兴趣的可以自己试试相差多少

另外还有一些枚举项,不确定是否对性能有影响,不过还是按规则使用会比较好

  • RegexOptions.IgnoreCase    // 指定不区分大小写的匹配,  如果表达式中没有字母,则不需要设定
  • RegexOptions.Multiline         // 多行模式。更改 ^ 和 $ 的含义....  如果表达式中没有^和$,则不需要设定
  • RegexOptions.Singleline       // 指定单行模式。更改点 (.) 的含义....  如果表达式中没有.,则不需要设定

让编译器预处理常量的计算

编译器在编译程序段的时候 如果发现有一些运算是常量对常量的,那么他会在编译期间就计算完成,这样可以使程序在执行时不用重复计算了

比如

不过编译器有的时候也不是那么聪明的

这个时候就需要我们帮助一下了

给他加一个括号,让他知道应该先计算常量,这样就可以在编译期间进行运算了

字符串比较

这个可能很多人知道了,但还是提一下

  1. string s = "";
  2. ) if(s == ""){}
  3. ) if(s == string.Empty){}
  4. ) if (string.IsNullOrEmpty(s)) { }
  5. ) if(s != null && s.Length ==) {}
  6. ) if((s+"").Length == ){}

1,2最慢 3较快 4,5最快

1,2几乎没区别 4,5几乎没区别

不过这个只适用于比较null和空字符串,如果是连续的空白就是string.IsNullOrWhiteSpace最快了,不过这个方法2.0里面没有

所以2.0可以这样 (s+"").trim() == 0

这里的关键就是 s + ""  这个操作可以把null转换为""

注意第二个参数只能是""或string.Empty 这样的累加几乎是不消耗时间的,如果第二个参数是" "(一个空格)这个时间就远远不止了

字符串拼接

字符串累加,这个道理和Regex一样,不要盲目崇拜StringBuilder

在大量(或不确定的)string拼接的时候,StringBuilder确实可以起到提速的作用

而少数几个固定的string累加的时候就不需要StringBuilder 了,毕竟StringBuilder 的初始化也是需要时间的

感谢#5楼 2014-03-24 16:45 残蛹 博友提供的说明

ps: 这段我确实记得我是写过的来着,不知道怎么的,发出来的时候就不见了.....

此外还有一个string.Concat方法,该方法可以小幅度的优化程序的速度,幅度很小

他和string.Join的区别在于没有间隔符号(我之前常用string.Join("",a,b,c,d),不要告诉我只有我一个人这么干)

另一种经常遇到的字符串拼接

  1. public string JoinIds(List<User> users)
  2. {
  3.     StringBuilder sb = new StringBuilder();
  4.     foreach (var user in users)
  5.     {
  6.         sb.Append("'");
  7.         sb.Append(user.Id);
  8.         sb.Append("',");
  9.     }
  10.     sb.Length = sb.Length - ;
  11.     return sb.ToString();
  12. }

对于这种情况有2中优化的方案

对于3.5以上可以直接使用Linq辅助,这种方案代码少,但是性能相对差一些

  1. public string JoinIds(List<User> users)
  2. {
  3.     return "'" + string.Join("','", users.Select(it => it.Id)) + "'";
  4. }

对于非3.5或对性能要求极高的场合

  1. public string JoinIds(List<User> users)
  2. {
  3.     var ee = users.GetEnumerator();
  4.     StringBuilder sb = new StringBuilder();
  5.     if (ee.MoveNext())
  6.     {
  7.         sb.Append("'");
  8.         sb.Append(ee.Current.Id);
  9.         sb.Append("'");
  10.         while (ee.MoveNext())
  11.         {
  12.             sb.Append(",'");
  13.             sb.Append(ee.Current.Id);
  14.             sb.Append("'");
  15.         }
  16.     }
  17.     return sb.ToString();
  18. }

bool类型的判断返回

这种现象常见于新手程序员中

  1. //写法1
  2. if(state == )
  3. {
  4.     return true;
  5. }
  6. else
  7. {
  8.     return false;
  9. }
  10. //写法2
  11. return state ==  ? true : false;
  12. //优化后
  13. return state == ;

类型的判断

一般类型的判断有2种形式

1,这种属于代码比较好写,但是性能比较低, 原因就是GetType()的时候消耗了很多时间

  1. Type type = obj.GetType();
  2. switch (type.Name)
  3. {
  4.     case "Int32":
  5.         break;
  6.     case "String":
  7.         break;
  8.     case "Boolean":
  9.         break;
  10.     case "DateTime":
  11.         break;
  12.     ...
  13.     ...
  14.     default:
  15.         break;
  16. }

2,这种属性写代码麻烦,但是性能很高的类型

  1. if (obj is string)
  2. {
  3.  
  4. }
  5. else if (obj is int)
  6. {
  7.  
  8. }
  9. else if (obj is DateTime)
  10. {
  11.  
  12. }
  13. ...
  14. ...
  15. else
  16. {
  17.  
  18. }

其实有个中间之道,既可以保证性能又可以比较好写

  1. IConvertible conv = obj as IConvertible;
  2. if (conv != null)
  3. {
  4.     switch (conv.GetTypeCode())
  5.     {
  6.         case TypeCode.Boolean:
  7.             break;
  8.         case TypeCode.Byte:
  9.             break;
  10.         case TypeCode.Char:
  11.             break;
  12.         case TypeCode.DBNull:
  13.             break;
  14.         case TypeCode.DateTime:
  15.             break;
  16.         case TypeCode.Decimal:
  17.             break;
  18.         case TypeCode.Double:
  19.             break;
  20.         case TypeCode.Empty:
  21.             break;
  22.         case TypeCode.Int16:
  23.             break;
  24.         case TypeCode.Int32:
  25.             break;
  26.         ...
  27.         ...
  28.         default:
  29.             break;
  30.     }
  31. }
  32. else
  33. {
  34.     //处理其他类型
  35. }

大部分情况下 这个是可以用的 如果你自己有个类型实现了IConvertible,然后返回TypeCode.Int32 就不再这个讨论范围之内了

使用枚举作为索引

下面这个是一个真实的例子,为了突出重点,做了部分修改,删除了多余的分支,源代码中不只4个

  1. enum TemplateCode
  2. {
  3.     None = ,
  4.     Head = ,
  5.     Menu = ,
  6.     Foot = ,
  7.     Welcome = ,
  8. }
  9.  
  10. public string GetHtml(TemplateCode tc)
  11. {
  12.     switch (tc)
  13.     {
  14.         case TemplateCode.Head:
  15.             return GetHead();
  16.         case TemplateCode.Menu:
  17.             return GetMenu();
  18.         case TemplateCode.Foot:
  19.             return GetFoot();
  20.         case TemplateCode.Welcome:
  21.             return GetWelcome();
  22.         default:
  23.             throw new ArgumentOutOfRangeException("tc");
  24.     }
  25. }

优化后

  1. readonly static Func<string>[] GetTemplate = InitTemplateFunction();
  2.  
  3. private static Func<string>[] InitTemplateFunction()
  4. {
  5.     var arr = new Func<string>[];
  6.     arr[] = GetHead;
  7.     arr[] = GetMenu;
  8.     arr[] = GetFoot;
  9.     arr[] = GetWelcome;
        return arr;
  10. } 
  11.  
  12. public string GetHtml(TemplateCode tc)
  13. {
  14.     var index = (int)tc;
  15.     if (index >=  && index <= )
  16.     {
  17.         return GetTemplate[index]();
  18.     }
  19.     throw new ArgumentOutOfRangeException("tc");
  20. }

不过有的时候,枚举不一定都是连续的数字,那么也可以使用Dictionary

  1. readonly static Dictionary<TemplateCode, Func<string>> TemplateDict = InitTemplateFunction();
  2.  
  3. private static Dictionary<TemplateCode, Func<string>> InitTemplateFunction()
  4. {
  5.     var ditc = new Dictionary<TemplateCode, Func<string>>();
  6.     ditc.Add(TemplateCode.Head, GetHead);
  7.     ditc.Add(TemplateCode.Menu, GetMenu);
  8.     ditc.Add(TemplateCode.Foot, GetFoot);
  9.     ditc.Add(TemplateCode.Welcome, GetWelcome);
  10.     return ditc;
  11. } 
  12.  
  13. public string GetHtml(TemplateCode tc)
  14. {
  15.     Func<string> func;
  16.     if (TemplateDict.TryGetValue(tc,out func))
  17.     {
  18.         return func();
  19.     }
  20.     throw new ArgumentOutOfRangeException("tc");
  21. }

这种优化在分支比较多的时候很好用,少的时候作用有限

字符类型Char,分支判断时的处理技巧

这部分内容比较复杂,而且适用范围有限,如果平时用不到的就可以忽略了

在处理字符串对象的时候,有时会需要判断char的值然后做进一步的操作

  1. public string Show(char c)
  2. {
  3.     if (c >= '0' && c <= '9')
  4.     {
  5.         return "数字";
  6.     }
  7.     else if (c >= 'a' && c <= 'z')
  8.     {
  9.         return "小写字母";
  10.     }
  11.     else if (c >= 'A' && c <= 'Z')
  12.     {
  13.         return "大写字母";
  14.     }
  15.     else if (c == '/' || c == '\\' || c == '|'
  16.         || c == '$' || c == '#' || c == '+'
  17.         || c == '%' || c == '&' || c == '-'
  18.         || c == '^' || c == '*' || c == '=')
  19.     {
  20.         return "特殊符号";
  21.     }
  22.     else if (c == ',' || c == '.' || c == '!'
  23.         || c == ':' || c == ';' || c == '?'
  24.         || c == '"' || c == '\'')
  25.     {
  26.         return "标点符号";
  27.     }
  28.     else
  29.     {
  30.         return "其他";
  31.     }
  32. }

这里有一种空间换时间的优化方式, 虽说是空间换时间,但是实际浪费的空间不会很多,因为char最多只有65536长度

  1. readonly static byte[] CharMap = InitCharMap();
  2.  
  3. private static byte[] InitCharMap()
  4. {
  5.     var arr = new byte[char.MaxValue];
  6.     for (char i = ''; i <= ''; i++)
  7.     {
  8.         arr[i] = ;
  9.     }
  10.     for (char i = 'a'; i <= 'z'; i++)
  11.     {
  12.         arr[i] = ;
  13.     }
  14.     for (char i = 'A'; i <= 'Z'; i++)
  15.     {
  16.         arr[i] = ;
  17.     }
  18.     arr['/'] = ;
  19.     arr['\\'] = ;
  20.     arr['|'] = ;
  21.     arr['$'] = ;
  22.     arr['#'] = ;
  23.     arr['+'] = ;
  24.     arr['%'] = ;
  25.     arr['&'] = ;
  26.     arr['-'] = ;
  27.     arr['^'] = ;
  28.     arr['*'] = ;
  29.     arr['='] = ;
  30.  
  31.     arr[','] = ;
  32.     arr['.'] = ;
  33.     arr['!'] = ;
  34.     arr[':'] = ;
  35.     arr[';'] = ;
  36.     arr['?'] = ;
  37.     arr['"'] = ;
  38.     arr['\''] = ;
  39.     return arr;
  40. }
  41.  
  42. public string Show(char c)
  43. {
  44.     switch (CharMap[c])
  45.     {
  46.         case :
  47.             return "其他";
  48.         case :
  49.             return "数字";
  50.         case :
  51.             return "小写字母";
  52.         case :
  53.             return "大写字母";
  54.         case :
  55.             return "特殊符号";
  56.         case :
  57.             return "标点符号";
  58.         default:
  59.             return "其他";
  60.     }
  61. }

原先仅特殊符号一部分就需要判断12次,修改过后只判断一次就可以得到结果了

这方面的栗子在我的Json组件(代码)(文章1,2,3)中也有使用

  1. /// <summary>
  2. /// <para>包含1: 可以为头的字符</para>
  3. /// <para>包含2: 可以为单词的字符</para>
  4. /// <para>包含4: 可以为数字的字符</para>
  5. /// <para>等于8: 空白字符</para>
  6. /// <para>包含16:转义字符</para>
  7. /// <para></para>
  8. /// </summary>
  9. private readonly static byte[] _WordChars = new byte[char.MaxValue];
  10. private readonly static sbyte[] _UnicodeFlags = new sbyte[];
  11. private readonly static sbyte[, ,] _DateTimeWords;
  12. static UnsafeJsonReader()
  13. {
  14.     for (int i = ; i < ; i++)
  15.     {
  16.         _UnicodeFlags[i] = -;
  17.     }
  18.  
  19.     _WordChars['-'] =  | ;
  20.     _WordChars['+'] =  | ;
  21.  
  22.     _WordChars['$'] =  | ;
  23.     _WordChars['_'] =  | ;
  24.     for (char c = 'a'; c <= 'z'; c++)
  25.     {
  26.         _WordChars[c] =  | ;
  27.         _UnicodeFlags[c] = (sbyte)(c - 'a' + );
  28.     }
  29.     for (char c = 'A'; c <= 'Z'; c++)
  30.     {
  31.         _WordChars[c] =  | ;
  32.         _UnicodeFlags[c] = (sbyte)(c - 'A' + );
  33.     }
  34.  
  35.     _WordChars['.'] =  |  | ;
  36.     for (char c = ''; c <= ''; c++)
  37.     {
  38.         _WordChars[c] = ;
  39.         _UnicodeFlags[c] = (sbyte)(c - '');
  40.     }
  41.  
  42.     //科学计数法
  43.     _WordChars['e'] |= ;
  44.     _WordChars['E'] |= ;
  45.  
  46.     _WordChars[' '] = ;
  47.     _WordChars['\t'] = ;
  48.     _WordChars['\r'] = ;
  49.     _WordChars['\n'] = ;
  50.  
  51.     _WordChars['t'] |= ;
  52.     _WordChars['r'] |= ;
  53.     _WordChars['n'] |= ;
  54.     _WordChars['f'] |= ;
  55.     _WordChars[''] |= ;
  56.     _WordChars['"'] |= ;
  57.     _WordChars['\''] |= ;
  58.     _WordChars['\\'] |= ;
  59.     _WordChars['/'] |= ;
  60.  
  61.     string[] a =  { "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec" };
  62.     string[] b =  { "mon", "tue", "wed", "thu", "fri", "sat", "sun" };
  63.     _DateTimeWords = new sbyte[, , ];
  64.  
  65.     for (sbyte i = ; i < a.Length; i++)
  66.     {
  67.         var d = a[i];
  68.         _DateTimeWords[d[] - , d[] - , d[] - ] = (sbyte)(i + );
  69.     }
  70.  
  71.     for (sbyte i = ; i < b.Length; i++)
  72.     {
  73.         var d = b[i];
  74.         _DateTimeWords[d[] - , d[] - , d[] - ] = (sbyte)-(i + );
  75.     }
  76.     _DateTimeWords['g' - , 'm' - , 't' - ] = sbyte.MaxValue;
  77. }

摘取部分blqw.Json的代码

结束了...还要后续吗?...貌似我又要懒一段时间

C#中那些[举手之劳]的性能优化的更多相关文章

  1. 【转】PHP中被忽略的性能优化利器：生成器.md

      PHP  如果是做Python或者其他语言的小伙伴,对于生成器应该不陌生.但很多PHP开发者或许都不知道生成器这个功能,可能是因为生成器是PHP 5.5.0才引入的功能,也可以是生成器作用不是很明 ...

  2. Java开发中程序和代码性能优化

    现在计算机的处理性能越来越好,加上JDK升级对一些代码的优化,在代码层针对一些细节进行调整可能看不到性能的明显提升, 但是我觉得在开发中注意这些,更多的是可以保持一种性能优先的意识,对一些敲代码时间比 ...

  3. Android中数据库Sqlite的性能优化

    1.索引简单的说,索引就像书本的目录,目录可以快速找到所在页数,数据库中索引可以帮助快速找到数据,而不用全表扫描,合适的索引可以大大提高数据库查询的效率.(1). 优点大大加快了数据库检索的速度,包括 ...

  4. java开发代码中的50个性能优化细节

    在java程序中,性能的大部分原因并不在java与语言,而是程序本身.养成好的编码习惯非常重要,能够显著地提升程序性能. 1:尽量在合适的场合使用单例 使用单利可以减轻加载的负担,缩短加载时间,提高加 ...

  5. 一次项目实践中DBCP数据库连接池性能优化

    关于数据库连接池DBCP的关注源于刚刚结束的一轮测试,测试内容是衡量某Webserver服务创建用户接口的性能.这是一款典型的tomcat应用,使用的测试工具是Grinder.DBCP作为tomcat ...

  6. PHP中被忽略的性能优化利器：生成器

    如果是做Python或者其他语言的小伙伴,对于生成器应该不陌生.但很多PHP开发者或许都不知道生成器这个功能,可能是因为生成器是PHP 5.5.0才引入的功能,也可以是生成器作用不是很明显.但是,生成 ...

  7. PHP系列 | [转] PHP中被忽略的性能优化利器：生成器

    官方:https://www.php.net/manual/zh/language.generators.overview.php 原文:https://segmentfault.com/a/1190 ...

  8. EntityFramework之异步、事务及性能优化（九）

    前言 本文开始前我将循序渐进先了解下实现EF中的异步,并将重点主要是放在EF中的事务以及性能优化上,希望通过此文能够帮助到你. 异步 既然是异步我们就得知道我们知道在什么情况下需要使用异步编程,当等待 ...

  9. T- SQL性能优化详解

    摘自:http://www.cnblogs.com/Shaina/archive/2012/04/22/2464576.html 故事开篇:你和你的团队经过不懈努力,终于使网站成功上线,刚开始时,注册 ...

随机推荐

  1. Elasticsearch之java的基本操作一

    摘要   接触ElasticSearch已经有一段了.在这期间,遇到很多问题,但在最后自己的不断探索下解决了这些问题.看到网上或多或少的都有一些介绍ElasticSearch相关知识的文档,但个人觉得 ...

  2. Online Judge（OJ）搭建（第一版）

    搭建 OJ 需要的知识(重要性排序): Java SE(Basic Knowledge, String, FileWriter, JavaCompiler, URLClassLoader, Secur ...

  3. dotNET跨平台相关文档整理

    一直在从事C#开发的相关技术工作,从C# 1.0一路用到现在的C# 6.0, 通常情况下被局限于Windows平台,Mono项目把我们C#程序带到了Windows之外的平台,在工作之余花了很多时间在M ...

  4. Entity Framework 6 Recipes 2nd Edition 译 -> 目录 -持续更新

    因为看了<Entity Framework 6 Recipes 2nd Edition>这本书前面8章的翻译,感谢china_fucan. 从第九章开始,我是边看边译的,没有通读,加之英语 ...

  5. OpenCASCADE Expression Interpreter by Flex & Bison

    OpenCASCADE Expression Interpreter by Flex & Bison eryar@163.com Abstract. OpenCASCADE provide d ...

  6. SELECT INTO 和 INSERT INTO SELECT 两种表复制语句

    Insert是T-sql中常用语句,Insert INTO table(field1,field2,...) values(value1,value2,...)这种形式的在应用程序开发中必不可少.但我 ...

  7. inline-block元素间距问题的几种解决方案

    不知道大家有没有碰到过设置了display:inline-block;的几个相邻元素之间有几px间距的问题,这里提供几种简单实用的解决方法,希望能够帮到大家!   方法1. 将<li>标签 ...

  8. bcp 命令实例

    set sql_flow="select Id,',',ApplierName,',',FlowStatus,',',IsApproved,',',CreateTime from *** w ...

  9. 【开发软件】 在Mac下配置php开发环境：Apache+php+MySql

    本文地址 原文地址   本文提纲: 1. 启动Apache 2. 运行PHP 3. 配置Mysql 4. 使用PHPMyAdmin 5. 附录   有问题请先 看最后的附录   摘要: 系统OS X ...

  10. 封装集合（Encapsulate Collection）

    封装就是将相关的方法或者属性抽象成为一个对象. 封装的意义: 对外隐藏内部实现,接口不变,内部实现自由修改. 只返回需要的数据和方法. 提供一种方式防止数据被修改. 更好的代码复用. 当一个类的属性类 ...