Func<int, int> invoker = ...;
 
var ar = invoker.BeginInvoke(42, ar =>
    {
        //We need to retrieve the delegate and the state:
        AsyncResult realAR = (AsyncResult)ar;
        int typedState = (int)ar.AsyncState;
        var invoker = (Func<int, int>)realAR.AsyncDelegate;
        //End the operation and print the result:
        int result = invoker.EndInvoke(ar);

var conn = new SqlConnection(CONN_STR);
var cmd = new SqlCommand("Select * from Employee", conn);
conn.Open();
cmd.BeginExecuteReader(ar =>
    {
        int affected = cmd.EndExecuteNonQuery(ar);
        cmd.Dispose();
        conn.Dispose();
    }, null);

public static class TypeEx
{
    public static string GetFriendlyName(this Type t)
    {
        using (var provider = new CSharpCodeProvider())
        {
            var typeRef = new CodeTypeReference(t);
            return provider.GetTypeOutput(typeRef);
        }
    }

// compile in release mode
bool stop = false;
bool toggle = false;
ThreadPool.QueueUserWorkItem(delegate
{
    while (!stop)
    {
        toggle = !toggle;
        //Thread.MemoryBarrier();
    }

private static WeakReference _weak;
const int ALLOCATION = 1024 * 100;
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
static void Main(string[] args)
{
    
    int count = 0;
    int times = 0;
    int i;
    string x = null;

class Program
{
    static void Main(string[] args)
    {
        bool isComplete = false;
        var t = Task.Factory.StartNew(() =>
        {
            bool toggle = false;
            while (!isComplete) // read the cached value
            {

static void Main(string[] args)
{
    var xs = Observable.Interval(TimeSpan.FromSeconds(0.5)).Publish().RefCount();
    var zs = xs.Buffer(xs.Sample(TimeSpan.FromSeconds(1.5)), x => xs.Skip(5).Take(1));
 
    zs.Subscribe(item => Console.WriteLine("{0} - {1}", item.First(), item.Last()));
    Console.ReadKey();
    Task<WebResponse>[] results = GetesourcesAsync(
        new []
        {

var xs = Observable.Interval(TimeSpan.FromSeconds(0.5)).Publish().RefCount();
var zs = xs.Buffer(xs.Sample(TimeSpan.FromSeconds(1.5)), x => xs.Skip(5).Take(1));

<system.diagnostics>
      <sources>
        <source name="TraceSourceApp"
          switchName="sourceSwitch"
          switchType="System.Diagnostics.SourceSwitch">
          <listeners>
            <add name="console"
              type="System.Diagnostics.ConsoleTraceListener">
              <filter type="System.Diagnostics.EventTypeFilter"
                initializeData="Warning"/>

private static TraceSource mySource =
            new TraceSource("TraceSourceApp");
static void Main(string[] args)
{
    mySource.TraceEvent(TraceEventType.Error, 1, "Error message.");
 
    // Change the event type for which tracing occurs.
    // The console trace listener must be specified 
    // in the configuration file. First, save the original
    // settings from the configuration file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reactive.Linq;
using System.Reactive.Concurrency;
using System.Reactive.Disposables;
using System.Threading.Tasks;
 
namespace Sela.Samples

 <!-- find Microsoft.Common.targets under C:\Windows\Microsoft.NET\Framework\ -->
<Project DefaultTargets="Build" InitialTargets="_CheckForInvalidConfigurationAndPlatform"
         xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 
    <PropertyGroup>
        <UseVSHostingProcess>false</UseVSHostingProcess>
    </PropertyGroup>
 
    <!-- ... -->
</Project>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
 
namespace StaticMEF
{
    class Program

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
 
namespace TplKeepAlive
{
    class Program

public static class TaskCast
{
    public static explicit operator Task<T>(T sr);
    public static Task<T> operator +(T i1, T i2);
    public static Task<T> operator -(T i1, T i2);
    public static Task<T> operator *(T i1, T i2);
    public static Task<T> operator /(T i1, T i2);
    public static Task<T> operator %(T i1, T i2);
    public static Task<T> operator -(T i);
    public static Task<bool> operator ==(T i1, T i2);

layout="${longdate} ${logger} ${level} ${message} ${exception:format=Type,Message,StackTrace:separator=[br]}"

if (Environment.UserInteractive)
{
    service.Start(args);
 
    Console.WriteLine("Press any key to stop program");
 
    Console.ReadKey();
    service.Stop();
}
else

const string PC_CATEGORY = "_Tmp";
const string PC_NAME = "_Tmp";
 
if (!PerformanceCounterCategory.Exists(PC_CATEGORY))
{
    CounterCreationDataCollection data = new CounterCreationDataCollection();
    CounterCreationData counter = new CounterCreationData(PC_NAME, "", PerformanceCounterType.NumberOfItems32);
    var pcCategory = PerformanceCounterCategory.Create(PC_CATEGORY, "", PerformanceCounterCategoryType.MultiInstance, data);
 
    data.Add(counter);

<Border BorderBrush="Black" BorderThickness="1.5" CornerRadius="12">
    <Border.Background>
        <ImageBrush>
            <ImageBrush.ImageSource>
                <BitmapImage UriSource="c:\temp\happy.jpg" />
            </ImageBrush.ImageSource>
        </ImageBrush>
    </Border.Background>
</Border>

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;
 
namespace Tpl.Samples
{
    public enum MyEnum
    {
        None = 0,
        A = 1,