See Document | 查看中文文档

Prjoect Description

DataVeryLite is a lightweight *Persistence Framework*.

Please get source code first! MORE DOWNLOADS

Database Is support? Description
MySql Y Preview
SqlServer Y Preview
Sqlite Y Preview
Access Y Preview
PostpreSql Y Preview
Oracle Y Preview
Db2 Y Preview
Sysbase N Planning

DataVeryLite Documentation

Release History

About DataVeryLite
    Based on the.net 4.0 c # lightweight persistence framework
    Support vs2010 development
    Support vs2012 development

Project Mission
    Easy to use.
    No config.

Some links
blogs:
    http://blog.sina.com.cn/cshuqizhao
    http://www.cnblogs.com/shuqizhao/
email:
    shuqizhao@qq.com

Version Information
+2013-6-14 v0.0.1.0beta
      +Support Oracle
      +Support Db2
      +Support MySql
      +Support PostgreSql
      +Support SqlServer
      +Support Sqlite
      +Support Access

Quick Start

Hello world!
  1,First of all get the latest released version, please go to the DOWNLOADS page for download
  2,Then use vs2010 or vs2012 open solution (.sln)
  3,Finally, press F5 to run the code, you can output window to check the 'DEBUG' information in VS

Guide

Structure
    A typical DataVeryLite projects including, Drivers, and Models of two folders. You can find in DataVeryLite. The Test project directory to find the two folders.
    Drivers folder contains all supported database Driver, you can manually Delete some DLL according to your project situation, but I don't suggest you to do so.
    Models folder contains T4 Template, including Model.tt is a database entity class to convert T4 Template, generally we generate or update entity class, you need to perform the Template. Perform a T4 Template you just need to save the Template.

Project Type
    DataVeryLite projects included the Current Project Type and the Startup Project Type.
    The current project is entity class project. In the current project folders must contain Drivers and Models.
    The startup project is vs startup project. In startup project must have App.config or Web.Config, And needs Connection String in the node connectionStrings of config.
    The startup project and the current project must add DataVeryLite.dll, the DLL in the Drivers folder.
    Of course, the current project can be the startup project, like DataVeryLite project. If you don't set a startup project in vs, T4 Template won't be able to convert entity class for you.

T4 Template
    There is a Model.tt under the Models folder,the T4 Template provides converting tables in the database entity to c# class.
    If the project is a Web project, and the current project is not the startup project, T4 Template will be in the Drivers folder of all content will be copied to the directory of the Web project.
    If the project is a Web project, and the current project is the startup project, T4 Template will not have a copy operation.
    If the startup project is not a Web project, and the current project is not a startup project, T4 Template will be in the Drivers folder of all content will be copied to the bin\Debug directory under the Web project.
    If the startup project is not a Web project, and the current project is a startup project, T4 Template will be in the Drivers folder of all content will be copied to the bin\Debug directory under the project.

Driver
    The name of the DLL in the Drivers folder is not allowed to Modify, otherwise it will cause an exception.
    DataVeryLite.dll is a driver of DataVeryLite project.Throughout the development process, you only need to refer to the DLL.
    IBM.Data.DB2.dll is a driver of Db2.
    MySql.Data.dll is a driver of MySql.
    System.Data.SQLite.dll is a driver of Sqlite.
    Npgsql.dll and Mono.Security.dll are drivers of PostgreSql.
    Oracle,Sqlserver and Access use .net drivers.
    Oracle and Db2 need to install their client.

Connection String
    At App.config or Web.config in connectionStrings node,add Connection String.
    e.g:
    <add name="sqlite" connectionString="Data Source=dbs\Localite.db;Version=3;" providerName="sqlite"/>
    You must provider providerName property,otherwise it will cause an exception.
    ProviderName must be specified.See the table below.
     

DataBase Connection String sample providerName
Sqlite Data Source=dbs\Localite.db;Version=3; sqlite
Access Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\LocalAccess.mdb access
MySql server = localhost; user id = root; password = 123456; database = datawarehouse; mysql
PostgreSql Server=localhost;User Id=admin;Password=admin;Database=MyDb; postgresql
SqlServer Data Source=.;Initial Catalog=DandelionExt;Integrated Security=True sqlserver
Db2 Database=SAMPLE;User ID=db2admin;Server=192.168.40.128;password=123456 db2
Oracle Data Source=XE;User Id=HR;Password=VBshuqizhao12; oracle


Naming Conventions
     T4 Template transform to code ,and namespace is default namesapce.Models.your db name.The name of generated entities and properties are as well as the name of database and tables.

Build Your Project
    1,Copy Drivers and Models folders to your current project,and included in your project.
    2,Create new App.config or Web.config for you project(if exists not need),and add Connection String to node of connectionStrings.
    3,Transform Model.tt.

Query

Query entity
using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
       //Query by primary key
       var p=Models.Localite.Person();
       p.Load(1);
      //Get table count
       int count=Models.Localite.Person.Count();
   }
}
Query list
using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
       var lo = new Models.Localite.Localite();
       //You can query anything
       //Persons will be checked at runtime
       List<dynamic> persons = lo.List("select * from  Person");
       //Query all
       List<Models.Localite.Person> persons1 = lo.ListAll<Models.Localite.Person>();
       //Query bettween
 List<Models.Localite.Person> persons2 = lo.ListByBetween<Models.Localite.Person>(1, 10);
       //Query top
       List<Models.Localite.Person> persons3 = lo.ListByTop<Models.Localite.Person>(10);
       //Query page
 List<Models.Localite.Person> persons4 = lo.ListByPage<Models.Localite.Person>(1, 10);
       //Query sql
 List<Models.Localite.Person> persons5= lo.ListBySql<TEntity>("select * from Person");
      //Query all and sort
       List<Models.Localite.Person> persons6 = lo.ListAll<Models.Localite.Person>(false);
   }
}

Insert

Insert entity
using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
       //Primary key is auto increase
       var p=Models.Localite.Person();
       p.Name="p";
       p.Save();
       //Primary key is not auto increase
       var p1=Models.Localite.Person();
       p1.Id=1;
       p1.Name="p1";
       p1.Save(false);
   }
}
Insert batch
using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
       var lo = new Models.Localite.Localite();
       Models.Localite.Person p1 = new Models.Localite.Person();
       Models.Localite.Person p2 = new Models.Localite.Person();
       p2.Name = "p2n";
       //The first way
       lo.Save(p1, p2);
       List<Models.Localite.Person> list=new List<Models.Localite.Person>();
       list.add(p1);
       list.add(p2);
       //The second way
       lo.Save(list);
   }
}

Modify

Modify Entity
using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
       var p=Models.Localite.Person();
       p.Id=1;
       p.Name="p";
       p.Update();
   }
}
Modify batch
using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
       var lo = new Models.Localite.Localite();
       Models.Localite.Person p1 = new Models.Localite.Person();
       Models.Localite.Person p2 = new Models.Localite.Person();
       p2.Id=1;
       p2.Name = "p2n";
       //The first way
       lo.Update(p1, p2);
       List<Models.Localite.Person> list=new List<Models.Localite.Person>();
       list.add(p1);
       list.add(p2);
       //The second way
       lo.Update(list);
   }
}

Delete

Delete entity
using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
       var p=Models.Localite.Person();
       p.Id=1;
       p.Name="p";
       p.Del();
   }
}
Delete batch
using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
       var lo = new Models.Localite.Localite();
       Models.Localite.Person p1 = new Models.Localite.Person();
       Models.Localite.Person p2 = new Models.Localite.Person();
       p2.Id=1;
       p2.Name = "p2n";
       //The first way
       lo.Del(p1, p2);
       List<Models.Localite.Person> list=new List<Models.Localite.Person>();
       list.add(p1);
       list.add(p2);
       //The second way
       lo.Del(list);
   }
}

Native Sql

using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
        Models.Localite.Localite.NativeSql.ExecuteNonQuery(...);
        Models.Localite.Localite.NativeSql.ExecuteScalar(...);
        Models.Localite.Localite.NativeSql.ExecuteReader(...);
        Models.Localite.Localite.NativeSql.ExecuteDataSet(...);
        //like lo.List("select * from  Person")
        Models.Localite.Localite.NativeSql.ExecuteDynamic(...);
   }
}

Use Transaction

using System;
public class HelloWorld
{
   public static void Main(params string[] args)
   {
       var lo = new Models.Localite.Localite();
       DbTransaction tran = lo.BeginTransaction();
       try{
           var lo = new Models.Localite.Localite();
            Models.Localite.Person p1 = new Models.Localite.Person();
            Models.Localite.Person p2 = new Models.Localite.Person();
            p2.Id=1;
            p2.Name = "p2n";
            p1.Save(tran);
            lo.Del(tran,p1, p2);
            lo.Update(tran,p1,p2);
            lo.Commit();
       }catch{
         lo.Rollback();
       }
   }
}

DataVeryLite.Base.Entity

public virtual Entity Load(object,DbTransaction)
    Load,by primary key.
        /// <summary>
        /// Load data for this entity
        /// </summary>
        /// <param name="idValue">A id value in your table,suppurt long,int & short etc...</param>
        /// <param name="trans">Transaction</param>
        /// <returns></returns>

public virtual Entity LoadBySql(string,DbTransaction,CommandType,params DbParameter[])
    LoadBySql,by sql.
        /// <summary>
        /// Load data for this entity by any sql text,can use transaction
        /// </summary>
        /// <param name="cmdText">Any sql text</param>
        /// <param name="trans">Transaction</param>
        /// <param name="cmdType">Sql text type</param>
        /// <param name="cmdParms">Parameter</param>
        /// <returns></returns>

public virtual Entity LoadBySql(string,CommandType,params DbParameter[])
     LoadBySql,by sql.
        /// <summary>
        /// Load data for this entity by any sql text
        /// </summary>
        /// <param name="cmdText">Any sql text</param>
        /// <param name="cmdType">Sql text type</param>
        /// <param name="cmdParms">Parameter</param>
        /// <returns></returns>

public virtual void Del(DbTransaction)
      Del,delete record.
        /// <summary>
        /// Delete record from database
        /// </summary>
        ///<param name="transaction">Transaction</param>

public virtual void Update(DbTransaction)
      Update,update record.
        /// <summary>
        /// Update record to database
        /// </summary>
        /// <param name="transaction">Transaction</param>

public virtual void Save(bool,DbTransaction)
      Save,insert record.
        /// <summary>
        /// Insert entity to database
        /// </summary>
        /// <param name="isIdAutoGrow">Id is or isn't auto grow </param>
        /// <param name="transaction">Transaction</param>

public virtual void Save(DbTransaction)
      Save,insert record.
        /// <summary>
        /// Insert entity to database,isIdAutoGrow = true
        /// </summary>
        /// <param name="transaction">Transaction</param>

public static int Count
      Count,get table's count.
        /// <summary>
        /// Table record count
        /// </summary>

DataVeryLite.Base.EntityPool

public virtual List<dynamic> List(string,DbTransaction) ListBySql<T>(string,DbTransaction,CommandType,params DbParameter)">
      ListBySql,get by sql.
        /// <summary>
        /// Load data  list by any sql text,can use transaction
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="cmdText">Any sql text</param>
        /// <param name="trans">Transaction</param>
        /// <param name="cmdType">Sql text type</param>
        /// <param name="cmdParms">Parameter</param>
        /// <returns></returns>

public virtual List<T> ListBySql<T>(string,CommandType,params DbParameter[]) ListAll<T>(bool,DbTransaction)">
      ListAll,get all.
        /// <summary>
        ///  Load all data
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="asc">Order by</param>
        /// <param name="trans">Transaction</param>
        /// <returns></returns>

public virtual List<T> ListByTop<T>(int,bool,DbTransaction) ListByPage<T>(int,int,bool,DbTransaction)">
      ListByPage,get by page.
        /// <summary>
        /// Load data page
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="page">Page value</param>
        /// <param name="pageSize">Page size</param>
        /// <param name="asc">Order by</param>
        /// <param name="trans">Transaction</param>
        /// <returns></returns>

public virtual List<T> ListByBetween<T>(int,int,bool,DbTransaction)(List<T>,DbTransaction)">
      Del,delete batch.
        /// <summary>
        /// Betch delete
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="list">Entity list</param>
        /// <param name="trans">Transaction</param>

public virtual void Del<T>(DbTransaction,params T[])(params T)">
      Del,delete batch.
        /// <summary>
        /// Betch delete
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="arr">Entity params</param>

public virtual void Update<T>(List<T>,DbTransaction)(DbTransaction trans,params T)">
      Update,Modify batch.
        /// <summary>
        /// Betch update
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="trans">Transaction</param>
        /// <param name="arr">Entity params</param>

public virtual void Update<T>(params T[])(List<T>,bool,DbTransaction)">
      Save,insert batch,and retun id atuo increase.
        /// <summary>
        /// Betch insert
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="list">Entity list</param>
        /// <param name="isIdAutoGrow">Is id auto grow?</param>
        /// <param name="trans">Transaction</param>

public virtual void Save<T>(DbTransaction,params T[])(DbTransaction,List<T>)">
      Save,insert batch,and retun id atuo increase.
        /// <summary>
        /// Betch insert,isIdAutoGrow = true
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="trans">Transaction</param>
        /// <param name="list">Entity list</param>

public virtual void Save<T>(params T[])(bool,params T)">
      Save,insert batch,and retun id atuo increase.
        /// <summary>
        /// Betch insert
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="isIdAutoGrow">Is id auto grow?</param>
        /// <param name="arr">Entity params</param>

public virtual void Save<T>(bool,DbTransaction,params T[])(List<T>,bool,DbTransaction)">
      SaveOnly,insert batch.
        /// <summary>
        /// Betch insert,don't return id value
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="isIdAutoGrow">Is id auto grow?</param>
        /// <param name="list">Entity list</param>

public virtual void SaveOnly<T>(DbTransaction,params T[])(DbTransaction,List<T>)">
      SaveOnly,insert batch.
        /// <summary>
        /// Betch insert,isIdAutoGrow = true,don't return id value
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="trans">Transaction</param>
        /// <param name="list">Entity list</param>

public virtual void SaveOnly<T>(bool,DbTransaction,params T[])(params T)">
       SaveOnly,insert batch.
        /// <summary>
        /// Betch insert,isIdAutoGrow = true,don't return id value
        /// </summary>
        /// <typeparam name="T">Entity</typeparam>
        /// <param name="arr">Entity params</param>

public virtual void SaveOnly<T>(bool,params T[])
      BeginTransaction,start trans.
        /// <summary>
        /// Start transaction
        /// </summary>
        /// <param name="isolationLevel">transaction level</param>
        /// <returns></returns>

public virtual void Commit()
      Commit,commit trans.
        /// <summary>
        /// Commit transaction
        /// </summary>

public virtual void Rollback()
      Rollback,rollback trans.
        /// <summary>
        /// Rollback transaction
        /// </summary>

DataVeryLite.Util.SqlHelper

   SqlHelper provider the Ability of Native Sql.Main methods provide the encapsulation of DbCommand method, make it easy to use.

public SqlHelper(string dbConnectionString, string providerName,string driverPath)
    SqlHelper constructor, use the Connection String, database name and driver's path initialize.
        /// <summary>
        /// Sql CRUD provider and helper
        /// </summary>
        /// <param name="dbConnectionString">ConnectionString</param>
        /// <param name="providerName">ConnectionString provider name in config</param>
        /// <param name="driverPath">Your driver path,the default path is strat up dir</param>

public SqlHelper(string key, string driverPath = null)
    SqlHelper constructor,use ConnectionString node of config.
        /// <summary>
        /// Sql CRUD provider and helper
        /// </summary>
        /// <param name="key">ConnectionString key in config</param>
        /// <param name="driverPath">Your driver path,the default path is strat up dir</param>

public int ExecuteNonQuery(string,string,CommandType,params DbParameter[])
    ExecuteNonQuery,Return the affected rows .
        /// <summary>
        /// Return the affected rows 
        /// </summary>
        /// <param name="connectionString">Connection String</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The affected rows </returns>

public int ExecuteNonQuery(string,CommandType, params DbParameter[])
    ExecuteNonQuery,Return the affected rows.In DataVeryLite project recommend this method.
        /// <summary>
        /// Return the affected rows
        /// </summary>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The affected rows</returns>

public int ExecuteNonQuery(DbConnection,string,CommandType,params DbParameter[])
    ExecuteNonQuery,Return the affected rows.
        /// <summary>
        /// Return the affected rows
        /// </summary>
        /// <param name="conn">DbConnection</param>
        /// <param name="cmdText">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdType">DbParameter</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The affected rows</returns>

public int ExecuteNonQuery(DbTransaction,string,CommandType,params DbParameter[])
     ExecuteNonQuery,Return the affected rows.
        /// <summary>
        /// Return the affected rows
        /// </summary>
        /// <param name="trans">DbTransaction</param>
        /// <param name="cmdText">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdType">DbParameter</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The affected rows</returns>

public object ExecuteScalar(string,string,CommandType,params DbParameter[])
     ExecuteScalar,return the single value.
        /// <summary>
        /// Return the single value
        /// </summary>
        /// <param name="connectionString">Connection String</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The single value</returns>

public object ExecuteScalar(string,CommandType,params DbParameter[])
     ExecuteScalar,return the single value.In DataVeryLite project recommend this method.
        /// <summary>
        /// Return the single value
        /// </summary>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The single value</returns>

public object ExecuteScalar(DbConnection,string,CommandType,params DbParameter[])
     ExecuteScalar,return the single value.
        /// <summary>
        /// Return the single value
        /// </summary>
        /// <param name="conn">DbConnection</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The single value</returns>

public object ExecuteScalar(DbTransaction,string,CommandType,params DbParameter[])
     ExecuteScalar,return the single value.
        /// <summary>
        /// Return the single value
        /// </summary>
        /// <param name="trans">DbTransaction</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The single value</returns>

public DbDataReader ExecuteReader(string,string,CommandType,params DbParameter[])
     ExecuteReader,retrun the DataReader.
        /// <summary>
        /// Return the DataReader
        /// </summary>
        /// <param name="connectionString">Connection String</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The DataReader</returns>

public DbDataReader ExecuteReader(string,CommandType,params DbParameter[])
      ExecuteReader,retrun the DataReader.In DataVeryLite project recommend this method.
        /// <summary>
        /// Return the DataReader
        /// </summary>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The DataReader</returns>

public DbDataReader ExecuteReader(DbConnection,string,CommandType,params DbParameter[])
      ExecuteReader,retrun the DataReader.
        /// <summary>
        /// Return the DataReader
        /// </summary>
        /// <param name="conn">DbConnection</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The DataReader</returns>

public DbDataReader ExecuteReader(DbTransaction,string,CommandType,params DbParameter[])
      ExecuteReader,retrun the DataReader.
        /// <summary>
        /// Return the DataReader
        /// </summary>
        /// <param name="trans">DbTransaction</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The DataReader</returns>

public DataSet ExecuteDataSet(string,string,CommandType,params DbParameter[])
      ExecuteDataSet,return the DataSet.
        /// <summary>
        /// Return the DataSet
        /// </summary>
        /// <param name="connectionString">Connection String</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The DataSet</returns>

public DataSet ExecuteDataSet(string,CommandType, params DbParameter[])
      ExecuteDataSet,return the DataSet.In DataVeryLite project recommend this method.
        /// <summary>
        /// Return the DataSet
        /// </summary>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The DataSet</returns>

public DbDataReader ExecuteReader(DbConnection,string,CommandType,params DbParameter[])
      ExecuteDataSet,return the DataSet.
        /// <summary>
        /// Return the DataSet
        /// </summary>
        /// <param name="conn">DbConnection</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>The DataSet</returns>

public DataSet ExecuteDataSet(DbTransaction,string,CommandType,params DbParameter[])
      ExecuteDataSet,return the DataSet.
        /// <summary>
        /// Return the DataSet
        /// </summary>
        /// <param name="trans">DbTransaction</param>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns></returns>

public List<dynamic> ExecuteDynamic(string,DbTransaction,CommandType,params DbParameter[]) ExecuteDynamic(string,CommandType,params DbParameter)">
      ExecuteDynamic,return anything you want
        /// <summary>
        /// Return anything you want
        /// </summary>
        /// <param name="cmdText">Sql</param>
        /// <param name="cmdType">CommandType,default value is CommandType.Text</param>
        /// <param name="cmdParms">DbParameter</param>
        /// <returns>Anything you want</returns>

Last edited Jun 30, 2013 at 5:22 AM by shuqizhao, version 28

Comments

No comments yet.