Come bilanciare più contratti di assistenza con strutture duplicate

Question

Come bilanciare più contratti di assistenza con strutture duplicate

#1 da (1 voti)

3

La mia attività corrente richiede l'utilizzo di una serie di chiamate al servizio Web a un fornitore di terze parti per recuperare e aggiornare le informazioni.

Gli oggetti utilizzati in queste chiamate, ovvero la risposta da un get e l'oggetto passato a (e ricevuto da) un aggiornamento - sono identici ad eccezione del prefisso attaccato agli oggetti.

Ad esempio, una chiamata al metodo get può restituire un oggetto come questo ( la struttura effettiva può essere profonda una dozzina di livelli e avere un mix di proprietà / collezioni ):

<getFooResponse>
    <getFooResponsePropertyA>1</getFooResponsePropertyA>
    <getFooResponsePropertyB>2</getFooResponsePropertyB>
    <getFooResponsePropertyC>3</getFooResponsePropertyC>
</getFooResponse>

e una chiamata al metodo update può richiedere un oggetto simile:

<updateFooRequest>
    <updateFooRequestPropertyA>4</updateFooRequestPropertyA>
    <updateFooRequestPropertyB>5</updateFooRequestPropertyB>
    <updateFooRequestPropertyC>6</updateFooRequestPropertyC>
</updateFooRequest>

e restituisce un terzo oggetto simile:

<updateFooResponse>
    <updateFooResponsePropertyA>4</updateFooResponsePropertyA>
    <updateFooResponsePropertyB>5</updateFooResponsePropertyB>
    <updateFooResponsePropertyC>6</updateFooResponsePropertyC>
</updateFooResponse>

Usando C #, i riferimenti di servizio sono facilmente aggiunti al mio progetto e le concrezioni delle classi necessarie per chiamare l'API o analizzare una risposta vengono generate per me.

Il mio problema sta nel fatto che 3 classi vengono generate automaticamente con una struttura quasi identica.

Così ho (generato automaticamente):

ottieni Foo Risposta
aggiornamento Foo richiesta
aggiornamento Foo risposta

l'unica differenza è il prefisso / suffisso.

Mi interessa davvero solo l'oggetto Foo (poiché è identico a tutti i 3 scenari).

È uno scenario abbastanza comune fare quanto segue

ottieni una risposta dal sistema di terze parti
modifica leggermente la risposta
invia la risposta modificata al sistema di terze parti (dopo averlo convertito da un getFooResponse a un updateFooRequest )

Il problema sta nella quantità di codice necessaria per mappare da una versione all'altra dell'oggetto. Mi rendo conto che posso farlo con la riflessione, ma non è chiaro come vorrei e non sono sicuro di quanto sia mantenibile per chi viene dopo di me.

Ho altre opzioni oltre a scrivere codice che mappatura dei codici rigidi tra diversi sapori degli oggetti?

c# web-services

posta Michael 31.08.2015 - 22:18

fonte

1 risposta

Leggi altre domande sui tag c# web-services

Come scrivere contemporaneamente dati in Java senza bloccare? In che modo questo esempio del libro di Robert Martin viola il Principio di Responsabilità Unica? [duplicare]

score 1 · Answer 1

Supponendo che stai deserializzando dalla risposta xml e serializzando dagli oggetti stessi, ecco un modello che potrebbe funzionare per te.

public abstract class FooMessage
{
      [XmlIgnore]
      string A { get; set; }
      [XmlIgnore]
      string B { get; set; }
      [XmlIgnore]
      string C { get; set; }
}

public class UpdateFooRequest : FooMessage
{
      public string UpdateFooRequestPropertyA { get { return this.A;} set { this.A = value;} }
      public string UpdateFooRequestPropertyB { get { return this.B;} set { this.B = value;} }
      public string UpdateFooRequestPropertyC { get { return this.A;} set { this.C = value;} }
}

public class UpdateFooResponse : FooMessage
{
      public string UpdateFooResponsePropertyA { get { return this.A;} set { this.A = value;} }
      public string UpdateFooResponsePropertyB { get { return this.B;} set { this.B = value;} }
      public string UpdateFooResponsePropertyC { get { return this.A;} set { this.C = value;} }
}

// usage
var myMessage = new FooMessage{ A="TestA", B="TestB", C="TestC" };

var myUpdateMessage = myMessage as UpdateFooRequest;
if(myUpdateMessage != null)
{
      var messageString = ConvertToXml(myUpdateMessage);
      SendMessage(messageString);
}

Questo non è molto meglio del semplice fare il codice di mappatura, ma farlo in questo modo permetterebbe facilmente la creazione di codice. Suppongo anche che tu voglia serializzare / deserializzare direttamente dall'oggetto / messaggio stesso.