在 C# 中使用默认构造函数初始化只读成员变量

Question

I have a simple Factory implementation in my code. I'm aiming to have the constructed objects retain a reference to the factory that created them, so I have them wired up similar to this:

public class Factory {

    public T CreateObject<T>() where T : Foo, new() 
    {
        return new T() {
            parent = this
        };
    }
}

public class Foo {

    internal Factory parent;
    internal Foo() { }
}

This works as it reads, but I've been thinking that I probably want that parent variable so that it cannot be changed once it's set by the factory. However, if I declare it like internal readonly Factory parent; , then the factory can't set it's value anymore on construction.

I'd normally remedy this by providing a parametered constructor, but that kills the generic implementation, because AFAIK where T: new() implies a parameter-less constructor.

I may just be missing a few cogs with my C# chops, but what would be the best way to go about implementing something like this? (Or would it be better to just ditch the readonly and trust that the code won't be modifying parent in an unsafe manner --- NullReferenceException s come to mind ---?)

Answer 1

You could use reflection to set the field, this will work regardless of the readonly modifier:

public class Factory
{
    public T CreateObject<T>() where T : Foo, new()
    {
        T t = new T();
        t.GetType()
         .GetField("parent", BindingFlags.NonPublic | BindingFlags.Instance)
         .SetValue(t, this);
        return t;
    }
}

Answer 2

I do not think you can obtain exactly what you want, but you could make a property that is only assignable once and let the factory overwrite it. But I guess the user can always force an override with new CreatingFactory , but I think this makes it difficult and at least clearly shows your intention.

You could do something like below.

    class Foo
    {
        private Factory factory;

        public Factory CreatingFactory
        {
            get { return factory; }
            set
            {
                if (factory != null)
                {
                    throw new InvalidOperationException("the factory can only be set once");
                }
                factory = value;
            }
        }
    }

    class Factory
    {
        public T Create<T>()
            where T : Foo, new()
        {
            T t = new T()
            {
                CreatingFactory = this
            };
            return t;
        }
    }

After having created it i searched and found an answer that is probably better than mine: Is there a way of setting a property once only in C#

Answer 3

I'm not sure if this is exactly what you want, but I came up with an approach that replaces your generic type parameter with a Func that shows how to construct the Foo object and allows you to set the parent in the constructor.

public class Factory {
    private Func<Factory, Foo> creator;

    public Factory(Func<Factory, Foo> creator) {
        this.creator = creator;
    }

    public Foo CreateObject()
    {
        return this.creator(this);
    }
}

public class Foo {
    internal readonly Factory parent;
    internal Foo(Factory parent) {
        this.parent = parent;
    }
}

and then

public void Main() {
    Factory myfactory = new Factory(fact => new Foo(fact));
    Foo myfoo = myfactory.CreateObject();
}