List<int> list = ...;
List<int> result = (from i in list where i > 10 select i).ToList();

List<int> list = ...;
List<int> result = (from i in list where i > 10 select i * i).ToList();

StringBuilder sb = new StringBuilder();
foreach (decimal d in list) {
    sb.Append(d.ToString("0.00") + ";  ");
}
if (sb.Length > 0) sb.Length -=2; // Trennzeichen am Ende entfernen
return sb.ToString();

static class StringExtensions
{
    public static string SerializeToString<T>(this IEnumerable<T> list, Func<T, string> serialize, string separator)
    {
        StringBuilder sb2 = list.Aggregate(new StringBuilder(), (sb, item) => sb.Append(serialize(item) + separator));
        if (sb2.Length > 0) sb2.Length -= separator.Length;
        return sb2.ToString();
    }
}

string serializedValues = list.SerializeToString(d => d.ToString("0.00"));

List<List<DateTime>> list = ...;
 
string serializedValues = list.SerializeToString(i1 => i1.Count + " Elemente: " + i1.SerializeToString(i2 => i2.ToString(), ", "), "\r\n");
// Beispiel-Ausgabe:
// 1.1.2010, 2.1.2010
// 1.1.2011, 2.1.2011, 3.1.2011
// ...

using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Threading;
using System.Diagnostics;
using System.Drawing;
 
namespace MyProject
{
    /// <summary>
    /// Control to display the  current WorkingSet size. Aka "RamControl". Just call Start to start the monitoring.
    /// </summary>
    class WorkingSetControl : Control
    {
        Thread t1;
        bool active = false;
 
        public WorkingSetControl()
        {
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
        }
 
        /// <summary>
        /// Start displaying the current WorkingSet size. If you don't call Start you won't see a thing!
        /// </summary>
        internal void Start()
        {
            // start only if not started yet
            if (t1 == null)
            {
                // although we could use a lambda expression to create this thread don't use one to be .NET 2.0 compatible.
                t1 = new Thread(run);
 
                // if you *HAVE* to use a lambda expression, fine have fun with your cryptic code:
                /*
                t1 = new Thread(() =>
                {
                    while (active)
                    {
                        Invalidate();
                        Thread.Sleep(100);
                    }
                });
                */
 
                // set active to true, so our run method does actually run in loops 'n loops 'n loops until active is set to false ==> see Dispose.
                active = true;
                t1.Start();
            }
        }
 
        void run()
        {
            while (active)
            {
                Invalidate();
                Thread.Sleep(100);
            }
        }
 
        /// <summary>
        /// Get and draw the WorkingSet size
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPaint(PaintEventArgs e)
        {
            string ram = "xxx";
 
            // Only get the WorkingSet size if the control is in active mode.
            // This prevents the control displaying the WorkingSet size of Visual Studio in the designer (which works actually, but is somehow confusing).
            if (active)
            {
                long lngSessMemory = Process.GetCurrentProcess().WorkingSet64;
                ram = (Convert.ToDouble(lngSessMemory) / 1000 / 1000).ToString("0.00");
            }
 
            // do the grphics stuff
            e.Graphics.Clear(BackColor);
            e.Graphics.DrawString("WorkingSet: " + ram + " MB", Font, new SolidBrush(ForeColor), 0, 0);
        }
 
        /// <summary>
        /// Lets make sure our thread terminates at some point in time.
        /// </summary>
        /// <param name="disposing"></param>
        protected override void Dispose(bool disposing)
        {
            // I know we should wait for the thread to actually funish by using t1.Join() but that would slow down this methob by up to 100ms.
            // If you have any Problems with controls not disposing properly, let me know and send me a solution ;)
            active = false;
            base.Dispose(disposing);
        }
    }
}

class MyClass : IEnumerable<ClassA>, IEnumerable<ClassB> {
...
}

protected override void OnKeyDown(KeyEventArgs e)
{
	/* wird für Pfeiltasten nicht aufgerufen */
	base.OnKeyDown(e);
	if (e.KeyCode == Keys.Up) MoveIndex(-1);
}

protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{
	if (keyData == Keys.Up) MoveIndex(-1);
 
	return base.ProcessCmdKey(ref msg, keyData);
}

bool shift = (keyData & Keys.Shift) != 0;
bool control = (keyData & Keys.Control) != 0;
bool alt = (keyData & Keys.Alt) != 0;
Keys unmodifiedKey = (keyData & Keys.KeyCode);

    public partial class Form1 : Form
    {
        void ForceException()
        {
            while (true)
            {
                Label l = new Label();
                this.Controls.Add(l);
                this.Controls.Clear();
            }
        }
    }

    public partial class Form1 : Form
    {
        void ForceException()
        {
            while (true)
            {
                Label l = new Label();
                this.Controls.Add(l);
                this.Controls.Clear();
                l.Dispose();
            }
        }
    }

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
 
class MyForm : Form
{
	protected override void OnKeyDown(KeyEventArgs e)
	{
		if (e.Modifiers == Keys.Control)
		{
			switch (e.KeyCode)
			{
				case Keys.C:
					tryCopy();
					break;
				case Keys.V:
					tryPaste(); 
					break;
				case Keys.X:
					tryCut();
					break;
				case Keys.Delete:
					tryDelete();
					break;
				case Keys.Right:
					tryMoveNext();
					break;
				case Keys.Left:
					tryMovePrevious();
					break;
			}
		}
		base.OnKeyDown(e);
	}
}

class TextControl : Control
{
	private Brush brush = new SolidBrush(Color.Black);
	private StringFormat stringFormat;
	private Graphics graphics = null;
 
	internal static StringFormat GetStringFormat()
	{
		StringFormat stringFormat = new StringFormat();
		stringFormat.Alignment = StringAlignment.Center;
		stringFormat.LineAlignment = StringAlignment.Near;
		stringFormat.Trimming = StringTrimming.None;
		stringFormat.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.MeasureTrailingSpaces;
		return stringFormat;
	}
 
	public TextControl()
	{
		this.stringFormat = GetStringFormat();
		graphics = this.CreateGraphics();
		this.TabStop = false;
	}
	~TextControl()
	{
		graphics.Dispose();
	}
 
	protected override void OnPaint(PaintEventArgs e)
	{
		base.OnPaint(e);
		RePaint();
	}
	void RePaint()
	{
		Graphics g = this.CreateGraphics();
		g.Clear(this.BackColor);
		g.DrawString(base.Text, base.Font, brush, base.ClientRectangle, stringFormat);
	}
	protected override void OnParentChanged(EventArgs e)
	{
		base.OnParentChanged(e);
		if (this.AutoSize)
		{
			DoAutoSize();
		}
	}
 
	[System.ComponentModel.Browsable(true)]
	[System.ComponentModel.Category("Layout")]
	public override bool AutoSize
	{
		get { return base.AutoSize; }
		set { base.AutoSize = value; }
	}
 
	protected override void OnForeColorChanged(EventArgs e)
	{
		base.OnForeColorChanged(e);
		brush.Dispose();
		brush = new SolidBrush(this.ForeColor);
	}
 
	protected override void OnTextChanged(EventArgs e)
	{
 
		base.OnTextChanged(e);
		if (this.AutoSize && this.Parent != null)
		{
			DoAutoSize();
		}
	}
	void DoAutoSize()
	{
		RectangleF rf = MeasureText(base.Text, graphics, stringFormat, base.Font);
		this.Size = new Size((int)rf.Width, (int)rf.Height);
	}
 
	public static RectangleF MeasureText(string text, Graphics g, StringFormat sf, Font font)
	{
		if (text.Length > 0)
		{
			sf.SetMeasurableCharacterRanges(new CharacterRange[] { new CharacterRange(0, text.Length) });
			Region[] stringRegions = g.MeasureCharacterRanges(text, font, new RectangleF(0, 0, 1000, 100), sf);
			return stringRegions[0].GetBounds(g);
		}
		else
		{
			return new RectangleF(new PointF(0, 0), new SizeF(0, 0));
		}
	}
	public static float getTextLength(string Text, Graphics g, StringFormat sf, Font font)
	{
		RectangleF rf = MeasureText(Text, g, sf, font);
		return rf.Width;
	}
 
	public static int GetMaxTextByLength(string text, int maxLength, Graphics g, StringFormat sf, Font font)
	{
		if (getTextLength(text, g, sf, font) <= maxLength)
		{
			return text.Length;
		}
		string[] parts = text.Split(new char[] { ' ' }, StringSplitOptions.None);
		int len = 0;
		string current = parts[0];
		len = (int)getTextLength(current, g, sf, font);
		if (len > maxLength) return 0;
		int n = 1;
		while (len < maxLength)
		{
			current += " " + parts[n];
			n++;
			len = (int)getTextLength(current, g, sf, font);
		}
		return len;
 
	}
 
	protected override void OnAutoSizeChanged(EventArgs e)
	{
		base.OnAutoSizeChanged(e);
		this.OnTextChanged(e);
	}
 
}