Super-interface in a partial class in WCF -


i creating wcf service multiple interfaces "iservice" main interface (service contract) , other interfaces added based on modules. - "istudent", "iclass", "iteacher" etc.

so planning -

[servicecontract] public interface ikccwebservice : istudent, iclass, iteacher {} 

and use service -

public partial class myservice : ikccwebservice {}   public partial class myservice : istudent {    // student interface implemented }   public partial class myservice : iclass {    // class interface implemented }  

and on. if getting error - "myservice not implement interface member "ikccwebservice"".

i dont want implement interfaces @ 1 shot taking approach.

let me know if have suggestions.

i think you're misunderstanding partial classes for.

partial classes don't allow implement "part" of class or interface. partial classes method allow parts of class defined in different places. when compiler builds project, finds of partial definitions class , mashes them complete definition.

for example, code:

partial class myclass: baseclass { }  sealed partial class myclass: ifirstinterface {     public void firstmethod(){ } }   public partial class myclass: isecondinterface {     public void secondmethod(){ } }  

really translates this:

public sealed class myclass : baseclass, ifirstinterface, isecondinterface {     public void firstmethod(){ }     public void secondmethod(){ } } 

all of members, modifiers, implemented interfaces, , inherited classes applied class when built.

the typical usage when part of class dynamically generated (e.g. tool or designer) , part of class manually generated. class can declared partial , split between 2 files - 1 don't touch (because tool regenerate @ time) , 1 tool doesn't touch, put of code.


in case, declaring multiple partial classes serves no purpose. since 1 of partial definitions includes myservice : ikccwebservice, myservice class required define all of members defined ikccwebservice.

if don't want implement logic interfaces in 1 shot, don't have to. define required interface methods single line: throw new notimplementedexeption(); compiler doesn't care methods do, long methods defined.