Съставни типове данни на X++

Бележка

Групите с интереси на общността сега са се преместили от Yammer в Microsoft Viva Engage. За да се присъедините към Viva Engage общност и да участвате в последните обсъждания, попълнете формуляра Заявете достъп до финанси и операции Viva Engage общността и изберете общността, към която искате да се присъедините.

В тази статия са описани съставни типове данни в X++. Комбинираните типове данни в X++ са масиви, контейнери, класове като типове данни, представители като типове данни и таблици като типове данни.

Масив

Масивът е променлива, която съдържа списък с елементи, които имат един и същ тип данни. До елементите на масив се осъществява достъп с помощта на цели индекси. Можете да използвате отделна команда, за да инициализирате всеки елемент в масив. Когато използвате тип данни на контейнер или обект масив, за да създадете колекция, можете да инициализирате няколко елемента с помощта на една команда. По подразбиране всички елементи в масив имат стойността по подразбиране на типа данни в масива. Има три вида масиви: динамични масиви, масиви с фиксирана дължина и частично върху дискови масиви.

• Динамични масиви – тези масиви са обявени с помощта на опция за празен масив. С други думи, те имат само скоби ([]).
• Масиви с фиксирана дължина – тези масиви могат да задържат броя на елементите, зададени в декларацията. Масивите с фиксирана дължина се обявяват като динамични масиви, но опцията за дължина е включена в скобите.
• Частично върху дискови масиви – тези масиви са декларирани като динамични масиви или масиви с фиксирана дължина, които имат допълнителна опция, която декларира колко елемента трябва да се задържат в паметта. Другите елементи се съхраняват на диска и се зареждат автоматично, когато бъдат указани.

X++ поддържа само едномерни масиви. Можете обаче да имитирате поведението на множество индекси на масиви. (За повече информация вж. раздела Множество индекси на масиви ). Променливите в обекти и таблици могат да бъдат декларирани като масиви. Например тази функционалност се използва в адресни редове в стандартното приложение. Класът на колекцията от масиви ви позволява да съхранявате обекти в масив.

Индексите на масивите започват от 1. Първият елемент в масива се посочва като [1], вторият елемент се посочва като [2] и т.н. За достъп до елемент на масив се използва следният синтаксис: ArrayItemReference = ArrayVariable [ Индекс ]. В този синтаксис ArrayVariable е идентификаторът на масива, а "индекс " е номерът на елемента за масив. Индексът може да бъде целочислен израз. Елемент нула [0] се използва за изчистване на масива. Ако дадена стойност е присвоена на индекс 0 в масив, всички елементи в масива се нулират до тяхната стойност по подразбиране.

Присвояването на един цял масив към друг се извършва чрез препратка.

Примери за масиви

public void ArrayMethod()
{
    int myArray[10]; // Fixed-length array with 10 integers.
    myArray[4] = 1; // Accessing the 4th element in the array.
    myArray[0] = 0; // Resets all elements in intArray.

    // Dynamic array of integers.
    int intArray[];

    // Dynamic array of variables of type Datatype.
    //Datatype arrayVariable[];

    // Fixed-length arrays.
    boolean boolArray[100]; // Fixed-length array of booleans with 100 items.

    // Two examples of Partly On Disk Arrays.
    // Dynamic integer array with only 100 elements in memory.
    int arrayVariable [ ,100];
    // Fixed-length string array with 1000 elements, and only 200 in memory.
    str arrayVariable2 [1000,200];

    // A dynamic array of integers.
    int i[];
    // A fixed-length real array with 100 elements.
    real r[100];
    // A dynamic array of dates with only 10 elements in memory.
    date d[,10];
    // A fixed length array of NoYes variables with 100 elements and 10 in memory.
    NoYes ny[100,10];
}

Множество индекси на масиви

Някои езици, като например C++ и C#, ви позволяват да декларирате масиви, които имат повече от един индекс. С други думи, можете да дефинирате "масиви от масиви". В X++не можете директно да създавате множество индекси на масиви, защото се поддържат само едномерни масиви. Можете обаче да реализирате няколко индекса с помощта на метода, описан в този раздел. Например искате да декларирате масив, който има две измерения, за да задържите сума, която се печели по страна/регион по размер. Има 10 страни/региони и три измерения. В C++ и C#декларирате следния масив.

// This is C# or C++ code, not X++ code.
long earning[10, 3];

X++ обаче не поддържа тази декларация. Вместо това можете да дефинирате едномерен масив, където броят на елементите е произведението на елементите във всяка размерност. Ето един пример.

public void MultipleArrayMethod()
{
    // Step 1: define a one-dimensional array with the number
    // of elements that is the product of the elements in each dimension.
    real earnings[10*3];

    // Step 2: to refer to a specific element, such as earnings[i,j], write the following:
    // declare i and j (maybe) and assign the value to something
    int i = 1;
    int j = 2;
    real element = earnings[(i-1)*3 + j];
}

// This can be written into a macro like this:
#localmacro.earningIndex
(%1-1)*3+%2
#endmacro

public void CallTheMacro()
{
    // Next, call the specific element within the macro like this:
    int i = 1;
    int j = 2;
    real element = earnings[#earningIndex(i,j)];

    // The previous scheme can be extended to any number of dimensions.
    // The element a[i1, i2, ..., ik] can be accessed by computing the
    // offset into an array containing (d1*d2*...*dk) elements.
    //(i1 - 1)*d2*d3*..*dk +
    //(i2 - 1)*d3*d4*...*dk + .... +
    //(ik-1 -1)*dk +
    //(ik-1)
}

Контейнер

Обектът контейнер е динамичен списък с елементи, който съдържа примитивни типове данни или съставни типове данни. Контейнерът е полезен, когато трябва да предавате различни типове стойности между клиентските и сървърните нива. Ако обаче планирате многократно да добавяте към списък в цикъл, контейнерът не е добър избор. Контейнерите са най-подходящи за процеси, които не включват прекомерно модифициране на размера или съдържанието на контейнера. Когато даден контейнер претърпи прекомерно събиране на данни, общата производителност на системата може да намалее, тъй като данните в контейнера трябва да се копират многократно и трябва многократно да се заделя ново пространство.

Контейнерът не е клас. Контейнерът съдържа подредена последователност от примитивни стойности или други контейнери. Поради гъвкавостта на всеки тип контейнерът предлага добър начин за съхраняване на стойности от различни типове заедно. Контейнерът може да се съхранява в базата данни. Контейнерът е един от типовете колони, които можете да изберете, когато използвате Application Explorer, за да добавите колона към таблица. Контейнерът малко прилича на масив или колекции, като например класовете List или Stack . Въпреки това никога не можете да промените размера или съдържанието на контейнера, след като контейнерът бъде създаден.

X++ командите, които изглежда, че променят контейнер, изграждат вътрешно нов контейнер и копират стойностите според изискванията. Дори присвояване на контейнер на друга променлива контейнер създава ново копие на контейнера. Всички тези операции могат да повлияят на производителността. Във функциите, които предоставят достъп до контейнер (например conPeek), контейнерът е базиран на 1, а не на базата на 0. Индексирането е базирано на 1 за масиви. Стойността по подразбиране на контейнер е празна. Контейнерът не съдържа никакви стойности. Някои команди, които използват контейнери, може да изглеждат като модифициращи контейнер, но вътре в системата контейнерите никога не се модифицират. Вместо това данните от първоначалния контейнер се комбинират с данни от командата за създаване на нов контейнер. Можете да създадете нов контейнер с помощта на една от следните функции: conDel, conIns или conPoke.

Освен това глобалният клас има статични методи за обработка на контейнери. Тези методи включват con2ArraySource, con2Buf, con2List, con2Str, containerFromXmlNode, conView и str2Con. Има няколко присъщи функции за обработка на контейнер, като конфигурации и конфигурации. Функцията X++ conPeek връща тип anytype , следователно е по-лесно да се прочетат стойностите от контейнер, когато не знаете типа на всяка стойност. Всеки тип може да бъде присвоен на всеки тип стойност X++, при условие че стойността може да бъде преобразувана. Вашият код е по-лесен за четене, когато избягва явни преобразувания на типове данни. Следователно присвоете стойности от контейнер към същия тип данни, който е използван за поставяне на стойността в контейнера. Не трябва да присвоите даден контейнер на тип, тъй като системата може да не успее да определи правилните преобразувания. В тези случаи може да възникне неочаквано поведение или грешки.

Сравняване на контейнер с други опции

Типът контейнер прилича на други конструкции, като например масиви и класове на събиране, като например Списък и Стек. Разликата между контейнер и списък е, че екземпляр от клас "Списък" е нестабилен. Обектът List първо заделя повече място, отколкото използват данните му. След това, когато се добавят данни, мястото се запълва. Това поведение е по-ефективно от разпределянето на повече място всеки път, когато се добавя елемент. Актуализацията на списък работи по-бързо от подобни операции в контейнер.

Когато изграждате обект List , вие определяте типа на данните, които обектът List може да съхранява. Това ограничение е по-малко гъвкаво за списък , отколкото за контейнер. Можете обаче да съхранявате обекти в списък, докато един контейнер може да съхранява само типове стойности. Разликата между контейнер и масив е, че масив може да съдържа само елементи от неговия деклариран тип. Можете да разпределите място в паметта за масив и да запълните интервала със стойностите по-късно. Можете например да попълните стойностите в цикъл. Това поведение е ефективно и работи добре. Когато искате да създадете нов контейнер чрез добавяне на нови данни, можете да използвате или оператора += , или функцията conIns . Операторът += е по-бързата алтернатива. Използвайте функцията conIns само когато искате да добавите нови данни преди последния индекс на първоначалните данни.

Не можете да съхранявате препратки към обекти в контейнери. Когато компилаторът открие опит за съхраняване на препратка към обект в контейнер, той издава съобщение за грешка. Ако типът на елемента, който се добавя към контейнера, е anytype, компилаторът не може да определи дали стойността е тип препратка. В този случай компилаторът позволява опита. Въпреки че компилаторът не диагностицира кода като грешен, ще бъде възникнала грешка по време на изпълнение.

Примери за контейнер

public void ContainerExample()
{
    // First, declare the variables you are using.
    container myContainer;
    container myContainer4;
    container myContainer5;
    // Three ways to declare a container.
    myContainer = [1];
    myContainer += [2];
    myContainer4 = myContainer5;

    // Declare a container.
    container cr3;

    // Assign a literal container to a container variable.
    cr3 = [22, "blue"];

    // Declare and assign a container.
    container cr2 = [1, "blue", true];

    // Mimic container modification (implicitly creates a copy).
    cr3 += [16, strMyColorString];
    cr3 = conIns(cr3, 1, 3.14);
    cr3 = conPoke(cr3, 2, "violet");

    // Assignment of a container (implicitly creates a copy).
    cr2 = cr3;

    // Read a value from the container.
    str  myStr = conPeek(cr2, 1);

    // One statement that does multiple assignments from a container.
    str myStr;
    int myInt;
    container cr4 = ["Hello", 22, 20\07\1988];
    [myStr, myInt] = cr4; // "Hello", 22

    // Example of applying the = operator to a container. The example
    // initializes myContainer2 and myContainer33.
    myContainer2 = [2, "apple"];

    // Next, you make a copy of myContainer33 and assign the copy to myContainer2.
    myContainer33 = [33, "grape"];
    myContainer2 = myContainer33;  // The container that myContainer2 had been holding is no longer available and cannot be recovered.
    // An example of building a new container by
    // assigning a new value to myContainer33 through the += operator.
    myContainer33 += [34, "banana"];
}

// Container example. In this example, variable2 and variable33 hold different containers.
static void JobC(Args _args)
{
    container variable2, variable33;
    variable2 += [98];
    variable33 = variable2;
    variable2 += [97];
}

// List class example. In this example, variable2 and variable33 refer to the same List object.
static void JobL(Args _args)
{
    List variable2,variable33;
    variable2 = new List(Types::Integer);
    variable2.addEnd(98);
    variable33 = variable2;
    variable2.addEnd(97);
}

// The automatic type conversion by anytype also applies to the special syntax for making multiple
// assignments from a container in one statement. This is shown in the following code example,
// which assigns a str to an int, and an int to a str.
static void JobContainerMultiAssignmentUsesAnytype(Args _args)
{
    container con2;
    int int4;
    str str7;
    con2 = ["11", 222];
    [int4, str7] = con2;
    info(strfmt("int4==11==(%1), str7==222==(%2)", int4, str7));
}

/***  Output:
Message (10:36:22 am)
int4==11==(11), str7==222==(222)
***/

static void UseQuery()
{
    // An example of how the compiler diagnoses attempts to store object in containers
    container c = [new Query()];   // This statement will cause the error message shown below.
    /*** Instance of type 'Query' cannot be added to a container. ***/

    // An example of a code that won't cause an error message, but will
    // cause an error message to be thrown at runtime.
    anytype a = new Query();
    container d = [a];
}

Класове като типове данни

Класът е дефиниция на тип, която описва както променливи, така и методи за екземпляри на класа. (Екземплярите на класа са известни също като обекти.) Класът е само дефиниция за обекти и всички обекти са Null , когато са декларирани. В Application Explorer всеки клас приложения под възела Classes е тип данни. Можете да декларирате променливи от тези типове във вашия код. Можете да създадете екземпляри на клас и да присвоите екземплярите на променливи.

Класовете могат да бъдат вложени в първичен код. Вложените класове са налични само във формуляри (например клас, който разширява FormRun) и се използват за представяне на контроли, източници на данни или полета за данни. Украсата на атрибут, като например украсата на атрибут на клас или метод, може да пропусне суфикса на името на атрибута, ако суфиксът е Attribute. Следователно X++ позволява на [MyFavorite], вместо да изисква [MyFavoriteAttribute]. Освен това атрибутите сега се прилагат към манипулаторите на представители и методи, за да се съпоставят манипулаторите с тези цели.

В AX 2012 и по-стари версии можете да посочите метод за изпълнение на клиента или сървъра. Обаче в приложения за финанси и операции всички компилирани X++ код се изпълнява като .NET Common Intermediate Language (CIL) на сървъра. Вече няма код, който да се оценява на клиентския сайт или в браузъра. Следователно ключовите думи за клиента и сървъра сега се игнорират. Въпреки че тези ключови думи не предизвикват грешка при компилиране, ако се използват, те не трябва да се използват в никакъв нов код.

Променливи на личен и защитен член

Преди всички променливи на членове, които са били дефинирани в клас, са били защитени. Сега можете да направите видимостта на променливите на членовете явни, като добавите личните, защитените и публичните ключови думи. Интерпретацията на тези модификатори е очевидна и съответства на семантиката за методите:

• private – Променливата на члена може да се използва само в рамките на класа, в който е дефинирана.
• защитен – Променливата на члена може да се използва в класа, където е дефинирана, и във всички подкласове на този клас.
• public – Променливата на члена може да се използва навсякъде. Тя е видима извън границите на йерархията на класа, където е дефинирана.

По подразбиране променливите на членовете, които не са украсени с изричен модификатор, все още са защитени. Като най-добра практика обаче трябва изрично да зададете видимостта. Както описахме по-рано, когато променлива член е дефинирана като публична, тя може да бъде достъпна извън класа, където е дефинирана. В този случай трябва да зададете ограничител, който посочва обекта, който хоства променливата. За да зададете ограничител, използвайте точ.нотация, както правите за извиквания на метода.

В следващия пример се осъществява достъп до поле1 с помощта на явен този ограничител. В този случай може да не е добра идея да направите променлива член публична, тъй като този подход излага вътрешните работи на класа на неговите потребители и следователно създава силна зависимост между прилагането на класа и неговите потребители. Винаги трябва да се опитвате да разчитате само на договор, а не на реализация.

public class AnotherClass3
{
    int field1;
    str field2;
    void new()
    {
        this.field1 = 1;   // Explicit object designated.
        field2 = "Banana";  // 'this' assumed, as usual.
    }
}

Статични конструктори и статични полета

Статичните полета са полета, които са обявени с помощта на статична ключова дума. Концептуално, за класа се прилагат статични полета, а не за екземпляри на класа. Гарантирано е, че статичните конструктори ще се изпълняват преди провеждането на статични повиквания или извиквания на екземпляри към класа. Изпълнението на статичния конструктор е спрямо сесията на потребителя. Никога не се обаждате изрично на статичния конструктор. Вместо това компилаторът ще генерира код, за да се уверите, че конструкторът се нарича точно един път, преди да се извика друг метод в класа. Статичен конструктор се използва за инициализиране на всички статични данни или извършване на действие, което трябва да се извърши само веднъж. Не можете да предоставите параметри за статичния конструктор и той трябва да бъде маркиран със статична ключова дума.

// An example of how a singleton (call instance in the example below)
// can be created using the static constructor.
public class Singleton
{
    private static Singleton instance;
    private void new()
    {
    }
    static void TypeNew()    // This is the static constructor.
    {
        instance = new Singleton();
    }

    public static Singleton Instance()
    {
        return Singleton::instance;
    }
}

// The singleton ensures that only one instance of the class
// will be called, which is consumed by the following.
{
    // Your code here.
    Singleton i = Singleton::Instance();
}

Елементи на клас в Application Explorer

Под повечето възли на класа в Application Explorer има два специални възела: възел classDeclaration и нов възел. КласDeclaration винаги съдържа ключовата дума за класа X++. Могат да бъдат включени допълнителни ключови думи, като например разширения, за да се промени класът. Този възел може също да съдържа декларации на променливи на член.

В следващия пример променливите m_priority и m_rectangle са членове на класа.

// An example of a classDeclaration.
public class YourDerivedClass extends YourBaseClass
{
    int m_priority;
    Rectangle m_rectangle;
    void new(int _length, int _width)
    {
        this.m_rectangle = new Rectangle(_length, _width);
    }
}

Новият оператор съдържа логика, която се изпълнява, когато новият оператор се използва за създаване на екземпляр на класа. Логиката в новия метод може да конструира обект и да присвои този обект на променлива, която е декларирана в classDeclaration. Всеки клас може да има само един нов метод. Въпреки това в новия метод често трябва да извикате новия метод на базовия клас. За да извикате новия метод на базовия клас, обадете се на super().

Следващият пример показва новия метод за класа YourDerivedClass в предишния пример classDeclaration . В този нов метод кодът изгражда екземпляр на класа "Правоъгълник" . Екземплярът е присвоен на променливата m_rectangle . Тази ключова дума, която се използва в примера, не е задължителна, но ако я включите, IntelliSense може да е по-полезно.

// An example of the new method from the previous classDeclaration example.
void new(int _length, int _width)
{
    this.m_rectangle = new Rectangle(_length, _width);
}

Събиране на отпадъци

В крайна сметка по време на изпълнение повечето обекти вече нямат променлива, която сочи към тях. Системата сканира за тези обекти и ги изтрива от паметта. След това пространството на паметта става достъпно за други цели. Класът "Обект" има метод, който е с име "финализиране". Обаче методът за финализиране не е деструктор. Runtime никога не извиква метода за финализиране дори когато даден обект се събира като боклук.

Класове на системата

В Application Explorer, под Класове документация на> системата, има списък на класовете на ядрото или класовете на системата. Класовете на системата не са написани в X++и не можете да видите техния първичен код. Не можете да добавяте системни класове. Класовете на системата обикновено имат нов метод, но нямат възел classDeclaration . Всеки клас приложения неявно разширява класа На системата object . Някои системни класове се разширяват с клас приложения, който има подобно име. Например xClassFactory се разширява с ClassFactory. В тези случаи не трябва да използвате класа на системата. За повече информация вижте "Заместване на класовете приложения за системни класове" в Класове и методи.

Методи за разширение

Функцията за метод на разширение ви позволява да добавите методи за разширение към целеви клас, като напишете методите в отделен клас на разширение. Прилагат се следните правила:

• Класът на разширение трябва да бъде статичен.
• Името на разширения клас трябва да завършва с десет знака, _Extension обаче няма ограничение за частта от името, която предхожда суфикса.
• Всеки метод на разширение в разширения клас трябва да бъде деклариран като публичен статичен.
• Първият параметър във всеки метод на разширение е типът, който методът на разширение разширява. Когато обаче се извиква методът на разширение, повикващият не трябва да подава нищо за първия параметър. Вместо това системата автоматично предава необходимия обект за първия параметър.
• Целта на метода на разширение трябва да бъде тип обект клас, таблица, изглед или карта на приложение.

Разширеният клас може да съдържа лични или защитени статични методи. Тези методи обикновено се използват за подробности за внедряването и не се показват като разширения. Методът на разширение не влияе върху първичния код на класа, който разширява, следователно добавянето към класа не изисква многослойно.

Надстройките до целевия клас никога не се влияят от съществуващите методи за разширение. Ако надстройване до целевия клас добавя метод, който има същото име като вашия метод за разширение, вашият метод на разширение вече не може да бъде достигнат чрез обекти от целевия клас. Методът на разширение използва същия синтаксис с разделители точка, който често използвате за извикване на методи на обикновен екземпляр. Методите за разширение имат достъп до всички публични артефакти на целевия клас, но нямат достъп до нищо, което е защитено или лично. Следователно, методите на разширение могат да се считат за тип синтактична захар. Независимо от типа цел, клас разширение се използва за добавяне на методи за разширение към типа. Например таблица с разширения не се използва за добавяне на методи към таблица и няма такова нещо като допълнителна таблица.

// An example of an extension class holding a few extension methods.
public static class AtlInventLocation_Extension
{
    public static InventLocation refillEnabled(
        InventLocation _warehouse,
        boolean _isRefillEnabled = true)
    {
        _warehouse.ReqRefill = _isRefillEnabled;
        return _warehouse;
    }

    public static InventLocation save(InventLocation _warehouse)
    {
        _warehouse.write();
        return _warehouse;
    }
}

Представители като типове данни

Представител събира методи, които се абонират за него. Представителят указва подписа на параметъра, който всички негови методи за абонати трябва да споделят. Когато представителят бъде повикан, представителят се обажда на всеки от своите абонати. Представителят никога не връща стойност и не може да има стойност по подразбиране. В началото всеки представител няма абонирани методи. Няма ограничение за броя на параметрите, които представителят може да декларира и няма ограничение за типа на тези параметри. Основният текст на представителя винаги е празен, защото единствената цел на представителя е да дефинира договора, с който абонатите трябва да отговарят. Не е необходимо представителят да бъде дефиниран в клас. Представителите могат също да бъдат дефинирани в таблица, формуляр или заявка.

Примери за представител

abstract class VarDatClass
{

    void new(utcdatetime _dateTime, str _changeDescription)
    {
        // An example of subscribing a delegate.
        this.notifyChanged += eventhandler(this.InfologChanges);
        this.notifyChanged += eventhandler(this.SaveInDatabase);
        
        notifyChange(_dateTime, _changeDescription);
    }

    void notifyChange(utcdatetime _dateTime, str _changeDescription)
    {
        // An example of calling a delegate.
        this.notifyChanged(_dateTime, _changeDescription);
    }
    
    // delegate method examples
    // An example of declaring a delegate.
    delegate void notifyChanged(utcdatetime _dateTime, str _changeDescription)
    {
    }

    // method that is to be subscribed.
    public static void InfologChanges(utcDateTime _dateTime, str _changeDescription)
    {
        info("A notification has occurred calling static handler:" +
            DateTimeUtil::toStr(_dateTime) +
            " Message:" +
            _changeDescription);
    }
    
    // method that is to be subscribed.
    public static void SaveInDatabase(utcDateTime _dateTime, str _changeDescription)
    {
       // save changes in database.
    }
    
    
}

Таблици като типове данни

Всички таблици могат да се третират като дефиниции на клас. Променлива на таблица може да се счита за екземпляр (обект) на дефиницията на таблицата (класа). За всяко поле в променлива на таблица стойността по подразбиране е празна. Можете да адресирате полета и да създавате методи в таблици. Методите могат да бъдат извикани в екземпляри на таблицата. За да управлявате (т.е. да четете, актуализирате, вмъквате и изтривате) записи в таблици, трябва да декларирате поне една променлива на таблица, която може да задържи записа на фокус. Като най-добра практика трябва да използвате името на таблицата като име на променливата, но да използвате начална малка буква. Ето няколко важни разлики между таблици и обекти:

• Не можете да разпределите място за променливите на таблицата. Разпределението се извършва неявно.
• Полетата в променливите на таблицата са публични. Можете да се обръщате към тях навсякъде.
• Полетата в променливите на таблицата могат да бъдат адресирани с помощта на изрази.

Няма автоматично преобразуване, но променливите на таблицата, които са декларирани като Общи , могат да задържат данни от всяка таблица.

Обхват на променливите на таблицата

В повечето отношения променливите на таблицата могат да се считат за обекти, но за разлика от обектите, те не са изрично разпределени. Изисква се само деклариране на променлива. Всички таблици са съвместими с таблицата Common , точно както всички обекти са съвместими с класа Object . Променливите в таблицата се декларират като общи буфери и могат да се използват за задържане на данни от всяка таблица. Нямате достъп до таблици, които нямат променливи на таблица. Принципите за деклариране на променливите и обектите в таблицата са едни и същи, с изключение на разпределението на пространството.

Примери за таблица

Синтаксисът позволява различни възможности за препращане на полета в записи. Например можете да използвате TableName.( Синтаксис на FieldId ).

Примерът по-долу отпечатва съдържанието на полетата в текущия запис в таблицата "Клиент".

// Declares and allocates space for one CustTable record.
public void myMethod()
{
    CustomerTable custTable;
}

// An example of referencing table variables.
public void printAccountNo()
{
    CustomerTable custTable;
    print custTable.AccountNo;  // Prints the field reference.
}

Следващият пример използва методите fieldCnt и fieldCnt2Id . Методът fieldCnt преброява полетата в таблица, докато fieldCnt2Id връща ИД за номер на поле. Можете например да използвате метода fieldCnt2Id , за да научите, че полето с номер 6 в таблица има ИД 54. Това преобразуване е задължително, тъй като няма гаранция, че ИД на полетата в таблица са последователни.

// An example of the various possibilities for referencing fields in records.
public void printCust()
{
    int i, n, k;
    CustomerTable custTable;
    DictTable dictTable;
    dictTable = new DictTable(custTable.TableId);
    n = dictTable.fieldCnt();
    print "Number of fields in table: ", n;
    for(i=1; i<=n; i++)
    {
        k = dictTable.fieldCnt2Id(i);
        print "The ", dictTable.fieldName(k),
        " field with Id=",k, " contains '",
        custTable.(k), "'";
    }
}