2004年最后一天的原创：C#通过HTTP操作数据的模块

// 本程序提供了一个通过HTTP来操作数据库的类，这样少了本地安装乱七八糟的数据库驱动程序及复杂的设置，
// Web 服务器可以是任意的类型的,可以为 ASP , ASP.NET JSP 或其他,本模块提供了服务器的ASP.NET 的
// 例子
// 南京千里独行原创 请引用时勿删除本行 2004-12-31
using System;
using System.Net ;
namespace myConnection
{
///
/// XMLHttp数据库连接操作事件处理委托
///
/// 数据库连接对象
/// 数据库命令对象
/// 总的数据字节数
/// 已完成的数据字节数
public delegate void XMLHttpDBExecutingHandler( XMLHttpConnection conn , XMLHttpCommand cmd , long ContentLength , long ContentCompleted );
///
/// XMLHttp类型的数据库数据读取对象
///
public class XMLHttpReader : System.Data.IDataReader
{
private string[] strHead = null;
private System.Collections.ArrayList myRows = new System.Collections.ArrayList();
private bool bolClosed = false;
private int intRowIndex = 0 ;
private const string c_NullFlag = "[NULL]" ;

///
/// 根据字段名称获得字段序号,比较不区分大小写
///
/// 字段名称
/// 字段的从0开始的序号，若没找到则返回-1
public int GetIndexByName( string strName )
{
if( strName == null ) return -1 ;
strName = strName.ToUpper().Trim();
for( int iCount = 0 ; iCount < strHead.Length ; iCount ++ )
if( strName.Equals( strHead[iCount]))
return iCount ;
return -1 ;
}

///
/// 从一个数据库读取对象加载对象数据
///
/// 数据库数据读取对象
/// 加载的记录的行数
public int FromReader(System.Data.IDataReader myReader)
{
if( myReader != null)
{
// 加载列头信息
strHead = new string[ myReader.FieldCount ];
for( int iCount = 0 ; iCount < myReader.FieldCount ; iCount ++ )
strHead[iCount] = myReader.GetName(iCount).ToLower().Trim();
// 加载数据
myRows.Clear();
intRowIndex = -1 ;
while( myReader.Read())
{
string[] strValues = new string[ myReader.FieldCount];
myRows.Add( strValues );
for( int iCount = 0 ; iCount < myReader.FieldCount ;iCount ++ )
{
if( myReader.IsDBNull( iCount ) == false)
{
if( myReader[iCount] is byte[])
{
strValues[iCount] = Convert.ToBase64String( (byte[])myReader[iCount]);
}
else
strValues[iCount] = myReader[iCount].ToString();
}
}// for
}// while
return myRows.Count ;
}// if
return -1;
}// FromReader
///
/// 保存对象数据到XML节点
///
/// 根XML节点
/// 保存的记录个数
public int ToXML( System.Xml.XmlElement RootElement )
{
System.Xml.XmlElement RowElement = null;
System.Xml.XmlElement FieldElement = null;
while( RootElement.FirstChild != null)
RootElement.RemoveChild( RootElement.FirstChild);
// 保存列数据
if( strHead != null && strHead.Length > 0 )
{
for( int iCount = 0 ; iCount < strHead.Length ;iCount ++ )
{
RootElement.SetAttribute("f" + iCount.ToString() , strHead[iCount]);
}
RootElement.SetAttribute("fieldcount" , strHead.Length.ToString());
}
// 保存数据
if( myRows != null && myRows.Count > 0 )
{
System.Xml.XmlDocument myDoc = RootElement.OwnerDocument ;
for( int RowCount = 0 ; RowCount < myRows.Count ; RowCount ++ )
{
string[] strValue = ( string[] ) myRows[RowCount];
RowElement = myDoc.CreateElement("r");
RootElement.AppendChild( RowElement );
for( int iCount = 0 ; iCount < strValue.Length ; iCount ++ )
{
FieldElement = myDoc.CreateElement("f" + iCount.ToString());
RowElement.AppendChild( FieldElement );
if( strValue[iCount] == null )
FieldElement.InnerText = c_NullFlag ;
else
FieldElement.InnerText = strValue[iCount];
}
}// for
return myRows.Count ;
}
return -1 ;
}// ToXML
///
/// 从XML元素加载对象数据
///
/// XML节点
/// 加载的数据的行数
public int FromXML( System.Xml.XmlElement RootElement )
{
System.Xml.XmlElement RowElement = null;
strHead = null;
myRows.Clear();
intRowIndex = -1 ;
if( RootElement == null ) return -1 ;
// 获得列信息
System.Collections.ArrayList myHeads = new System.Collections.ArrayList();
for( int iCount = 0 ; iCount < 255 ; iCount ++ )
{
if( RootElement.HasAttribute( "f" + iCount.ToString()))
{
string strName = RootElement.GetAttribute("f" + iCount.ToString());
myHeads.Add( strName.ToLower().Trim());
}
else
break;
}
//strHead = new string[ myHeads.Count ];
strHead = ( string[]) myHeads.ToArray( typeof(string));
// 获得数据
foreach( System.Xml.XmlNode myNode in RootElement.ChildNodes )
{
if( myNode is System.Xml.XmlElement )
{
RowElement = ( System.Xml.XmlElement ) myNode ;
// 获得数据
string[] strValues = new string[ strHead.Length];
myRows.Add( strValues );
int iFieldCount = 0 ;
foreach(System.Xml.XmlNode myFieldNode in RowElement.ChildNodes)
{
if( myFieldNode is System.Xml.XmlElement )
{
strValues[iFieldCount] = ( myFieldNode.InnerText == c_NullFlag ? null : myFieldNode.InnerText ) ;
iFieldCount ++ ;
}
}// foreach
}// if
}// foreach
return myRows.Count ;
}// FromXML
#region IDataReader 成员
///
/// 未实现
///
public int RecordsAffected
{
get {return 0; }
}
///
/// 已重载：关闭对象
///
public bool IsClosed
{
get{ return bolClosed ; }
}
///
/// 未实现
///
///
public bool NextResult()
{
if( myRows == null || (intRowIndex+1) >= myRows.Count )
return false;
else
return true;
}
///
/// 已重载：关闭对象
///
public void Close()
{
bolClosed = true;
strHead = null;
myRows = null;
}
///
/// 移动当前记录到下一行
///
///
public bool Read()
{
intRowIndex ++ ;
if( intRowIndex >= myRows.Count )
return false;
else
return true;
}
///
/// 已重载：不支持
///
public int Depth
{
get{ return 0; }
}
///
/// 已重载：不支持
///
///
public System.Data.DataTable GetSchemaTable()
{
// TODO: 添加 XMLHttpReader.GetSchemaTable 实现
return null;
}
#endregion
#region IDisposable 成员
public void Dispose()
{
// TODO: 添加 XMLHttpReader.Dispose 实现
}
#endregion

#region IDataRecord 成员
///
/// 已重载：获得指定列号的整数型数据
///
/// 从0开始的列号
/// 转换成功的整形数据
public int GetInt32(int i)
{
return Convert.ToInt32( this.GetString(i));
}
///
/// 获得指定列名的数据
///
public object this[string name]
{
get
{
return this.GetString( this.GetIndexByName( name));
}
}
///
/// 获得指定列号的数据
///
object System.Data.IDataRecord.this[int i]
{
get
{
return this.GetString(i);
}
}
///
/// 获得指定列号的数据
///
/// 从0开始的列号
/// 获得的数据
public object GetValue(int i)
{
return GetString(i);
}
///
/// 判断指定列号的数据是否为空
///
/// 从0开始的列号
/// 是否为空
public bool IsDBNull(int i)
{
return GetString(i) == null;
}
public long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length)
{
byte[] bytData = Convert.FromBase64String( GetString(i));
int iCount = 0 ;
for( ; iCount < length && ( iCount + fieldOffset < bytData.Length ) ; iCount ++ )
buffer[iCount + bufferoffset ] = bytData[ iCount + fieldOffset];
return iCount ;
}
///
/// 获得指定列的字节数据
///
///
///
public byte GetByte(int i)
{
return Convert.ToByte( GetString(i));
}
///
/// 未实现
///
///
///
public Type GetFieldType(int i)
{
return null;
}
///
/// 获得数值数据
///
///
///
public decimal GetDecimal(int i)
{
return Convert.ToDecimal( this.GetString( i));
}
///
/// 未实现
///
///
///
public int GetValues(object[] values)
{
// TODO: 添加 XMLHttpReader.GetValues 实现
return 0;
}
///
/// 已重载：返回指定列的名称
///
///
///
public string GetName(int i)
{
if( i >= 0 && i < strHead.Length )
return strHead[i];
else
return null;
}
///
/// 已重载：返回列数
///
public int FieldCount
{
get
{
return strHead.Length ;
}
}
///
/// 获得长整形数据
///
///
///
public long GetInt64(int i)
{
return Convert.ToInt64( GetString(i));
}
///
/// 获得双精度浮点数
///
///
///
public double GetDouble(int i)
{
return Convert.ToDouble( GetString(i));
}
///
/// 获得布尔类型数据
///
///
///
public bool GetBoolean(int i)
{
return Convert.ToBoolean( GetString(i));
}
///
/// 未实现
///
///
///
public Guid GetGuid(int i)
{
// TODO: 添加 XMLHttpReader.GetGuid 实现
return new Guid ();
}
///
/// 获得时间类型数据
///
///
///
public DateTime GetDateTime(int i)
{
return Convert.ToDateTime( GetString(i));
}
///
/// 未实现
///
///
///
public int GetOrdinal(string name)
{
return 0;
}
///
/// 未实现
///
///
///
public string GetDataTypeName(int i)
{
return null;
}
///
/// 获得单精度浮点数
///
///
///
public float GetFloat(int i)
{
return Convert.ToSingle( GetString(i));
}
///
/// 未实现
///
///
///
public System.Data.IDataReader GetData(int i)
{
return null;
}
///
/// 未实现
///
///
///
///
///
///
///
public long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length)
{
return 0;
}
///
/// 获得字符串类型数据
///
///
///
public string GetString(int i)
{
if( intRowIndex >= 0 && intRowIndex < myRows.Count && i >= 0 && i < strHead.Length )
{
string[] strValues = ( string[] ) myRows[intRowIndex];
return strValues[i];
}
else
throw new System.IndexOutOfRangeException("记录表错误：行数或列数越界,Row:" + intRowIndex.ToString() + " Col:" + i.ToString() );
}
///
/// 获得字符类型数据
///
///
///
public char GetChar(int i)
{
return Convert.ToChar( GetString(i));
}
///
/// 获得短整型数据
///
///
///
public short GetInt16(int i)
{
return Convert.ToInt16( GetString(i));
}
#endregion
}// class XMLHttpReader
//*******************************************************************************************
//*******************************************************************************************
///
/// XMLHttp数据库处理对象使用的参数集合
///
public class XMLHttpParameterCollection : System.Data.IDataParameterCollection
{
private System.Collections.ArrayList myParams = new System.Collections.ArrayList();
#region IDataParameterCollection 成员
///
/// 返回指定名称的参数对象
///
public object this[string parameterName]
{
get
{
foreach( XMLHttpParameter myParam in myParams )
if( myParam.ParameterName == parameterName )
return myParam ;
return null;
}
set
{
// TODO: 添加 XMLHttpParameterCollection.this setter 实现
}
}
public void RemoveAt(string parameterName)
{
object obj = this[parameterName];
if( obj != null)
myParams.Remove( obj );
}
public bool Contains(string parameterName)
{
return ( this[parameterName] != null);
}
public int IndexOf(string parameterName)
{
foreach( XMLHttpParameter myParam in myParams )
if( myParam.ParameterName == parameterName )
return myParams.IndexOf( myParam ) ;
return -1 ;
}
#endregion
#region IList 成员
public bool IsReadOnly
{
get
{
// TODO: 添加 XMLHttpParameterCollection.IsReadOnly getter 实现
return false;
}
}
object System.Collections.IList.this[int index]
{
get
{
return myParams[index];
}
set
{
myParams[index] = value;
}
}
void System.Collections.IList.RemoveAt(int index)
{
myParams.RemoveAt( index );
}
public void Insert(int index, object obj)
{
myParams.Insert( index , obj );
// TODO: 添加 XMLHttpParameterCollection.Insert 实现
}
int System.Collections.IList.IndexOf( object obj)
{
return myParams.IndexOf( obj );
}
public void Remove(object obj)
{
myParams.Remove( obj );
}
bool System.Collections.IList.Contains(object obj)
{
return myParams.Contains( obj );
}
public void Clear()
{
myParams.Clear();
}

public int Add(object obj)
{
myParams.Add( obj );
return 0 ;
}
public bool IsFixedSize
{
get
{
// TODO: 添加 XMLHttpParameterCollection.IsFixedSize getter 实现
return false;
}
}
#endregion
#region ICollection 成员
public bool IsSynchronized
{
get
{
// TODO: 添加 XMLHttpParameterCollection.IsSynchronized getter 实现
return false;
}
}
public int Count
{
get
{
return myParams.Count ;
}
}
public void CopyTo(Array array, int index)
{
// TODO: 添加 XMLHttpParameterCollection.CopyTo 实现
}
public object SyncRoot
{
get
{
// TODO: 添加 XMLHttpParameterCollection.SyncRoot getter 实现
return null;
}
}
#endregion
#region IEnumerable 成员
public System.Collections.IEnumerator GetEnumerator()
{
return myParams.GetEnumerator();
}
#endregion
}
//********************************************************************************
//********************************************************************************
///
/// XMLHttp数据库连接对象使用的参数类型
///
public class XMLHttpParameter : System.Data.IDataParameter
{
private System.Data.ParameterDirection intDirection = System.Data.ParameterDirection.Input ;
private System.Data.DataRowVersion intSourceVersion = System.Data.DataRowVersion.Default ;
private System.Data.DbType intDbType = System.Data.DbType.String ;

private object objValue = null;
private string strParameterName = null;
private string strSourceColumn = null;

///
/// 用指定字符串数据初始化对象
///
///
public XMLHttpParameter( string strValue)
{
objValue = strValue ;
}
///
/// 无参数的初始化对象
///
public XMLHttpParameter()
{}
#region IDataParameter 成员
///
/// 获取或设置一个值，该值指示参数是只可输入、只可输出、双向还是存储过程返回值参数。
///
public System.Data.ParameterDirection Direction
{
get{ return intDirection ;}
set{ intDirection = value;}
}
///
/// 获取或设置参数的 System.Data.DbType
///
public System.Data.DbType DbType
{
get{ return intDbType ;}
set{ intDbType = value ;}
}
///
/// 获取或设置该参数的值
///
public object Value
{
get{ return objValue ;}
set{ objValue = value;}
}
public bool IsNullable
{
get
{
return false;
}
}
public System.Data.DataRowVersion SourceVersion
{
get{ return intSourceVersion ;}
set{ intSourceVersion = value;}
}
///
/// 参数名称
///
public string ParameterName
{
get{ return strParameterName ;}
set{ strParameterName = value;}
}
///
/// 参数栏目名称
///
public string SourceColumn
{
get{ return strSourceColumn ;}
set{ strSourceColumn = value;}
}
#endregion
}
//*************************************************************************************
//*************************************************************************************
///
/// 使用XMLHttp进行数据库访问的命令对象
///
public class XMLHttpCommand : System.Data.IDbCommand
{
private System.Data.CommandType intCommandType = System.Data.CommandType.Text ;
private System.Data.CommandBehavior intCmdBehavior = System.Data.CommandBehavior.Default ;
private System.Data.UpdateRowSource intUpdatedRowSource = System.Data.UpdateRowSource.Both ;
private int intCommandTimeout = 0 ;
private bool bolCancel = false;
private string strCommandText = null;
///
/// 对象执行类型 0:查询数据库 1:更新数据库
///
private int intExecuteType = 0 ;
private XMLHttpConnection myConnection = null;
private XMLHttpParameterCollection myParameters = new XMLHttpParameterCollection();
private int intExecuteState = 0 ;
private System.Xml.XmlDocument myXMLDoc = new System.Xml.XmlDocument();
private const string c_NullFlag = "[NULL]" ;


///
/// 正在执行命令事件处理
///
public XMLHttpDBExecutingHandler ExecuteEvent = null;
private string strHttpMethod = "POST";
///
/// 正在执行的状态 0:没有执行 1:正在发送数据 2:正在接受数据 3:正在解析数据
///
public int ExecuteState
{
get{ return intExecuteState ;}
}
///
/// 向HTTP服务器提交数据的方法
///
public string HttpMethod
{
get{ return strHttpMethod ;}
set{ strHttpMethod = value;}
}
///
/// 保存对象数据到一个XML节点中
///
///
///
public bool FromXML(System.Xml.XmlElement myElement )
{
if( myElement != null)
{
intExecuteType = StringCommon.ToInt32Value( myElement.GetAttribute("type"),0);
strCommandText = myElement.GetAttribute("text");
myParameters.Clear();
foreach( System.Xml.XmlNode myNode in myElement.ChildNodes)
{
if( myNode.Name == "param" )
{
System.Xml.XmlElement myPElement = myNode as System.Xml.XmlElement ;
XMLHttpParameter myParam = new XMLHttpParameter();
myParam.ParameterName = myPElement.GetAttribute("name");
myParam.Value = myPElement.InnerText ;
myParameters.Add( myParam );
}
}
}
return true;
}
///
/// 从一个XML节点加载对象数据
///
///
///
public bool ToXML( System.Xml.XmlElement myElement )
{
if( myElement != null)
{
myElement.SetAttribute("text", strCommandText);
myElement.SetAttribute("type", intExecuteType.ToString());
foreach( XMLHttpParameter myParam in myParameters )
{
System.Xml.XmlElement myPElement = myElement.OwnerDocument.CreateElement("param");
myElement.AppendChild( myPElement );
myPElement.SetAttribute("name" , myParam.ParameterName );
myPElement.InnerText =( myParam.Value == null ? c_NullFlag : myParam.Value.ToString());
}
}
return true;
}

///
/// 发送并接受二进制数据
///
///
///
internal byte[] SendByteData( byte[] bytSend)
{
// 发送数据
System.Net.HttpWebRequest myReq = myConnection.CreateHttpRequest();
System.IO.Stream myStream = myReq.GetRequestStream();
int iCount = 0 ;
bolCancel = false;
intExecuteState = 1 ;
while( iCount < bytSend.Length )
{
if( iCount + 1024 > bytSend.Length)
{
myStream.Write(bytSend, iCount , bytSend.Length - iCount );
iCount = bytSend.Length ;
}
else
{
myStream.Write(bytSend , iCount , 1024);
iCount += 1024;
}
if( ExecuteEvent != null)
{
ExecuteEvent( myConnection , this , bytSend.Length , iCount );
}
if( bolCancel )
{
myStream.Close();
myReq.Abort();
return null;
}
}
myStream.Close();
// 接受数据
intExecuteState = 2 ;
System.Net.HttpWebResponse myRes = null;
myRes = (System.Net.HttpWebResponse) myReq.GetResponse();
myStream = myRes.GetResponseStream();
System.IO.MemoryStream myBuf = new System.IO.MemoryStream(1024);
byte[] bytBuf = new byte[1024];
while(true)
{
int iLen = myStream.Read(bytBuf,0,1024);
if(iLen ==0)
break;
myBuf.Write(bytBuf,0,iLen);
if( ExecuteEvent != null)
{
ExecuteEvent( myConnection , this , myRes.ContentLength , myBuf.Length );
}
if( bolCancel )
{
myStream.Close();
myRes.Close();
myReq.Abort();
return null ;
}
}
myStream.Close();
myRes.Close();
myReq.Abort();
byte[] bytReturn = myBuf.ToArray();
myBuf.Close();
return bytReturn ;
}

///
/// 执行命令
///
///
private bool ExecuteCommand()
{
myXMLDoc.LoadXml("");
this.ToXML( myXMLDoc.DocumentElement);
string strSend = myXMLDoc.DocumentElement.OuterXml ;
byte[] bytSend = myConnection.SendEncod.GetBytes( strSend );
byte[] bytReturn = SendByteData(bytSend);
if( bytReturn == null)
return false;
// 解析数据
intExecuteState = 3 ;
char[] chrReturn = myConnection.ReserveEncod.GetChars(bytReturn);
string strReserve =new string(chrReturn);
strReserve = strReserve.Trim();
myXMLDoc.PreserveWhitespace = true;
//try {
myXMLDoc.LoadXml( strReserve );
/