with(obj1, obj2){
    .member1 = .member2 * 10;
}

Expression-bodied function members allow methods, properties and other kinds of function members to have bodies that are expressions instead of statement blocks, just like with lambda expressions.

Methods as well as user-defined operators and conversions can be given an expression body by use of the “lambda arrow”:

public Point Move(int dx, int dy) => new Point(x + dx, y + dy); 
public static Complex operator +(Complex a, Complex b) => a.Add(b); 
public static implicit operator string(Person p) => "\{p.First} \{p.Last}";

The effect is exactly the same as if the methods had had a block body with a single return statement.

For void returning methods – and Task returning async methods – the arrow syntax still applies, but the expression following the arrow must be a statement expression (just as is the rule for lambdas):

public void Print() => Console.WriteLine(First + " " + Last);

Properties and indexers can have getters and settersgetter-only properties and indexers can have an expression body:

public string Name => First + " " + Last; 
public Customer this[long id] => store.LookupCustomer(id);

S>var a = Eval(() => { using (var x = GetX()) return x.y; });
S>

object x = Foo();
if(
    x is A
    &&
    {
        //Компилятор сам переносит объявление куда нужно
        #using(var a, SCOPES_OUTER) = 5; 
        return true;
    }
)
{
    Console.WriteLine("{0}", a);
}

#using(var a, INFERENCE_LAZY);
a = 5;

public int F(int a) =>
(
    Console.WriteLine(a);
    a + 1
)

public int F(int a) =>
(
    Console.WriteLine(a);
    a + 1
)
// и
public int F(int a)
{
    Console.WriteLine(a);
    return a + 1;
}

Func<int, int> x = i => { ... };

B>with(obj1, obj2){
B>    .member1 = .member2 * 10;
B>}
B>

using System.Coinsole;
class Prog
{
  static void Main()
  {
    var obj1 = new Obj1();
    using obj1;

    WriteLine(member1);
  }
}

B> чем вот эта помойка, которую они сделают из функций и названий классов. Почему проектировщики такие индусы?? Неужто НИЧЕГО не кликает в башке, когда явно совесть подзуживает?

Note: The Preview will only import members of static classes. We have since changed the design in several ways:
1. The syntax will be more different from current using clauses – it will have the keywords “using static”.
2. Members of non-static types can be imported, including structs and enums
3. Members of VB modules and F# top level functions can be imported
4. Extension methods will not be imported into top-level scope; instead they will show up as extension methods. This gives a way to import extension methods from just a single class, something which wasn’t possible before.

public Point Move(int dx, int dy) => new Point(x + dx, y + dy); 
public static Complex operator +(Complex a, Complex b) => a.Add(b); 
public static implicit operator string(Person p) => "\{p.First} \{p.Last}"; // в следующем релизе будет $"{p.First} {p.Last}"

try
{
    try
    {
        Run();
    }
    catch (Exception1 err1)
    {
        ...
    }
}
catch (Exception2 err2)
{
    ...
}

try {
  // Что-то делаем на более низком уровне
} catch(Exception ex) {
  Log(ex);
  throw;
}

NET Core is very much in the same family as the .NET Framework. For example, the SIMD and Immutable Collections NuGet packages work on both the .NET Framework and .NET Core, by design. You can expect that most aspects of your development experience will be unchanged when targeting .NET Core.
...

ASP.NET 5 is the first workload that has adopted .NET Core. ASP.NET 5 runs on both the .NET Framework and .NET Core.
...

.NET Core has two major components. It includes a small runtime that is built from the same codebase as the .NET Framework CLR. The .NET Core runtime includes the same GC and JIT (RyuJIT), but doesn’t include features like Application Domains or Code Access Security. The runtime is delivered via NuGet, as part of the ASP.NET 5 core package.

.NET Core also includes the base class libraries. These libraries are largely the same code as the .NET Framework class libraries, but have been factored (removal of dependencies) to enable us to ship a smaller set of libraries. These libraries are shipped as System.* NuGet packages on NuGet.org.

S>Не, серьёзно, зачем портить язык, добавляя 100500й способ сделать то же самое, только на пару символов короче? Не, для write-only кода, который никогда читать не будут, а сразу выбросят и перепишут, оно может и удобно.

S>public int F(int a) =>
S>(
S>    Console.WriteLine(a);
S>    a + 1
S>)
S>// и
S>public int F(int a)
S>{
S>    Console.WriteLine(a);
S>    return a + 1;
S>}
S>

S>?

S>Func<int, int> x = i => { ... };
S>

int a = 
 lock(dataInstance) 
 { 
 return dataInstance.Member1; 
 };

int a = (Func<int>)(
    () => {
    lock(dataInstance) 
     { 
     return dataInstance.Member1; 
     };
    })();

var a = Eval(() => { using (var x = GetX()) return x.y; });

var a = λ(() => { using (var x = GetX()) return x.y; });

int a;
lock(dataInstance) 
{ 
  a = dataInstance.Member1; 
};

A>int a = (Func<int>)(
A>    () => {
A>    lock(dataInstance) 
A>     { 
A>     return dataInstance.Member1; 
A>     };
A>    })();
A>

var a = x => x + 1;
var b = a(1); // выводит Func<int, int> a

X>>try {
X>>  // Что-то делаем на более низком уровне
X>>} catch(Exception ex) {
X>>  Log(ex);
X>>  throw;
X>>}

using System;
using System.Console;
using System.Diagnostics;

static class Program
{
  static void Main() {
    try { Layer1_Catch(); } catch { }
    try { Layer1_Filter(); } catch { }
  }

  static void Do() {
    throw new Exception();
  }

  static bool Log(Exception ex) {
    WriteLine(ex);
    return false;
  }

  static void Layer1_Catch() {
    try {
      Layer2_Catch();
    } catch(Exception ex) {
      Log(ex);
      throw;
    }
  }

  static void Layer2_Catch() {
    try {
      Layer3_Catch();
    } catch(Exception ex) {
      Log(ex);
      throw;
    }
  }

  static void Layer3_Catch() {
    try {
      Do();
    } catch(Exception ex) {
      Log(ex);
      throw;
    }
  }

  static void Layer1_Filter() {
    try {
      Layer2_Filter();
    } catch(Exception ex) if(Log(ex)) {
      Debug.Fail(ex.ToString());
      throw;
    }
  }

  static void Layer2_Filter() {
    try {
      Layer3_Filter();
    } catch(Exception ex) if(Log(ex)) {
      Debug.Fail(ex.ToString());
      throw;
    }
  }

  static void Layer3_Filter() {
    try {
      Do();
    } catch(Exception ex) if(Log(ex)) {
      Debug.Fail(ex.ToString());
      throw;
    }
  }
}

More libraries. Consider the subset we have today a down-payment on what is to come. Our goal is to open source the entire .NET Core library stack by Build 2015.