C#

Jan Sommer wrote:

I'm asking because my teacher says that the above example is bad OOP

public IEnumerator<Customer> GetCustomersEnumerator()
{
    return this.cust.GetEnumerator();
}

IEnumerator<Customer> alist = partners.GetCustomerEnumerator();

while(alist.MoveNext())
{
    Console.WriteLine(alist.Current.someProperty);
}

Jan Sommer wrote:

Am i doing it all wrong?

George_George wrote:

Are there anything wrong with my code?

George_George wrote:

But Dispose(bool) is defined as static in my sample, how could I call it from destructor?

class Logger : IDisposable
{
        private static bool disposed = false;

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

        ~Logger()
        {
            Dispose(false);
        }

        private static void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.
            if (false == disposed)
            {
                // If disposing equals true, dispose all managed 
                // and unmanaged resources.
                if (disposing)
                {
                    // Dispose managed resources.
                    currentLogStream.Dispose();
                }
            }
            disposed = true;
        }

        public static void Uninitialize()
        {
            Dispose(true);
        }
}

George_George wrote:

he class is singleton -- only once instance is created.

public class StreamWrapper : IDisposable
{
   private StreamWriter currentLogStream;
   private bool disposed; // no need to initialize here as the default is false

   public void Dispose()
   {
      this.Uninitialize();
   }
 
   protected virtual void Dispose(bool disposing)
   {
      if (!disposed)
      {
         if (disposing)
         {
            if (currentLogStream != null)
            {
               currentLogStream.Dispose();
            }
         }
      }
      disposed = true;
   }
 
   public void Uninitalize()
   {
      Dispose(true);
      GC.SuppressFinalize(this);
   }
}

class Logger : IDisposable
{
        private static bool disposed = false;
        private static StreamWriter  logStream;

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

        ~Logger()
        {
            Dispose(false);
        }

        private static void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.
            if (false == disposed)
            {
                // If disposing equals true, dispose all managed 
                // and unmanaged resources.
                if (disposing)
                {
                    // Dispose managed resources.
                    LogStream.Dispose();
                    LogStream = null;
                }
            }
            disposed = true;
        }

        public static void Uninitialize()
        {
            Dispose(true);
            GC.SuppressFinalize(l ogStream);
        }
}

public sealed class Logger : IDisposable
{
   // This is the actual instance of the logger maintained by the singleton.
   private static Logger instance;
   private StreamWriter logStream;   
   private bool disposed; // No need to initialize here as the default is false.
   private static readonly object syncLock = new object();
    
   private Logger()
   {
   }
    
   public void Dispose()
   {
      this.Uninitialize();
   }
 
   protected virtual void Dispose(bool disposing)
   {
      if (!disposed)
      {
         if (disposing)
         {
            if (logStream != null)
            {
               logStream.Dispose();
               logStream = null; // Not strictly necessary, but won't hurt either.
            }            
         }
      }
      disposed = true;
   }
 
   public void Uninitalize()
   {
      Dispose(true);
      GC.SuppressFinalize(this);
   }
    
   public static Logger Instance
   {
      get
      {
         lock(syncLock)
         {
            if (instance == null)
            {
               instance = new Logger();
            }
         }
         return instance;
      }
   }
}

Logger.Instance.Uninitalize();