如何基于是否将函数分配给变量来修改函数的行为？

Question

如标题中所示.

我知道这在其他语言中是可行的 - 它是在C#中吗？

如果问题标题不清楚,我想要做的事情(如下):

MyClass exampleObject1 = new MyClass(...)

exampleObject1.sort() //sort method detects that value is not being assigned and performs sort in place.

MyClass exampleObject2 = exampleObject1.sort() //method detects assignment and returns new sorted object leaving original untouched.

这是不可能诉诸魔法的东西？如果有可能,但是以某种令人讨厌的方式,这是什么方式？

编辑:对于那些想要看到你可以做到这一点的例子(在python中):这里.请注意,我告诉它它并不总是有效的问题 - 但这仅仅与我回答问题时的方式有关.现在我对检查有了更多了解,如果在任何地方分配,您可以从堆栈中获取所需的所有信息.

Answer 1

当然,你肯定不应该这样做,但是因为如果可以为好奇心做,OP会更感兴趣,那么这里有一段代码来演示这个功能:

class SomeWeirdClass
{
    private bool sortApplied = false;
    private List<int> elements;

    public IList<int> Elements
    {
        get
        {
            if(sortApplied)
            {
                elements.Sort();
                sortApplied = false;
            }

            return elements;
        }
    }

    public SomeWeirdClass(IEnumerable<int> elements)
    {
        this.elements = elements.ToList();
    }

    public SortedWeirdClass Sort()
    {
        sortApplied = true;

        return new SortedWeirdClass(this);
    }

    public class SortedWeirdClass
    {
        SomeWeirdClass parent;

        internal SortedWeirdClass(SomeWeirdClass parent)
        {
            this.parent = parent;
        }

        public static implicit operator SomeWeirdClass(SortedWeirdClass sorted)
        {
            sorted.parent.sortApplied = false;

            var elementCopy = new int[sorted.parent.elements.Count];
            sorted.parent.elements.CopyTo(elementCopy);

            var result = new SomeWeirdClass(elementCopy);
            result.Sort();

            return result;
        }
    }    
}

现在在程序中使用它:

static void Main(string[] args)
{
    SomeWeirdClass original = new SomeWeirdClass(new[] { 5, 1, 4, 3, 2 });

    Console.WriteLine("Original Data: ");
    Console.WriteLine(string.Join(" ", original.Elements));

    SomeWeirdClass copy = original.Sort();

    Console.WriteLine("Original Data after Sort and Assignment: ");
    Console.WriteLine(string.Join(" ", original.Elements));

    Console.WriteLine("Sorted Copy:");
    Console.WriteLine(string.Join(" ", copy.Elements));

    original.Sort();

    Console.WriteLine("Original Data after Sort without Assignment: ");
    Console.WriteLine(string.Join(" ", original.Elements));
}

该方案产出:

Original Data:
5 1 4 3 2
Original Data after Sort and Assignment:
5 1 4 3 2
Sorted Copy:
1 2 3 4 5
Original Data after Sort without Assignment:
1 2 3 4 5

这里的黑客是排序实际上创建了一个包装原始的临时类.除非通过赋值将结果隐式转换为原始类型,否则排序效果将应用于原始数据集.如果进行了分配,则取消排序,并为新变量进行复制.