blocks|key|52395|text|很抱歉成为那些自己回答问题的讨厌的人中的一员，但我想通了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|52396|public+class+TestLog
{
++++private+Func<string,+ILog>+logFactory;

++++public+TestLog(Func<string,+ILog>+logFactory)
++++{
+++++++++this.logFactory+=+logFactory;
++++}
++++public+ILog+CreateLog(string+name)
++++{
++++++++return+logFactory(name);
++++}
}

Container.RegisterType<Func<string,+ILog>>(
+++++new+InjectionFactory(c+=>+
++++++++new+Func<string,+ILog>(name+=>+new+Log(name))
+++++));

TestLog+test+=+Container.Resolve<TestLog>();
ILog+log+=+test.CreateLog("Test+Name");|code-block|syntax|javascript|52397|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Sorry to be one of those annoying people who answer their own questions but I figured it out.

<pre><code>public class TestLog
{
 private Func&lt;string, ILog&gt; logFactory;

 public TestLog(Func&lt;string, ILog&gt; logFactory)
 {
 this.logFactory = logFactory;
 }
 public ILog CreateLog(string name)
 {
 return logFactory(name);
 }
}

Container.RegisterType&lt;Func&lt;string, ILog&gt;&gt;(
 new InjectionFactory(c =&gt; 
 new Func&lt;string, ILog&gt;(name =&gt; new Log(name))
 ));

TestLog test = Container.Resolve&lt;TestLog&gt;();
ILog log = test.CreateLog("Test Name");
</code></pre>

blocks|key|53361|text|如果您正在寻找一个完全类型化的工厂接口(例如，允许使用XML文档和参数名称)，您可以使用我创建的NuGet+package，您只需为工厂定义一个接口，然后将其与您想要实例化的具体类型相关联，就可以利用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|53362|代码位于GitHub中：https://github.com/PombeirP/FactoryGenerator|53363|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.pedropombeiro.com/typed-factories-a-la-castle-windsor-for-unity/|1|https://github.com/PombeirP/FactoryGenerator^0|1C|D|0|0|C|18|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

In case you're looking for a fully typed factory interface (allowing for XML documentation and parameter names, for instance), you could use a <a href="http://blog.pedropombeiro.com/typed-factories-a-la-castle-windsor-for-unity/" rel="nofollow">NuGet package</a> I created, which you can leverage simply by defining an interface for the factory, and then associating it with the concrete type you want to instantiate.

Code lives in GitHub: <a href="https://github.com/PombeirP/FactoryGenerator" rel="nofollow">https://github.com/PombeirP/FactoryGenerator</a>

blocks|key|51995|text|@TheCodeKing的答案运行良好，但在大多数情况下(可能是所有？)案例可以缩短为以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|51996|Container.RegisterInstance<Func<string,+ILog>>(name+=>+new+Log(name));|code-block|syntax|javascript|51997|(请注意，我使用的是RegisterInstance()，而不是RegisterType()__)|offset|length|style|CODE|51998|由于Func<>实现已经是一种工厂，因此通常不需要将其包装在InjectionFactory中。它只能确保Func<string,+ILog>的每个分辨率都是一个新实例，而我真的想不出有哪种场景需要这样做。|51999|entityMap^0|0|0|A|I|W|E|0|2|6|U|G|1H|I|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@$I|Y|J|Z|K|L]|$I|10|J|11|K|L]|$I|12|J|13|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$]]

The answer by @TheCodeKing works fine, but in most (possibly all?) cases could be shortened to the following:

<pre><code>Container.RegisterInstance&lt;Func&lt;string, ILog&gt;&gt;(name =&gt; new Log(name));
</code></pre>

(note that I'm using <code>RegisterInstance()</code> instead of <code>RegisterType()</code>)

Since the <code>Func&lt;&gt;</code> implementation is already a kind of factory there's usually no need to wrap it in a <code>InjectionFactory</code>. It only ensures that each resolution of the <code>Func&lt;string, ILog&gt;</code> is a new instance, and I can't really think of a scenario that requires this.

blocks|key|2536498|text|Autofac有parameterized+instantiation来处理需要带参数的自动工厂的场景。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2536499|虽然Unity不支持开箱即用，但可以实现一个扩展，它将以类似于Autofac的方式工作。|2536500|一个无耻的插件:我实现了这样一个扩展--+Parameterized+Auto+Factory。|2536501|它的使用方法与下面类似：|2536502|public+class+Log
{
++++public+void+Info(string+info)+{+/*+...+*/+}
++++public+void+Warn(string+info)+{+/*+...+*/+}
++++public+void+Error(string+info)+{+/*+...+*/+}
}

public+class+LogConsumer
{
++++private+readonly+Log+_log;
++++private+readonly+string+_consumerName;

++++public+LogConsumer(Log+log,+string+consumerName)
++++{
++++++++_log+=+log;
++++++++_consumerName+=+consumerName;
++++}

++++public+void+Frobnicate()
++++++++=>+_log.Info($"{nameof(Frobnicate)}+called+on+{_consumerName}");
}

var+container+=+new+UnityContainer()
++++.AddNewExtension<UnityParameterizedAutoFactoryExtension>();

var+logConsumerFactory+=+container.Resolve<Func<string,+LogConsumer>>();
var+gadget+=+logConsumerFactory("Gadget");
gadget.Frobnicate();|code-block|syntax|javascript|2536503|请注意：|2536504|2536505|Func<string,+LogConsumer>是从container解析的，但是它没有在任何地方注册--它是自动生成的。|unordered-list-item|style|CODE|2536506|Func<string,+LogConsumer>仅向LogConsumer的构造函数提供string+consumerName参数。因此，将从容器中解析Log+log参数。如果自动工厂函数看起来像此Func<string,+Log,+LogConsumer>，则LogConsumer的构造函数的所有参数都将通过自动工厂提供。|2536507|2536508|基本上，扩展的工作方式是这样的：|2536509|2536510|它在Unity的pipeline.|ordered-list-item|2536511|This策略中注册一个所谓的BuilderStrategy。|2536512|如果要构建的类型尚未显式注册，并且是带参数的Func，则扩展会截获实例构建过程。|2536513|现在我们只需要动态创建给定类型的Func，它从容器中解析其返回类型，并将D30的参数作为集合传递给D32方法。H233G234|2536514|2536515|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.autofac.org/|1|http://docs.autofac.org/en/latest/resolve/relationships.html#parameterized-instantiation-func-x-y-b|2|https://github.com/unitycontainer/unity|3|https://github.com/mykolav/unitycontainer-param-autofactory^0|0|7|0|8|R|1|0|2|5|2|0|L|Q|3|0|0|0|0|0|0|P|R|9|0|0|P|R|B|19|J|25|7|2S|U|3O|B|0|0|0|0|0|E|F|0|M|4|0|G|4|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@$A|1R|B|1S|1|1T]|$A|1U|B|1V|1|1W]]|C|$]]|$1|D|3|E|5|6|7|1X|8|@]|9|@$A|1Y|B|1Z|1|20]]|C|$]]|$1|F|3|G|5|6|7|21|8|@]|9|@$A|22|B|23|1|24]]|C|$]]|$1|H|3|I|5|6|7|25|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|26|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|27|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|28|8|@]|9|@]|C|$]]|$1|R|3|S|5|T|7|29|8|@$A|2A|B|2B|U|V]|$A|2C|B|2D|U|V]]|9|@]|C|$]]|$1|W|3|X|5|T|7|2E|8|@$A|2F|B|2G|U|V]|$A|2H|B|2I|U|V]|$A|2J|B|2K|U|V]|$A|2L|B|2M|U|V]|$A|2N|B|2O|U|V]|$A|2P|B|2Q|U|V]]|9|@]|C|$]]|$1|Y|3|-4|5|6|7|2R|8|@]|9|@]|C|$]]|$1|Z|3|10|5|6|7|2S|8|@]|9|@]|C|$]]|$1|11|3|-4|5|6|7|2T|8|@]|9|@]|C|$]]|$1|12|3|13|5|14|7|2U|8|@]|9|@]|C|$]]|$1|15|3|16|5|14|7|2V|8|@$A|2W|B|2X|U|V]]|9|@]|C|$]]|$1|17|3|18|5|14|7|2Y|8|@$A|2Z|B|30|U|V]]|9|@]|C|$]]|$1|19|3|1A|5|14|7|31|8|@$A|32|B|33|U|V]]|9|@]|C|$]]|$1|1B|3|-4|5|6|7|34|8|@]|9|@]|C|$]]|$1|1C|3|-4|5|6|7|35|8|@]|9|@]|C|$]]]|1D|$1E|$5|1F|1G|1H|C|$1I|1J]]|1K|$5|1F|1G|1H|C|$1I|1L]]|1M|$5|1F|1G|1H|C|$1I|1N]]|1O|$5|1F|1G|1H|C|$1I|1P]]]]

<a href="http://docs.autofac.org" rel="nofollow noreferrer">Autofac</a> has <a href="http://docs.autofac.org/en/latest/resolve/relationships.html#parameterized-instantiation-func-x-y-b" rel="nofollow noreferrer">parameterized instantiation</a> to handle scenarios which need an auto-factory with parameters. 

While <a href="https://github.com/unitycontainer/unity" rel="nofollow noreferrer">Unity</a> doesn't support this out of the box, it's possible to implement an extension which will work in a way similar to Autofac's. 

A shameless plug: I implemented such an extension -- <a href="https://github.com/mykolav/unitycontainer-param-autofactory" rel="nofollow noreferrer">Parameterized Auto Factory</a>. 
It can be used in a way similar to this: 

<pre><code>public class Log
{
 public void Info(string info) { /* ... */ }
 public void Warn(string info) { /* ... */ }
 public void Error(string info) { /* ... */ }
}

public class LogConsumer
{
 private readonly Log _log;
 private readonly string _consumerName;

 public LogConsumer(Log log, string consumerName)
 {
 _log = log;
 _consumerName = consumerName;
 }

 public void Frobnicate()
 =&gt; _log.Info($"{nameof(Frobnicate)} called on {_consumerName}");
}

var container = new UnityContainer()
 .AddNewExtension&lt;UnityParameterizedAutoFactoryExtension&gt;();

var logConsumerFactory = container.Resolve&lt;Func&lt;string, LogConsumer&gt;&gt;();
var gadget = logConsumerFactory("Gadget");
gadget.Frobnicate();
</code></pre>

Please notice: 

<ul>
<li><code>Func&lt;string, LogConsumer&gt;</code> is resolved from <code>container</code>, but it wasn't registered anywhere -- it's generated automatically. </li>
<li><code>Func&lt;string, LogConsumer&gt;</code> only provides the <code>string consumerName</code> parameter to <code>LogConsumer</code>'s constructor. As a result, the <code>Log log</code> parameter is resolved from the container. If the auto-factory func looked like this <code>Func&lt;string, Log, LogConsumer&gt;</code> instead, then all the parameters of <code>LogConsumer</code>'s constructor would've been supplied through the auto-factory. </li>
</ul>

Basically, the extension works like this:

<ol>
<li>It registers a so called <code>BuilderStrategy</code> in Unity's pipeline.</li>
<li>This strategy gets invoked whenever Unity is going to build a type's instance.</li>
<li>If the type to be built hasn't been registered explicitly and is a <code>Func</code> with parameters, the extension intercepts the instance building process.</li>
<li>Now we only need to dynamically create a <code>Func</code>of the given type which resolves its return type from the container and passes the <code>Func</code>'s parameters as a <code>ResolverOverride</code> collection to the <code>IUnityContainer.Resolve</code> method.</li>
</ol>

I'm trying to figure out the correct way to inject an auto-factory which takes params, or even if this is possible with Unity. 

For example I know I can do this:

<pre><code>public class TestLog
{
 private Func&lt;ILog&gt; logFactory;

 public TestLog(Func&lt;ILog&gt; logFactory)
 {
 this.logFactory = logFactory;
 }
 public ILog CreateLog()
 {
 return logFactory();
 }
}

Container.RegisterType&lt;ILog, Log&gt;();
TestLog test = Container.Resolve&lt;TestLog&gt;();
ILog log = test.CreateLog();
</code></pre>

Now what I'll like to be able to do is:

<pre><code>public class TestLog
{
 private Func&lt;string, ILog&gt; logFactory;

 public TestLog(Func&lt;string, ILog&gt; logFactory)
 {
 this.logFactory = logFactory;
 }
 public ILog CreateLog(string name)
 {
 return logFactory(name);
 }
}

Container.RegisterType&lt;ILog, Log&gt;();
TestLog test = Container.Resolve&lt;TestLog&gt;();
ILog log = test.CreateLog("Test Name");
</code></pre>

Unfortunately this doesn't work. I can see how you can set up custom factories for creating instances in Unity, just can't seem to fund any clear examples for this example.

Obviously I could create my own factory but I'm looking for an elegant way to do this in Unity and with minimum code.

Unity auto-factory with params

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在尝试找出正确的方法来注入一个带有参数的自动工厂，或者即使使用Unity也可以做到这一点。例如，我知道我可以这样做：public class TestLog{ private Func<ILog> logFactory; public TestLog(Func<ILog> logFactory) ...

问带参数的Unity自动工厂
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问带参数的Unity自动工厂EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问带参数的Unity自动工厂
EN