Are there any official ways to write an Immediately Invoked Function Expression?

For real code make it a function... For entertainment purposes C# equivalent of JavaScript IIFE is more direct than Select:

var myObject = new MyClass()
{
   x =((Func<int>)(() => {return 2;}))(),...

Here is what my coworker came up with:

var myObject = new { 
    x = new Func<int>(() => {return 2;})() 
};

Note that this is based Alexei's answer.

It can be tricky to get an implicitly typed delegate, but it works if you write your own static methods for it.

You can create an implicitly typed function like this:

public static class Func {
   public static Func<T> Create<T>(
      Func<T> func
   ) =>
     func;       
}

...

var x = Func.Create(() => "result")();
Assert.AreEqual("result", x);

var x = Func.Create(() => {
   // complex logic to create a value
})();

And you can also write one to immediately evaluate a function and then you don't need to do it manually:

public static class Func {
   public static T Eval<T>(
      Func<T> func
   ) =>
      func();
}

...

var x = Func.Eval(() => 5);
Assert.AreEqual(5, x);

While certainly not "official", you could use optional named parameters in the constructor or a separate factory/builder method:

public class MyClass
{
   public string x { get; private set; }

   public MyClass(Func<string> x = null)
    {
        if (x != null)
            this.x = x();
    }
}

with usage like:

var myClass = new MyClass(
        x: () =>
            {
                //Do stuff..
                if (2 + 2 == 5)
                    return "I like cookies";
                else if (2 + 2 == 3)
                    return "I like muffins";
                //More conditions...
                else
                    return "I'm a bitter old man";
            }
    );

    Console.WriteLine(myClass.x); //"I'm a bitter old man"

So, it's not the exact syntax you were asking for, but pretty close and skips the LINQ weirdness.

That said, I don't like it. Just offering it as food for thought. :)

EDIT: I figured I'd add a factory method style since it's plausible you're using this on a class that you can't (or don't want to) change its constructor:

public static class MyFactory
{
    public static MyClass CreateMyClass(Func<string> x = null)
    {
        var myClass = new MyClass()

        if (x != null)
                myClass.x = x();

        return myClass;
    }
}

With similar usage (just calling a factory method instead):

var myClass = MyFactory.CreateMyClass(
    x: () =>
        {
            //Do stuff..
            if (2 + 2 == 5)
                return "I like cookies";
            else if (2 + 2 == 3)
                return "I like muffins";
            //More conditions...
            else
                return "I'm a bitter old man";
        }
);

EDIT: And hey, while we're at it. Why not go off the deep end and do it with a separate builder and abuse implicit operators!

public class MyClassBuilder
{
    public Func<string> x { get; set; }

    public static implicit operator MyClass(MyClassBuilder builder)
    {
        var myClass = new MyClass();

        if (builder.x != null)
            myClass.x = builder.x();

        return myClass;
    }
}

With usage like:

MyClass myClass = new MyClassBuilder
{
    x = () =>
        {
            //Do stuff..
            if (2 + 2 == 5)
                return "I like cookies";
            else if (2 + 2 == 3)
                return "I like muffins";
            //More conditions...
            else
                return "I'm a bitter old man";
        }
};

So now the syntax is identical, except you have to explicitly type your instance instead of using var.

Maybe not quite answering the question but ... one reason I wanted IIFE in C# was to give better meaning to a function being called on an object. In this example I wanted to give meaning as to what the 'Click' method does in a particular context within test code (and I do not like comments).

Before ...

lastLine.Click(); //click to begin editing line

After ...

Action<IWebElement> clickToStartEditing = line => line.Click();
clickToStartEditing(lastLine);

Later I discovered I could simply create a new method with another name ...

Action clickToStartEditing = lastLine.Click;
clickToStartEditing(lastLine);

Finally simply naming the variable in a better way can better solve the issue (for me)

lastLineForEditing.Click();

This solved an IIFE issue for me, to give meaning to the method name.

You can do:

global using static System.IIFE;

namespace System {
  public static class IIFE {
    public static T Scope<T>(Func<T> f) => f();
  }
}

And then:

var x = Scope(() => {
  var t1 = getVal();
  vat t2 = getVal2();
  return t1+t2;
});

The advantage of IIFE here is that t1 and t2 do not pollute the outside scope