C＃中的“对象表达”是否存在于F＃中？

Question

There is one interesting concept in F# language:

Object Expressions (F#)

http://msdn.microsoft.com/en-us/library/dd233237.aspx

Definition:

An object expression is an expression that creates a new instance of a dynamically created, anonymous object type that is based on an existing base type, interface, or set of interfaces.

I wonder, does something similar exist in C#? Or this stuff is only available in F# programming language?

Answer 1

No that does not exist. I think the closest thing is a class that implements those interfaces.

Anonymous types are unable to conform to an interface or derive from anything.

Lambdas and delegates offer functions as variables.

The documentation for Object Expressions state this which makes it sound like its a language convenience.

You use object expressions when you want to avoid the extra code and overhead that is required to create a new, named type. If you use object expressions to minimize the number of types created in a program, you can reduce the number of lines of code and prevent the unnecessary proliferation of types. Instead of creating many types just to handle specific situations, you can use an object expression that customizes an existing type or provides an appropriate implementation of an interface for the specific case at hand.

You could fake it (although you couldn't constrain it to an interface) with something like this

var foo = new { square = new Func<int, int>(x => x * x) };

Answer 2

A pattern that I use is to create a bunch of "ad-hoc" classes that implement an interface that I instantiate with a delegate (usually a closure):

For instance:

public sealed class AdHocEquatable<T> : IEquatable<T>
{
    readonly Func<T, bool> equals;

    public AdHocEquatable(Func<T, bool> eq)
    {
        equals = eq;
    }

    public bool Equals(T other)
    {
        return equals(other);
    }
}

Then use like so:

var eq = new AdHocEquatable<Person>(p => p.ID == some_person_ref.ID);

In my experience, object expressions are needed for only a handful of interfaces (usually from the the BCL).

See here for more examples.

Answer 3

I think the closest you're going to get is a delegate (comments are taken from the description of Object Expression that you gave):

public delegate int MyDelegate(int input);
// ...is based on an existing base type, interface, or set of interfaces

Then somewhere

MyDelegate myDelegate = (i) => i * 2;
// An object expression is an expression that creates a new instance of a dynamically created, anonymous object type

myDelegate(1); // returns 2

But this only really deals with signature. Methods, properties - I can't think of anything that does those at the moment.

---

Although...

One important thing to remember is that you can have F# and C# in the same solution, so you can always write the bulk of your application in C# and do the fiddly bits which can't be done in C# (like this) with F#.