WCF: Interfaces, Generics und ServiceKnownType

Gut, ich denke, dies ist ein weiterer Fall von SOA vs. OOP "impedance mismatch". Die beiden Welt sind ziemlich getrennt.

In der WCF ist, alle übergeben wird, die vom client an den server übergeben serialisierten Nachrichten - keine Verweise verwendet werden.

Bedeutet dies: alles, was Sie wollen, zu serialisieren, die auf den client senden es über den server, und deserialisiert es und verwenden Sie es, Sie werden müssen konkrete -, die Sie nicht passieren können, um Schnittstellen, die Sie nicht verwenden "nicht-gelöst" Generika - Sie müssen spell it out. Im Grunde, alles, was übergeben wird vom client über das Netzwerk zu der server muss expressable in XML-schema.

Dies hat viele Auswirkungen:

• keine Schnittstellen, die Sie nicht passieren können, um Schnittstellen, die Sie benötigen, um die Arbeit mit konkreten Typen
• keine "automatische" Vererbung - Sie können nicht einfach definieren einer Basis-Klasse und übergeben, um abgeleiteten Klassen, die auf ihm basieren - diese müssen specificied zu (das ist, was die ServiceKnownType Attribut ist für)
• keine automatische Generika - immer wieder, müssen Sie die Verwendung von konkreten Typen statt

Dies klingt vielleicht wie eine Menge von Einschränkungen - aber es ist da WCF ist mit allen message-basierte Kommunikation - es kann nicht umgehen mit refereces, Vererbung, generics etc. - Sie müssen spell it out.

So dass ich nicht wirklich eine Antwort für Sie per se - ich denke nur, Sie müssen Ihre Strategie zu überdenken und zu ändern, wie auf Ihrem client und der server tauschen Informationen über WCF.

Marc

PS: ich habe etwas mehr Forschung, und im Gegensatz zu meinem Verständnis, es scheint einen Weg zu serialisieren alles, was, basierend auf einer Schnittstelle und/oder eine abstrakte Basisklasse, die über den Draht, so lange wie Sie können sicher sein, dass es immer nur .NET, die an beiden enden des Drahtes (D. H. es ist nicht kompatibel mit z.B. Java).

Sehen Aaron Skonnard blog-post auf der NetDataContractSerializer und anderen blog-post und ein weiteres zeigt, wie Sie mithilfe der NetDataContractSerializer weitergeben kann, um Dinge wie IPerson als Parameter an die Methoden.

Es ist eine alte Frage, und obwohl die akzeptierte Antwort ist völlig richtig, ich stumpled upon diese bei der Suche für ein ähnliches problem und dachte, ich könnte meine Erlebnisse teilen. Es ist oft ein Kopfschmerz, aber es ist möglich, dass Generika verwendet werden, kombiniert mit Schnittstellen mit WCF. Hier ist ein Beispiel eines anderen (ähnlichen) - Implementierung, die ich gemacht habe:

[ServiceContract]
[ServiceKnownType(typeof(CollectionWrapper<IAssociation>))]
public interface IService : 
{
    [OperationContract]
    ICollectionWrapper<IAssociation> FindAssociation(string name, int pageSize, int page);
}

public interface ICollectionWrapper<TModel>
{
    int TotalCount { get; set; }
    IEnumerable<TModel> Items { get; set; }
}

[KnownType(typeof(OrganizationDto))]
[KnownType(typeof(CompanyDto))]
public class CollectionWrapper<TModel> : ICollectionWrapper<TModel>
{
    [DataMember]
    public int TotalCount { get; set; }
    [DataMember]
    public IEnumerable<TModel> Items { get; set; }
}

public class CompanyDto :  IAssociation
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class OrganizationDto :  IAssociation
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Der Schlüssel ist hier, die Kombination von KnownType und ServiceKnownType.

So, in Ihrem Fall kann man etwas wie das hier tun:

[ServiceContract]
[ServiceKnownType(typeof(ActionParameters))]
[ServiceKnownType(typeof(ActionResult<ISportProgram>))] //Actual implementation of container, but interface of generic.
public interface ISportProgramBl  
{
    [OperationContract]
    IActionResult<ISportProgram> Get(IActionParameters parameters);
}

[KnownType(typeof(SportProgram))] //Actual implementation here.
public class ActionResult<T>
{
    //Other stuff here
    T FooModel { get; set; }
}

Diese arbeiten, wenn Sie einen gemeinsamen Vertrag (Zugang zu den eigentlichen service-Schnittstelle) und verbrauchen den Vertrag mit ChannelFactory<ISportProgramBl>. Ich weiß nicht, ob es funktioniert mit einem service-Referenz.

Jedoch scheint es einige Probleme mit der Umsetzung, wie Sie hier erwähnt:

WCF Mit einem interface und ein generisches Modell

Und andere ähnliche Frage gestellt und hier beantwortet:

Generische Rückgabetypen mit interface type params in WCF

Sind Sie spezifizieren Schnittstellen, die Objekte und nicht auf den konkreten Typen?

PPS.Core.DomainModel.Support.Action.ActionListResult<IList<PPS.Core.DomainModel.SportProgram.ISportProgram>>

Edit:

Was ich damit sagen will, ist, dass sich alle konkreten Typen, die Sie übergeben, in der Generika (auch in sub-Objekt über Schnittstellen) übergeben wird in der Bekannten Typen-Liste. Wir hatten serialasation Fragen, wo all die Typen waren nicht bekannt.