如果"objectToBeDisposed"的引用是由"useDisposableObject"保存的,我可以知道它是否会被处理掉？
using(IDisposable objectToBeDisposed = new ObjectImplementedIDisposable ()){
ChildObject useDisposableObject = new ChildObject(objectToBeDisposed);
.... doing stuff with useDisposableObject;
}
我编码如下:
class myclass : IDisposable
{
public int a;
public void Dispose()
{
GC.SuppressFinalize(this);
}
}
class Program
{
static void Main(string[] args)
{
myclass cl = null;
using (myclass n = new myclass())
{
n.a = 10;
cl = n;
}
int a = cl.a;// statement 1
}
}
我希望语句1不起作用,因为cl对象已被释放(n对象已释放).但它有效.那么n对象是否真的在声明1中发布了？
我有一个无限循环,用于消耗BlockingCollection中的项目.
public class MessageFileLogger
{
private BlockingCollection<ILogItem> _messageQueue;
private Thread _worker;
private bool _enabled = false;
public MessageFileLogger()
{
_worker = new Thread(LogMessage);
_worker.IsBackground = true;
_worker.Start();
}
private void LogMessage()
{
while (_enabled)
{
if (_messageQueue.Count > 0)
{
itm = _messageQueue.Take();
processItem(itm);
}
else
{
Thread.Sleep(1000);
}
}
}
}
由每分钟或几分钟实例化的另一个对象引用(可以移动到1小时增量等)
public class Helper
{
MessageFileLogger _logger;
public Helper(string logFilePath, LogMode logMode)
{
_logger = new MessageFileLogger(logFilePath, logMode);
_logger.Enabled = true;
}
public void foo()
{
}
} …我正在使用类似于此问题的接受答案的代码来制作自定义光标.我想我可以问,"当我完成自定义光标后我该怎么办？" 但具体来说,我的问题分为两部分:
一:我看到使用反射来设置光标的"ownHandle"字段的代码.是否这样可以在放置Cursor对象时销毁(本机)句柄？如果不是它做什么？
二:我是否必须手动处理光标对象或者为控件分配新光标,导致控件为我配置光标？例如:
private void customCursorButton_Clicked(object sender, EventArgs e)
{
this.Cursor = NativeMethods.LoadCustomCursor(@"c:\windows\cursors\aero_busy.ani");
}
private void defaultCursorButton_Clicked(object sender, EventArgs e)
{
var tmp = this.Cursor; // do I have to do this
this.Cursor = Cursors.Default;
tmp.Dispose(); // and this?
}
我很惊讶反应式扩展CompositeDisposable类未能通过以下测试
[Test]
public void TestDisposable()
{
var ds = new List<IDisposable>();
int[] a = { 1, 2, 3 };
using (new CompositeDisposable(ds))
{
ds.Add(Disposable.Create(() => a[0] = 3));
ds.Add(Disposable.Create(() => a[2] = 1));
}
Assert.That(a[0],Is.EqualTo(3)); //Failed here
Assert.That(a[1], Is.EqualTo(2));
Assert.That(a[2], Is.EqualTo(1));
}
所以这意味着如果我CompositeDisposable通过给定 a创建 aIEnumerable<IDisposable>它实际上迭代它的所有元素，而不是将其推迟到Dispose被调用者。
这在其他情况下可能很有用，但在我的情况下却很不方便。是否还有其他课程可以更轻松地完成上述任务？
我在'C++/CLI'中有一个程序集,它实现了某些类.我们假设该类是'SomeType'.
现在,在'C#'开发的应用程序中,执行以下操作 -
while(!Console.KeyAvailable)
{
using(SomeType type = new SomeType())
{
type.doSomething(); //do something
}
}
在任何情况下都会有任何后果,例如内存泄漏等,比如是否存在未处理的异常或任何此类情况？
我读到using关键字通常应该用于实现IDisposable的类,但对于C++/CLI类？
我需要编写一个类,我想让消费者通过using(...)在C#中包装带有语句的代码来处理代码.
为此,我必须实现Microsoft的IDisposable界面.
基于Microsoft实现它的方法,我应该做这样的事情
这样的通用接口
public interface ISomeClass : IDisposable
{
// ... some methods to include
}
public class SomeClass : ISomeClass
{
private readonly TimeTrackerContext _context;
private bool disposed = false;
protected virtual void Dispose(bool disposing)
{
if (!this.disposed && disposing && _context != null)
{
_context.Dispose();
}
this.disposed = true;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
我正在尝试以正确的方式学习C#,因此我对此实现有一些疑问.
题
为什么我真的需要有一个属性告诉我在处理之前对象是否已被处置？
换句话说,_context在处理它之前,我不能只检查是否为null吗？像这样的东西
public class SomeClass : ISomeClass
{
private …也许我太懒了,但是using在方法中嵌套s使得该方法看起来很复杂且难以理解.是否有任何IDisposable方法可以在退出方法时由于异常而自动处理在方法中创建的所有对象？
PS.感谢您的反馈.我现在知道现在没有这样的功能.但是,从理论上讲,以下假设的语法是否合理？
void SomeMethod()
{
autodispose var com = new SQLCommand();
...
autodispose var file = new FileStream();
....
autodispose var something = CreateAnObjectInAMethod();
....
}
出于任何原因退出方法时,所有三个对象都会自动处理.
IDisposable我确信这是一个简单的问题，但是在没有 using 语句的情况下处理对象时我应该做什么？
我Controller.Dispose(bool)在我的ASP.NET MVC2控制器中重写该方法,以便根据需要处理事物,同时让它们尽可能长时间处于活动状态.这与在从Controller的操作方法返回之前处置它们相反.
我的问题,简而言之; 这是否像我期望的那样工作？
从我目前所看到的情况来看,这似乎正是我所需要的; 所有IDisposable对象都被处理掉(该Controller.Dispose()方法调用虚拟对象Controller.Dispose(bool)),但直到不再需要它们为止.
编辑#2:
我很欣赏我应该做的建议.我的意思是; 事实上,我刚刚投了这么一个答案.
对于这个问题的目的,不过,让我们假设我已经评估自己的需要,并已决定,在我看来调用一个偶然相关的实体属性最适合我的,而且我已经决定,我不是真的需要一个依赖注入框架只是为了确保我的对象被正确处理.
我现在真正需要知道的是,如果有人知道在重写Controller.Dispose(bool)方法中处理这些对象的生命周期相关问题.
我发现了一件有趣的事情.c#,.NET 4.0.我有一个代表IDisposable接口的类.在上面提到的类中我有一个函数,返回IEnumerable并返回yield.在调用时,controll跳过该函数.请勿介入.示例:
class Program
{
static void Main(string[] args)
{
using (DispClass d = new DispClass())
{
d.Get2();
d.Get1();
}
}
}
public class DispClass: IDisposable
{
public DispClass()
{
Console.WriteLine("Constructor");
}
public void Dispose()
{
Console.WriteLine("Dispose");
}
public int Get1()
{
Console.WriteLine("Getting one");
return 1;
}
public IEnumerable<int> Get2()
{
Console.WriteLine("Getting 1");
yield return 1;
Console.WriteLine("Getting 2");
yield return 2;
}
}
输出:"构造函数""获取一个""处理"
"获得1","获得2"在哪里？如果没有收益率返回并返回本地列表,我可以看到这些......
请解释!
foreach循环调用自动.dispose()实现的对象IDisposable.这是一个很好的功能,但是假设你有以下功能:
public COMWrapper GetCOMWrapperByName(string COMWrapperName)
{
List<COMWrapper> COMWrapperList = GetCOMWrappersFromPlace();
foreach(COMWrapper cw in COMWrapperList)
{
if(cw.name == COMWrapperName)
return cs;
}
}
这COMWrapper的.dispose()方法发布它相关的COM对象.
据我所知,foreach循环将COMWrapper在循环结束时处理每个循环,但随后离开匹配,COMWrapper因为它在到达语句结束之前返回.
然而,对于列表中COMWrapper留下的引用,这成为一个问题,COMWrapperList因为它们中的一半已经删除了它们的底层COM对象RCW包装器而没有被丢弃.更糟糕的是,列表的剩余部分有完全不受管理的COM对象现在漂浮在以太网中,并且由于COMWrapper它们存在的对象尚未被处理掉,因此在一个声明中进行适当的遍历List和调用变得非常困难(我们不是毕竟,想要释放COM对象两次)..dispose()finally
是否可以确定是否已释放COM对象而不捕获ObjectDisposedException异常？是否有更好的方法来处理剩余的COM对象及其包装器？或者我可能完全误解了这种情况,需要重新评估我对COM对象的基本理解,我做错了什么？