首页 > > 程序设计 > delphi >

RTC Remote Functions - working with flexible …

2018-06-17 18:57:12来源：未知阅读 ()

Author

RTC Remote Functions - working with flexible structures

Danijel Tkalcec [RTC]

01.06.2006 20:27:57
Registered user

You can form your structure as simple and as complex as you want. RTC uses highly flexible format, so that you can define virtually any structure you want, even call remote function which will call other remote functions to get parameters.

You can store multiple values in each element by using newRecord, newArray or newDataSet. Here is one example of creating an array called “numbers”, which will hold a number of records (here 0 to 9) with “x:integer; dt:TDateTime” and send this to a remote function named “callme”.

This is the client-side code:

with myClientModule do
  begin
  with Data.newFunction(’callme’) do
    begin
    // prepare an array to send as parameter
    with NewArray(’numbers’) do
      begin
      for I := 0 To 9 do
        begin
        // each item inside this array
        // will be a new record
        with newRecord(I) do
          begin
          asInteger[’X'] := I;
          asDateTime[’dt’] := Now;
          end;
        end;
    end;
  Call(myResult);
  end;

And on the server side, you can access all data inside this array like this:

// need to make sure this parameter is an array …
if isType[’numbers’]=rtc_Array then
  with asArray[’numbers’] do
    begin
    // loop through all elements
    for I := 0 to Count-1 do
      begin
      // make sure this element is a record
      if isType[i]=rtc_Record then
        with asRecord[I] do
          begin
          // read the data inside the record
          X := asInteger[’X'];
          dt := asDateTime[’dt’];
          end;
        end;
      end;

Whenever you expect to use complex types, you should use “isType” to check if that element really contains the data type you expect, so you don’t end up with access violations in case the element is not assigned (in which case asRecord, asArray and asDataSet would return NIL).

Using the same paradigm, you can write your remote function to return any complex structure back to the client. You will simply prepare the data for “Result” using the same newRecord, newArray and newDataSet properties as you did on the client side to send parameters to the server. The only difference is that when you call a remote function from the client, you are sending data using a record, so that each of your parameters have a name and when returning a result back to the client, you actually have only “one” parameter (Result) and if you want to send more values back, you will use something like this …

with Result.newRecord do
  begin
  // prepare an array to send as parameter
  with NewArray(’numbers’) do
    begin
    for I := 0 To 9 do
      begin
      // each item inside this array
      // will be a new record
      with newRecord(I) do
        begin
        asInteger[’X'] := I;
        asDateTime[’dt’] := Now;
        end;
      end;
    end;
  end;

You see that the code is identical to the one I used to send this structure from client to the server. Difference is only that here I’m creating a record using “newRecord”, while client has created a function call using “newFunction”.

You can also use nested function calls by using “newFunction” as a “parameter” for any parameter expected by the function you are calling. For example, you can call something like “add(mull(a,b), mull(c,d))” by using this code …

with rtcClientModule do
  begin
  with Data.newFunction(’add’) do
    begin
    // to prepare the “A” parameter
    // when calling the “add” function
    // we will call the “mull” function

    with newFunction(’A', ‘mull’) do
      begin
      // prepare “A” and “B” parameters
      // for first call to the “mull” function
      asInteger[’A']:=12;
      asInteger[’B']:=34;
      end;

    // to prepare the “B” parameter
    // when calling the “add” function
    // we will call the “mull” function

    with newFunction(’B', ‘mull’) do
      begin
      // prepare “A” and “B” parameters
      // for second call to “mull”
      asFloat[’A']:=56.7;
      asFloat[’B']:=78.92;
      end;
    end;

  Call(myResult);
  end;

In this example, we are sending a nested function call to the server. Remote functions on the server-side do not have to be specially prepared to be able to execute nested function calls, this is already given by RTC design. What will happen is that the two “mull” functions will be executed and results from those functions will be passed as parameters to the “add” function, which will prepare the final result which will be returned to the client. This is comparable to calling normal functions in delphi, where you call other functions to prepare parameters and expect to get the final result back from the “outside” function (in this case, “add”).

I was only going to 2-nd level depth in those examples, but there is no limit to how deep your complex structure can be and you can combine all data types (simple and complex) at all levels, while every value you use can be of ANY data type. Here’s another example, preparing another complex structure to return as a result of a remote function …

with Result.newRecord do
  begin

  // “data” var will be a DataSet
  with newDataSet(’data’) do
    begin
    // will be creating 100 records
    for a:=1 to 100 do
      begin
      Append;

      // “x” field will be an array
      with newArray(’X') do
        for b:=0 to 99 do
          // fill the array
          asInteger[b]:=b;

      // “y” field will be a record
      with newRecord(’Y') do
        begin
        // “txt” in record is a string
        asString[’txt’]:=’We are on ‘+IntToStr(A);

        // “rand” in record is an array
        with newArray(’rand’) do
          for a:=1 to 100 do
            asFloat[a]:=random(1000)/a;
        end;

      // “name” field will be a string
      asString[’name’]:=’my Name is X’;

      // “tim” field will hold current date/time
      asDateTime[’tim’]:=Now;
      end;
    end;

  // “test” var will be a record
  with newRecord(’test’) do
    begin
    asString[’var1']:=’hola’;
    asInteger[’var2']:=1234;
    asFloat[’var3']:=123.45;
    asDateTime[’var4']:=Date;
    asCurrency[’var5']:=13.5;
    asBoolean[’ok']:=True;
    end;

  // “num” var will be a simple number
  asInteger[’num']:=1564;
  end;

Well, I guess this shows how complex and how simple structures can be used with RTC remote functions. Free your imagination. If you can imagine a structure, then you can also send it as a parameter of your RTC remote function and also receive it as a result from your remote functions. There are no limits.

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有