{
}
public static class ChatEngine
{
}
依我看类都继承于IDisposable难道不更好么,用完就可以把占用的资源释放;另外如果一个类没有继承于这个接口,那它就不能释放资源了么?
8 个解决方案
#1
为什么要继承接口,你因为你要实现他,为什么要实行他,因为别人要调用它!
一样道理,为什么卫冕要继承IDisposable , 因为实现了该接口, .net FRAMWORK在垃圾
回收你的对象的时候回调用你实现的IDisposable的接口方法Dispose.
我猜,其实每个对象都继承于object ,而object 已经实现了IDisposable,且dipose 是虚函数。
你在dipose里面实现什么呢?释放你对象定义的一些变量,特别是占用大量内存的变量,就是释放分配的资源。
比如你的对象有很多字典变量、集合变量、动态分配了内存(marshal)等等,
你完全可以在dispose方法里面把它们清空并释放掉,垃圾回收掉GC.Collect();
一样道理,为什么卫冕要继承IDisposable , 因为实现了该接口, .net FRAMWORK在垃圾
回收你的对象的时候回调用你实现的IDisposable的接口方法Dispose.
我猜,其实每个对象都继承于object ,而object 已经实现了IDisposable,且dipose 是虚函数。
你在dipose里面实现什么呢?释放你对象定义的一些变量,特别是占用大量内存的变量,就是释放分配的资源。
比如你的对象有很多字典变量、集合变量、动态分配了内存(marshal)等等,
你完全可以在dispose方法里面把它们清空并释放掉,垃圾回收掉GC.Collect();
#2
不是继承了该IDisposable接口,就会自动释放资源,其实要释放的什么资源并且怎么实现你必须要在dipose里面写!
#4
IDisposable只是一个接口而已 继承了还要由你来实现的 你不实现相当于什么都没做
#5
懂了,也就是说实现后还得自己写代码去真正释放这个类所占用的资源,但是为什么看到人家有的类实现这个接口,有的不实现呢,我认识任何一个类都得战胜一定内存和资源的。另外即使我不写:IDisposable,我照样可以在类里写一个方法来实现释放资源的功能呀,那我为什么要来一个:IDisposable呢?
#6
.net 下普通的类是被gc管理,所以会自动释放,而有的类,拥有非托管资源,无法被gc管理,
所以。。。
所以。。。
#7
mark
#8
是用来自己增加点代码用的,比如
public class SQLBase : IDisposable
{
private SqlConnection conn;
private SqlTransaction trans = null;
#region 释放资源
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(true);
}
/// <summary>
/// 释放资源
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (trans != null)// 如果
trans.Commit();
this.conn.Close();
}
#endregion
/// <summary>
/// 执行查询语句
/// </summary>
/// <param name="strSQL"></param>
/// <param name="arrParameter"></param>
/// <param name="CT"></param>
/// <returns></returns>
public int ExecuteNonQuery(string strSQL, SqlParameter[] arrParameter, CommandType CT)
{
using (SqlCommand cmd = new SqlCommand(strSQL, conn))
{
if (trans == null)
{
trans = conn.BeginTransaction(); ;
}
cmd.Transaction = trans;
cmd.CommandType = CT;
if (arrParameter != null)
{
foreach (SqlParameter sp in arrParameter)
{
cmd.Parameters.Add(sp);
}
}
try
{
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}
catch (Exception ex)
{
trans.Rollback();
trans = null;
throw new Exception("执行" + strSQL + "发生错误,已经回滚事务,错误信息是:" + ex.Message);
}
}
}
}
比如这段代码,执行完毕了ExecuteNonQuery
不管是否正常还是异常 都会执行关闭数据库,异常的情况下还多个回滚事务。
public class SQLBase : IDisposable
{
private SqlConnection conn;
private SqlTransaction trans = null;
#region 释放资源
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(true);
}
/// <summary>
/// 释放资源
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (trans != null)// 如果
trans.Commit();
this.conn.Close();
}
#endregion
/// <summary>
/// 执行查询语句
/// </summary>
/// <param name="strSQL"></param>
/// <param name="arrParameter"></param>
/// <param name="CT"></param>
/// <returns></returns>
public int ExecuteNonQuery(string strSQL, SqlParameter[] arrParameter, CommandType CT)
{
using (SqlCommand cmd = new SqlCommand(strSQL, conn))
{
if (trans == null)
{
trans = conn.BeginTransaction(); ;
}
cmd.Transaction = trans;
cmd.CommandType = CT;
if (arrParameter != null)
{
foreach (SqlParameter sp in arrParameter)
{
cmd.Parameters.Add(sp);
}
}
try
{
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}
catch (Exception ex)
{
trans.Rollback();
trans = null;
throw new Exception("执行" + strSQL + "发生错误,已经回滚事务,错误信息是:" + ex.Message);
}
}
}
}
比如这段代码,执行完毕了ExecuteNonQuery
不管是否正常还是异常 都会执行关闭数据库,异常的情况下还多个回滚事务。
#1
为什么要继承接口,你因为你要实现他,为什么要实行他,因为别人要调用它!
一样道理,为什么卫冕要继承IDisposable , 因为实现了该接口, .net FRAMWORK在垃圾
回收你的对象的时候回调用你实现的IDisposable的接口方法Dispose.
我猜,其实每个对象都继承于object ,而object 已经实现了IDisposable,且dipose 是虚函数。
你在dipose里面实现什么呢?释放你对象定义的一些变量,特别是占用大量内存的变量,就是释放分配的资源。
比如你的对象有很多字典变量、集合变量、动态分配了内存(marshal)等等,
你完全可以在dispose方法里面把它们清空并释放掉,垃圾回收掉GC.Collect();
一样道理,为什么卫冕要继承IDisposable , 因为实现了该接口, .net FRAMWORK在垃圾
回收你的对象的时候回调用你实现的IDisposable的接口方法Dispose.
我猜,其实每个对象都继承于object ,而object 已经实现了IDisposable,且dipose 是虚函数。
你在dipose里面实现什么呢?释放你对象定义的一些变量,特别是占用大量内存的变量,就是释放分配的资源。
比如你的对象有很多字典变量、集合变量、动态分配了内存(marshal)等等,
你完全可以在dispose方法里面把它们清空并释放掉,垃圾回收掉GC.Collect();
#2
不是继承了该IDisposable接口,就会自动释放资源,其实要释放的什么资源并且怎么实现你必须要在dipose里面写!
#3
#4
IDisposable只是一个接口而已 继承了还要由你来实现的 你不实现相当于什么都没做
#5
懂了,也就是说实现后还得自己写代码去真正释放这个类所占用的资源,但是为什么看到人家有的类实现这个接口,有的不实现呢,我认识任何一个类都得战胜一定内存和资源的。另外即使我不写:IDisposable,我照样可以在类里写一个方法来实现释放资源的功能呀,那我为什么要来一个:IDisposable呢?
#6
.net 下普通的类是被gc管理,所以会自动释放,而有的类,拥有非托管资源,无法被gc管理,
所以。。。
所以。。。
#7
mark
#8
是用来自己增加点代码用的,比如
public class SQLBase : IDisposable
{
private SqlConnection conn;
private SqlTransaction trans = null;
#region 释放资源
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(true);
}
/// <summary>
/// 释放资源
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (trans != null)// 如果
trans.Commit();
this.conn.Close();
}
#endregion
/// <summary>
/// 执行查询语句
/// </summary>
/// <param name="strSQL"></param>
/// <param name="arrParameter"></param>
/// <param name="CT"></param>
/// <returns></returns>
public int ExecuteNonQuery(string strSQL, SqlParameter[] arrParameter, CommandType CT)
{
using (SqlCommand cmd = new SqlCommand(strSQL, conn))
{
if (trans == null)
{
trans = conn.BeginTransaction(); ;
}
cmd.Transaction = trans;
cmd.CommandType = CT;
if (arrParameter != null)
{
foreach (SqlParameter sp in arrParameter)
{
cmd.Parameters.Add(sp);
}
}
try
{
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}
catch (Exception ex)
{
trans.Rollback();
trans = null;
throw new Exception("执行" + strSQL + "发生错误,已经回滚事务,错误信息是:" + ex.Message);
}
}
}
}
比如这段代码,执行完毕了ExecuteNonQuery
不管是否正常还是异常 都会执行关闭数据库,异常的情况下还多个回滚事务。
public class SQLBase : IDisposable
{
private SqlConnection conn;
private SqlTransaction trans = null;
#region 释放资源
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(true);
}
/// <summary>
/// 释放资源
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (trans != null)// 如果
trans.Commit();
this.conn.Close();
}
#endregion
/// <summary>
/// 执行查询语句
/// </summary>
/// <param name="strSQL"></param>
/// <param name="arrParameter"></param>
/// <param name="CT"></param>
/// <returns></returns>
public int ExecuteNonQuery(string strSQL, SqlParameter[] arrParameter, CommandType CT)
{
using (SqlCommand cmd = new SqlCommand(strSQL, conn))
{
if (trans == null)
{
trans = conn.BeginTransaction(); ;
}
cmd.Transaction = trans;
cmd.CommandType = CT;
if (arrParameter != null)
{
foreach (SqlParameter sp in arrParameter)
{
cmd.Parameters.Add(sp);
}
}
try
{
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}
catch (Exception ex)
{
trans.Rollback();
trans = null;
throw new Exception("执行" + strSQL + "发生错误,已经回滚事务,错误信息是:" + ex.Message);
}
}
}
}
比如这段代码,执行完毕了ExecuteNonQuery
不管是否正常还是异常 都会执行关闭数据库,异常的情况下还多个回滚事务。