何时该用泛型类何时该用泛型方法

何时该用泛型类何时该用泛型方法[@more@] 泛型：
泛型可以让类、结构、接口、委托和方法按它们存储和操作的数据的类型进行参数化。使用过 Eiffel 或 Ada 泛型的用户或 C++ 模板的用户很快就能熟悉 C# 泛型，而且这些用户会发现 C# 泛型较之过去这些语言更加简便易用。

泛型类：
泛型类声明是一种类的声明，它需要提供类型实参才能构成实际类型。
class Gclass
{

}
泛型方法：
泛型方法是在声明中包括了类型形参的方法。泛型方法可以在类、结构或接口声明中声明，这些类、结构或接口本身可以是泛型或非泛型。
class Class
{
public Gm()
{
}
}

在做数据访问层的时候对一种类型的实体有统一的访问方法的时候采用泛型类会比较合适。
class SQLHelper
{
private string _ConnectString = "Data Source=xxxx;Initial Catalog=EmrcDBStationW;Persist Security Info=True;User ID=sa;pwd=future;";

public string ConnectString
{
get { return _ConnectString; }
set { _ConnectString = value; }
}
///
/// Inserts the specified o.
///
/// The o.
///
public int Insert(T Entity)
{

int ret = 1;
Grove.ORM.ObjectOperator oo = new ObjectOperator(ConnectString);
oo.BeginTranscation();
try
{
oo.Insert(Entity);
oo.Commit();
}
catch (Exception ex)
{
oo.Rollback();
ret = 0;
}
return ret;

}
///
/// Updates the specified entity.
///
/// The entity.
///
public int Update(T Entity)
{
int ret = 1;
Grove.ORM.ObjectOperator oo = new ObjectOperator(ConnectString);
oo.BeginTranscation();
try
{
oo.Update(Entity);
oo.Commit();
}
catch (Exception ex)
{
oo.Rollback();
ret = 0;
}
return ret;
}
public int Update(string filter, params string[] UpdateItem)
{
int ret = 1;
Grove.ORM.ObjectOperator oo = new ObjectOperator(ConnectString);
oo.BeginTranscation();

try
{
oo.Update(typeof(T), filter, UpdateItem);
oo.Commit();
}
catch (Exception ex)
{
oo.Rollback();
ret = 0;
}
return ret;
}
///
/// Deletes the specified entity.
///
/// The entity.
///
public int Delete(T Entity)
{
int ret = 1;
Grove.ORM.ObjectOperator oo = new ObjectOperator(ConnectString);
oo.BeginTranscation();
try
{
oo.Remove(Entity);
oo.Commit();
}
catch (Exception ex)
{
oo.Rollback();
ret = 0;
}
return ret;
}
///
/// Deletes the specified filter.
///
/// The filter.
///
public int Delete(string filter)
{
int ret = 1;
Grove.ORM.ObjectOperator oo = new ObjectOperator(ConnectString);
oo.BeginTranscation();
try
{
oo.Remove(typeof(T), filter);
oo.Commit();
}
catch (Exception ex)
{
oo.Rollback();
ret = 0;
}
return ret;
}
public DataTable GetData( string filter, string orderby)
{
int ret = 1;
Grove.ORM.ObjectOperator oo = new ObjectOperator(ConnectString);
ObjectQuery query=new ObjectQuery(typeof(T),filter,orderby);
DataSet Ds = oo.GetObjectSource(query);

return Ds.Tables[0];
}
}
在业务逻辑处理的时候不是一种类型对应一个类中的方法而是每个这个方法可以对应许多类
public class LeanConfigSetingToXML: ILeanConfigSeting
{
public int SyncConfig( string LeanNumber,string Filter,string orderby)
{
int ret = 1;
try
{
IEntity Table = DataAccess.CreateInstance();
DataTable Dt;
Dt = Table.GetData(Filter, orderby);
string FilePath = @"ClinetConfigFile" + LeanNumber + Dt.TableName + ".xml";
Dt.WriteXml(FilePath);
}
catch
{
ret = 0;
}
return ret;
}
public int SyncCarType(string LeanNumber)
{

string filter = "laneNumber = '" + LeanNumber + "' and len(laneNumber)>0 and len(carType)>0 and len(standardCartypeExplain)>0 and len(laneNumber) >0";
return SyncConfig(LeanNumber, filter, "");

}
}

根据场景选择使用泛型类与泛型方法既能达到高灵活性又不会受到不必要的约束。

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/7317239/viewspace-915518/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/7317239/viewspace-915518/