C#几个经常犯错误汇总

在我们平常编程中，时间久了有时候会形成一种习惯性的思维方式，形成固有的编程风格，但是有些地方是需要斟酌的，即使是一个很小的错误也可能会导致昂贵的代价，要学会善于总结，从错误中汲取教训，尽量不再犯同样错误，注重编程之美，代码的优雅，总结几个平常经常犯的错误。

且末网站制作公司哪家好，找创新互联！从网页设计、网站建设、微信开发、APP开发、成都响应式网站建设公司等网站项目制作，到程序开发，运营维护。创新互联于2013年成立到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联。

1、在C#编程中，字符型类型是最容易处理出错的地方，代价是非常昂贵，在.Net Framwork中，字符串是一个相当特别的引用类型，string本省就是一个不可继承的密封类，但是它具有了值类型所应用的特点，但是它在CLR中内存还是保存于托管堆之上，也就是说，当我们每次定义一个字符串类型的时候，就在堆内存中开辟一端内存，而当我们字符串被修改之后，它会创建一个新的内存，注意这里的内存是不连续的，而是通过修改栈内地址引用而拼凑字符串，不会改变源字符串在内存中的地址，所以有些程序员总是喜欢使用这样的方法格式化字符串：

 
 
 
    
  
  
  
  1. string  SelectText="select * from "+TableName+" where UserName='"+Name+"'"; 
    2.

上述代码，使用了字符串拼凑的方法，因为使用了多重串联，因此会在内存中创建两个不必要的字符串垃圾副本。

其实在C#中，已经为我们提供了StringBuilder和String.Fromat来解决此问题，虽然他们可以实现同样的功能，但是他们有质的变化，StringBuilder在内存中开辟的是一段连续内存，当增加新字符串时候，它会在栈中指向的同一个堆内存中连续存放字符，这就形成了性能的提升。所以我们将上面代码改成：

 
 
 
    
  
  
  
  1. string SelectText=string.Format("select  *  from {0} where UserName={1}",TableName,Name); 
    2.

2、大多数开发人员都不知道内置的验证数据类型的方法，如System.Int32，因此很多人都是自己实现的，其实这是不妥的，因为这些基本类型中都存在自己固有的类型验证方法，下面这个就是自己实现验证的一个字符串是否是数值的代码：

 
 
 
    
  
  
  
  1. public bool CheckIfNumeric(string value)  
    2. 
  
  
  
  2. {  
    3. 
  
  
  
  3.     bool IsNumeric=true;  
    4. 
  
  
  
  4.     try 
    5. 
  
  
  
  5.      {  
    6. 
  
  
  
  6.            int i=Convert.ToInt32(value);  
    7. 
  
  
  
  7.      }  
    8. 
  
  
  
  8.      catch(FormatException excepiton)  
    9. 
  
  
  
  9.      {  
    10. 
  
  
  
  10.            IsNumeric=false;  
    11. 
  
  
  
  11.      }  
    12. 
  
  
  
  12.      return IsNumeric;  
    13. 
  
  
  
  13. } 
    14.

虽然使用了try catch语句，这不是最佳的做法，更好的方法是下面使用Int.TryParse；

 
 
 
    
  
  
  
  1. int output=0;  
    2. 
  
  
  
  2. bool IsNumeric=int.TryParse(value,out output); 
    3.

int.TryParse是更快、更简洁的方法。

3、自己利用IDisposable接口手动释放内存

在.NET Framework中，对象的处理和使用一样重要，理想的方法是在使用完对象的时候，在类中实现IDisposable接口中的dispose方法进行内存的释放，当然在.Net本身提供的垃圾回收机制（GC）中就提供了这样的功能，在我们实例化类对象时，在类本身的析构函数中会调用dispose方法，GC在各级内存堆满的情况下，自动检查对象使用情况，去相应的释放内存，但是运行在非托管平台上的方法，需要我们自己手动释放内存，比如我们常见的SqlConnection对象，也就有了下面的创建、使用和处理方法：

 
 
 
    
  
  
  
  1. public void  DALOneMethod()  
    2. 
  
  
  
  2. {  
    3. 
  
  
  
  3.     SqlConnection  connection=null;  
    4. 
  
  
  
  4.     try 
    5. 
  
  
  
  5.      {  
    6. 
  
  
  
  6.           connection =new SqlConnection("。。。。。。。。。。。");  
    7. 
  
  
  
  7.           connection.Open();  
    8. 
  
  
  
  8.           //sqlcommand。。run  
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10.      }  
    11. 
  
  
  
  11.      catch(Exception exception)  
    12. 
  
  
  
  12.      {  
    13. 
  
  
  
  13.              // manager exception  
    14. 
  
  
  
  14.      }  
    15. 
  
  
  
  15.      finally 
    16. 
  
  
  
  16.      {  
    17. 
  
  
  
  17.             connection.Close();  
    18. 
  
  
  
  18.             connection.Disopse();  
    19. 
  
  
  
  19.      }  
    20. 
  
  
  
  20. } 
    21.

上述代码是大部分程序员会出现的代码，乍看没啥问题，连接处理在最后一个代码中被明确调用，但是如果发生了一个异常，catch代码块就被执行,然后再执行最后一个代码块处理连接，因此在最后一个代码块执行之前，连接将一直留在内存中，大部分我们会在此处记录错误，一般涉及到IO操作，如果延时时间比较长的话，这个连接将在内存时间长时间停留。我们一个原则就是当对象不再使用的时候我们里面释放资源。

我们采用程序逻辑域来处理这个问题会更好：

 
 
 
    
  
  
  
  1. public void  DALOneMethod()  
    2. 
  
  
  
  2. {  
    3. 
  
  
  
  3.     using(SqlConnction  connection=new SqlConnection("。。。。。。。"))  
    4. 
  
  
  
  4.      {  
    5. 
  
  
  
  5.          connction.Open()；  
    6. 
  
  
  
  6.       // do SUAD  
    7. 
  
  
  
  7.      }  
    8. 
  
  
  
  8. } 
    9.

当使用using代码快时，对象上的dispose()方法将在执行推出逻辑域的时候调用，这样就保证了SqlConnection的资源处理被尽早释放，当然这个方法也适用于实现IDisposable接口的类，当时个人不推荐这样做，在非常有把握的情况下可以手动释放，但是没把握还是叫给.net系统释放，因为本身类的析构函数就实现这个方法，当我们自己重写后，反而会导致系统误以为你自己定义了方法，而推迟释放资源，有兴趣可以研究下GC运行本质，假如能在第一代被释放的内存，如果我们重写dispose方法反而推迟到第二代内存堆中释放，显然是不可取的。

4、学会合理的管理公共变量，我们在系统中经常会滥用公共变量，没有做到合适的封装好。

 
 
 
    
  
  
  
  1. static  void Main(string[]  args)  
    2. 
  
  
  
  2. {  
    3. 
  
  
  
  3.             MyAccount  account=new MyAccount();  
    4. 
  
  
  
  4.            //这地方不能随便的调用account里面的字段进行更改，但是缺改了  
    5. 
  
  
  
  5.         account.AccountNumber="ddddddddd";  
    6. 
  
  
  
  6.            Console.ReadKey();  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8. public class MyAccount  
    9. 
  
  
  
  9. {  
    10. 
  
  
  
  10.           public  string AccountNumber;  
    11. 
  
  
  
  11.           public  MyAcctount()  
    12. 
  
  
  
  12.           {  
    13. 
  
  
  
  13.                 AccountNumber="ssssssssssssss";  
    14. 
  
  
  
  14.           }  
    15. 
  
  
  
  15. } 
    16.

在上面的MyAccount类中生命了一个AccountNumber公共变量，理想情况下，AccountNumber应该是只读的，不能让外界修改，但是这里MyAccount类却没有对它做任何控制。

声明公共做法应该是使用属性，如：

 
 
 
    
  
  
  
  1. public  class  MyAccount  
    2. 
  
  
  
  2. {  
    3. 
  
  
  
  3.    private stirng _accountNumber;  
    4. 
  
  
  
  4.    public  string AccountNumber  
    5. 
  
  
  
  5.    {  
    6. 
  
  
  
  6.         get {  return  _accountNumber;  }  
    7. 
  
  
  
  7.    }  
    8. 
  
  
  
  8.    public  MyAccount()  
    9. 
  
  
  
  9.    {  
    10. 
  
  
  
  10.           _accountNumber="dddddddd";  
    11. 
  
  
  
  11.    }  
    12. 
  
  
  
  12. } 
    13.

这里我们封装了AccountNumber公共变量，它变成了只读，不能由调用者类进行修改。

5、嵌套的异常处理，有的开发人员喜欢在方法末尾加上处理的嵌套方法，如

 
 
 
    
  
  
  
  1. public class NestedExceptionHandling  
    2. 
  
  
  
  2.   {  
    3. 
  
  
  
  3.       public void MainMethod()  
    4. 
  
  
  
  4.       {  
    5. 
  
  
  
  5.           try 
    6. 
  
  
  
  6.           {  
    7. 
  
  
  
  7.               //some implementation  
    8. 
  
  
  
  8.               ChildMethod1();  
    9. 
  
  
  
  9.           }  
    10. 
  
  
  
  10.           catch (Exception exception)  
    11. 
  
  
  
  11.           {  
    12. 
  
  
  
  12.               //Handle exception  
    13. 
  
  
  
  13.           }  
    14. 
  
  
  
  14.       }  
    15. 
  
  
  
  15.     
    16. 
  
  
  
  16.       private void ChildMethod1()  
    17. 
  
  
  
  17.       {  
    18. 
  
  
  
  18.           try 
    19. 
  
  
  
  19.           {  
    20. 
  
  
  
  20.               //some implementation  
    21. 
  
  
  
  21.               ChildMethod2();  
    22. 
  
  
  
  22.           }  
    23. 
  
  
  
  23.           catch (Exception exception)  
    24. 
  
  
  
  24.           {  
    25. 
  
  
  
  25.               //Handle exception  
    26. 
  
  
  
  26.            throw;  
    27. 
  
  
  
  27.     
    28. 
  
  
  
  28.           }  
    29. 
  
  
  
  29.       }  
    30. 
  
  
  
  30.     
    31. 
  
  
  
  31.       private void ChildMethod2()  
    32. 
  
  
  
  32.       {  
    33. 
  
  
  
  33.           try 
    34. 
  
  
  
  34.           {  
    35. 
  
  
  
  35.               //some implementation  
    36. 
  
  
  
  36.           }  
    37. 
  
  
  
  37.           catch (Exception exception)  
    38. 
  
  
  
  38.           {  
    39. 
  
  
  
  39.               //Handle exception  
    40. 
  
  
  
  40.               throw;  
    41. 
  
  
  
  41.           }  
    42. 
  
  
  
  42.       }  
    43. 
  
  
  
  43.   } 
    44.

如果相同的异常被处理多次，性能开销将会增加。

我们的解决方法是让异常处理方法独立开来，如：

 
 
 
    
  
  
  
  1. public class NestedExceptionHandling  
    2. 
  
  
  
  2.   {  
    3. 
  
  
  
  3.       public void MainMethod()  
    4. 
  
  
  
  4.       {  
    5. 
  
  
  
  5.           try 
    6. 
  
  
  
  6.           {  
    7. 
  
  
  
  7.               //some implementation  
    8. 
  
  
  
  8.               ChildMethod1();  
    9. 
  
  
  
  9.           }  
    10. 
  
  
  
  10.           catch(Exception exception)  
    11. 
  
  
  
  11.           {  
    12. 
  
  
  
  12.               //Handle exception  
    13. 
  
  
  
  13.           }  
    14. 
  
  
  
  14.       }  
    15. 
  
  
  
  15.     
    16. 
  
  
  
  16.       private void ChildMethod1()  
    17. 
  
  
  
  17.       {  
    18. 
  
  
  
  18.           //some implementation  
    19. 
  
  
  
  19.           ChildMethod2();  
    20. 
  
  
  
  20.       }  
    21. 
  
  
  
  21.     
    22. 
  
  
  
  22.       private void ChildMethod2()  
    23. 
  
  
  
  23.       {  
    24. 
  
  
  
  24.           //some implementation  
    25. 
  
  
  
  25.       }  
    26. 
  
  
  
  26.   } 
    27.

6、大数据量上使用Dataset和DataReader混用，当单表数据量很大的情况，使用DataSet是一种很不明智的选择，应为DataSet是以DataTable内存形式存放数据量，一次性将数据拖入内存，当数据很大的情况下，这种方式是很吃内存的，相比DataSer，DataReader就显得优雅很多，它是每次读取一条数据，然后轮询调用机制，但是也有它的弊端，就是相对长连接，但是对内存消耗而言这是有利的，当然DataSet在大部分应用场景下也是有自己的优点，充分解耦、一次性操作、领域模型操作等方面，两者分情况分场景而用，这里只是稍微提提，根据场景分析区别。

原文链接：http://www.cnblogs.com/zhijianliutang/archive/2012/03/20/2407688.html

【编辑推荐】

  1. 浅谈面向对象程序设计C#中的类
  2. 详解C#中不同类的类型
  3. 浅谈C#中标准Dispose模式的实现
  4. C#选择正确的集合进行编码
  5. C# 4.0新特性:协变与逆变中的编程思想

分享标题：C#几个经常犯错误汇总
文章地址：http://www.shufengxianlan.com/qtweb/news5/44455.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸建站知识

分类信息网站

黔盛装饰　　 　正泰动物　　 　买链接　　 　泸州叙永网站建设　　 　成都全屋定制　　 　郫都区消防器材　　 　一带一路　　 　重庆电信回兴机房　　 　成都营销网站制作　　 　云主机　　 　解决方案　　 　成都画册制作　　 　成都免费网站建设　　 　广告媒介投放　　 　国泰民安消防　　 　定制网站开发　　 　成都网站建设　　 　小程序开发　　 　网站制作报价　　 　红光高低压开关厂