WebService: Come restituire una matrice di tipo complesso?

Question

2 Domande davvero, e io non sono sicuro se sto facendo questo diritto o no ...

Voglio mandare indietro una serie di qualche tipo per un oggetto Entity ho creato. Io non sono davvero sicuro di come contrassegnare per l'invio (quali attributi sono necessarie o qualsiasi altra cosa), e io non sono davvero sicuro di come rispedirlo (IList, Lista, Collezione, ICollection).

Idealmente mi piacerebbe essere in grado di restituire un ObservableCollection, ma vorrei che il lavoro se un cliente che vuole consumare il servizio non è in .NET?

[ServiceContract(Namespace = "http://www.tempuri.com/MyService",
                 ConfigurationName = "IMyService")]
public interface IMyServie
{
    [OperationContract(Action = "http://www.tempuri.com/MyService/GetUsers",
                       ReplyAction = "*")]
    [XmlSerializerFormat(SupportFaults = true)]
    GetUsersResponse GetUsers(GetUsersRequest request);
}

[MessageContract(IsWrapped = false)]
public sealed class GetUsersRequest
{
    public GetUsersRequest() { }
    public GetUsersRequest(Int32 record = -1)
    {
        Record = record;
    }

    [MessageBodyMember(Namespace = "", Order = 0)]
    public Int32 Record { get; private set; }

}

[MessageContract(IsWrapped = false)]
//[ServiceKnownType(??)]
public sealed class GetUsersResponse
{
    public GetUsersResponse() { }
    public GetUsersResponse(PersonEntity[] entities)
    {
        Entities = entities;
    }

    [MessageBodyMember(Namespace = "", Order = 1)]
    //[XmlElement(DataType = "??")]
    public PersonEntity[] Entities { get; private set; }
    //Should this have been some other type of array-type (Collection, List, etc?)
}

//Does this need any attributes besides Serializable?
[Serializable()]
public PersonEntity : AbstractEntity
{
    public PersonEntity() { }
    public PersonEntity(Int32 id = 0, String fname = "", String lname = "")
    {
        ID        = id;
        FirstName = fname;
        LastName  = lname;
    }

    public String FirstName { get; set; }
    public String LastName { get; set; }

    //Functionality (Clone, Clear, Default, Equals, etc) Removed...
}

[Serializable()]
public abstract class AbstractEntity : IEntity
{
    public Int32 ID { get; set; }

    //Abstracts or Implements some functionality...
}

public interface IEntity
{
    //Defines functionality requirements
}

Answer 1

DataContract è quello che stai cercando. Per maggiori dettagli si veda questo

Sul fronte raccolta osservabile, non so perché l'invio di una matrice sarebbe diverso per voi. Si può elaborare un po 'di più per aiutarci a capire questo.

Answer 2

Quando si tratta di oggetti che passano attraverso il cavo, si deve pensare dei dati piuttosto che il comportamento. Quindi, per quanto questa è interessato, di un elenco o di IEnumerable o T [] non sarebbero diverse e la mia preferenza sarebbe di matrice che è supportato in tutte le lingue. Il server non deve sapere o fare qualsiasi ipotesi unncessary sul client (WPF, Windows Form, ...) e tutto quello che sta passando è una raccolta di dati, in modo almeno prescrittivo è il migliore:. T [] (Array of T)

Come ha detto myermian, il vostro ObservableCollection inviati in rete non avrebbe lavorato come ObservableCollection sul client.

Inoltre si utilizza MessageContract pur non utilizzando uno qualsiasi dei suoi benefici del corpo / intestazione. Quindi è necessario utilizzare DataContract.

Answer 3

La maggior parte dei mezzi interoperabili potrebbe essere quella di restituire una matrice di tipo complesso, qualunque cosa tu decida che per essere. La mia preferenza personale è quello di utilizzare un oggetto DTO dedicato per il trasferimento attraverso il filo, piuttosto che esporre entità interne direttamente tramite il servizio.

Per quanto riguarda ObservableCollection, ti suggerisco di avvolgere la matrice in un ObservableCollection lato client piuttosto che cercare di ObservableCollection ritorno.

Tieni presente che ObservableCollection non trasmetterà cambia di nuovo al servizio; si sta andando ad ave a fare quelle manualmente.