Краткий обзор C# Располагает метод
Я засовываю это в свой .emacs:
(setq x-select-enable-clipboard t)
(setq interprogram-paste-function 'x-cut-buffer-or-selection-value)
у меня впоследствии нет в основном проблем, вырезающих и вставляющих назад и вперед ни от чего в Emacs ни к какому другому X11 или приложению Gnome.
Премия: для получения этих вещей произойти в Emacs, не имея необходимость перезагружать целый .emacs сделайте C-x C-e с курсором сразу после завершения paren каждого из тех выражений в буфере .emacs.
Удачи!
5 ответов
Вы должны следовать стандартному шаблону для реализации Dispose . Создание виртуального Dispose () считается плохой практикой, потому что традиционный шаблон подчеркивает повторное использование кода в «управляемой очистке» (клиент API вызывает Dispose () напрямую или через с использованием ) и «неуправляемая очистка» (финализатор вызова GC). Напомним, что шаблон таков:
public class Base
{
~Base()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this); // so that Dispose(false) isn't called later
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
// Dispose all owned managed objects
}
// Release unmanaged resources
}
}
Ключевым моментом здесь является то, что нет дублирования между финализатором и Dispose для неуправляемой очистки, и все же любой производный класс может расширять как управляемую, так и неуправляемую очистку.
В этом случае вам следует сделать следующее:
protected abstract void Dispose(bool disposing)
, а все остальное оставить как есть. Даже это имеет сомнительную ценность, поскольку вы усиление производных классов для реализации Dispose прямо сейчас - и как узнать, что всем это нужно? Если вашему базовому классу нечего удалять, но большинство производных классов, вероятно, справляются с этим (возможно, за некоторыми исключениями), тогда просто предоставьте пустую реализацию. Это то, что делает System.IO.Stream (сам абстрактный), поэтому есть прецедент.
Единственная претензия, которую я испытываю к представленным на данный момент ответам, состоит в том, что все они предполагают, что вам нужен финализатор, что не всегда так. С финализацией связаны довольно значительные накладные расходы на производительность, которые я бы не хотел накладывать на все мои производные классы, если бы в этом не было необходимости.
См. это сообщение в блоге Джо Даффи, которое объясняет, когда вам может понадобиться финализатор, а когда нет, и как правильно реализовать шаблон Dispose в любом случае.
Подводя итог сообщения в блоге Джо, можно сказать, что если вы не занимаетесь чем-то довольно низкоуровневым, связанным с неуправляемой памятью, вам не следует реализовывать финализатор. Как правило, если ваш класс содержит только ссылки на управляемые типы, которые сами реализуют IDisposable, вам не нужен финализатор (но следует реализовать IDisposable и удалить эти ресурсы). Если вы выделяете неуправляемые ресурсы непосредственно из своего кода (PInvoke?), И эти ресурсы необходимо освободить, он вам понадобится. Производный класс всегда может добавить финализатор, если он действительно нужен, но принуждение всех производных классов иметь финализатор путем помещения его в базовый класс приводит к тому, что на все производные классы влияет снижение производительности финализируемых объектов, когда эти накладные расходы могут не быть необходимо.
Предупреждение в основном говорит вам о том, что вам нужно реализовать шаблон Dispose в вашем классе.
Результирующий код должен выглядеть так:
public abstract class ConnectionAccessor : IDisposable
{
~ConnectionAccessor()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
}
}
Однако предупреждение интересно. Эрик Липперт, один из разработчиков C #, написал в блоге, почему сообщения об ошибках должны быть «диагностическими, но не предписывающими: описывать проблему, а не решение». Прочтите здесь.
Хотя это немного похоже на придирку, совет действителен. Вы уже указываете, что ожидаете, что любые подтипы ConnectionAccessor будут иметь что-то , которое им необходимо удалить. Поэтому кажется лучше убедиться, что надлежащая очистка выполняется (с точки зрения вызова GC.SuppressFinalize) базовым классом, а не полагаться на каждый подтип для этого.
Я использую шаблон удаления, упомянутый в Брюсе Вагнерсе книга Эффективный C # , который в основном:
public class BaseClass : IDisposable
{
private bool _disposed = false;
~BaseClass()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(true);
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
return;
if (disposing)
{
//release managed resources
}
//release unmanaged resources
_disposed = true;
}
}
public void Derived : BaseClass
{
private bool _disposed = false;
protected override void Dispose(bool disposing)
{
if (_disposed)
return;
if (disposing)
{
//release managed resources
}
//release unmanaged resources
base.Dispose(disposing);
_disposed = true;
}