var custs =
	from c in db.BESTELLUNG
	join h in db.HERSTELLER on c.HERSTELLER_ID equals h.HERSTELLER_ID into tempHST
	from hst in tempHST.DefaultIfEmpty()
	join k in db.KUNDE on c.KUNDE_ID equals k.KUNDE_ID into tempKU
	from kun in tempKU.DefaultIfEmpty()
	where
		c.BESTELLNUMMER.StartsWith(myBestellungSuche.Bestellnummer) &&
		hst.NAME_1.StartsWith(myBestellungSuche.Hersteller) &&
		kun.KUNDENNUMMER.StartsWith(myBestellungSuche.Kundennummer) &&
		c.LIEFER_NAME_1.StartsWith(myBestellungSuche.Liefer_Name_1) &&
		c.LIEFER_NAME_2.StartsWith(myBestellungSuche.Liefer_Name_2) &&
		(!string.IsNullOrEmpty(myBestellungSuche.Bestelldatum) ? c.BESTELLDATUM.Equals(myBestellungSuche.Bestelldatum) : true) &&
		(!string.IsNullOrEmpty(myBestellungSuche.Bestellstatus) ? c.BESTELLSTATUS.Equals(myBestellungSuche.Bestellstatus) : true) &&
		(!string.IsNullOrEmpty(myBestellungSuche.Bestellart) ? c.BESTELLART.Equals(myBestellungSuche.Bestellart) : true) &&
	select new { .... };

this._current = this._internalDictionary[this._index];
this._index++;

this._current = this._internalDictionary[this._index++];

this._current = this._internalDictionary[this._index];
++this._index;

public TKey Current
{
   get { 
      if(_keys.Count ≤ 0) throw new ApplicationException();
     return _keys[_index];
   }
}

object IEnumerator.Current
{
   get { return this.Current; }
}

public class RegistryHelper
    {
        private RegistryKey m_registryKey = null;
        private string m_registryPath = null;

        public RegistryHelper(RegistryKey registryKey, string registryPath)
        {
            this.RegistryKey = registryKey;
            this.RegistryPath = registryPath;
        }

        public RegistryKey ConfigurationStore
        {
            get { return this.RegistryKey.CreateSubKey(this.RegistryPath); }
        }

        public RegistryKey RegistryKey
        {
            get { return m_registryKey; }
            set { m_registryKey = value; }
        }

        public string RegistryPath
        {
            get { return m_registryPath; }
            set { m_registryPath = value; }
        }

        public string LoadString(string name, string def, bool create)
        {
            RegistryKey key = this.ConfigurationStore;
            try
            {
                return (string)key.GetValue(name, def);
            }
            finally
            {
                if (create && !HasValue(name))
                    SaveString(name, def);
                key.Close();
            }
        }

        public string[] LoadStringArray(string name, string[] def, bool create)
        {
            return this.LoadStringArray(name, def, ",", create);
        }

        public string[] LoadStringArray(string name, string[] def, string sep, bool create)
        {
            string s = this.LoadString(name, def != null ? string.Join(sep, def) : "", create);
            return s.Split(new string[] { sep }, StringSplitOptions.RemoveEmptyEntries);
        }

        public void SaveString(string name, string val)
        {
            RegistryKey key = this.ConfigurationStore;
            try
            {
                key.SetValue(name, val);
            }
            finally
            {
                key.Close();
            }
        }

        public int LoadInteger(string name, int def, bool create)
        {
            RegistryKey key = this.ConfigurationStore;
            try
            {
                return (int)key.GetValue(name, def);
            }
            finally
            {
                if (create && !HasValue(name))
                    this.SaveInteger(name, def);
                key.Close();
            }
        }

        public uint LoadDword(string name, uint def, bool create)
        {
            RegistryKey key = this.ConfigurationStore;
            try
            {
                return (uint)key.GetValue(name, def);
            }
            finally
            {
                if (create && !HasValue(name))
                    this.SaveDword(name, def);
                key.Close();
            }
        }

        public void SaveDword(string name, uint val)
        {
            RegistryKey key = this.ConfigurationStore;
            try
            {
                key.SetValue(name, val, RegistryValueKind.DWord);
            }
            finally
            {
                key.Close();
            }
        }

        public void SaveInteger(string name, int val)
        {
            RegistryKey key = this.ConfigurationStore;
            try
            {
                key.SetValue(name, val, RegistryValueKind.DWord);
            }
            finally
            {
                key.Close();
            }
        }

        public Type GetValueType(string name)
        {
            RegistryKey key = this.ConfigurationStore;
            try
            {
                RegistryValueKind kind = key.GetValueKind(name);
                if (kind == RegistryValueKind.DWord)
                    return typeof(int);
                else if (kind == RegistryValueKind.String)
                    return typeof(string);
                else
                    return typeof(object);
            }
            catch (System.IO.IOException) { return null; }
            finally
            {
                key.Close();
            }
        }

        public bool HasValue(string name)
        {
            RegistryKey key = this.ConfigurationStore;
            try
            {
                return key.GetValue(name) != null;
            }
            finally
            {
                key.Close();
            }
        }

        public void DeleteValue(string Name)
        {
            RegistryKey key = this.ConfigurationStore;
            try
            {
                key.DeleteValue(Name, false);
            }
            finally
            {
                key.Close();
            }
        }        
    }

public interface IConfiguration
    {
        uint LoadDword(string name, uint def, bool create);
        int LoadInteger(string name, int def, bool create);
        string LoadString(string name, string def, bool create);
        decimal LoadDecimal(string name, decimal def, bool create);
        string[] LoadString(string name, string[] def, bool create);

        void SaveDword(string name, uint val);
        void SaveInteger(string name, int val);
        void SaveString(string name, string val);
        void SaveDecimal(string name, decimal val);

        IConfiguration GetSection(string name);

        StringDictionary GetValues();
        StringDictionary GetValues(Strings names);
        Strings SectionNames { get; }
        Strings ValueNames { get; }
        Type GetValueType(string valueName);
    }

 public class RegConfiguration : Win32.RegistryHelper, IConfiguration
    {        
        public RegConfiguration(string registryPath)
            : base(Microsoft.Win32.Registry.LocalMachine, registryPath)
        {            
        }

        #region IConfiguration Members

        public decimal LoadDecimal(string name, decimal def, bool create)
        {
            decimal retval;
            if (!decimal.TryParse(this.LoadString(name, def.ToString(ThreadHelper.Culture), create), NumberStyles.Number, ThreadHelper.Culture, out retval))
                retval = def;
            return retval;
        }

        public void SaveDecimal(string name, decimal val)
        {
            this.SaveString(name, val.ToString(ThreadHelper.Culture));
        }

        public IConfiguration GetSection(string name)
        {
            return new RegConfiguration(Path.Combine(this.RegistryPath, name));
        }

        public Strings SectionNames
        {
            get
            {
                Strings strings = new Strings();
                strings.AddRange(this.ConfigurationStore.GetSubKeyNames());
                return strings;
            }
        }

        public Strings ValueNames
        {
            get
            {
                Strings strings = new Strings();
                strings.AddRange(this.ConfigurationStore.GetValueNames());
                return strings;
            }
        }
        
        public StringDictionary GetValues(Strings names)
        {
            return ConfigurationHelper.GetValues(this, names);
        }

        public StringDictionary GetValues()
        {
            return ConfigurationHelper.GetValues(this, null);
        }

        public string[] LoadString(string name, string[] def, bool create)
        {
            return ConfigurationHelper.LoadStringArray(this, name, def, create);
        }

        #endregion
    }

tooltip.Show("Hallo Welt", (sender as ToolStripMenuItem).Owner.Parent, Control.MousePosition);

private void MouseHover(object sender, EventArgs e)
{
      tooltip.Show("Hallo Welt", this, Control.MousePosition.X, Control.MousePosition.Y);
}

ThreadPool.QueueUserWorkItem(delegate(object unused) { notifier.SendTileNotification(subscribers, "PushNotificationsToken", "/Images/" + weatherType + ".png", temperature, location, OnMessageSent)});

menuItemForSave.Click += new EventHandler(this.OnSaveSomething);
buttonForSave.Click += new EventHandler(this.OnSaveSomething);

protected virtual void OnSaveSomething(object sender, EventArgs ea)
{
}

bool b1 = value != title;
bool b2 = !value.Equals(title);
if(b1 && b2)

var foo1 = "foo";
var foo2 = new string(new char[] { 'f', 'o', 'o' });

Console.WriteLine(foo1 == foo2);
Console.WriteLine(foo1 == "foo");

public class Window<T> where T: Form, new()
    {
        public Window()
        {
            this.InnerForm = new T();
        }

        public T InnerForm
        {
            get; private set;
        }
    }

class BaseForm : System.Windows.Forms.Form, ITransportHandler

class DockableBaseForm : Irgendeine.Andere.DockingLibrary.Form, ITransportHandler

SpecialForm : BaseForm

SpecialDockableForm : DockableBaseForm 

class Window : Form 
{
    public Window(Form innerForm) 
    {
       this.InnerForm = form;
    }

    public Form InnerForm { get; private set; }
}

public class TabModelPersistenceHelperBinder : System.Runtime.Serialization.SerializationBinder
    {
        public override Type BindToType(string assemblyName, string typeName)
        {
            Type retval = Type.GetType(String.Format("{0}, {1}", typeName, assemblyName));
            if(retval.Equals(typeof(Dictionary<string, List<string>>)))
                retval = typeof(Dictionary<string, HybridSet<string>>);
            else if(retval.Equals(typeof(KeyValuePair<string, List<string>>)))
                retval = typeof(KeyValuePair<string, HybridSet<string>>);
            else if (retval.Equals(typeof(List<string>)))
                retval = typeof(HybridSet<string>);
            return retval;
        }        
    }

public class TabModelPersistenceHelperBinder : System.Runtime.Serialization.SerializationBinder
    {
        public override Type BindToType(string assemblyName, string typeName)
        {
            Type retval = Type.GetType(String.Format("{0}, {1}", typeName, assemblyName));
            if(retval.Equals(typeof(Dictionary<string, List<string>>)))
                retval = typeof(Dictionary<string, HybridSet<string>>);
            return retval;
        }        
    }