Something like this:
var myObject = new MyClass() { x = " ".Select(y => { //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"; }) };
I realize Select is not intended to be used this way. But yeah, what are some other ways to do the same thing?
An Immediate-Invoked Function Expression (IIFE) is a function that is executed instantly after it's defined. This pattern has been used to alias global variables, make variables and functions private and to ensure asynchronous code in loops are executed correctly.
An IIFE (Immediately Invoked Function Expression) is a JavaScript function that runs as soon as it is defined.
The following expression is called an immediately invoked function expression (IIFE) because the function is created as an expression and executed immediately: (function(a,b){ return a + b; })(10,20); Code language: JavaScript (javascript) This is the general syntax for defining an IIFE: (function(){ //...
Function expressions are evaluated during execution. So you can't execute function declarations immediately because even variables don't exist yet and other code that the function might depend on hasn't been executed either.
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;}))(),...
I'm surprised no one's mentioned this yet, but you could use the Lazy<T>
class:
var myObject = new MyClass() { x = new Lazy<string>(() => { //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"; }).Value // <-- Evaluate the function here };
Alternatively, if you want to avoid having to specify the return type anywhere (as you do with new Lazy<string>
because constructors do not support type inference), you can implement a simple generic method like this:
public static T Eval<T>(Func<T> func) { return func(); }
And then you can call like this:
var myObject = new MyClass() { x = Eval(() => { //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"; }) };
Update: C#7 introduces local functions. These are not really IFFEs, but they may solve a variety of related issues. For example:
var myObject = new MyClass() { x = GetX() }; string GetX() { //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"; }
The key here is that GetX
can be declared within the same method as myObject
share the same scope as it.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With