blocks|key|1310003|text|如果没有看到COITemplate的其余部分，假设它不是一个接口，那么您应该只需要让函数返回接口类型本身。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1310004|public+iTemplateWriter+Write(COITemplateModel+model)
{
+++//+if+the+"COITemplateModel"+class+is+an+iTemplateWriter+you+could+just+return+that+back.
+++return+model;

+++//+OR+if+some+other+object+you+are+working+with+is+that+interface.
+++return+(iTemplateWrite)OfWhateverClassYouAreTrying;

}|code-block|syntax|javascript|1310005|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|$]]

Without seeing the rest of what COITemplate is, assuming it is not an interface, you should just need to have the function return the interface type itself.
<pre><code>public iTemplateWriter Write(COITemplateModel model)
{
 // if the &quot;COITemplateModel&quot; class is an iTemplateWriter you could just return that back.
 return model;

 // OR if some other object you are working with is that interface.
 return (iTemplateWrite)OfWhateverClassYouAreTrying;

}
</code></pre>

blocks|key|1181985|text|你混淆了运行时允许你做的事情和编译器在编译时需要知道的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1181986|这就是泛型在C#中的作用|1181987|看起来您想要一个接口iTemplateWriter，在该接口上，您希望能够使用此方法Write，该方法可以接受任何iTemplateModel并返回任何iTemplate|offset|length|style|CODE|1181988|您可以通过两种方式完成此操作：|1181989|方法1-您可以在接口级别定义接口的实现者将使用哪种类型的iTemplateModel和哪种类型的iTemplate：|1181990|++++public+interface+iTemplateWriter<TTemplate,+TTemplateModel>+
++++++++where+TTemplate+:+iTemplate
++++++++where+TTemplateModel+:+iTemplateModel
++++{
+++++++++TTemplate+Write(TTemplateModel+model);
++++}|code-block|syntax|javascript|1181991|这样做将允许您定义使用COITemplate和COITemplateModel的COITemplateWritter|1181992|public+class+COITemplateWritter+:+iTemplateWriter<COITemplate,+COITemplateModel>
{
++++public+COITemplate+Write(COITemplateModel+model)
++++{
++++++++throw+new+System.NotImplementedException();
++++}
}|1181993|如果您在编译时知道实现类需要使用的类类型，请使用方法1|BOLD|1181994|如果您需要实现类在运行时处理所有类型，并且您不知道编译时的类型，则使用方法2：|1181995|方法2-您可以在方法级别定义该方法将使用哪种类型的iTemplate和哪种类型的iTemplateModel。这将要求所有实现类能够返回在运行时传入的任何类型，这允许更多的灵活性，但在编译时结构化较少。|1181996|public+interface+iTemplateWriter
{
++++TTemplate+Write<TTemplate,+TTemplateModel>(TTemplateModel+model)
++++++++where+TTemplate+:+iTemplate
++++++++where+TTemplateModel+:+iTemplateModel;
}

public+class+COITemplateWritter+:+iTemplateWriter
{
++++public+TTemplate+Write<TTemplate,+TTemplateModel>(TTemplateModel+model)
++++++++where+TTemplate+:+iTemplate
++++++++where+TTemplateModel+:+iTemplateModel
++++{
++++++++
++++++++throw+new+System.NotImplementedException();
++++}
}|1181997|entityMap^0|0|0|A|F|16|5|1L|E|24|9|0|0|S|E|1C|9|0|0|B|B|N|G|14|I|0|0|0|G|0|0|P|9|14|E|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|18|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|19|8|@$F|1A|G|1B|H|I]|$F|1C|G|1D|H|I]|$F|1E|G|1F|H|I]|$F|1G|G|1H|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1I|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1J|8|@$F|1K|G|1L|H|I]|$F|1M|G|1N|H|I]]|9|@]|A|$]]|$1|N|3|O|5|P|7|1O|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1P|8|@$F|1Q|G|1R|H|I]|$F|1S|G|1T|H|I]|$F|1U|G|1V|H|I]]|9|@]|A|$]]|$1|U|3|V|5|P|7|1W|8|@]|9|@]|A|$Q|R]]|$1|W|3|X|5|6|7|1X|8|@$F|1Y|G|1Z|H|Y]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|20|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|21|8|@$F|22|G|23|H|I]|$F|24|G|25|H|I]]|9|@]|A|$]]|$1|13|3|14|5|P|7|26|8|@]|9|@]|A|$Q|R]]|$1|15|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|16|$]]

You are confusing what you are allowed to do during run-time with what the compiler needs to know at compile-time.
This is what generics are for in C#
It looks like you want an interface <code>iTemplateWriter</code> where you want to be able to have this method <code>Write</code> that will take in any <code>iTemplateModel</code> and return any <code>iTemplate</code>
You can do this two ways:
Method 1- You can define at the interface level what type of <code>iTemplateModel</code> and what type of <code>iTemplate</code> the implementer of the interface will use:
<pre><code> public interface iTemplateWriter&lt;TTemplate, TTemplateModel&gt; 
 where TTemplate : iTemplate
 where TTemplateModel : iTemplateModel
 {
 TTemplate Write(TTemplateModel model);
 }
</code></pre>
doing this will allow you to define a <code>COITemplateWritter</code> that uses a <code>COITemplate</code> and a <code>COITemplateModel</code>:
<pre><code>public class COITemplateWritter : iTemplateWriter&lt;COITemplate, COITemplateModel&gt;
{
 public COITemplate Write(COITemplateModel model)
 {
 throw new System.NotImplementedException();
 }
}
</code></pre>
Use method 1 if you know at compile time what class types the implementing class needs to use
If you need your implementing class to handle all types at run time and you do not know the type at compile-time, then use method 2:
Method 2- You can define this at the method level of what type of <code>iTemplate</code> and what type of <code>iTemplateModel</code> the method will use. This will require all implementing classes to be able to return whatever type is passed in at runtime, which allows for more flexibility but is less structured at compile time.
<pre><code>public interface iTemplateWriter
{
 TTemplate Write&lt;TTemplate, TTemplateModel&gt;(TTemplateModel model)
 where TTemplate : iTemplate
 where TTemplateModel : iTemplateModel;
}

public class COITemplateWritter : iTemplateWriter
{
 public TTemplate Write&lt;TTemplate, TTemplateModel&gt;(TTemplateModel model)
 where TTemplate : iTemplate
 where TTemplateModel : iTemplateModel
 {
 
 throw new System.NotImplementedException();
 }
}
</code></pre>

I'm receiving the compile error:
Error CS0535 'COITemplateWriter' does not implement interface member 'iTemplateWriter.Write(iTemplateModel)' TemplateService
For the following code:
<pre><code> public COITemplate Write(COITemplateModel model)
 {
 throw new NotImplementedException();
 }
</code></pre>
The interface signature for the above method is as follows:
<pre><code>public interface iTemplateWriter
{
 public iTemplate Write(iTemplateModel model);
}
</code></pre>
Type COITemplate implements the iTemplate interface and type COITemplateModel implements the iTemplateModel interface, so why does this code fail? Wouldn't it stand to reason that if the interface requires the method to return anything that implements iTemplate and takes as a parameter anything that implements iTemplateModel that this should compile?

In C#, why can't I return a derived interface type from a function whose interface signature has the base interface type as its return type?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我收到编译错误:错误CS0535 'COITemplateWriter‘没有为以下代码实现接口成员'iTemplateWriter.Write(iTemplateModel)’TemplateService：    public COITemplate Write(COITemplateModel model)    ...

问在C#中，为什么我不能从接口签名具有基接口类型作为返回类型的函数返回派生接口类型？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C#中，为什么我不能从接口签名具有基接口类型作为返回类型的函数返回派生接口类型？EN