先保存一个临时文件，然后再做其他处理。

 

这是思路，基本解决大部分类似问题。主要是系统线程锁定源文件引起。

C# 利用WinRAR (加密)压缩及解压缩 相关文件夹及文件 (转)收藏
本次示例主要实现：
1.压缩文件夹及其下文件
2.压缩文件夹下文件
3.压缩文件夹及其下文件为rar 还是 zip
4.解压缩
5.加密压缩及解加密压缩
-----------
示例代码如下：
protected void Button1_Click(object sender, EventArgs e)
    {
        string strtxtPath = Cfreezipfree.txt;
        string strzipPath = Cfreezipfree.zip;
        System.Diagnostics.Process Process1 = new System.Diagnostics.Process();
        Process1.StartInfo.FileName = Winrar.exe;
        Process1.StartInfo.CreateNoWindow = true;

         1
        压缩cfreezipfree.txt(即文件夹及其下文件freezipfree.txt)
        到cfreezipfree.rar
        strzipPath = Cfreezipfree;默认压缩方式为 .rar
        Process1.StartInfo.Arguments =  a -r  + strzipPath +   + strtxtPath;

         2
        压缩cfreezipfree.txt(即文件夹及其下文件freezipfree.txt)
        到cfreezipfree.rar
        strzipPath = Cfreezipfree;设置压缩方式为 .zip
        Process1.StartInfo.Arguments =  a -afzip  + strzipPath +   + strtxtPath;

         3
        压缩cfreezipfree.txt(即文件夹及其下文件freezipfree.txt)
        到cfreezipfree.zip  直接设定为free.zip
        Process1.StartInfo.Arguments =  a -r +strzipPath+  + strtxtPath ;

         4
        搬迁压缩cfreezipfree.txt(即文件夹及其下文件freezipfree.txt)
        到cfreezipfree.rar 压缩后 原文件将不存在
        Process1.StartInfo.Arguments =  m  + strzipPath +   + strtxtPath;

         5
        压缩cfreezip下的free.txt(即文件free.txt)
        到cfreezipfree.zip  直接设定为free.zip 只有文件 而没有文件夹
        Process1.StartInfo.Arguments =  a -ep  + strzipPath +   + strtxtPath;

查看更多...

之前，一直没有注意到这个问题，编辑器里的字体样式通常很大，

今天重新去看了官方的事例。

发现每个编辑实例都可以加载不同的css样式表，而且其样式不继承 页面的css。

 

于是我就单独建立个Editor.css

另外在属性设置上设置：

查看更多...

仔细模拟一下你的数据库程序，你有没有发现在计算时（特别是多用户计算时）经常重复读取数据库数据？！这是数据库处理程序的性能的最主要的杀手。

有些人说在写程序之前应该把算法想好，使得数据记录成批地、一次性地读取。但是这实际上往往不可能，因为复杂的程序贴近逻辑流程才清晰可维护。更何况这也不能解决多用户访问的情况。最好，我们根本不用在写程序时去考虑数据是否会被重复读取从而改变程序流程，但是又能自然而然地防止重复读取数据库。当对计算过程进行优化，而又不想破坏逻辑清晰性的时候，当然就是要依靠简单的Cache —— 对象只要能够缓存几秒钟就好。

下面我这里写一个世界上最懒惰的程序员使用.net写的一个最简单的Cache，但是它往往可以让复杂的计算程序大大提高计算速度。

 

C# code

using System;
using System.Collections.Generic;

namespace DomainBase
{
    public class ObjectCache
    {
        //Dictionary<K,T> 会自动维护一个空链表来保存不用的单元。
        //这里，使用被缓存对象的“弱引用”，允许这些对象被垃圾回收。
        private Dictionary<string, WeakReference> Buffer = new Dictionary<string, WeakReference>();

        public object this[string key]
        {
            get
            {
                WeakReference ret;
                if (Buffer.TryGetValue(key, out ret) && ret.IsAlive)
                    return ret.Target;
                else
                    return null;
            }
            set
            {
                WeakReference ret;
                if (Buffer.TryGetValue(key, out ret))
                    ret.Target = value;
                else
                    Buffer.Add(key, new WeakReference(value));
            }
        }

        public void Remove(string key)
        {
            Buffer.Remove(key);
        }
    }
}

这就是最简单的Cache。例如：

public Class User
{
    static ObjectCache Buffer=new ObjectCache();

    public static GetUser(string id)
    {
      User ret=Buffer[id];
      if(ret==null)
      {
            ret=读取数据库产生User对象(id);
            Buffer[id]=ret;
      }
      return ret;
    }
.....

这里，在一个Dictionary <K,T>结构字典中保存了对象的key以及对象的“弱引用”。这样，当内存不足时GC会照样去释放被缓存的对象。当我们需要将对象在几秒钟内进行缓存时，使用这个最简单的Cache很有用。

.net framework中有非常多非常多的东西需要程序员去了解，不要仅仅抱着那些空洞、不实惠的“放之四海而皆准”的大部头的著作，有时间要多读一些实际地分析 .net framework 系统本身的方面的资料。在每一个技术中都可以找对一两个细节，这个细节就像掌握DNA技术一样能够让你不但扩展原理而且通过动手能力得到巨大实惠。

该日志是私密日志，只有管理员或发布者可以查看！

SQLite包含了如下时间/日期函数：
datetime().......................产生日期和时间
date()...........................产生日期
time()...........................产生时间
strftime().......................对以上三个函数产生的日期和时间进行格式化

datetime()的用法是：datetime(日期/时间,修正符,修正符...)
date()和time()的语法与datetime()相同。

在时间/日期函数里可以使用如下格式的字符串作为参数：
YYYY-MM-DD
YYYY-MM-DD HH:MM
YYYY-MM-DD HH:MM:SS
YYYY-MM-DD HH:MM:SS.SSS
HH:MM
HH:MM:SS
HH:MM:SS.SSS
now
其中now是产生现在的时间。
举例（写这个笔记的时间是2006年10月17日晚8点到10点，测试环境：SQLite 2.8.17，WinXP，北京时间）：
例1.
select datetime('now');
结果：2006-10-17 12:55:54
例2.
select datetime('2006-10-17');
结果：2006-10-17 12:00:00
例3.
select datetime('2006-10-17 00:20:00','+1 hour','-12 minute');
结果：2006-10-17 01:08:00
例4.
select date('2006-10-17','+1 day','+1 year');
结果：2007-10-18
例5.
select datetime('now','start of year');
结果：2006-01-01 00:00:00
例6.
select datetime('now','start of month');
结果：2006-10-01 00:00:00
例7.
select datetime('now','start of day');
结果：2006-10-17 00:00:00
例8.
select datetime('now','+10 hour','start of day','+10 hour');
结果：2006-10-17 10:00:00
例9.
select datetime('now','localtime');
结果：2006-10-17 21:21:47
例10.
select datetime('now','+8 hour');
结果：2006-10-17 21:24:45
例3中的+1 hour和-12 minute表示可以在基本时间上（datetime函数的第一个参数）增加或减少一定时间。
例5中的start of year表示一年开始的时间。
从例8可以看出，尽管第2个参数加上了10个小时，但是却被第3个参数“start of day”把时间归零到00:00:00，随后的第4个参数在00:00:00
的基础上把时间增加了10个小时变成了10:00:00。

例9把格林威治时区转换成本地时区。

例10把格林威治时区转换成东八区。

strftime()函数可以把YYYY-MM-DD HH:MM:SS格式的日期字符串转换成其它形式的字符串。
strftime()的语法是strftime(格式, 日期/时间, 修正符, 修正符, ...)

查看更多...

 

我用Repeater和PagedDataSource邦定后，可以按照每页20行的设置进行分页。分页后，我想在第一列的左边显示每行的序号。就用 <%# Container.ItemIndex + 1%>来实现，可是这样做的结果是：第一页显示从1到20的编号，第二页还是显示从1到20的编号，第三页还是显示从1到20的编号…………

我想要的结果是：
第一页显示从1到20的编号，第二页显示从21到40的编号，第三页显示从41到60的编号…………

请问：这种效果怎样实现呢？

 

<%# (Container.ItemIndex + 1)+（当前页数-1）*10 %>

<%# pagesize*pageindex + Container.ItemIndex + 1%>
pagesize--每页显示条数
pageindex--当前页码,记住要从0开始

另外 SQL的 Top N语句 在相同排序的字段会出现误算

比如2行时间一样的记录

查看更多...

using　　C# 语言参考
　　using 关键字有两个主要用途：
　　(一).作为语句，用于定义一个范围，在此范围的末尾将释放对象
　　C# 通过 .NET Framework 公共语言运行库 (CLR) 自动释放用于存储不再需要的对象的内存。内存的释放具有不确定性；一旦 CLR 决定执行垃圾回收，就会释放内存。但是，通常最好尽快释放诸如文件句柄和网络连接这样的有限资源。
　　using 语句允许程序员指定使用资源的对象应当何时释放资源。为 using 语句提供的对象必须实现 IDisposable 接口。此接口提供了 Dispose 方法，该方法将释放此对象的资源。
　　可以在到达 using 语句的末尾时，或者在该语句结束之前引发了异常并且控制权离开语句块时，退出 using 语句。
　　1. 可以在 using 语句中声明对象（如上所示），或者在 using 语句之前声明对象，如下所示：
　　Font font2 = new Font("Arial", 10.0f);
　　using (font2)
　　{
　　// use font2
　　}
　　2. 可以有多个对象与 using 语句一起使用，但是必须在 using 语句内部声明这些对象，如下所示：
　　Font font2 = new Font("Arial", 10.0f);
　　using (font2)
　　{
　　// use font2
　　}
　　3.可以有多个对象与 using 语句一起使用，但是必须在 using 语句内部声明这些对象，如下所示：
　　using (Font font3 = new Font("Arial", 10.0f),
　　font4 = new Font("Arial", 10.0f))
　　{
　　// Use font3 and font4.
　　}
　　示例:
　　下面的示例显示用户定义类可以如何实现它自己的 Dispose 行为。注意类型必须从 IDisposable 继承。
　　using System;
　　class C : IDisposable
　　{
　　public void UseLimitedResource()
　　{
　　Console.WriteLine("Using limited resource...");
　　}
　　void IDisposable.Dispose()
　　{
　　Console.WriteLine("Disposing limited resource.");
　　}
　　}
　　class Program
　　{
　　static void Main()
　　{
　　using (C c = new C())
　　{
　　c.UseLimitedResource();
　　}
　　Console.WriteLine("Now outside using statement.");
　　Console.ReadLine();
　　}
　　}
　　(二).作为指令，用于为命名空间创建别名或导入其他命名空间中定义的类型
　　①.允许在命名空间中使用类型，这样，您就不必在该命名空间中限定某个类型的使用：
　　using System.Text;
　　②.为命名空间或类型创建别名。
　　using Project = PC.MyCompany.Project;
　　using 指令的范围限制为包含它的文件。
　　创建 using 别名，以便更易于将标识符限定到命名空间或类型。
　　创建 using 指令，以便在命名空间中使用类型而不必指定命名空间。using 指令不为您提供对嵌套在指定命名空间中的任何命名空间的访问。
　　命名空间分为两类：用户定义的命名空间和系统定义的命名空间。用户定义的命名空间是在代码中定义的命名空间。若要查看系统定义的命名空间的列表
　　 1.下面的示例显示了如何为命名空间定义和使用 using 别名：
　　namespace PC
　　{
　　// Define an alias for the nested namespace.
　　using Project = PC.MyCompany.Project;
　　class A
　　{
　　void M()
　　{
　　// Use the alias
　　Project.MyClass mc = new Project.MyClass();
　　}
　　}
　　namespace MyCompany
　　{
　　namespace Project
　　{
　　public class MyClass{}
　　}
　　}
　　}
　　 2.下面的示例显示了如何为类定义 using 指令和 using 别名：
　　// cs_using_directive2.cs
　　// Using directive.
　　using System;
　　// Using alias for a class.
　　using AliasToMyClass = NameSpace1.MyClass;
　　namespace NameSpace1
　　{
　　public class MyClass
　　{
　　public override string ToString()
　　{
　　return "You are in NameSpace1.MyClass";
　　}
　　}
　　}
　　namespace NameSpace2
　　{
　　class MyClass
　　{
　　}
　　}
　　namespace NameSpace3
　　{
　　// Using directive:
　　using NameSpace1;
　　// Using directive:
　　using NameSpace2;
　　class MainClass
　　{
　　static void Main()
　　{
　　AliasToMyClass somevar = new AliasToMyClass();
　　Console.WriteLine(somevar);
　　}
　　}
　　}
　　输出: You are in NameSpace1.MyClass
　　=========================================================================================
[编辑本段]深入讨论
　　1. 引言
　　在.NET大家庭中，有不少的关键字承担了多种角色，例如new关键字就身兼数职，除了能够创建对象，在继承体系中隐藏基类成员，还在泛型声明中约束可能用作类型参数的参数，在详细讨论using的多重身份的基础上来了解.NET在语言机制上的简便与深邃。
　　那么，using的多重身份都体现在哪些方面呢，我们先一睹为快吧：
　　· 引入命名空间
　　· 创建别名
　　· 强制资源清理
　　下面，本文将从这几个角度来阐述using的多彩应用。
　　2. 引入命名空间
　　using作为引入命名空间指令的用法规则为：
　　using Namespace;
　　在.NET程序中，最常见的代码莫过于在程序文件的开头引入System命名空间，其原因在于System命名空间中封装了很多最基本最常用的操作，下面的代码对我们来说最为熟悉不过：
　　using System;
　　这样，我们在程序中就可以直接使用命名空间中的类型，而不必指定详细的类型名称。using指令可以访问嵌套命名空间。
　　关于：命名空间
　　命名空间是.NET程序在逻辑上的组织结构，而并非实际的物理结构，是一种避免类名冲突的方法，用于将不同的数据类型组合划分的方式。例如，在.NET中很多的基本类型都位于System命名空间，数据操作类型位于System.Data命名空间，
　　误区：
　　· using类似于Java语言的import指令，都是引入命名空间（Java中称作包）这种逻辑结构；而不同于C语言中的#include指令，用于引入实际的类库，
　　· using引入命名空间，并不等于编译器编译时加载该命名空间所在的程序集，程序集的加载决定于程序中对该程序集是否存在调用操作，如果代码中不存在任何调用操作则编译器将不会加载using引入命名空间所在程序集。因此，在源文件开头，引入多个命名空间，并非加载多个程序集，不会造成“过度引用”的弊端。 using为命名空间创建别名的用法规则为：
　　using alias = namespace | type;
　　其中namespace表示创建命名空间的别名；而type表示创建类型别名。例如，在.NET Office应用中，常常会引入Microsoft.Office.Interop.Word.dll程序集，在引入命名空间时为了避免繁琐的类型输入，我们通常为其创建别名如下：
　　using MSWord = Microsoft.Office.Interop.Word;
　　这样，就可以在程序中以MSWord来代替Microsoft.Office.Interop.Word前缀，如果要创建Application对象，则可以是这样，
　　private static MSWord.Application ooo = new MSWord.Application();
　　同样，也可以创建类型的别名，用法为：
　　using MyConsole = System.Console;
　　class UsingEx
　　{
　　public static void Main()
　　{
　　MyConsole.WriteLine("应用了类的别名。");
　　}
　　}
　　而创建别名的另一个重要的原因在于同一cs文件中引入的不同命名空间中包括了相同名称的类型，为了避免出现名称冲突可以通过设定别名来解决，例如：
　　namespace Boyspace
　　{
　　public class Player
　　{
　　public static void Play()
　　{
　　System.Console.WriteLine("Boys play football.");
　　}
　　}
　　}
　　namespace Girlspace
　　{
　　public class Player
　　{
　　public static void Play()
　　{
　　System.Console.WriteLine("Girls play violin.");
　　}
　　}
　　}
　　以using创建别名，有效的解决了这种可能的命名冲突，尽管我们可以通过类型全名称来加以区分，但是这显然不是最佳的解决方案，using使得这一问题迎刃而解，不费丝毫功夫，同时在编码规范上看来也更加的符合编码要求。
　　4. 强制资源清理
　　4.1 由来
　　要理解清楚使用using语句强制清理资源，就首先从了解Dispose模式说起，而要了解Dispose模式，则应首先了解.NET的垃圾回收机制。这些显然不是本文所能完成的宏论，我们只需要首先明确的是.NET提供了Dispose模式来实现显式释放和关闭对象的能力。
　　Dispose模式
　　Dispose模式是.NET提供的一种显式清理对象资源的约定方式，用于在.NET 中释放对象封装的非托管资源。因为非托管资源不受GC控制，对象必须调用自己的Dispose()方法来释放，这就是所谓的Dispose模式。从概念角度来看，Dispose模式就是一种强制资源清理所要遵守的约定；从实现角度来看，Dispose模式就是让要一个类型实现IDisposable接口，从而使得该类型提供一个公有的Dispose方法。
　　本文不再讨论如何让一个类型实现Dispose模式来提供显示清理非托管资源的方式，而将注意集中在如何以using语句来简便的应用这种实现了Dispose模式的类型的资源清理方式。我们在内存管理与垃圾回收章节将有详细的讨论。
　　using语句提供了强制清理对象资源的便捷操作方式，允许指定何时释放对象的资源，其典型应用为：
　　using (Font f = new Font("Verdana", 12, FontStyle.Regular))
　　{
　　//执行文本绘制操作
　　Graphics g = e.Graphics;
　　Rectangle rect = new Rectangle(10, 10, 200, 200);
　　g.DrawString("Try finally dispose font.", f, Brushes.Black, rect);
　　}//运行结束，释放f对象资源
　　在上述典型应用中，using语句在结束时会自动调用欲被清除对象的Dispose()方法。因此，该Font对象必须实现IDispose接口，才能使用using语句强制对象清理资源。我们查看其类型定义可知：
　　public sealed class Font : MarshalByRefObject, ICloneable, ISerializable, IDisposable
　　Font类型的确实现了IDisposeable接口，也就具有了显示回收资源的能力。然而，我们并未从上述代码中，看出任何使用Dispose方法的蛛丝马迹，这正式using语句带来的简便之处，其实质究竟怎样呢？
　　4.2 实质
　　要想了解using语句的执行本质，了解编译器在背后做了哪些手脚，就必须回归到IL代码中来揭密才行：
　　.method public hidebysig static void Main() cil managed
　　{
　　.entrypoint
　　// 代码大小 40 (0x28)
　　.maxstack 4
　　.locals init ([0] class [System.Drawing]System.Drawing.Font f,
　　[1] bool CS$4$0000)
　　IL_0000: nop
　　IL_0001: ldstr "Verdana"
　　IL_0006: ldc.r4 12.
　　IL_000b: ldc.i4.0
　　IL_000c: newobj instance void [System.Drawing]System.Drawing.Font::.ctor(string,float32,
　　valuetype [System.Drawing]System.Drawing.FontStyle)
　　IL_0011: stloc.0
　　.try
　　{
　　……部分省略……
　　} // end .try
　　finally
　　{
　　……部分省略……
　　IL_001f: callvirt instance void [mscorlib]System.IDisposable::Dispose()
　　IL_0024: nop
　　IL_0025: endfinally
　　} // end handler
　　IL_0026: nop
　　IL_0027: ret
　　} // end of method UsingDispose::Main
　　显然，编译器在自动将using生成为try-finally语句，并在finally块中调用对象的Dispose方法，来清理资源。
　　在.NET规范中，微软建议开放人员在调用一个类型的Dispose()或者Close()方法时，将其放在异常处理的finally块中。根据上面的分析我们可知，using语句正是隐式的调用了类型的Dispose方法，因此以下的代码和上面的示例是完全等效的：
　　Font f2 = new Font("Arial", 10, FontStyle.Bold);
　　try
　　{
　　//执行文本绘制操作
　　Graphics g = new Graphics();
　　Rectangle rect = new Rectangle(10, 10, 200, 200);
　　g.DrawString("Try finally dispose font.", f2, Brushes.Black, rect);
　　}
　　finally
　　{
　　if (f2 != null)
　　((IDisposable)f2).Dispose();
　　}
　　4.3 规则
　　· using只能用于实现了IDisposable接口的类型，禁止为不支持IDisposable接口的类型使用using语句，否则会出现编译时错误；
　　· using语句适用于清理单个非托管资源的情况，而多个非托管对象的清理最好以try-finnaly来实现，因为嵌套的using语句可能存在隐藏的Bug。内层using块引发异常时，将不能释放外层using块的对象资源。
　　· using语句支持初始化多个变量，但前提是这些变量的类型必须相同，例如：
　　using(Pen p1 = new Pen(Brushes.Black), p2 = new Pen(Brushes.Blue))
　　{
　　//
　　}
　　否则，编译将不可通过。不过，还是有变通的办法来解决这一问题，原因就是应用using语句的类型必然实现了IDisposable接口，那么就可以以下面的方式来完成初始化操作，
　　using (IDisposable font = new Font("Verdana", 12, FontStyle.Regular), pen = new Pen(Brushes.Black))
　　{
　　float size = (font as Font).Size;
　　Brush brush = (pen as Pen).Brush;
　　}
　　另一种办法就是以使用try-finally来完成，不管初始化的对象类型是否一致。
　　· Dispose方法用于清理对象封装的非托管资源，而不是释放对象的内存，对象的内存依然由垃圾回收器控制。
　　· 程序在达到using语句末尾时退出using块，而如果到达语句末尾之前引入异常则有可能提前退出。
　　· using中初始化的对象，可以在using语句之前声明，例如：
　　Font f3 = new Font("Verdana", 9, FontStyle.Regular);
　　using (f3)
　　{
　　//执行文本绘制操作
　　}
　　5. 结论
　　一个简单的关键字，多种不同的应用场合。本文从比较全面的角度，诠释了using关键字在.NET中的多种用法，值得指出的是这种用法并非实现于.NET的所有高级语言，本文的情况主要局限在C#中。

<本书介绍>

你将从本书学到什么？

《深入浅出 C#》是一段物件导向编程、C#、Visual Studio IDE 的完整学习经验。本书专为你的大脑量身打造，内容涵盖 C# 3.0 与 Visual Studio 2008，并且教导你许多事情，从垃圾收集机制（Garbage Collection）、扩展方法（Extension Method）、到双缓衝动画（double buffered animation）都有。另外，你也将精通 C# 最热门与最新的 LINQ 语法，可於 .NET 群集、SQL 资料库、等资料来源中查询你的资料。完成本书的阅读之时，你将是一个熟练的 C# 程式设计师，并且有能力设计与撰写大型应用程式。

查看更多...

 

 

 

 

通过本类库，可以实现对输入内容的自动分析，并会给出评分，程序可以根据此评分判断内容是否达到某一敏感度级别，从而进行相应的自动化处理。

Visual C# 中XML注释的使用（含注释在开发时显示换行）

在C#智能注释时，常常希望它能在开发时显示为换行，使得提示更加友好！原来一直想怎么实现，今天偶然发现原来如此简单，只需将<para> 标记用于诸如 <summary>、<remarks> 或 <returns> 等标记内即可。环境：VS.NET2008

一、注释在开发时换行显示的办法

<para> 标记用于诸如 <summary>、<remarks> 或 <returns> 等标记内，使您得以将结构添加到文本中。

/// <summary>
/// 基类（第1行）
///<para>说明：（第2行）</para>
///<para>　　封装一些常用的成员（第3行）</para>
///<para>　　前面要用全角空格才能显示出空格来（第4行）</para>
/// </summary>
public class MyBase 
{
    /// <summary>
    /// 构造函数（第1行）
    ///<para>说明：（第2行）</para>
    ///<para>　　初始化一些数据（第3行）</para>
    /// </summary>
    public MyBase()
    {
         //
    //TODO: 在此处添加构造函数逻辑
    //
    }
}

二、XML注释

查看更多...

好处多多

1、节约数据库开销，又让数据和程序分离

2、便于分层架构

基础代码：

前台代码：

XML：

 

 

DateTime.Ticks

public long Ticks {get;}
   
 属性值

表示此实例的日期和时间的刻度数。该值介于 MinValue 和 MaxValue 之间。

备注

此属性的值为自 0001 年 1 月 1 日午夜 12:00 以来所经过时间以 100 毫微秒为间隔表示时的数字。


好了一个返回的是毫秒一个返回的是微秒，所以知道毫秒与微妙之间的转化也是有必要的

1秒=1000毫秒(ms) 1毫秒=1/1,000秒(s)
1秒=1,000,000 微秒(μs) 1微秒=1/1,000,000秒(s)
1秒=1,000,000,000 纳秒(ns)
1纳秒=1/1,000,000,000秒(s)
1秒=1,000,000,000,000 皮秒(ps)
1微毫秒=1纳秒
1纳秒=10埃秒

 

1 毫秒 = 10^-3 秒， ------->10的-3次方 小数点从1开始向左移3位即0.001
1 微秒 = 10^-6 秒，
1 毫微秒 = 10^-9 秒，
100 毫微秒 = 10^-7 秒。

 

查看更多...

1.关闭使用后的数据连接

      访问数据库资源需要创建连接、打开连接和关闭连接几个操作。这些过程需要多次与数据库交换信息以通过身份验证，比较耗费服务器资源。ASP.NET中提供了连接池（Connection Pool）改善打开和关闭数据库对性能的影响。系统将用户的数据库连接放在连接池中，需要时取出，关闭时收回连接，等待下一次的连接请求。

　　 连接池的大小是有限的，如果在连接池达到最大限度后仍要求创建连接，必然大大影响性能。因此，在建立数据库连接后只有在真正需要操作时才打开连接，使用完毕后马上关闭，从而尽量减少数据库连接打开的时间，避免出现超出连接限制的情况。

用（推荐）
using(SqlDataReader dr = SH.ExecSqlDataReader(sql))
{
   if (dr.Read())
   {
  
   }
}
{}//不必显示关闭,在using{}大括号之后就会释放

或
try{conn.Open();}
catch{}
finally{conn.Close();}

2.必要时使用Asp.net缓存机制

查看更多...

本质地讲 类。属性——它也是一种方法

我们设置的时候是这样，读取的时候也很简单

类的属性用途很广泛：

1、给类内部传递固定参数，增加类的灵活性。（相信在高手写的那些类中你可以看到很多初始化的东西，那其中就很多是用这个东东搞出来的，可以让你72变低使用高手写的东西）

2、全局性的参数传递（这里是指在调用类的地方，能够跨越，有点全局变量的感觉。）

 

查看更多...