月度归档：1999年11月

存储过程

数据库

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
GO
ALTER PROCEDURE [dbo].[StoredProcedure1]
/*
(
@parameter1 int = 5,
@parameter2 datatype OUTPUT
)
*/
AS
declare @time datetime
set @time=DATEADD(hour, DATEDIFF(hour, 0, getdate()), 0) 
declare ShopAmount cursor for SELECT     SUM(dbo.DlsDownloadLog.MediaID) AS Expr1, dbo.Shop.ShopID
FROM         dbo.DlsDownloadLog INNER JOIN
dbo.EndUser ON dbo.DlsDownloadLog.EndUserID = dbo.EndUser.EndUserID INNER JOIN
dbo.Shop ON dbo.EndUser.ShopID = dbo.Shop.ShopID
WHERE     (dbo.DlsDownloadLog.DownloadDate > dateadd(hour,-1,@time)) AND (dbo.DlsDownloadLog.DownloadDate <= @time)
GROUP BY dbo.Shop.ShopID

declare @amount int, @shopid int
open ShopAmount
Fetch ShopAmount into @amount,@shopid
While (@@fetch_status=0)
Begin

insert into DlsShopDownloadAmount
(
ShopID,
Amount,
RecordTime
)
values
(
@shopid,
@amount,
@time
)

Fetch ShopAmount into @amount,@shopid
End
close ShopAmount
deallocate ShopAmount

RETURN

NHibernate??????sql°??±?????????á??×??????è??·????à?????????à??

NHibernate

public IList<ShopDownloadAmountEntity> GetDayByShopBetween(int shopID, DateTime startTime, DateTime endTime)
{
StringBuilder sb = new StringBuilder();
sb.Append("SELECT sum(sizeamount) as SizeAmount,[ShopID],");

sb.Append("dateadd(hh, – datepart(hour,downloadtime) % 24 ,downloadtime) as DownloadTime ");
sb.Append("FROM ShopDownloadAmount ");
sb.Append("WHERE downloadtime between ‘" + startTime + "’ and ‘" + endTime + "’");
sb.Append(" GROUP BY shopid, dateadd(hh, – datepart(hour,downloadtime) % 24 ,downloadtime) ");
sb.Append(" order by dateadd(hh, – datepart(hour,downloadtime) % 24 ,downloadtime)");//sql string

ISQLQuery sql = NHibernateSession.CreateSQLQuery(sb.ToString());
sql.AddScalar("SizeAmount", NHibernateUtil.Int32);//set type of data
sql.AddScalar("ShopID", NHibernateUtil.Int32);
sql.AddScalar("DownloadTime", NHibernateUtil.DateTime);
sql.SetResultTransformer(Transformers.AliasToBean(typeof(ShopDownloadAmountEntity)));//make the result set to entity
return sql.List<ShopDownloadAmountEntity>();
}
ShopDownloadAmountEntity???????à??SizeAmount??ShopID??DownloadTime??setter

automapper list

AutoMapper 
Mapper.CreateMap<Source, Destination>();
var sources = new[]
{
new Source {Value = 5},
new Source {Value = 6},
new Source {Value = 7}
};
IEnumerable<Destination> ienumerableDest = Mapper.Map<Source[], IEnumerable<Destination>>(sources);
ICollection<Destination> icollectionDest = Mapper.Map<Source[], ICollection<Destination>>(sources);
IList<Destination> ilistDest = Mapper.Map<Source[], IList<Destination>>(sources);
List<Destination> listDest = Mapper.Map<Source[], List<Destination>>(sources);
Destination[] arrayDest = Mapper.Map<Source[], Destination[]>(sources);

如果sources不是数组的话，可以调用ToArray<Destination>()转换一下

asp.net性能优化的几个方面

.Net

c#（或vb.net）程序改进
1、使用值类型的ToString方法
在连接字符串时，经常使用"+"号直接将数字添加到字符串中。这种方法虽然简单，也可以得到正确结果，但是由于涉及到不同的数据类型，数字需要通过装 箱操作转化为引用类型才可以添加到字符串中。但是装箱操作对性能影响较大，因为在进行这类处理时，将在托管堆中分配一个新的对象，原有的值复制到新创建的 对象中。
使用值类型的ToString方法可以避免装箱操作，从而提高应用程序性能。
int num=1;
string str="go"+num.ToString();

2、运用StringBuilder类
String类对象是不可改变的，对于String对象的重新赋值在本质上是重新创建了一个String对象并将新值赋予该对象，其方法ToString对性能的提高并非很显著。
在处理字符串时，最好使用StringBuilder类，其.NET 命名空间是System.Text。该类并非创建新的对象，而是通过Append，Remove，Insert等方法直接对字符串进行操作，通过ToString方法返回操作结果。
其定义及操作语句如下所示：
int num;
System.Text.StringBuilder str = new System.Text.StringBuilder(); //创建字符串
str.Append(num.ToString()); //添加数值num
Response.Write(str.ToString); //显示操作结果

3、使用 HttpServerUtility.Transfer 方法在同一应用程序的页面间重定向
采用 Server.Transfer 语法，在页面中使用该方法可避免不必要的客户端重定向（Response.Redirect）。
4、避免使用ArrayList。
因为任何对象添加到ArrayList都要封箱为System.Object类型，从ArrayList取出数据时，要拆箱回实际的类型。建议使用自定义 的集合类型代替ArrayList。asp.net 2.0提供了一个新的类型，叫泛型，这是一个强类型，使用泛型集合就可以避免了封箱和拆箱的发生，提高了性能。
5、使用HashTale代替其他字典集合类型
（如StringDictionary,NameValueCollection,HybridCollection），存放少量数据的时候可以使用HashTable.
6、为字符串容器声明常量，不要直接把字符封装在双引号" "里面。
//避免
MyObject obj = new MyObject();
obj.Status = "ACTIVE";
//推荐
const string C_STATUS = "ACTIVE";
MyObject obj = new MyObject();
obj.Status = C_STATUS;
7、不要用ToUpper(),ToLower()转换字符串进行比较，用String.Compare代替，它可以忽略大小写进行比较.
例：
const string C_VALUE = "COMPARE";
if (String.Compare(sVariable, C_VALUE, true) == 0)
{
Console.Write( "相同");
}
也可以用str == String.Empty或者str.Length == 0判断是否为空。(注意判断输入数据的长度，可防止sql注入式攻击)
将String对象的Length属性与0比较是最快的方法，避免不必要的调用 ToUpper 或 ToLower 方法。
8、类型转化Int32.TryParse()优于Int32.Parse()优于Convert.ToInt32()。
建议.NET1.1下用Int32.Parse()；.NET2.0用Int32.TryParse()。
因为：
Convert.ToInt32 会把最终的解析工作代理给 Int32.Parse；
Int32.Parse 会把最终的解析工作代理给Number.ParseInt32；
Int32.TryParse 会把最终的解析工作代理给Number.TryParseInt32。
9、如果只是从XML对象读取数据，用只读的XPathDocument代替XMLDocument,可以提高性能
//避免
XmlDocument xmld = new XmlDocument();
xmld.LoadXml(sXML);
txtName.Text = xmld.SelectSingleNode( "/packet/child").InnerText;
//推荐
XPathDocument xmldContext = new XPathDocument(new StringReader(oContext.Value));
XPathNavigator xnav = xmldContext.CreateNavigator();
XPathNodeIterator xpNodeIter = xnav.Select( "packet/child");
iCount = xpNodeIter.Count;
xpNodeIter = xnav.SelectDescendants(XPathNodeType.Element, false);
while(xpNodeIter.MoveNext())
{
sCurrValues += xpNodeIter.Current.Value+ ",";
}

10、避免在循环体里声明变量，应该在循环体外声明变量，在循环体里初始化。

C#程序开发要遵循的一个基本原则就是避免不必要的对象创建

//避免
for(int i=0; i <10; i++)
{
SomeClass objSC = new SomeClass();
}
//推荐
SomeClass objSC = null;
for(int i=0; i <10; i++)
{
objSC = new SomeClass();
}
11、捕获指定的异常，不要使用通用的System.Exception.
//避免
try
{
<some logic>
}
catch(Exception exc)
{
<Error handling>
}

//推荐
try
{
<some logic>
}
catch(System.NullReferenceException exc)
{
<Error handling>
}
catch(System.ArgumentOutOfRangeException exc)
{
<Error handling>
}
catch(System.InvalidCastException exc)
{
<Error handling>
}
12、使用Try…catch…finally时， 要在finally里释放占用的资源如连接，文件流等
不然在Catch到错误后占用的资源不能释放。

try
{}
catch
{}
finally
{
conntion.close();
}

13、不要用Exception控制程序流程
有些程序员可能会使用异常来实现一些流程控制。例如：
try{
result=100/num;
}
Catch(Exception e)
{
result=0;
}
但实际上，Exception是非常消耗系统性能的。除非必要，不应当使用异常控制来实现程序流程。上面的代码应当写为：
if(num!=0)
result=100/num;
else
result=0;

14、避免使用递归调用和嵌套循环，使用他们会严重影响性能，在不得不用的时候才使用。
15、禁用VB.net和Jscript动态数据类型
应当始终显示地申明变量数据类型，这能够节约程序的执行时间。以往，开发人员喜欢使用 Visual Basic、VBScript 和 JScript 的原因之一就是它们所谓“无类型”的性质。变量不需要显式类型声明，并能够简单地通过使用来创建它们。当从一个类型到另一个类型进行分配时，转换将自动执 行。不过，这种便利会大大损害应用程序的性能。
如：
为了获得最佳的性能，当声明 JScript .NET 变量时，请为其分配一个类型。例如，var A : String;

面向对象的三个基本特征

未分类


面向对象的三个基本特征是：封装、继承、多态。

封装

封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从一般到特殊的过程。

要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

 

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。

OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

 

多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。 当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法 确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对 象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了――代码重用。而多态则是为了实现另一个目的――接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

java基础类型知识

未分类

Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。
原始类型封装类
boolean –>Boolean
char —>Character
byte –>Byte
short –>Short
int –>Integer
long –>Long
float –>Float
double –>Double
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的 数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。同时为了面向对象操作的一致性，这些基本类型都有相应的封装类型：Integer、Short、 Long、Byte、Float、Double、Character等。      
因为封装类型是对象，所以可以进行相应的很多对象能力函数操作，这样就可以提供很多基本类型难以完成的工作的完成和实现。   
你可以通过以下方式来声明该类型。

int a，a为int类型的变量
char a，a为char类型的

String对象

1. 首先String不属于8种基本数据类型，String是一个对象。

　　因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。

　　2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；

　　3. String str=”punkll”；

　　　String str=new String (“punkll”);的区别：

　　在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。

　　常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

　　看例1：

　　String s0=”punkll”;

　　String s1=”punkll”;

　　String s2=”punk” + “ll”;

　　System.out.println( s0==s1 );

　　System.out.println( s0==s2 );

　　结果为：

　　true

　　true

　　首先，我们要知结果为道Java会确保一个字符串常量只有一个拷贝。

　　因为例子中的s0和s1中的”punkll”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”punk”和”ll” 也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是 常量池中”punkll”的一个引用。

　　所以我们得出s0==s1==s2;

　　用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

　　看例2：

　　String s0=”punkll”;

　　String s1=new String(”punkll”);

　　String s2=”punk” + new String(“ll”);

　　System.out.println( s0==s1 );

　　System.out.println( s0==s2 );

　　System.out.println( s1==s2 );

　　结果为：

　　false

　　false

　　false

　　例2中s0还是常量池中”punkll”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”punkll”的引用，s2因为有后半 部分new String(“ll”)所以也无法在编译期确定，所以也是一个新创建对象”punkll”的应用;明白了这些也就知道为何得出此结果了。

bit与byte的区别

未分类

Bit意为“位”或“比特”，是计算机运算的基础，属于二进制的范筹；
Byte意为“字节”，是计算机文件大小的基本计算单位； 
这两者应用的场合不同。通常用bit来作数据传输的单位，因为物理层，数据链路层的传输对于用户是透明的，而这种通信传输是基于二进制的传输。在应 用层通常是用byte来作单位，表示文件的大小，在用户看来就是可见的数据大小。比如一个字符就是1byte,如果是汉字，则是2byte。
下面是2个具体应用实例：
Mbps=mega bits per second(兆位/秒)是速率单位，
MB=mega bytes(兆比、兆字节)是量单位，1MB/S（兆字节/秒）=8MBPS（兆位/秒）。
我们所说的硬盘容量是40GB、80GB、100GB，这里的B指是的Byte也就是“字节”。(与容量相关，应用层）
1 KB = 1024 bytes =2^10 bytes
1 MB = 1024 KB = 2^20 bytes
1 GB = 1024 MB = 2^30 bytes
USB2.0标准接口传输速率是480兆位/秒,即480MBps。这里的B指是的Bit也就是“位”。（与传输相关，底层）

注：另外，Byte通常简写为B(大写），而bit通常简写为b（小写）。可以这么记忆，用大写的就是数据值比较大的位，而小字的就是数据值比较小的字节，1B=8b。

Java的线程安全四种方式五个等级

Java

四种方式 sychronized关键字

　　sychronized method(){}

　　sychronized (objectReference) {/*block*/}

　　static synchronized method(){}

　　sychronized(classname.class)

　　其中1和2是代表锁当前对象，即一个对象就一个锁，3和4代表锁这个类，即这个类的锁

　 　要注意的是sychronized method()不是锁这个函数，而是锁对象，即：如果这个类中有两个方法都是sychronized，那么只要有两个线程共享一个该类的 reference，每个调用这两个方法之一，不管是否同一个方法，都会用这个对象锁进行同步。锁类的3和4类推，即该类的不同reference调用了 sychronized区段的咚咚就会受类锁的控制

　　还有，如果两个函数调用的先后顺序不能被打断，那么可以有个专门的锁对象来完成这个任务：

class MyLock
{
synchronized getLock()
{
//####还没写完
}
}

　　五个等级 参见effective java　Item 52 ： Document thread safety

　　immutable　 不可变对象

　　thread-safe 线程安全的，可以放心使用，如java.util.Timer

　　conditionally thread-safe 条件线程安全的，如Vector和Hashtable，一般是安全的，除非存在几个方法调用之间的顺序不能被打断，这时可以用额外的锁来完成

　　thread-compatible 可以使用synchronized （objectReference)来协助完成对线程的调用

　　thread-hostile 不安全的

　　wait & notifyAll

　　在循环中使用wait 使用notifyAll而不是notify

　　pipe

　　java中也有pipe的，四个类：PipedInputStream, PipedInputReader, PipedOutputStream, PipedOutputWriter 下面是一段生产者消费者的代码（摘自core javaII）：

/* set up pipes */
PipedOutputStream pout1 = new PipedOutputStream();
PipedInputStream pin1 = new PipedInputStream(pout1);
PipedOutputStream pout2 = new PipedOutputStream();
PipedInputStream pin2 = new PipedInputStream(pout2);
/* construct threads */
Producer prod = new Producer(pout1);
Filter filt = new Filter(pin1, pout2);
Consumer cons = new Consumer(pin2);
/* start threads */
prod.start();
filt.start();
cons.start();

C#中class和struct的区别和用法

C#

1,class 是引用类型，structs是值类型

既然class是引用类型，class可以设为null。但是我们不能将struct设为null,因为它是值类型。

struct AStruct
{
  int aField;
}
class  AClass
{
  int aField;
}
class MainClass
{
  public static void Main()
  {
    AClass b = null; // No error.
    AStruct s = null; // Error [ Cannot convert null to 'AStruct'
    because it is a value type ].
  }
}

2,当你实例一个class，它将创建在堆上。而你实例一个struct，它将创建在栈上

3，你使用的是一个对class实例的引用。而你使用的不是对一个struct的引用。（而是直接使用它们）

4，当我们将class作为参数传给一个方法，我们传递的是一个引用。struct传递的是值而非引用。

5，structs, 不可以有初始化器，class可以有初始化器。

class MyClass
{
  int myVar =10;  //  no syntax error.
  public void MyFun( )
  {
    // statements
  }
}
struct MyStruct
{
  int myVar = 10;  //  syntax error.
  public void MyFun( )
  {
    // statements
  }
}

6,Classes 可以有明显的无参数构造器，但是Struct不可以

class MyClass
{
  int myVar = 10;
  public MyClass( ) // no syntax error.
  {
    // statements
  }
}
struct MyStruct
{
  int myVar;
  public MyStruct( ) // syntax error.
  {
    // statements
  }
}

7, 类使用前必须new关键字实例化，Struct不需要

MyClass aClassObj;     //  MyClass aClassObj=new MyClass(); is the correct format.aClassObj.
myVar=100;//NullReferenceException(because aClassObj does not contain a reference to an object of type myClass).
MyStruct  aStructObj;
aStructObj.myVar=100; //  no exception.

8, class支持继承和多态，Struct不支持. 注意：但是Struct 可以鹤类一样实现接口

9, 既然Struct不支持继承，其成员不能以protected 或Protected Internal 修饰

10, Class的构造器不需要初始化全部字段，Struct的构造器必须初始化所有字段

class MyClass    //No error( No matter whether the Field ’ MyClass.myString ’ is initialized or not ).
{
  int myInt;
  string myString;
  public MyClass( int aInt )
  {
    myInt = aInt;
  }
}
struct MyStruct    // Error ( Field ’ MyStruct.myString ’ must be fully assigned before it leaves the constructor ).
{
  int myInt;
  string myString;
  public MyStruct( int aInt )
  {
    myInt = aInt;
  }
}

11, Class可以定义析构器但是Struct不可以

12, Class比较适合大的和复杂的数据，Struct适用于作为经常使用的一些数据组合成的新类型。

适用场合：Struct有性能优势，Class有面向对象的扩展优势。
用于底层数据存储的类型设计为Struct类型，将用于定义应用程序行为的类型设计为Class。如果对类型将来的应用情况不能确定，应该使用Class。