C#

if (m_pTexture != null)
{
    graphicsManager.Begin();
    if (bSetupClientArea)
        graphicsManager.SetupClientRect(TranslatedArea);
    if (Image_States == 0 || Image_States == 1)
        graphicsManager.Draw(m_pTexture, TranslatedArea, new Color(255, 255, 255, (byte)Alpha));
    else
    {
        int nSubHeight = m_pTexture.Height / Image_States;
        Rectangle src = new Rectangle(0, (int)Current_State * nSubHeight, m_pTexture.Width, nSubHeight);
        graphicsManager.Draw(m_pTexture, TranslatedArea, src, new Color(255, 255, 255, (byte)Alpha));
    }
    graphicsManager.End();
    DrawBorder(graphicsManager);
}
for (int i = 0; i < m_pComponents.Count; ++i)
{
    Component component = m_pComponents[i];
    if (component.Visible)
        component.Draw(gameTime, graphicsManager, true);
}

FileStream fs = new FileStream(timestr, FileMode.CreateNew);
ScriptData.LogFile = new StreamWriter(fs);
ScriptData.LogFile.WriteLine("Logile created {0:yyyy'-'MM'-'dd'T'HHmmss}.log", DateTime.Now);

ScriptData.LogFile.WriteLine("Script {0} completed.", ScriptData.LogName);
ScriptData.LogFile.Close();        // Only close when exiting root script file
ScriptData.LogFile.Dispose();

// Some type a user of the framework wants to store persistently.
public class Toto
{
   int n;
   string s;
   Toto parent;

   // .. other members that we don't really care about; only fields matter.
}


public class Storage
{
   // Storage itself doesn't really have a clue how anything is stored, 
   // but it knows about an object that can generate implementations based
   // on type, it caches such generated objects, and delegates the actual
   // loading and saving to these generated objects.
   static public ObjectManagerFactory ObjectManagerFactory { get; set; }

   Dictionary<Type, IObjectManager> objectManagers;

   public List<T> Load<T>(Selection selection) 
   {
      IObjectManager m;
      Type t = typeof(T);
      if (!objectManagers.TryGetValue(t, out m))
      {
         m = ObjectManagerFactory.CreateManager(t);
         objectManagers[t] = m;
      }
      return (T)m.Load(selection);
   }

   // Similarly for Save, the implementation in Storage only sees if an ObjectManager
   // for the type already exists, and if not has the factory create one and cache
   // the result, then delegate the actual saving to the ObjectManager instance.
   public void Save(object data) { ... }
}

public class Toto : IFieldAccessible
{
   int n;
   string s;
   Toto parent;

   object[] IFieldAccessible GetFieldValues()
   {
      return new object[] { n, s, parent };
   }

   void IFieldAccessible SetFieldValues(object[] values)
   {
      n = (int)values[0];
      s = (string)values[1];
      parent = (Toto)values[2];
   }

   // .. other members that we don't really care about; only fields matter.
}