Класс C#, подклассы, IClonable, IDisposable

Question

Я работаю в C# некоторые упражнения, и я не понимаю общую картину. Если бы они реализовались на Java, у меня не было бы проблем. Но я новичок в C#, поэтому я все перепутал и не знаю, как должна выглядеть структура. Я читаю некоторые объяснения, такие как: http://www.codeproject.com/Articles/15360/Implementing-IDisposable-and-the-Dispose-Pattern-P и http://msdn.microsoft.com/en-us/library/fs2xkftw.aspx

У меня есть первый класс, где я делаю LinkedList, а его тип является узлом, поэтому: LinkedList связанный список = новый LinkedList, чем я делаю некоторые узлы в пути в связном списке с помощью некоторых методов, также здесь есть метод print, который печатает элементы из связанного списка.

Мой "объектный" класс - это Node, где у меня есть конструкторы, свойства и так далее геттеры и сеттеры. У меня также есть здесь метод virtula print, и я не знаю, что я должен добавить в этот метод, потому что этот класс узлов является просто абстрактным классом, и здесь я должен реализовать методы IDisposable:

 public void Dispose()  {}
 protected virtual void Dispose(bool disposing) {}

Здесь я не понимаю, почему я должен использовать IDispose? Во всех примерах я видел, что он использовался для доступа к какому-либо файлу и работы с изображениями. В некоторых примерах я видел:

 public interface IDisposable
 {
   void Dispose();
 }

и я не знаю, должен ли я поместить это в какой-то новый класс, должен ли я поместить его в тот же класс или даже не реализовать его.

И затем я делаю подклассы NodeLong и Nodestring, которые используют узел суперкласса, куда я добавляю некоторые новые свойства, и сеттеры, и геттеры. Я также использовал метод печати. Я тоже не понимаю genercis.

Класс Linearcollection:

public class LinearCollection{
     void Main(string[] args){
         LinkedList<Node> linkedlist = new LinkedList<Node>
          //calling methods for adding some elements, deleting, getting some elements
     }
     //implemented methods

     public void Print(){
        foreach( NodeElement item in linkedList){
              // what to do??
        }
     }

Мой класс Nodeelemts:

 public abstract class Node:{

     private bool _disposed;
     //constructors
     //properties, set, get ex:
     private Object data;
     public Object _data{
        get{
            rethurn this._data;
        }
        set{
            this._data=value;
        }
     }

     public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing){
        if(!_disposed){
            if(disposing){
                //disposed managed resources
            }
            //
        }
        _disposed = true;
        //
    }

     virtual public void Print(){
        //what to implemetn?
     }
 }
 //stil the same file
 public class NodeString : Node{
    //prop
    public string typeOfElement{ get set ...}
   //new constructor where is involved new property
   public overrride void Print()
   {
        Console.WriteLine(_data.ToString());
        base.Print();
    }
 }

 public class NodeLong : Node{
    //prop
    public long typeOfElement{ get set ...}
   //new constructor where is involved new property
   public overrride void Print()
   {
        Console.WriteLine(_data.ToString());
        base.Print();
    }
 }

Если я сделаю NodeLang: IClonable, я не смогу сделать NodeLang:Node.

В моих инструкциях сказано, что я должен использовать методы IClonable в обоих подклассах, я не знаю, как мне его использовать? Также используйте IDisposable в классе Node, как? Надеюсь мне понятно?

Итак, последний вопрос: как должен выглядеть мой класс, подкласс, IDisposable и ICloneable?

Answer 1

Есть моменты, когда это может иметь смысл для класса, который реализует IDisposable иметь метод клонирования, и в этом случае любой код вызывает метод клонирования, объект будет отвечать за Dispose будет вызвана новая копия (либо путем вызова Dispose сам или передавая ответственность другому кодексу). Есть также случаи, когда имеет смысл иметь контейнерный класс с Dispose метод, который вызывает Dispose на каждом члене, хранящемся в нем, хотя в большинстве таких ситуаций цель класса контейнера будет сосредоточена вокруг такого удаления, и у него не будет никаких причин поддерживать какое-либо клонирование.

Если только Node класс будет открыт для внешнего мира, я не вижу особой цели для его реализации IDisposable, Даже если класс, который содержит связанный список, является агрегатором удаления (чем-то, что принимает объекты, полезное время жизни которых будет короче своего собственного, а затем очищает их, когда его собственный Dispose метод), и каждый узел, кроме последнего, будет не только содержать что-то, что требует очистки, но также будет знать о другом узле. Наличие вызова узла Dispose на следующем узле это приведет к ненужной рекурсии, что приведет к сбою, если будет слишком много узлов. Альтернативой было бы иметь Node класс реализовать Node DisposeAndReturnNext() метод, который вызвал бы Node распоряжаться всеми известными ему ресурсами и затем возвращать ссылку на следующий узел. Затем вызывающий абонент может использовать что-то вроде:

while(nodeToDispose != null)
  nodeToDispose = nodeToDispose.DisposeAndReturnNext();

Здесь было бы ясно, что DisposeAndReturnNext Ожидается, что метод избавится от следующего узла (и его потомков), даже если он будет знать, что они нуждаются в удалении. Хотя это было бы возможно для Node определить Dispose метод, который включает в себя цикл, подобный описанному выше, с обработкой первого элемента списка Dispose метод и распоряжение любым другим элементом, управляемым циклом, подобным приведенному выше, кажется довольно странным. Лучше иметь один цикл во вложенном классе, который обрабатывает удаление для всех.