C'è un modo semplice per chiamare un metodo su un oggetto in un altro programma con un dato id su TCP?

Question

C'è un modo semplice per chiamare un metodo su un oggetto in un altro programma con un dato id su TCP?

#1 da (1 voti)

1

Sto lavorando a un progetto in cui ho due programmi che richiedono di invocare metodi su alcuni dei rispettivi oggetti.

Lo faccio inviando oggetti JSON su una connessione TCP. Questi oggetti hanno un receiverID, methodName e quindi un elenco di parametri. Ogni programma ha una HashMap da receiverIDs a istanze di oggetto reali, e quindi uso reflection per invocare il metodo con methodName fornito sull'istanza dell'oggetto corretta.

Funziona, ma forza i metodi che vengono chiamati in remoto per avere un array di stringhe come parametro. Quindi devo osservare l'ordine in cui i parametri sono impacchettati nell'array e letti attraverso l'altro lato per analizzare ogni parametro in ciò che sono i parametri effettivi del metodo.

Questo sicuramente non mi sembra un modo molto pulito per raggiungere il mio obiettivo, ma non sono sicuro di come altro farlo. Suppongo che potrei contrassegnare ogni parametro con un tipo e poi lanciarli in base al tipo, ma dovrei aggiungere il codice per ogni nuovo tipo di parametro che voglio passare.

design-patterns networking rpc reflection tcp

posta lane spangler 01.02.2018 - 21:34

fonte

1 risposta

Leggi altre domande sui tag design-patterns networking rpc reflection tcp

Funzioni dell'iniezione e dell'aiuto di dipendenza dall'unità Aggiunta di un'API REST a un progetto C # esistente

score 1 · Accepted Answer

Ci sono due possibilità per quanto posso vedere:

il nome del metodo determina i parametri:

 string method1(string arg1, double arg2)

In questo caso è possibile fornire un metodo wrapper (ogni metodo ha un wrapper) che accetta l'oggetto parametro JSON e crea la chiamata. Questo è essenzialmente lo stesso di una decorazione, e potresti essere in grado di farlo usando le annotazioni, a seconda della lingua che stai usando (come ha osservato Laiv:

     *********
     * Wrapper
     *********
     string method1ViaJSON(json *pack):
         return this.composeReply(
              method1(
                  extractString('arg1', pack),
                  extractDouble('arg1', pack)
             )
         )

      # Decorators.
      @jsonReturning("string")
      @jsonCallable(name = "arg1", type = "string")
      @jsonCallable(name = "arg2", type = "double")
      def method1(arg1, arg2):
          ...

      /**
       * Annotations.
       */
      @jsonable(arg1 = "string", arg2 = "double", returns = "string")
      public String method1(String arg1, double arg2) {
          ...
      }

il chiamante stabilisce il parametro e il loro tipo determina quale metodo verrà chiamato:

 string method1(string arg1, double arg2)

 string method1(string arg1, string arg2)

 string method1(double arg1)

In questo caso è necessario codificare il tipo nel JSON, nel nome o come proprietà ausiliaria:

{
    "strArg1": "This is a string",
    "dblArg2": 12345.678
}

o { "arg1": { "tipo": "stringa", "valore": "Anche questa è una stringa" } }

Naturalmente, il callee avrà sempre bisogno di verificare che i dati forniti siano del tipo corretto; questo non sarà accettato:

    { "type": "double", "value": "toil and trouble" }

In sostanza, l'endpoint JSON è one e decodifica i parametri in base al metodo o invoca il metodo tramite wrapper e decoratori appropriati. Questi mettono in cascata la chiamata al metodo originale o sollevano un'eccezione ("Bad Parameter").