C# – Call class method while instantiating

I don't know how to describe it better so the title might be a bit confusing.

I would like to know if it is possible to instantiate a class by using ... = new MyClass() and to call non static methods of this class instantly while instantiating?

For example something like that:

return new MyClass().SetName("some name");

I guess I have seen something similar like this before but I can't find it.
It is a bit annoying to do something like…

MyClass myclass = new MyClass();
myclass.SetName("some name");
return myclass;

Is there a way to shorten it or to do it like my first example?
(Please do not suggest me to use a property instead of SetName(string) – it is just an example)

Thanks in advance!

Best Answer

Well, if you did have a property, you could use an object initializer:

return new MyClass { Name = "some name" };

If you really, really have to use a method, then the only option is to make the method return the instance again:

public Foo SomeMethod()
{
    // Do some work
    return this;
}

This you can write:

return new Foo().SomeMethod();

As a really extreme way of doing things if you can't change the methods you're calling, you could write an extension method:

public static T ExecuteAndReturn<T>(this T target, Action<T> action)
{
    action(target);
    return target;
}

Then you could write:

return new Foo().ExecuteAndReturn(f => f.SomeMethod());

But that's really foul. It would be far simpler to use a local variable in these cases...

Related Solutions

C# – Create Generic method constraining T to an Enum

Since Enum Type implements IConvertible interface, a better implementation should be something like this:

public T GetEnumFromString<T>(string value) where T : struct, IConvertible
{
   if (!typeof(T).IsEnum) 
   {
      throw new ArgumentException("T must be an enumerated type");
   }

   //...
}

This will still permit passing of value types implementing IConvertible. The chances are rare though.

C# – Virtual member call in a constructor

When an object written in C# is constructed, what happens is that the initializers run in order from the most derived class to the base class, and then constructors run in order from the base class to the most derived class (see Eric Lippert's blog for details as to why this is).

Also in .NET objects do not change type as they are constructed, but start out as the most derived type, with the method table being for the most derived type. This means that virtual method calls always run on the most derived type.

When you combine these two facts you are left with the problem that if you make a virtual method call in a constructor, and it is not the most derived type in its inheritance hierarchy, that it will be called on a class whose constructor has not been run, and therefore may not be in a suitable state to have that method called.

This problem is, of course, mitigated if you mark your class as sealed to ensure that it is the most derived type in the inheritance hierarchy - in which case it is perfectly safe to call the virtual method.

Best Answer

Related Solutions

C# – Create Generic method constraining T to an Enum

C# – Virtual member call in a constructor

Related Topic