Category Archives: Asp.net

“锁定”语句（C# 参考）

lock 关键字将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。下面的示例包含一个 lock 语句。

class Account

{

decimal balance;

private Object thisLock = new Object();

public void Withdraw(decimal amount)

{

lock (thisLock)

{

if (amount > balance)

{

throw new Exception("Insufficient funds");

}

balance -= amount;

}

有关更多信息，请参见线程同步（C# 和 Visual Basic）。备注 lock 关键字可确保当一个线程位于代码的临界区时，另一个线程不会进入该临界区。如果其他线程尝试进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。线程处理（C# 和 Visual Basic）这节讨论了线程处理。 lock 关键字在块的开始处调用 Enter，而在块的结尾处调用 Exit。 ThreadInterruptedException 引发，如果 Interrupt 中断等待输入 lock 语句的线程。通常，应避免锁定 public 类型，否则实例将超出代码的控制范围。常见的结构 lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 违反此准则：如果实例可以被公共访问，将出现 lock (this) 问题。如果 MyType 可以被公共访问，将出现 lock (typeof (MyType)) 问题。由于进程中使用同一字符串的任何其他代码都将共享同一个锁，所以出现 lock("myLock") 问题。最佳做法是定义 private 对象来锁定, 或 private static 对象变量来保护所有实例所共有的数据。在 lock 语句的正文不能使用等待关键字。示例下面演示在 C# 中使用未锁定的线程的简单示例。 C#

//using System.Threading;

class ThreadTest

{

public void RunMe()

{

Console.WriteLine("RunMe called");

}

static void Main()

{

ThreadTest b = new ThreadTest();

Thread t = new Thread(b.RunMe);

t.Start();

}

// Output: RunMe called

示例下例使用线程和 lock。只要 lock 语句存在，语句块就是临界区并且 balance 永远不会是负数。 C#

// using System.Threading;

class Account

{

private Object thisLock = new Object();

int balance;

Random r = new Random();

public Account(int initial)

{

balance = initial;

}

int Withdraw(int amount)

{

// This condition never is true unless the lock statement

// is commented out.

if (balance < 0)

{

throw new Exception("Negative Balance");

}

// Comment out the next line to see the effect of leaving out

// the lock keyword.

lock (thisLock)

{

if (balance >= amount)

{

Console.WriteLine("Balance before Withdrawal : " + balance);

Console.WriteLine("Amount to Withdraw : -" + amount);

balance = balance - amount;

Console.WriteLine("Balance after Withdrawal : " + balance);

return amount;

}

else

{

return 0; // transaction rejected

}

public void DoTransactions()

{

for (int i = 0; i < 100; i++)

{

Withdraw(r.Next(1, 100));

}

class Test

{

static void Main()

{

Thread[] threads = new Thread[10];

Account acc = new Account(1000);

for (int i = 0; i < 10; i++)

{

Thread t = new Thread(new ThreadStart(acc.DoTransactions));

threads[i] = t;

}

for (int i = 0; i < 10; i++)

{

threads[i].Start();

}

from:https://msdn.microsoft.com/zh-cn/library/c5kehkcz.aspx

龙生 17 Sep 2016

View Details

Entity Framework 增删改查和事务操作

1、增加对象

DbEntity db = new DbEntity();

//创建对象实体，注意，这里需要对所有属性进行赋值（除了自动增长主键外），如果不赋值，则会数据库中会被设置为NULL（注意是否可空）

var user = new User

{

Name = "bomo",

Age = 21,

Gender = "male"

};

db.User.Add(user);

db.SaveChanges();

2、删除对象，删除只需要对象的主键

DbEntity db = new DbEntity();

//删除只需要主键，这里删除主键为5的行

var user = new User {Id = 5};

//将实体附加到对象管理器中

db.User.Attach(user);

//方法一：

db.User.Remove(user);

//方法二：把当前实体的状态改为删除

//db.Entry(user).State = EntityState.Deleted;

db.SaveChanges();

3、修改对象方法一：

DbEntity db = new DbEntity();

//修改需要对主键赋值，注意：这里需要对所有字段赋值，没有赋值的字段会用NULL更新到数据库

var user = new User

{

Id = 5,

Name = "bomo",

Age = 21,

Gender = "male"

};

//将实体附加到对象管理器中

db.User.Attach(user);

//把当前实体的状态改为Modified

db.Entry(user).State = EntityState.Modified;

db.SaveChanges();

方法二：方法一中每次都需要对所有字段进行修改，效率低，而且麻烦，下面介绍修改部分字段

DbEntity db = new DbEntity();

//修改需要对主键赋值，注意：这里需要对所有字段赋值，没有赋值的字段会用NULL更新到数据库

var user = new User

{

Id = 5,

Name = "bomo",

Age = 21

};

//将实体附加到对象管理器中

db.User.Attach(user);

//获取到user的状态实体，可以修改其状态

var setEntry = ((IObjectContextAdapter) db).ObjectContext.ObjectStateManager.GetObjectStateEntry(user);

//只修改实体的Name属性和Age属性

setEntry.SetModifiedProperty("Name");

setEntry.SetModifiedProperty("Age");

db.SaveChanges();

4、使用事务：使用事务很简单，只要把需要的操作放在 TransactionScope 中，最后提交

DbEntity db = new DbEntity();

using (var scope = new TransactionScope())

{

//执行多个操作

var user1 = new User

{

Name = "bomo",

Age = 21,

Gender = "male"

};

db.User.Add(user1);

db.SaveChanges();

var user2 = new User

{

Name = "toroto",

Age = 20,

Gender = "female"

};

db.User.Add(user2);

db.SaveChanges();

//提交事务

scope.Complete();

}

5、查询：查询通过LinQ查询

DbEntity db = new DbEntity();

//选择部分字段

var user = db.User.Where(u => u.Name == "bomo").Select(u => new {Id = u.Id, Name = u.Name, Age = u.Age}).FirstOrDefault();

//只有调用了FirstOrDefault, First, Single, ToList, ToArray等函数才会执行对数据库的查询

from:http://www.cnblogs.com/bomo/p/3331602.html

龙生 15 Sep 2016

View Details

Entity Framework中的批量提交与事务处理

在Entity Framework 中使用SaveChanges()是很频繁的，单次修改或删除数据后调用SaveChanges()返回影响记录数。要使用批量修改或者批量删除数据，就需要SaveChanges(false)+AcceptAllChanges()方法了。 SaveChanges(false) 只是通知EF需要对数据库执行的操作，在内存中是属于挂起状态，在必要的时候是可以撤销的，比如AcceptAllChange()提交为真正成功，EF将撤销SaveChanges(false)的操作。而在处理分布式事务操作的时候，就有必要使用TransactionScope 来处理了，很多时候我们会这样写：

using (TransactionScope scope = new TransactionScope())

{

//Do something with context1

//Do something with context2

//Save and discard changes

context1.SaveChanges();

//Save and discard changes

context2.SaveChanges();

//if we get here things are looking good.

scope.Complete();

}

但是这样写是有风险的，假如context1.SaveChanges()成功了，context2.SaveChanges()却是有问题的，我们在scope.Complete()提交事务的时候就会终止，而Context1已经成功执行了这可能不一定符合我们的需要。如果我们需要 context1、context2要不同时执行成功，要不都不成功，我们需要对代码作小小的调整，如用下面的代码：

using (TransactionScope scope = new TransactionScope())

{

//Do something with context1

//Do something with context2

//Save Changes but don't discard yet

context1.SaveChanges(false);

//Save Changes but don't discard yet

context2.SaveChanges(false);

//if we get here things are looking good.

scope.Complete();

context1.AcceptAllChanges();

context2.AcceptAllChanges();

}

我们用SaveChanges(false)先将必要的数据库操作命令发送给数据库，这是注意context1与context2并没有真正发生改变，如果事务终止，自动回滚，两者的更改都没有真正提交到数据库，所以是可以成功回滚的。在Entity Framework 中使用SaveChanges()是很频繁的，单次修改或删除数据后调用SaveChanges()返回影响记录数。要使用批量修改或者批量删除数据，就需要SaveChanges(false)+AcceptAllChanges()方法了。 SaveChanges(false) 只是通知EF需要对数据库执行的操作，在内存中是属于挂起状态，在必要的时候是可以撤销的，比如AcceptAllChange()提交为真正成功，EF将撤销SaveChanges(false)的操作。而在处理分布式事务操作的时候，就有必要使用TransactionScope 来处理了，很多时候我们会这样写：

using (TransactionScope scope = new TransactionScope())

{

//Do something with context1

//Do something with context2

//Save and discard changes

context1.SaveChanges();

//Save and discard changes

context2.SaveChanges();

//if we get here things are looking good.

scope.Complete();

}

using (TransactionScope scope = new TransactionScope())

{

//Do something with context1

//Do something with context2

//Save Changes but don't discard yet

context1.SaveChanges(false);

//Save Changes but don't discard yet

context2.SaveChanges(false);

//if we get here things are looking good.

scope.Complete();

context1.AcceptAllChanges();

context2.AcceptAllChanges();

}

我们用SaveChanges(false)先将必要的数据库操作命令发送给数据库，这是注意context1与context2并没有真正发生改变，如果事务终止，自动回滚，两者的更改都没有真正提交到数据库，所以是可以成功回滚的。 To use TransactionScope class you need to keep two things in mind You need to add System.Transactions reference to your project Make sure the Windows service “Distributed Transaction Coordinator” is up and running. from:http://www.cnblogs.com/hyl8218/archive/2011/10/10/2205576.html

龙生 15 Sep 2016

View Details

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

前言本文开始前我将循序渐进先了解下实现EF中的异步，并将重点主要是放在EF中的事务以及性能优化上，希望通过此文能够帮助到你。异步既然是异步我们就得知道我们知道在什么情况下需要使用异步编程，当等待一个比较耗时的操作时，可以用异步来释放当前的托管线程而无需等待，从而在管理线程中不需要花费额外的时间，也就是不会阻塞当前线程的运行。在客户端如：Windows Form以及WPF应用程序中，当执行异步操作时，则当前线程能够保持用户界面持续响应。在服务器端如：ASP.NET应用程序中，执行异步操作可以用来处理多个请求，可以提高服务器的吞吐量等等。在大部分应用程序中，对于比较耗时的操作用异步来实现可能会有一些改善，但是若你不多加考虑，动不动就用异步反而会得到相反的效果以及对应用程序也是致命的。鉴于上述描述，我们接下来通过EF实现异步来加深理解。（想想还是把所用类及映射给出来，以免没看过前面的文章的同仁不知所云。） Student（学生）类：

public class Student

{

public int Id { get; set; }

public string Name { get; set; }

public int FlowerId { get; set; }

public virtual Flower Flower { get; set; }

}

Flower（小红花）类

public class Flower

{

public int Id { get; set; }

public string Remark { get; set; }

public virtual ICollection<Student> Students { get; set; }

}

5天玩转C#并行和多线程编程 —— 第二天并行集合和PLinq

在上一篇博客5天玩转C#并行和多线程编程 —— 第一天认识Parallel中，我们学习了Parallel的用法。并行编程，本质上是多线程的编程，那么当多个线程同时处理一个任务的时候，必然会出现资源访问问题，及所谓的线程安全。就像现实中，我们开发项目，就是一个并行的例子，把不同的模块分给不同的人，同时进行，才能在短的时间内做出大的项目。如果大家都只管自己写自己的代码，写完后发现合并不到一起，那么这种并行就没有了意义。　　并行算法的出现，随之而产生的也就有了并行集合，及线程安全集合；微软向的也算周到，没有忘记linq，也推出了linq的并行版本，plinq – Parallel Linq. 一、并行集合 —— 线程安全集合　　并行计算使用的多个线程同时进行计算，所以要控制每个线程对资源的访问，我们先来看一下平时常用的List<T>集合，在并行计算下的表现，新建一个控制台应用程序，添加一个PEnumerable类(当然你也直接写到main方法里面测试，建议分开写)，写如下方法：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Collections.Concurrent;

namespace ThreadPool

{

public class PEnumerable

{

public static void ListWithParallel()

{

List<int> list = new List<int>();

Parallel.For(0, 10000, item =>

{

list.Add(item);

});

Console.WriteLine("List's count is {0}",list.Count());

}

点击F5运行，得到如下结果：看到结果中显示的5851，但是我们循环的是10000次啊！怎么结果不对呢？这是因为List<T>是非线程安全集合，意思就是说所有的线程都可以修改他的值。下面我们来看下并行集合 —— 线程安全集合，在System.Collections.Concurrent命名空间中，首先来看一下ConcurrentBag<T>泛型集合，其用法和List<T>类似，先来写个方法测试一下：

public static void ConcurrentBagWithPallel()

{

ConcurrentBag<int> list = new ConcurrentBag<int>();

Parallel.For(0, 10000, item =>

{

list.Add(item);

});

Console.WriteLine("ConcurrentBag's count is {0}", list.Count());

}

同时执行两个方法，结果如下：可以看到，ConcurrentBag集合的结果是正确的。下面我们修改代码看看ConcurrentBag里面的数据到底是怎么存放的，修改代码如下：

public static void ConcurrentBagWithPallel()

{

ConcurrentBag<int> list = new ConcurrentBag<int>();

Parallel.For(0, 10000, item =>

{

list.Add(item);

});

Console.WriteLine("ConcurrentBag's count is {0}", list.Count());

int n = 0;

foreach(int i in list)

{

if (n > 10)

break;

n++;

Console.WriteLine("Item[{0}] = {1}",n,i);

}

Console.WriteLine("ConcurrentBag's max item is {0}", list.Max());

}

先来看一下运行结果：可以看到，ConcurrentBag中的数据并不是按照顺序排列的，顺序是乱的，随机的。我们平时使用的Max、First、Last等linq方法都还有。其时分类似Enumerable的用法，大家可以参考微软的MSDN了解它的具体用法。关于线程安全的集合还有很多，和我们平时用的集合都差不多，比如类似Dictionary的ConcurrentDictionary，还有ConcurrentStack，ConcurrentQueue等。二、Parallel Linq的用法及性能 1、AsParallel 前面了解了并行的For和foreach,今天就来看一下Linq的并行版本是怎么样吧？为了测试，我们添加一个Custom类，代码如下：

public class Custom

{

public string Name { get; set; }

public int Age { get; set; }

public string Address { get; set; }

}

写如下测试代码：

public static void TestPLinq()

{

Stopwatch sw = new Stopwatch();

List<Custom> customs = new List<Custom>();

for (int i = 0; i < 2000000; i++)

{

customs.Add(new Custom() { Name = "Jack", Age = 21, Address = "NewYork" });

customs.Add(new Custom() { Name = "Jime", Age = 26, Address = "China" });

customs.Add(new Custom() { Name = "Tina", Age = 29, Address = "ShangHai" });

customs.Add(new Custom() { Name = "Luo", Age = 30, Address = "Beijing" });

customs.Add(new Custom() { Name = "Wang", Age = 60, Address = "Guangdong" });

customs.Add(new Custom() { Name = "Feng", Age = 25, Address = "YunNan" });

}

sw.Start();

var result = customs.Where<Custom>(c => c.Age > 26).ToList();

sw.Stop();

Console.WriteLine("Linq time is {0}.",sw.ElapsedMilliseconds);

sw.Restart();

sw.Start();

var result2 = customs.AsParallel().Where<Custom>(c => c.Age > 26).ToList();

sw.Stop();

Console.WriteLine("Parallel Linq time is {0}.", sw.ElapsedMilliseconds);

}

其实也就是加了一个AsParallel()方法，下面来看下运行结果：时间相差了一倍，不过有时候不会相差这么多，要看系统当前的资源利用率。大家可以多测试一下。其实，AsParallel()这个方法可以应用与任何集合，包括List<T>集合，从而提高查询速度和系统性能。 2、GroupBy方法在项目中，我们经常要对数据做处理，比如分组统计，我们知道在linq中也可以实现，今天来学习一下新的ToLookup方法，写一个测试方法，代码如下：

public static void OrderByTest()

{

Stopwatch stopWatch = new Stopwatch();

List<Custom> customs = new List<Custom>();

for (int i = 0; i < 2000000; i++)

{

customs.Add(new Custom() { Name = "Jack", Age = 21, Address = "NewYork" });

customs.Add(new Custom() { Name = "Jime", Age = 26, Address = "China" });

customs.Add(new Custom() { Name = "Tina", Age = 29, Address = "ShangHai" });

customs.Add(new Custom() { Name = "Luo", Age = 30, Address = "Beijing" });

customs.Add(new Custom() { Name = "Wang", Age = 60, Address = "Guangdong" });

customs.Add(new Custom() { Name = "Feng", Age = 25, Address = "YunNan" });

}

stopWatch.Restart();

var groupByAge = customs.GroupBy(item => item.Age).ToList();

foreach (var item in groupByAge)

{

Console.WriteLine("Age={0},count = {1}", item.Key, item.Count());

}

stopWatch.Stop();

Console.WriteLine("Linq group by time is: " + stopWatch.ElapsedMilliseconds);

stopWatch.Restart();

var lookupList = customs.ToLookup(i => i.Age);

foreach (var item in lookupList)

{

Console.WriteLine("LookUP:Age={0},count = {1}", item.Key, item.Count());

}

stopWatch.Stop();

Console.WriteLine("LookUp group by time is: " + stopWatch.ElapsedMilliseconds);

}

运行结果如下： ToLookup方法是将集合转换成一个只读集合，所以在大数据量分组时性能优于List.大家可以查阅相关资料，这里由于篇幅问题，不再细说。 from:http://www.cnblogs.com/yunfeifei/p/3998783.html

龙生 13 Sep 2016

View Details

5天玩转C#并行和多线程编程 —— 第一天认识Parallel

随着多核时代的到来，并行开发越来越展示出它的强大威力！使用并行程序，充分的利用系统资源，提高程序的性能。在.net 4.0中，微软给我们提供了一个新的命名空间：System.Threading.Tasks。这里面有很多关于并行开发的东西，今天第一篇就介绍下最基础，最简单的——认识和使用Parallel。一、 Parallel的使用在Parallel下面有三个常用的方法invoke,For和ForEach。 1、 Parallel.Invoke 这是最简单，最简洁的将串行的代码并行化。在这里先讲一个知识点，就是StopWatch的使用，最近有一些人说找不到StopWatch，StopWatch到底是什么东西，今天就来说明一下。 StopWatch在System.Diagnostics命名控件，要使用它就要先引用这个命名空间。其使用方法如下： var stopWatch = new StopWatch(); //创建一个Stopwatch实例 stopWatch.Start(); //开始计时 stopWatch.Stop(); //停止计时 stopWatch.Reset(); //重置StopWatch stopWatch.Restart(); //重新启动被停止的StopWatch stopWatch.ElapsedMilliseconds //获取stopWatch从开始到现在的时间差，单位是毫秒本次用到的就这么多知识点，想了解更多关于StopWatch的，去百度一下吧，网上有很多资料。下面进入整体，开始介绍Parallel.Invoke方法，废话不多说了，首先新建一个控制台程序，添加一个类，代码如下：

public class ParallelDemo

{

private Stopwatch stopWatch = new Stopwatch();

public void Run1()

{

Thread.Sleep(2000);

Console.WriteLine("Task 1 is cost 2 sec");

}

public void Run2()

{

Thread.Sleep(3000);

Console.WriteLine("Task 2 is cost 3 sec");

}

public void ParallelInvokeMethod()

{

stopWatch.Start();

Parallel.Invoke(Run1, Run2);

stopWatch.Stop();

Console.WriteLine("Parallel run " + stopWatch.ElapsedMilliseconds + " ms.");

stopWatch.Restart();

Run1();

Run2();

stopWatch.Stop();

Console.WriteLine("Normal run " + stopWatch.ElapsedMilliseconds + " ms.");

}

｝

代码很简单，首先新加一个类，在类中写了两个方法，Run1和Run2，分别等待一定时间，输出一条信息，然后写了一个测试方法ParallelInvokeMethod，分别用两种方法调用Run1和Run2，然后在main方法中调用，下面来看一下运行时间如何：大家应该能够猜到，正常调用的话应该是5秒多，而Parallel.Invoke方法调用用了只有3秒，也就是耗时最长的那个方法，可以看出方法是并行执行的，执行效率提高了很多。 2、Parallel.For 这个方法和For循环的功能相似，下面就在类中添加一个方法来测试一下吧。代码如下：

public void ParallelForMethod()

{

stopWatch.Start();

for (int i = 0; i < 10000; i++)

{

for (int j = 0; j < 60000; j++)

{

int sum = 0;

sum += i;

}

stopWatch.Stop();

Console.WriteLine("NormalFor run " + stopWatch.ElapsedMilliseconds + " ms.");

stopWatch.Reset();

stopWatch.Start();

Parallel.For(0, 10000, item =>

{

for (int j = 0; j < 60000; j++)

{

int sum = 0;

sum += item;

}

});

stopWatch.Stop();

Console.WriteLine("ParallelFor run " + stopWatch.ElapsedMilliseconds + " ms.");

}

写了两个循环，做了一些没有意义的事情，目的主要是为了消耗CPU时间，同理在main方法中调用，运行结果如下图：可以看到，Parallel.For所用的时间比单纯的for快了1秒多，可见提升的性能是非常可观的。那么，是不是Parallel.For在任何时候都比for要快呢？答案当然是“不是”，要不然微软还留着for干嘛？下面修改一下代码，添加一个全局变量num，代码如下：

public void ParallelForMethod()

{

var obj = new Object();

long num = 0;

ConcurrentBag<long> bag = new ConcurrentBag<long>();

stopWatch.Start();

for (int i = 0; i < 10000; i++)

{

for (int j = 0; j < 60000; j++)

{

//int sum = 0;

//sum += item;

num++;

}

stopWatch.Stop();

Console.WriteLine("NormalFor run " + stopWatch.ElapsedMilliseconds + " ms.");

stopWatch.Reset();

stopWatch.Start();

Parallel.For(0, 10000, item =>

{

for (int j = 0; j < 60000; j++)

{

//int sum = 0;

//sum += item;

lock (obj)

{

num++;

}

});

stopWatch.Stop();

Console.WriteLine("ParallelFor run " + stopWatch.ElapsedMilliseconds + " ms.");

}

Parallel.For由于是并行运行的，所以会同时访问全局变量num,为了得到正确的结果，要使用lock,此时来看看运行结果：是不是大吃一惊啊？Parallel.For竟然用了15秒多，而for跟之前的差不多。这主要是由于并行同时访问全局变量，会出现资源争夺，大多数时间消耗在了资源等待上面。一直说并行，那么从哪里可以看出来Parallel.For是并行执行的呢？下面来写个测试代码：

Parallel.For(0, 100, i =>

{

Console.Write(i + "\t");

});

从0输出到99，运行后会发现输出的顺序不对，用for顺序肯定是对的，并行同时执行，所以会出现输出顺序不同的情况。 2、Parallel.Foreach 这个方法跟Foreach方法很相似，想具体了解的，可以百度些资料看看，这里就不多说了，下面给出其使用方法：

List<int> list = new List<int>();

list.Add(0);

Parallel.ForEach(list, item =>

{

DoWork(item);

});

二、 Parallel中途退出循环和异常处理 1、当我们使用到Parallel，必然是处理一些比较耗时的操作，当然也很耗CPU和内存，如果我们中途向停止，怎么办呢？在串行代码中我们break一下就搞定了，但是并行就不是这么简单了，不过没关系，在并行循环的委托参数中提供了一个ParallelLoopState，该实例提供了Break和Stop方法来帮我们实现。 Break: 当然这个是通知并行计算尽快的退出循环，比如并行计算正在迭代100，那么break后程序还会迭代所有小于100的。 Stop：这个就不一样了，比如正在迭代100突然遇到stop，那它啥也不管了，直接退出。下面来写一段代码测试一下：

public void ParallelBreak()

{

ConcurrentBag<int> bag = new ConcurrentBag<int>();

stopWatch.Start();

Parallel.For(0, 1000, (i, state) =>

{

if (bag.Count == 300)

{

state.Stop();

return;

}

bag.Add(i);

});

stopWatch.Stop();

Console.WriteLine("Bag count is " + bag.Count + ", " + stopWatch.ElapsedMilliseconds);

}

这里使用的是Stop，当数量达到300个时，会立刻停止；可以看到结果"Bag count is 300"，如果用break,可能结果是300多个或者300个，大家可以测试一下。 2、异常处理首先任务是并行计算的，处理过程中可能会产生n多的异常，那么如何来获取到这些异常呢？普通的Exception并不能获取到异常，然而为并行诞生的AggregateExcepation就可以获取到一组异常。这里我们修改Parallel.Invoke的代码，修改后代码如下：

public class ParallelDemo

{

private Stopwatch stopWatch = new Stopwatch();

public void Run1()

{

Thread.Sleep(2000);

Console.WriteLine("Task 1 is cost 2 sec");

throw new Exception("Exception in task 1");

}

public void Run2()

{

Thread.Sleep(3000);

Console.WriteLine("Task 2 is cost 3 sec");

throw new Exception("Exception in task 2");

}

public void ParallelInvokeMethod()

{

stopWatch.Start();

try

{

Parallel.Invoke(Run1, Run2);

}

catch (AggregateException aex)

{

foreach (var ex in aex.InnerExceptions)

{

Console.WriteLine(ex.Message);

}

stopWatch.Stop();

Console.WriteLine("Parallel run " + stopWatch.ElapsedMilliseconds + " ms.");

stopWatch.Reset();

stopWatch.Start();

try

{

Run1();

Run2();

}

catch(Exception ex)

{

Console.WriteLine(ex.Message);

}

stopWatch.Stop();

Console.WriteLine("Normal run " + stopWatch.ElapsedMilliseconds + " ms.");

}

｝

顺序调用方法我把异常处理写一起了，这样只能捕获Run1的异常信息，大家可以分开写。捕获AggregateException 异常后，用foreach循环遍历输出异常信息，可以看到两个异常信息都显示了。点击这里，下载源码 from:http://www.cnblogs.com/yunfeifei/p/3993401.html

龙生 13 Sep 2016

View Details

C#中小数点后保留两位小数，四舍五入的函数及使用方法

Math.Round(45.367,2) //Returns 45.37 Math.Round(45.365,2) //Returns 45.36 C#中的Round()不是我们中国人理解的四舍五入，是老外的四舍五入，是符合IEEE标准的四舍五入，具体是四舍六入，下面的才是符合中国人理解的四舍五入 Math.Round(45.367,2,MidpointRounding.AwayFromZero);//45.37 Math.Round(45.365,2,MidpointRounding.AwayFromZero) //Returns 45.37 from:http://www.cnblogs.com/purplefox2008/archive/2011/08/08/2130635.html

龙生 12 Sep 2016

View Details

Asp.net+Mysql,查询出错:由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败

在网上看到的解决方案基本都是说host文件中127.0.0.1 localhost 的对应，但我查看了host文件，并没有问题，纠结半天，拿查询语句在Mysql Workbench上执行，报了一个错，说是子查询包含多个结果，我去~！这很简单的一个错误asp.net竟然没能准确反馈。于是在子查询语句后面加limit 1，Ok~ 所以，出现“由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败”这个错误时，有可能是查询语句有问题，而不是连接有问题。 from:http://blog.csdn.net/idoiknow/article/details/8923553

龙生 07 Sep 2016

View Details

NPOI读写Excel

1、整个Excel表格叫做工作表：WorkBook（工作薄），包含的叫页（工作表）：Sheet；行：Row；单元格Cell。 2、NPOI是POI的C#版本，NPOI的行和列的index都是从0开始 3、POI读取Excel有两种格式一个是HSSF，另一个是XSSF。 HSSF和XSSF的区别如下： HSSF is the POI Project’s pure Java implementation of the Excel ’97(-2007) file format. XSSF is the POI Project’s pure Java implementation of the Excel 2007 OOXML (.xlsx) file format. 即：HSSF适用2007以前的版本,XSSF适用2007版本及其以上的。下面是用NPOI读写Excel的例子：ExcelHelper封装的功能主要是把DataTable中数据写入到Excel中，或者是从Excel读取数据到一个DataTable中。 ExcelHelper类：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using NPOI.SS.UserModel;

using NPOI.XSSF.UserModel;

using NPOI.HSSF.UserModel;

using System.IO;

using System.Data;

namespace NetUtilityLib

{

public class ExcelHelper : IDisposable

{

private string fileName = null; //文件名

private IWorkbook workbook = null;

private FileStream fs = null;

private bool disposed;

public ExcelHelper(string fileName)

{

this.fileName = fileName;

disposed = false;

}

/// <summary>

/// 将DataTable数据导入到excel中

/// </summary>

/// <param name="data">要导入的数据</param>

/// <param name="isColumnWritten">DataTable的列名是否要导入</param>

/// <param name="sheetName">要导入的excel的sheet的名称</param>

/// <returns>导入数据行数(包含列名那一行)</returns>

public int DataTableToExcel(DataTable data, string sheetName, bool isColumnWritten)

{

int i = 0;

int j = 0;

int count = 0;

ISheet sheet = null;

fs = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);

if (fileName.IndexOf(".xlsx") > 0) // 2007版本

workbook = new XSSFWorkbook();

else if (fileName.IndexOf(".xls") > 0) // 2003版本

workbook = new HSSFWorkbook();

try

{

if (workbook != null)

{

sheet = workbook.CreateSheet(sheetName);

}

else

{

return -1;

}

if (isColumnWritten == true) //写入DataTable的列名

{

IRow row = sheet.CreateRow(0);

for (j = 0; j < data.Columns.Count; ++j)

{

row.CreateCell(j).SetCellValue(data.Columns[j].ColumnName);

}

count = 1;

}

else

{

count = 0;

}

for (i = 0; i < data.Rows.Count; ++i)

{

IRow row = sheet.CreateRow(count);

for (j = 0; j < data.Columns.Count; ++j)

{

row.CreateCell(j).SetCellValue(data.Rows[i][j].ToString());

}

++count;

}

workbook.Write(fs); //写入到excel

return count;

}

catch (Exception ex)

{

Console.WriteLine("Exception: " + ex.Message);

return -1;

}

/// <summary>

/// 将excel中的数据导入到DataTable中

/// </summary>

/// <param name="sheetName">excel工作薄sheet的名称</param>

/// <param name="isFirstRowColumn">第一行是否是DataTable的列名</param>

/// <returns>返回的DataTable</returns>

public DataTable ExcelToDataTable(string sheetName, bool isFirstRowColumn)

{

ISheet sheet = null;

DataTable data = new DataTable();

int startRow = 0;

try

{

fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);

if (fileName.IndexOf(".xlsx") > 0) // 2007版本

workbook = new XSSFWorkbook(fs);

else if (fileName.IndexOf(".xls") > 0) // 2003版本

workbook = new HSSFWorkbook(fs);

if (sheetName != null)

{

sheet = workbook.GetSheet(sheetName);

if (sheet == null) //如果没有找到指定的sheetName对应的sheet，则尝试获取第一个sheet

{

sheet = workbook.GetSheetAt(0);

}

else

{

sheet = workbook.GetSheetAt(0);

}

if (sheet != null)

{

IRow firstRow = sheet.GetRow(0);

int cellCount = firstRow.LastCellNum; //一行最后一个cell的编号即总的列数

if (isFirstRowColumn)

{

for (int i = firstRow.FirstCellNum; i < cellCount; ++i)

{

ICell cell = firstRow.GetCell(i);

if (cell != null)

{

string cellValue = cell.StringCellValue;

if (cellValue != null)

{

DataColumn column = new DataColumn(cellValue);

data.Columns.Add(column);

}

startRow = sheet.FirstRowNum + 1;

}

else

{

startRow = sheet.FirstRowNum;

}

//最后一列的标号

int rowCount = sheet.LastRowNum;

for (int i = startRow; i <= rowCount; ++i)

{

IRow row = sheet.GetRow(i);

if (row == null) continue; //没有数据的行默认是null　　　　　　　

DataRow dataRow = data.NewRow();

for (int j = row.FirstCellNum; j < cellCount; ++j)

{

if (row.GetCell(j) != null) //同理，没有数据的单元格都默认是null

dataRow[j] = row.GetCell(j).ToString();

}

data.Rows.Add(dataRow);

}

return data;

}

catch (Exception ex)

{

Console.WriteLine("Exception: " + ex.Message);

return null;

}

public void Dispose()

{

Dispose(true);

GC.SuppressFinalize(this);

}

protected virtual void Dispose(bool disposing)

{

if (!this.disposed)

{

if (disposing)

{

if (fs != null)

fs.Close();

}

fs = null;

disposed = true;

}

测试代码：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data;

namespace NPOIExcelExample

{

class Program

{

static DataTable GenerateData()

{

DataTable data = new DataTable();

for (int i = 0; i < 5; ++i)

{

data.Columns.Add("Columns_" + i.ToString(), typeof(string));

}

for (int i = 0; i < 10; ++i)

{

DataRow row = data.NewRow();

row["Columns_0"] = "item0_" + i.ToString();

row["Columns_1"] = "item1_" + i.ToString();

row["Columns_2"] = "item2_" + i.ToString();

row["Columns_3"] = "item3_" + i.ToString();

row["Columns_4"] = "item4_" + i.ToString();

data.Rows.Add(row);

}

return data;

}

static void PrintData(DataTable data)

{

if (data == null) return;

for (int i = 0; i < data.Rows.Count; ++i)

{

for (int j = 0; j < data.Columns.Count; ++j)

Console.Write("{0} ", data.Rows[i][j]);

Console.Write("\n");

}

static void TestExcelWrite(string file)

{

try

{

using (ExcelHelper excelHelper = new ExcelHelper(file))

{

DataTable data = GenerateData();

int count = excelHelper.DataTableToExcel(data, "MySheet", true);

if (count > 0)

Console.WriteLine("Number of imported data is {0} ", count);

}

catch (Exception ex)

{

Console.WriteLine("Exception: " + ex.Message);

}

static void TestExcelRead(string file)

{

try

{

using (ExcelHelper excelHelper = new ExcelHelper(file))

{

DataTable dt = excelHelper.ExcelToDataTable("MySheet", true);

PrintData(dt);

}

catch (Exception ex)

{

Console.WriteLine("Exception: " + ex.Message);

}

static void Main(string[] args)

{

string file = "..\\..\\myTest.xlsx";

TestExcelWrite(file);

TestExcelRead(file);

}

Excel相关DLL下载：NPOI-Lib.rar 1.NPOI下载地址：http://npoi.codeplex.com/releases/view/38113 2.NPOI学习系列教程推荐：http://www.cnblogs.com/tonyqus/archive/2009/04/12/1434209.html 参考： http://www.cnblogs.com/Erik_Xu/archive/2012/06/08/2541957.html http://www.cnblogs.com/linzheng/archive/2010/12/20/1912137.html http://www.cnblogs.com/knowledgesea/archive/2012/11/16/2772547.html from:http://www.cnblogs.com/luxiaoxun/p/3374992.html

龙生 06 Sep 2016

View Details

« Previous 1 … 20 21 22 … 48 Next »

April 2024
M	T	W	T	F	S	S
« Mar
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