一切福田，不離方寸，從心而覓，感無不通。

Category Archives: C#

volatile（C# 参考）

volatile 关键字指示一个字段可以由多个同时执行的线程修改。 声明为 volatile 的字段不受编译器优化（假定由单个线程访问）的限制。 这样可以确保该字段在任何时间呈现的都是最新的值。 volatile 修饰符通常用于由多个线程访问但不使用 lock 语句对访问进行序列化的字段。 volatile 关键字可应用于以下类型的字段： 引用类型。 指针类型（在不安全的上下文中）。 请注意，虽然指针本身可以是可变的，但是它指向的对象不能是可变的。 换句话说，您无法声明“指向可变对象的指针”。 类型，如 sbyte、byte、short、ushort、int、uint、char、float 和 bool。 具有以下基类型之一的枚举类型：byte、sbyte、short、ushort、int 或 uint。 已知为引用类型的泛型类型参数。 IntPtr 和 UIntPtr。 可变关键字仅可应用于类或结构字段。 不能将局部变量声明为 volatile。 示例 下面的示例说明如何将公共字段变量声明为 volatile。 C#

1
2
3
4
5
6
7
8
9
    <span style="color: blue;">class</span> VolatileTest
    {
        <span style="color: blue;">public</span> <span style="color: blue;">volatile</span> <span style="color: blue;">int</span> i;
 
        <span style="color: blue;">public</span> <span style="color: blue;">void</span> Test(<span style="color: blue;">int</span> _i)
        {
            i = _i;
        }
    }

下面的示例演示如何创建辅助线程，并用它与主线程并行执行处理。 有关多线程处理的背景信息，请参见托管线程处理和线程处理（C# 和 Visual Basic）。 C#

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
<span style="color: blue;">using</span> System;
<span style="color: blue;">using</span> System.Threading;
 
<span style="color: blue;">public</span> <span style="color: blue;">class</span> Worker
{
    <span style="color: green;">// This method is called when the thread is started.</span>
    <span style="color: blue;">public</span> <span style="color: blue;">void</span> DoWork()
    {
        <span style="color: blue;">while</span> (!_shouldStop)
        {
            Console.WriteLine(<span style="color: #a31515;">"Worker thread: working..."</span>);
        }
        Console.WriteLine(<span style="color: #a31515;">"Worker thread: terminating gracefully."</span>);
    }
    <span style="color: blue;">public</span> <span style="color: blue;">void</span> RequestStop()
    {
        _shouldStop = <span style="color: blue;">true</span>;
    }
    <span style="color: green;">// Keyword volatile is used as a hint to the compiler that this data</span>
    <span style="color: green;">// member is accessed by multiple threads.</span>
    <span style="color: blue;">private</span> <span style="color: blue;">volatile</span> <span style="color: blue;">bool</span> _shouldStop;
}
 
<span style="color: blue;">public</span> <span style="color: blue;">class</span> WorkerThreadExample
{
    <span style="color: blue;">static</span> <span style="color: blue;">void</span> Main()
    {
        <span style="color: green;">// Create the worker thread object. This does not start the thread.</span>
        Worker workerObject = <span style="color: blue;">new</span> Worker();
        Thread workerThread = <span style="color: blue;">new</span> Thread(workerObject.DoWork);
 
        <span style="color: green;">// Start the worker thread.</span>
        workerThread.Start();
        Console.WriteLine(<span style="color: #a31515;">"Main thread: starting worker thread..."</span>);
 
        <span style="color: green;">// Loop until the worker thread activates.</span>
        <span style="color: blue;">while</span> (!workerThread.IsAlive) ;
 
        <span style="color: green;">// Put the main thread to sleep for 1 millisecond to</span>
        <span style="color: green;">// allow the worker thread to do some work.</span>
        Thread.Sleep(1);
 
        <span style="color: green;">// Request that the worker thread stop itself.</span>
        workerObject.RequestStop();
 
        <span style="color: green;">// Use the Thread.Join method to block the current thread </span>
        <span style="color: green;">// until the object's thread terminates.</span>
        workerThread.Join();
        Console.WriteLine(<span style="color: #a31515;">"Main thread: worker thread has terminated."</span>);
    }
    <span style="color: green;">// Sample output:</span>
    <span style="color: green;">// Main thread: starting worker thread...</span>
    <span style="color: green;">// Worker thread: working...</span>
    <span style="color: green;">// Worker thread: working...</span>
    <span style="color: green;">// Worker thread: working...</span>
    <span style="color: green;">// Worker thread: working...</span>
    <span style="color: green;">// Worker thread: working...</span>
    <span style="color: green;">// Worker thread: working...</span>
    <span style="color: green;">// Worker thread: terminating gracefully.</span>
    <span style="color: green;">// Main thread: worker thread has terminated.</span>
}
 
 
from:http://msdn.microsoft.com/zh-cn/library/x13ttww7.aspx

龙生   30 Jun 2014
View Details

ManualResetEvent详解

1. 源码下载： 下载地址：http://files.cnblogs.com/tianzhiliang/ManualResetEventDemo.rar Demo： 2. ManualResetEvent详解 ManualResetEvent 允许线程通过发信号互相通信。通常，此通信涉及一个线程在其他线程进行之前必须完成的任务。当一个线程开始一个活动（此活动必须完成后，其他线程才能开始）时，它调用 Reset 以将 ManualResetEvent 置于非终止状态，此线程可被视为控制 ManualResetEvent。调用 ManualResetEvent 上的 WaitOne 的线程将阻止，并等待信号。当控制线程完成活动时，它调用 Set 以发出等待线程可以继续进行的信号。并释放所有等待线程。一旦它被终止，ManualResetEvent 将保持终止状态（即对 WaitOne 的调用的线程将立即返回，并不阻塞），直到它被手动重置。可以通过将布尔值传递给构造函数来控制 ManualResetEvent 的初始状态，如果初始状态处于终止状态，为 true；否则为 false。   using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; namespace ManualResetEventDemo {     class MREDemo     {         private ManualResetEvent _mre;         public MREDemo()         {             this._mre = new ManualResetEvent(true);         }         public void CreateThreads()         {             Thread t1 = new Thread(new ThreadStart(Run));             t1.Start();             Thread t2 = new Thread(new ThreadStart(Run));             t2.Start();         }         public void Set()         {             this._mre.Set();         }         public void Reset()         {             this._mre.Reset();         }         private void Run()         {             string strThreadID = string.Empty;             try             {                 while (true)                 {                     // 阻塞当前线程                     this._mre.WaitOne();                     strThreadID = Thread.CurrentThread.ManagedThreadId.ToString();                     Console.WriteLine("Thread(" + strThreadID + ") is running…");                     Thread.Sleep(5000);                 } […]

龙生   30 Jun 2014
View Details

浅谈ThreadPool 线程池

相关概念：     线程池可以看做容纳线程的容器；     一个应用程序最多只能有一个线程池；     ThreadPool静态类通过QueueUserWorkItem()方法将工作函数排入线程池；     每排入一个工作函数，就相当于请求创建一个线程； 线程池的作用： 线程池是为突然大量爆发的线程设计的，通过有限的几个固定线程为大量的操作服务，减少了创建和销毁线程所需的时间，从而提高效率。 如果一个线程的时间非常长，就没必要用线程池了(不是不能作长时间操作，而是不宜。)，况且我们还不能控制线程池中线程的开始、挂起、和中止。 什么时候使用ThreadPool？ ThreadPool 示例一 ： ThreadPool_1.cs using System; using System.Text; using System.Threading; namespace 多线程 { public class Example { public static void Main() { // Queue the task.             ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc)); Console.WriteLine("Main thread does some work, then sleeps."); Thread.Sleep(1000); Console.WriteLine("Main thread exits."); } static void ThreadProc(Object stateInfo) { // No state object was passed to QueueUserWorkItem, // so stateInfo is null.             Console.WriteLine("Hello from the thread pool."); } } } ThreadPool 示例二 ： ThreadPool_2.cs using System; using System.Collections.Generic; using System.Text; using System.Threading; namespace CS_Test { class ThreadPool_Demo { // 用于保存每个线程的计算结果         static int[] result = new int[10]; //注意：由于WaitCallback委托的声明带有参数， //      所以将被调用的Fun方法必须带有参数，即：Fun(object obj)。         static void Fun(object obj) { int n = (int)obj; //计算阶乘             int fac = 1; for (int i = 1; i <= n; i++) { fac *= i; } //保存结果             result[n] = fac; } static void Main(string[] args) { //向线程池中排入9个工作线程             for (int i = 1; i <= 9 ; i++) { //QueueUserWorkItem()方法：将工作任务排入线程池。                 ThreadPool.QueueUserWorkItem(new WaitCallback(Fun),i); // Fun 表示要执行的方法(与WaitCallback委托的声明必须一致)。 // i   为传递给Fun方法的参数(obj将接受)。             } //输出计算结果             for (int i = 1; i <= 9; i++) { Console.WriteLine("线程{0}: {0}! = {1}",i,result[i]); } } } } ThreadPool的作用： 参考来源： C#多线程学习(四) 多线程的自动管理(线程池)  [叩响C#之门]写给初学者：多线程系列( 十一)——线程池(ThreadPool) from:http://www.cnblogs.com/xugang/archive/2010/04/20/1716042.html

龙生   30 Jun 2014
View Details
Asp.net, C#

在Visual Studio 2012使用单元测试

Aside

本人之前很少使用单元测试，总觉得平时的工作写得代码够多了，单元测试还要再编码，增加大量工作量，相信不少程序猿也是这么认为吧。

但是我认为，在必要的时候正确运用单元测试，可以大大缩短代码的调试时间，正所谓磨刀不误砍柴工，在此建议仍不会单元测试的，还是学一下吧。当然本人在单元测试方面还是菜鸟，无论是鸡蛋鲜花都欢迎。

最近公司请微软的人做了一些关于使用VS2012进行单元测试的小培训，小生微做笔记，结合朦胧的记忆，在此自行总结，并分享之。废话少说，先上笔记：

1.先写单元测试（依我愚见，应该是接口先行，如果有的话） -> 测试失败 -> 以最小的改动（即编写实际代码）使测试通过（而在VS2012中已经不能通过现有项目直接生成测试项目了，我觉得这个功能还是应该保留，微软总是这副德行，强迫用户适应他们的产品，但是又不得不适应）；

2.不因单元测试而追加功能（代码），即逻辑不受单元测试影响；

3.改变了代码的逻辑（增删改），应及时运行单元测试；

4.在测试方法声明Attribute —— TestCategory("分类或特征名");

5.在单元测试项目添加Fakes程序集分离外部依赖（如数据库访问，获取配置信息等）；

6.初始化单元测试类中的成员等信息，可添加方法并声明Attribute[TestInitialize]（方法需为public）；

7.测试自动化。

以下我将通过自己编写代码来验证上述笔记中的部分要点。有些未涉及，以后再尝试了。

1.新建一个单元测试项目，并添加类XmlSerializationTest，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
    [TestClass]
    <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">class</span> XmlSerializationTest
    {
        [TestMethod]
        <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span> TestWriteXml()
        {
            UserInfo user = <span style="color: #0000ff;">new</span> UserInfo();
            XmlSerialization serialization = <span style="color: #0000ff;">new</span> XmlSerialization();
            <span style="color: #0000ff;">bool</span> flag = serialization.WriteXml&lt;UserInifo&gt;(user);
            Assert.IsTrue(flag);
        }
    }

由于我这个项目是对Xml序列化进行测试，因而前提是项目中已存在了一个UserModel类，并且在单元测试项目中添加相应引用

1
2
3
4
5
    <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">class</span> UserModel
    {
        <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">string</span> LoginName { <span style="color: #0000ff;">get</span>; <span style="color: #0000ff;">set</span>; }
        <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">string</span> Password { <span style="color: #0000ff;">get</span>; <span style="color: #0000ff;">set</span>; }
    }

接下来在编写实际的代码，微软讲师建议我们先在测试项目编写，待通过单元测试后再将代码移到相应的项目下面。

 XmlSerialization

现在整个解决方案结构如下图所示

保证整个解决方案生成成功之后点击菜单“测试” -〉 “运行” -〉 “所有测试”，发现测试不通过，于是就按照第一点笔记，以最小改动使测试通过。

修改WriteXml方法为:

1
2
3
4
<span style="color: #0000ff;">public</span> <span style="color: #0000ff;">bool</span> WriteXml&lt;T&gt;(T model)
{
    <span style="color: #0000ff;">return</span> <span style="color: #0000ff;">true</span>;
}

运行测试通过。对于返回值为bool的方法，个人建议进行至少两次Assert，也就是分别对返回true和false进行Assert，因而我们再对WriteXml方法添加一个测试方法，

1
2
3
4
5
        [TestMethod]
        <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span> TestWriteXmlFalse()
        {
            Assert.IsFalse(<span style="color: #0000ff;">new</span> XmlSerialization().WriteXml&lt;UserModel&gt;(<span style="color: #0000ff;">null</span>));
        }

运行测试，不通过，所以我得要好好改我的代码了，在改动当中坚持执行我的第三点笔记，改动代码及时运行单元测试。

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
    <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">class</span> XmlSerialization
    {
        <span style="color: #0000ff;">private</span> <span style="color: #0000ff;">string</span> filePath;
        <span style="color: #0000ff;">public</span> XmlSerialization(<span style="color: #0000ff;">string</span> filePath)
        {
            <span style="color: #0000ff;">this</span>.filePath = filePath;
        }
 
        <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">bool</span> WriteXml&lt;T&gt;(T model, <span style="color: #0000ff;">string</span> filePath = <span style="color: #0000ff;">null</span>) <span style="color: #0000ff;">where</span> T : <span style="color: #0000ff;">class</span>
        {
            <span style="color: #0000ff;">bool</span> result = <span style="color: #0000ff;">false</span>;
            <span style="color: #0000ff;">if</span> (model == <span style="color: #0000ff;">null</span>)
            {
                <span style="color: #0000ff;">return</span> result;
            }
 
            <span style="color: #0000ff;">if</span> (<span style="color: #0000ff;">string</span>.IsNullOrEmpty(filePath))
            {
                filePath = <span style="color: #0000ff;">this</span>.filePath;
            }
 
            XmlSerializer serializer = <span style="color: #0000ff;">new</span> XmlSerializer(<span style="color: #0000ff;">typeof</span>(T));
            <span style="color: #0000ff;">using</span> (TextWriter tr = <span style="color: #0000ff;">new</span> StreamWriter(filePath))
            {
                serializer.Serialize(tr, model);
                tr.Close();
                result = <span style="color: #0000ff;">true</span>;
            }
 
            <span style="color: #0000ff;">return</span> result;
        }
 
        <span style="color: #0000ff;">public</span> T ReadXml&lt;T&gt;(<span style="color: #0000ff;">string</span> filePath = <span style="color: #0000ff;">null</span>) <span style="color: #0000ff;">where</span> T : <span style="color: #0000ff;">class</span>
        {
            T model = <span style="color: #0000ff;">null</span>;
            <span style="color: #0000ff;">if</span> (<span style="color: #0000ff;">string</span>.IsNullOrEmpty(filePath))
            {
                filePath = <span style="color: #0000ff;">this</span>.filePath;
            }
 
            XmlSerializer serializer = <span style="color: #0000ff;">new</span> XmlSerializer(<span style="color: #0000ff;">typeof</span>(T));
            TextReader tr = <span style="color: #0000ff;">null</span>;
            <span style="color: #0000ff;">try</span>
            {
                tr = <span style="color: #0000ff;">new</span> StreamReader(filePath);
                model = (T)serializer.Deserialize(tr);
            }
            <span style="color: #0000ff;">catch</span> { }
            <span style="color: #0000ff;">finally</span>
            {
                <span style="color: #0000ff;">if</span> (tr != <span style="color: #0000ff;">null</span>)
                {
                    tr.Close();
                    tr.Dispose();
                }
            }
 
            <span style="color: #0000ff;">return</span> model;
        }
    }

我们发现这个类的构造函数多了一个参数，是对象序列化后保存的路径，且该类对应的测试类都需要用到，因而我希望在每次测试进行单元测试前先将对象的构建，这就是第六点笔记提供的“声明Attribute[TestInitialize]”（注意必须是public方法，我用private方法运行测试是不通过）。改造后的测试类如下：

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
26
27
28
29
30
31
32
33
34
    [TestClass]
    <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">class</span> XmlSerializationTest
    {
        <span style="color: #0000ff;">private</span> XmlSerialization serialization;
        [TestInitialize]
        <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span> InitTest()
        {
            <span style="color: #0000ff;">this</span>.serialization = <span style="color: #0000ff;">new</span> XmlSerialization(<span style="color: #800000;">@"</span><span style="color: #800000;">F:\usermodel.seri</span><span style="color: #800000;">"</span>);
        }
 
        [TestMethod]
        <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span> TestWriteXml()
        {
            UserModel user = <span style="color: #0000ff;">new</span> UserModel();
            <span style="color: #0000ff;">bool</span> flag = serialization.WriteXml&lt;UserModel&gt;(user);
            Assert.IsTrue(flag);
            Assert.IsFalse(serialization.WriteXml&lt;UserModel&gt;(<span style="color: #0000ff;">null</span>));
        }
 
        [TestMethod]
        <span style="color: #0000ff;">public</span> <span style="color: #0000ff;">void</span> TestReadXml()
        {
            UserModel user = <span style="color: #0000ff;">new</span> UserModel();
            user.LoginName = <span style="color: #800000;">"</span><span style="color: #800000;">aa</span><span style="color: #800000;">"</span>;
            serialization.WriteXml&lt;UserModel&gt;(user);
            UserModel model = serialization.ReadXml&lt;UserModel&gt;();
            Assert.IsNotNull(model);
            Assert.AreEqual(user.LoginName, model.LoginName);
 
            <span style="color: #008000;">//</span><span style="color: #008000;">路径不存在，应返回null</span>
            UserModel modelnull = serialization.ReadXml&lt;UserModel&gt;(<span style="color: #800000;">@"</span><span style="color: #800000;">F:\notexists.seri</span><span style="color: #800000;">"</span>);
            Assert.IsNull(modelnull);
        }
    }

还可以分析测试代码的覆盖率，如下图所示在测试资源管理器点击“运行”下的相应选项。

居然是100%，真不知道这个东西微软是怎么分析出来的。

把类XmlSerializationTest移到相应的项目，更改命名空间，在测试项目添加相应引用，测试通过。

将解决方案添加到TFS源码管理，我这边是用的是微软云TFS免费版。

收工。

VS提供了很多类型的测试，负载、UI等等测试，感觉还是蛮强大的。

from:http://www.cnblogs.com/FreeDong/archive/2013/06/10/3129625.html

System.MissingMethodException:Method not found:+解决方案

中文版本提示：System.MissingMethodException: 找不到方法:… 英文版本提示：System.MissingMethodException: Method not found:… 导致此异常的原因是引用程集版本冲突，通常可能是因为同一个项目（DLL）被多个项目（DLL）引用，导致新加的方法找不到，但是不会抛编译期异常，而是抛运行期异常。跟踪调试的时候根本无法运行到调用的地方，所以，很容易导致该解决该问题无从下手。 个人觉得这应该是VS的一个BUG，我用的是VS2008，不知道其它版本有没有同样的问题。 解决方法：修改引用的项目的AssemblyInfo.cs下的版本号，重新编译、发布。   问题解决方法： 不是补丁问题也不是版本号修改。问题发生在，提示找不到的方法，有的版本中确实未找到。替换使用的方法问题解决。 can’t get hostname for your address     Navicat for Mysql 远程连接数据库 出现 1042-Can’t get hostname for your address 错误！ 是什么问题。 编辑/etc/my.cnf，在：[mysqld]内添加一行：skip-name-resolveMySQL 忽略数据库表名大小写修改/etc/my.cnf，在 [mysqld] 内添加一行：lower_case_table_names=1 from:http://blog.csdn.net/jglie/article/details/6863067

龙生   05 Jun 2014
View Details

ASP.NET中BasePage的几种设计方式

使用它主要是为了复用代码的公用部分下面是整理出来三种实现方式：准备工作：1 先在BasePage.cs中创建部分类BasePage 比在创建接下来用到的用于演示的方法BaseLoad代码：public partial  class BasePage : System.Web.UI.Page{        protected void BaseLoad()        {            string code = Request.QueryString["id"];            if (String.IsNullOrEmpty(code))            {                Response.End();            }        }}2 使用BasePage.cs的Default.aspxDefault.aspx.cs代码：public partial class Default : BasePage{        protected  void Page_Load(object sender, EventArgs e)    {        //do something    }}一、重写BasePage的OnLoad方法,该方法会触发OnLoad事件BasePage.cs代码：public partial  class BasePage : System.Web.UI.Page{    protected override void OnLoad(EventArgs e)    {        BaseLoad();        base.OnLoad(e);    }}二、在构造函数中把BaseLoad注册到基类的this.Page.PreLoad事件BasePage.cs代码：public partial  class BasePage : System.Web.UI.Page{    public BasePage()    {        this.Page.PreLoad += BaseLoad;    }}三、这种方式让继承他的子类方式看起来有些怪异(不能在里面使用Page_Load)BasePage.cs 代码:public abstruct class BasePage : System.Web.UI.Page{    protected void Page_Load()    {        string code = Request.QueryString["id"];        if (String.IsNullOrEmpty(code))        {            Response.End();        }        PageLoad();        }    protected […]

龙生   29 May 2014
View Details

VS2010 生成Xml格式的注释文档

项目, 属性, build, 勾选xml document file, 重新build, 即可生成xml注释文件, 然后还得找工具软件(看到anytao推荐SandCastle) 生成更易读的帮助文档. from:http://www.cnblogs.com/liuzhendong/archive/2011/09/28/2194002.html

龙生   28 May 2014
View Details

ASP.NET中上传并读取Excel文件数据

在CSDN中，经常有人问如何打开Excel数据库文件。本文通过一个简单的例子，实现读取Excel数据文件。首先，创建一个Web应用程序项目，在Web页中添加一个DataGrid控件、一个文件控件和一个按钮控件。<INPUT id="File1" type="file" name="File1" runat="server"><asp:Button id="Button1" runat="server" Text="Button"></asp:Button><asp:DataGrid id="DataGrid1" runat="server"></asp:DataGrid>在代码视图中首先导入OleDb命名空间：using System.Data.OleDb; 在按钮的单击事件中输入如下代码：string strPath="c://test//" + DateTime.Now.ToString("yyyyMMddhhmmss") + ".xls";File1.PostedFile.SaveAs(strPath);string mystring="Provider = Microsoft.Jet.OLEDB.4.0 ; Data Source = '"+ strPath +"';Extended Properties=Excel 8.0";OleDbConnection cnnxls = new OleDbConnection (mystring);OleDbDataAdapter myDa =new OleDbDataAdapter("select * from [Sheet1$]",cnnxls);DataSet myDs =new DataSet();myDa.Fill(myDs); DataGrid1.DataSource=myDs.Tables[0];DataGrid1.DataBind();其中C:/test对ASPNET用户要有读写的权限. from:http://www.cnblogs.com/ranzige/p/3707316.html

龙生   20 May 2014
View Details

C#创建Excel(.xls和.xlsx)文件的三种方法

生成EXCEL文件是经常需要用到的功能，我们利用一些开源库可以很容易实现这个功能。 方法一：利用excellibrary，http://code.google.com/p/excellibrary/ excellibrary是国人写的开源组件，很容易使用，可惜貌似还不支持.xlsx(Excel 2007)，例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//Create the data set and table
DataSet ds = new DataSet("New_DataSet");
DataTable dt = new DataTable("New_DataTable");
//Set the locale for each
ds.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;
dt.Locale = System.Threading.Thread.CurrentThread.CurrentCulture;
//Open a DB connection (in this example with OleDB)
OleDbConnection con = new OleDbConnection(dbConnectionString);
con.Open();
//Create a query and fill the data table with the data from the DB
string sql = "SELECT Whatever FROM MyDBTable;";
OleDbCommand cmd = new OleDbCommand(sql, con);
OleDbDataAdapter adptr = new OleDbDataAdapter();
adptr.SelectCommand = cmd;
adptr.Fill(dt);
con.Close();
//Add the table to the data set
ds.Tables.Add(dt);
//Here's the easy part. Create the Excel worksheet from the data set
ExcelLibrary.DataSetHelper.CreateWorkbook("MyExcelFile.xls", ds);

  例子二：

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
26
27
28
29
30
31
32
33
//create new xls file
string file = "C:\\newdoc.xls";
Workbook workbook = new Workbook();
Worksheet worksheet = new Worksheet("First Sheet");
worksheet.Cells[0, 1] = new Cell((short)1);
worksheet.Cells[2, 0] = new Cell(9999999);
worksheet.Cells[3, 3] = new Cell((decimal)3.45);
worksheet.Cells[2, 2] = new Cell("Text string");
worksheet.Cells[2, 4] = new Cell("Second string");
worksheet.Cells[4, 0] = new Cell(32764.5, "#,##0.00");
worksheet.Cells[5, 1] = new Cell(DateTime.Now, @"YYYY\-MM\-DD");
worksheet.Cells.ColumnWidth[0, 1] = 3000;
workbook.Worksheets.Add(worksheet);
workbook.Save(file);
// open xls file
Workbook book = Workbook.Load(file);
Worksheet sheet = book.Worksheets[0];
// traverse cells
foreach (Pair<Pair<int, int>, Cell> cell in sheet.Cells)
{
dgvCells[cell.Left.Right, cell.Left.Left].Value = cell.Right.Value;
}
// traverse rows by Index
for (int rowIndex = sheet.Cells.FirstRowIndex;
rowIndex <= sheet.Cells.LastRowIndex; rowIndex++)
{
Row row = sheet.Cells.GetRow(rowIndex);
for (int colIndex = row.FirstColIndex;
colIndex <= row.LastColIndex; colIndex++)
{
Cell cell = row.GetCell(colIndex);
}
}

  方法二：利用EPPlus,http://epplus.codeplex.com/ EPPlus是一个使用Open Office XML(xlsx)文件格式，能读写Excel 2007/2010 文件的开源组件。 例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var file = @"Sample.xlsx";
if (File.Exists(file)) File.Delete(file);
using (var excel = new ExcelPackage(new FileInfo(file)))
{
var ws = excel.Workbook.Worksheets.Add("Sheet1");
ws.Cells[1, 1].Value = "Date";
ws.Cells[1, 2].Value = "Price";
ws.Cells[1, 3].Value = "Volume";
var random = new Random();
for (int i = 0; i < 10; i++)
{
ws.Cells[i + 2, 1].Value = DateTime.Today.AddDays(i);
ws.Cells[i + 2, 2].Value = random.NextDouble() * 1e3;
ws.Cells[i + 2, 3].Value = random.Next() / 1e3;
}
 
ws.Cells[2, 1, 11, 1].Style.Numberformat.Format = "dd/MM/yyyy";
ws.Cells[2, 2, 11, 2].Style.Numberformat.Format = "#,##0.000000";
ws.Cells[2, 3, 11, 3].Style.Numberformat.Format = "#,##0";
ws.Column(1).AutoFit();
ws.Column(2).AutoFit();
ws.Column(3).AutoFit();
excel.Save();
}

  例子二：

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
using OfficeOpenXml;
//指定Templete文档Text.xlsx
FileInfo newFile = new FileInfo("D:" + @"\Test.xlsx");
//开启
using (ExcelPackage pck = new ExcelPackage(newFile))
{
try
{
//设定ExcelWorkBook
ExcelWorkbook workBook = pck.Workbook;
if (workBook != null)
{
if (workBook.Worksheets.Count > 0)
{
//复制Temp这个Sheet同时命名为《清单》
ExcelWorksheet currentWorksheet = workBook.Worksheets.Copy("Temp", "清单");
//可以设定保护Sheet的密码
//currentWorksheet.Protection.SetPassword("1234");
int StartRow = 4;
for (int i = 0; i < tDS.Tables[0].Rows.Count; i++)
{
//Cells[RowIndex,CellIndex]
currentWorksheet.Cells[StartRow + i, 1].Value = Convert.ToString(tDS.Tables[0].Rows[i][0]);
currentWorksheet.Cells[StartRow + i, 2].Value = Convert.ToString(tDS.Tables[0].Rows[i][1]);
currentWorksheet.Cells[StartRow + i, 3].Value = Convert.ToString(tDS.Tables[0].Rows[i][2]);
currentWorksheet.Cells[StartRow + i, 4].Value = Convert.ToString(tDS.Tables[0].Rows[i][3]);
currentWorksheet.Cells[StartRow + i, 5].Value = Convert.ToString(tDS.Tables[0].Rows[i][4]);
currentWorksheet.Cells[StartRow + i, 6].Value = Convert.ToString(tDS.Tables[0].Rows[i][5]);
currentWorksheet.Cells[StartRow + i, 7].Value = Convert.ToString(tDS.Tables[0].Rows[i][6]);
currentWorksheet.Cells[StartRow + i, 8].Value = Convert.ToString(tDS.Tables[0].Rows[i][7]);
currentWorksheet.Cells[StartRow + i, 9].Value = Convert.ToString(tDS.Tables[0].Rows[i][8]);
currentWorksheet.Cells[StartRow + i, 10].Value = Convert.ToString(tDS.Tables[0].Rows[i][9]);
currentWorksheet.Cells[StartRow + i, 11].Value = Convert.ToString(tDS.Tables[0].Rows[i][10]);
currentWorksheet.Cells[StartRow + i, 12].Value = Convert.ToString(tDS.Tables[0].Rows[i][11]);
currentWorksheet.Cells[StartRow + i, 13].Value = Convert.ToString(tDS.Tables[0].Rows[i][12]);
}
//将Temp 这个Sheet删除
workBook.Worksheets.Delete("Temp");
}
}
//存至Text4.xlsx
pck.SaveAs(new FileInfo("H:" + @"\Test4.xlsx"));
}
catch (Exception e)
{
oLogger.Fatal(e.ToString());
}
}

  方法三：NPOI http://npoi.codeplex.com/ NPOI无需Office COM组件且不依赖Office，使用NPOI能够帮助开发者在没有安装微软Office的情况下读写Office 97-2003的文件，支持的文件格式包括xls, doc, ppt等。NPOI是构建在POI 3.x版本之上的，它可以在没有安装Office的情况下对Word/Excel文档进行读写操作。 被人称为操作EXCEL的终极方案，例子如下：

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//引用
using NPOI.HSSF.UserModel;
using NPOI.HPSF;
using NPOI.POIFS.FileSystem;
using NPOI.SS.UserModel;
//将WorkBook指到我们原本设计好的Templete Book1.xls
using (IWorkbook wb = new HSSFWorkbook(new FileStream("D:/Book1.xls", FileMode.Open)))
{
try
{
//设定要使用的Sheet为第0个Sheet
ISheet TempSheet = wb.GetSheetAt(0);
int StartRow = 4;
//tDS为Query回来的资料
for (int i = 0; i < tDS.Tables[0].Rows.Count; i++)
{
//第一个Row要用Create的
TempSheet.CreateRow(StartRow + i).CreateCell(0).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][0]));
//第二个Row之后直接用Get的
TempSheet.GetRow(StartRow + i).CreateCell(1).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][1]));
TempSheet.GetRow(StartRow + i).CreateCell(2).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][2]));
TempSheet.GetRow(StartRow + i).CreateCell(3).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][3]));
TempSheet.GetRow(StartRow + i).CreateCell(4).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][4]));
TempSheet.GetRow(StartRow + i).CreateCell(5).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][5]));
TempSheet.GetRow(StartRow + i).CreateCell(6).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][6]));
TempSheet.GetRow(StartRow + i).CreateCell(7).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][7]));
TempSheet.GetRow(StartRow + i).CreateCell(8).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][8]));
TempSheet.GetRow(StartRow + i).CreateCell(9).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][9]));
TempSheet.GetRow(StartRow + i).CreateCell(10).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][10]));
TempSheet.GetRow(StartRow + i).CreateCell(11).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][11]));
TempSheet.GetRow(StartRow + i).CreateCell(12).SetCellValue(Convert.ToString(tDS.Tables[0].Rows[i][12]));
}
//将文档写到指定位置
using (FileStream file = new FileStream("H:/Test_NPOI4.xls", FileMode.Create))
{
wb.Write(file);
file.Close();
file.Dispose();
}
}
catch (Exception e)
{
string a = e.ToString();
}
}

  from:http://www.cnblogs.com/kingboy2008/p/3711168.html

龙生   20 May 2014
View Details

C# 程序员最常犯的 10 个错误

关于C# C#是达成微软公共语言运行库（CLR）的少数语言中的一种。达成CLR的语言可以受益于其带来的特性，如跨语言集成、异常处理、安全性增强、部件组合的简易模型以及调试和分析服务。作为现代的CLR语言，C#是应用最为广泛的，其应用场景针对Windows桌面、移动手机以及服务器环境等复杂、专业的开发项目。 C#是种面向对象的强类型语言。C#在编译和运行时都有的强类型检查，使在大多数典型的编程错误能够被尽早地发现，而且位置定位相当精准。相比于那些不拘泥类型，在违规操作很久后才报出可追踪到莫名其妙错误的语言，这可以为程序员节省很多时间。然而，许多程序员有意或无意地抛弃了这个检测的有点，这导致本文中讨论的一些问题。 关于本文 本文描述了10个 C# 程序员常犯的错误，或应该避免的陷阱。 尽管本文讨论的大多数错误是针对 C# 的，有些错误与其他以 CLR 为目标的语言，或者用到了 Framework Class Library (FCL) 的语言也相关。 常见错误 #1: 把引用当做值来用，或者反过来 C++ 和其他很多语言的程序员，习惯了给变量赋值的时候，要么赋单纯的值，要么是现有对象的引用。然而，在C# 中，是值还是引用，是由写这个对象的程序员决定的，而不是实例化对象并赋值的程序员决定的。这往往会坑到 C# 的新手程序员。 如果你不知道你正在使用的对象是否是值类型或引用类型，你可能会遇到一些惊喜。例如：

1
2
3
4
5
6
7
8
9
10
11
  Point point1 = new Point(20, 30);
  Point point2 = point1;
  point2.X = 50;
  Console.WriteLine(point1.X);       // 20 (does this surprise you?)
  Console.WriteLine(point2.X);       // 50
  
  Pen pen1 = new Pen(Color.Black);
  Pen pen2 = pen1;
  pen2.Color = Color.Blue;
  Console.WriteLine(pen1.Color);     // Blue (or does this surprise you?)
  Console.WriteLine(pen2.Color);     // Blue

如你所见,尽管Point和Pen对象的创建方式相同,但是当一个新的X的坐标值被分配到point2时, point1的值保持不变 。而当一个新的color值被分配到pen2,pen1也随之改变。因此,我们可以推断point1和point2每个都包含自己的Point对象的副本,而pen1和pen2引用了同一个Pen对象 。如果没有这个测试,我们怎么能够知道这个原理? 一种办法是去看一下对象是如何定义的（在Visual Studio中，你可以把光标放在对象的名字上，并按下F12键）

1
2
  public struct Point { … }     // defines a “value” type
  public class Pen { … }        // defines a “reference” type

  如上所示，在C#中，struct关键字是用来定义一个值类型，而class关键字是用来定义引用类型的。 对于那些有C++编程背景人来说，如果被C++和C#之间某些类似的关键字搞混，可能会对以上这种行为感到很吃惊。 如果你想要依赖的行为会因值类型和引用类型而异，举例来说，如果你想把一个对象作为参数传给一个方法，并在这个方法中修改这个对象的状态。你一定要确保你在处理正确的类型对象。 常见的错误#2：误会未初始化变量的默认值 在C#中，值得类型不能为空。根据定义，值的类型值，甚至初始化变量的值类型必须有一个值。这就是所谓的该类型的默认值。这通常会导致以下，意想不到的结果时，检查一个变量是否未初始化：

1
2
3
4
5
6
  class Program {
      static Point point1;      static Pen pen1;      static void Main(string[] args) {
          Console.WriteLine(pen1 == null);      // True
          Console.WriteLine(point1 == null);    // False (huh?)
      }
  }

为什么不是【point 1】空？答案是，点是一个值类型，和默认值点（0,0）一样，没有空值。未能认识到这是一个非常简单和常见的错误，在C#中 很多（但是不是全部）值类型有一个【IsEmpty】属性，你可以看看它等于默认值：

1
Console.WriteLine(point1.IsEmpty);        // True

当你检查一个变量是否已经初始化，确保你知道值未初始化是变量的类型，将会在默认情况下，不为空值。 常见错误 #3: 使用不恰当或未指定的方法比较字符串 在C#中有很多方法来比较字符串。 虽然有不少程序员使用==操作符来比较字符串，但是这种方法实际上是最不推荐使用的。主要原因是由于这种方法没有在代码中显示的指定使用哪种类型去比较字符串。 相反，在C#中判断字符串是否相等最好使用Equals方法：

1
  public bool Equals(string value);  public bool Equals(string value, StringComparison comparisonType);

  第一个Equals方法（没有comparisonType这参数）和使用==操作符的结果是一样的，但好处是，它显式的指明了比较类型。它会按顺序逐字节的去比较字符串。在很多情况下，这正是你所期望的比较类型，尤其是当比较一些通过编程设置的字符串，像文件名，环境变量，属性等。在这些情况下，只要按顺序逐字节的比较就可以了。使用不带comparisonType参数的Equals方法进行比较的唯一一点不好的地方在于那些读你程序代码的人可能不知道你的比较类型是什么。 使用带comparisonType的Equals方法去比较字符串，不仅会使你的代码更清晰，还会使你去考虑清楚要用哪种类型去比较字符串。这种方法非常值得你去使用，因为尽管在英语中，按顺序进行的比较和按语言区域进行的比较之间并没有太多的区别，但是在其他的一些语种可能会有很大的不同。如果你忽略了这种可能性，无疑是为你自己在未来的道路上挖了很多“坑”。举例来说：

1
2
3
4
5
6
7
8
9
10
11
12
  string s = "strasse";
  
  // outputs False:
  Console.WriteLine(s == "stra&amp;szlig;e");
  Console.WriteLine(s.Equals("stra&amp;szlig;e"));
  Console.WriteLine(s.Equals("stra&amp;szlig;e", StringComparison.Ordinal));
  Console.WriteLine(s.Equals("Stra&amp;szlig;e", StringComparison.CurrentCulture));        
  Console.WriteLine(s.Equals("stra&amp;szlig;e", StringComparison.OrdinalIgnoreCase));
  
  // outputs True:
  Console.WriteLine(s.Equals("stra&amp;szlig;e", StringComparison.CurrentCulture));
  Console.WriteLine(s.Equals("Stra&amp;szlig;e", StringComparison.CurrentCultureIgnoreCase));

最安全的实践是总是为Equals方法提供一个comparisonType的参数。 下面是一些基本的指导原则： 当比较用户输入的字符串或者将字符串比较结果展示给用户时，使用本地化的比较(CurrentCulture 或者CurrentCultureIgnoreCase)。 当用于程序设计的比较字符串时，使用原始的比较(Ordinal 或者 OrdinalIgnoreCase) InvariantCulture和InvariantCultureIgnoreCase一般并不使用，除非在受限的情境之下，因为原始的比较通常效率更高。如果与本地文化相关的比较是必不可少的，它应该被执行成基于当前的文化或者另一种特殊文化的比较。 此外，对Equals 方法来说，字符串也通常提供了Compare方法，可以提供字符串的相对顺序信息而不仅仅中测试是否相等。这个方法可以很好适用于<, <=, >和>= 运算符，对上述讨论同样适用。 常见误区 #4: 使用迭代式 (而不是声明式)的语句去操作集合 在C# 3.0中，LINQ的引入改变了我们以往对集合对象的查询和修改操作。从这以后，你应该用LINQ去操作集合，而不是通过迭代的方式。 一些C#的程序员甚至都不知道LINQ的存在，好在不知道的人正在逐步减少。但是还有些人误以为LINQ只用在数据库查询中，因为LINQ的关键字和SQL语句实在是太像了。 虽然数据库的查询操作是LINQ的一个非常典型的应用，但是它同样可以应用于各种可枚举的集合对象。（如：任何实现了IEnumerable接口的对象）。举例来说，如果你有一个Account类型的数组，不要写成下面这样：

1
2
3
4
  decimal total = 0;  foreach (Account account in myAccounts) {    if (account.Status == "active") {
      total += account.Balance;
    }
  }

你只要这样写：

1
2
3
  decimal total = (from account in myAccounts
               where account.Status == "active"
                select account.Balance).Sum();

虽然这是一个很简单的例子，在有些情况下，一个单一的LINQ语句可以轻易地替换掉你代码中一个迭代循环（或嵌套循环）里的几十条语句。更少的代码通常意味着产生Bug的机会也会更少地被引入。然而，记住，在性能方面可能要权衡一下。在性能很关键的场景，尤其是你的迭代代码能够对你的集合进行假设时，LINQ做不到，所以一定要在这两种方法之间比较一下性能。 #5常见错误：在LINQ语句之中没有考虑底层对象 对于处理抽象操纵集合任务，LINQ无疑是庞大的。无论他们是在内存的对象，数据库表，或者XML文档。在如此一个完美世界之中，你不需要知道底层对象。然而在这儿的错误是假设我们生活在一个完美世界之中。事实上，相同的LINQ语句能返回不同的结果，当在精确的相同数据上执行时，如果该数据碰巧在一个不同的格式之中。 例如，请考虑下面的语句： 1 decimal total=(from accout in myaccouts 2 where accout.status==‘active" 3                    select accout .Balance).sum(); 想象一下，该对象之一的账号会发生什么。状态等于“有效的”（注意大写A)? 好吧，如果myaccout是Dbset的对象。（默认设置了不同区分大小写的配置），where表达式仍会匹配该元素。然而，如果myaccout是在内存阵列之中，那么它将不匹配，因此将产生不同的总的结果。 等一会，在我们之前讨论过的字符串比较中, 我们看见 == 操作符扮演的角色就是简单的比较. 所以，为什么在这个条件下， == 表现出的是另外的一个形式呢 ? 答案是，当在LINQ语句中的基础对象都引用到SQL表中的数据（如与在这个例子中，在实体框架为DbSet的对象的情况下），该语句被转换成一个T-SQL语句。然后遵循的T-SQL的规则，而不是C＃的规则，所以在上述情况下的比较结束是不区分大小写的。 […]

龙生   12 May 2014
View Details
1 … 31 32 33 … 43

Copyright © 2025 Longsheng All rights reserved