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> {
...
}

[zoomimage:src=screenshots/lueckentext-mit-hilfe.png, w=400, zw=800, float=right, alt=Lückentext zu den unregelmäßigen Verben]

function json2array($sJson) {
	$oJson = new Services_JSON ( SERVICES_JSON_LOOSE_TYPE );
	return $oJson->decode ( $sJson );
}

function json2array($sJson) {
	return json_decode($sJson, true);
}