In C#, the least code constructs required, to perform actions on an object and return it, in one block? Length of identifiers not important

Question

What is the shortest possible way of coding in C# where an action is performed on an object (Properties updated or Methods called etc) and is returned in a code block? Note, this will be used for small code actions, for example updating 1 or 3 properties.

Is there some way of using anonymous functions, Lambda, Action etc to make the code as small as possible? A kind of Fluent style. This will be mainly used as part of larger Lambdas.

The length of identifier names is not important, the shortest code construct is. Example here not really significant, only that ANY object needs to have 1 or 2 properties updated before being passed into to another Method call.

Example I wish to do this:

        public class Test2
        {
            void Display(Person p) => Console.Write(p.Name);

            //intentionally this will not compile, what is the least code to update p and return p.
            void ToAdultAndDisplay_XX(Person p){Display(p.Age = 21);}

            //using extension method
            void ToAdultAndDisplay_1(Person p) => Display(p.ActionOnSelf(i => i.Age = 21));

            //standard
            void ToAdultAndDisplay_2(Person p)
            {
                p.Age = 21;
                Display(p);
            }
        }

Note the Person object needs to be updated and returned, so that it can be passed into a method, all inline.

The following example below makes use of an Extension method ActionOnSelf that simply allows any object (in this example Person) to update itself via a Lambda.

void ToAdultAndDisplay_1(Person p) => Display(p.ActionOnSelf(i => i.Age = 21));

Questions:

1. Does the code using ActionOnSelf use less code constructs vs any other code block, especially if updating a single property?

2. Are there significant performance penalties using ActionOnSelf?

3. Any alternative ways to perform this with the shortest amount of code?

The extension method is shown below:

using System;
namespace DevTestPlayground.ForStackOverflowExamples
{
    public static class LambdaExtensions
    {
        public static T ActionOnSelf<T>(this T o, Action<T> action)
        {
            action.Invoke(o);
            return o;
        }

        public static T ActionOnSelf<T>(this T o, params Action<T>[] actions)
        {
            foreach (Action<T> f in actions) f.Invoke(o);
            return o;
        }
    }
}

Answer 1

The wave of comments saying exactly the same thing should give you a clue here. ActionOnSelf is not very nice code. It certainly doesn't 'look cleaner'. As everyone is saying good code isn't necessarily short. Good code does what it's supposed to do efficiently and is easy to understand. C# already has good syntax for doing basic operations on objects, you don't need to extend the language to do them. I'd argue the code below is better than any of your options.

public class PersonMoodHandler
{
    public Person MakeHappy(Person person)
    {
        person.HappinessLevel = 10;
        person.Comments = "Happy Now";
        return person;          
    }
}

public class Test
{
    public void DoStuffWithPerson()
    {
        Person person = new Person { Name = "Joe" };
        PersonMoodHandler personMoodHandler = new PersonMoodHandler();
        WritePersonComments(personMoodHandler.MakeHappy(person));
     }
}