---
title: 検索結果を理解する
slug: neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc
createdAt: 2026-10-29T01:28:25.992Z
---

S**earch&#x20;**&#x57;eb メソッドの戻り値は、2 次元配列内の W**ebServiceBusinessobject&#x20;**&#x30AA;ブジェクトのリストです。 前のセクションでは、単一のビジネス オブジェクトに対してレコードが返される単純な検索例を示しました。 現在のオブジェクトと関連オブジェクトに対して検索を実行する場合、2 次元配列の各項目は一致する親子の組み合わせを表します。

このセクションには次のトピックが含まれています。

- [検索結果のシナリオ](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#Search-Result-Scenarios)
- [関連検索例](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#Related)
- [ルール基準のグループ化](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#Grouping_the_Rule_Criteria)
- [全文検索について](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#About_Full-Text_Searching)
- [検索ウェブメソッドで使用されるクラスの正式な説明](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#Formal_Description_of_the_Classes_used_by_the_Search_Web_Method)

## 検索結果のシナリオ

- [シナリオ 1: 単一のビジネス オブジェクトを検索し、完全一致を返す](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#Scenario)
- [シナリオ 2: 単一のビジネス オブジェクトを検索し、複数の一致を返す](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#Scenario2)
- [シナリオ 3: 単一のビジネス オブジェクトとそれに関連する子オブジェクトを検索し、親ビジネス オブジェクトに完全に一致する 1 つのオブジェクトを返す](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#Scenario3)
- [シナリオ 4: 単一のビジネス オブジェクトとそれに関連する子ビジネス オブジェクトを検索し、親ビジネス オブジェクトに一致する複数のオブジェクトを返す](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#Scenario4)

### シナリオ 1: 単一のビジネス オブジェクトを検索し、完全一致を返す

このシナリオでは、検索は単一のビジネス オブジェクトに対して定義され、検索結果は 1 つの正確なレコードを返します。 **objList\[0]\[0]** には一致するインシデントレコードが含まれています。

```bash
ObjectQueryDefinition query = new ObjectQueryDefinition();

FieldClass[] fieldObjects = new FieldClass[] {
new FieldClass()
                {
                    名前 = "インシデント番号",
                    タイプ = "テキスト"
                },
new FieldClass()
                {
                    名前 = "ステータス"、
                    タイプ = "テキスト"
                }
            };

            query.Select = new SelectClass();
            query.Select.Fields = fieldObjects;

            query.From = new FromClass();
            query.From.Object = "Incident";
            query.Where = new RuleClass[] {
new RuleClass()
                {
                    フィールド = "IncidentNumber"、
                    条件 = "="、
                    値 = "10001"
                }
            };

FRSHEATIntegrationSearchResponse searchResponse = frSvc.Search(authSessionKey, tenantId, query);
if (searchResponse.status == "成功")
            {
WebServiceBusinessObject[][] objList = searchResponse.objList;
foreach (WebServiceBusinessObject[] objOuterList in objList)
                {
foreach (WebServiceBusinessObject obj を objOuterList に含めます)
                    {
WebServiceFieldValue[] objFieldList = obj.FieldValues;
Console.WriteLine("{0} と {1} \\"{2}\\" が選択条件に一致します", obj.BusinessObjectName, objFieldList[0].Name, objFieldList[0].Value);
                    }
                }
            }
        }
```

ここでは、テナント内のインシデント 10001 を具体的に検索しています。 レコードがテナント内に存在する場合、 **objList\[0]\[0]** 配列で使用できます。

### シナリオ 2: 単一のビジネス オブジェクトを検索し、複数の一致を返す

このシナリオでは、検索は単一のビジネス オブジェクトに対して定義され、検索結果として *n* の一致するレコードが返されます。 一致するレコードには、 **objList\[0]\[0]** から **objList\[*n*-1]\[0]**&#x307E;でアクセスできます。

たとえば、検索によって 10 件のインシデント レコードが返されるとします。  インシデントレコードには、 **objList\[0]\[0]** から **objList\[9]\[0]**&#x307E;でアクセスできます。 2 次元配列の最初のインデックスは変更されますが、2 番目のインデックスは 0 のままです。

```bash
ObjectQueryDefinition query = new ObjectQueryDefinition();

FieldClass[] fieldObjects = new FieldClass[] {
new FieldClass()
                {
                    名前 = "インシデント番号",
                    タイプ = "テキスト"
                },
new FieldClass()
                {
                    名前 = "ステータス"、
                    タイプ = "テキスト"
                }
            };

            query.Select = new SelectClass();
            query.Select.Fields = fieldObjects;

            query.From = new FromClass();
            query.From.Object = "Incident";
            query.Where = new RuleClass[] {
new RuleClass()
                {
                    フィールド = "IncidentNumber"、
                    条件 = "<="、
                    値 = "10010"
                }
            };
            query.OrderBy = new OrderByClass[] {
新しい OrderByClass()
                {
                    名前 = "インシデント番号",
                    方向 = "ASC"
                }
            };

FRSHEATIntegrationSearchResponse searchResponse = frSvc.Search(authSessionKey, tenantId, query);

if (searchResponse.status == "成功")
            {
WebServiceBusinessObject[][] objList = searchResponse.objList;
foreach (WebServiceBusinessObject[] objOuterList in objList)
                {
foreach (WebServiceBusinessObject obj を objOuterList に含めます)
                    {
WebServiceFieldValue[] objFieldList = obj.FieldValues;
Console.WriteLine("{0} と {1} \\"{2}\\" が選択条件に一致します", obj.BusinessObjectName, objFieldList[0].Name, objFieldList[0].Value);
                    }
                }
            }
        }
シナリオ 1 のコードと比較すると、次の部分のみが更新されています。
            query.Where = new RuleClass[] {
new RuleClass()
                {
                    フィールド = "IncidentNumber"、
                    条件 = "<="、
                    値 = "10010"
                }
            };
```

インシデント番号が 10010 以下のインシデント レコードを検索しています。 テナントに 10001 から 10010 までのインシデント レコードがある場合、インシデント 10001 には **objList\[0]\[0]**&#x7D4C;由でアクセスでき、インシデント 10002 には **objList\[1]\[0]**&#x7D4C;由でアクセスでき、インシデント 10010 までは **objList\[9]\[0]**&#x7D4C;由でアクセスできます。

このトピックでは、検索結果の 2 次元配列を介して、コレクション内の各項目に個別にアクセスする方法を説明します。 検索対象となる子オブジェクトがないため、 **objList\[n]\[0]**&#x3092;使用してすべての項目にアクセスできます。

*シナリオ 2 検索結果*

::Image[]{src="https://api.archbee.com/api/optimize/parib0MC3hVoUNdfQdnac/EJmYw3Wp2xSZbsl7Z4dfy_03000005.png" position="flex-start" size="81" width="567" height="202" initialPath="../../Resources/Images/help-images/03000005.png" githubPath="Admin-User-Jpn/Content/Resources/Images/help-images/03000005.png" showCaption="false" indent="1"}

### シナリオ 3: 単一のビジネス オブジェクトとそれに関連する子オブジェクトを検索し、親ビジネス オブジェクトに完全に一致する 1 つのオブジェクトを返す

このシナリオでは、 **Journal.Email** レコードが一致するインシデントを検索しています。 検索により、関連する 4 つの **Journal.Email** レコードを含む 1 つの一致するインシデント レコードが返されます。

現在のオブジェクトと関連オブジェクトに対して検索を実行する場合、2 次元配列内の各項目が一致する親子の組み合わせを表すことに注意することが重要です。 このシナリオでは、一致する親インシデント レコードが 1 つしかないため、検索結果には、一致する **Journal.Email** レコードごとに 1 つずつ、同じ親レコードが 4 回含まれます。

親インシデントレコードには、 **objList\[0]\[0]**、 **objList\[1]\[0]**、 **objList\[2]\[0]**、または **objList\[3]\[0]**&#x306E;いずれかを使用してアクセスできます。 ここで、最初のインデックス値は変化し、2 番目のインデックス値は 0 (メイン オブジェクトを示す) になります。

一致する個々の **Journal.Email** 子レコードには、 **objList\[0]\[1]**、 **objList\[1]\[1]**、 **objList\[2]\[1]**、および **objList\[3]\[1]**&#x3092;使用してアクセスできます。 最初のインデックス値は変化します (一致する各 **Journal.Email** レコードに対応するため)。2 番目のインデックスは 1 です (最初の子オブジェクトを示します)。

```bash
ObjectQueryDefinition query = new ObjectQueryDefinition();

FieldClass[] fieldObjects = new FieldClass[] {
new FieldClass()
                {
                    名前 = "インシデント番号",
                    タイプ = "テキスト"
                },
new FieldClass()
                {
                    名前 = "Journal.Subject",
                    タイプ = "テキスト"
                }
            };

            query.Select = new SelectClass();
            query.Select.Fields = fieldObjects;

            query.From = new FromClass();
            query.From.Object = "Incident";
            query.From.Links = new FromLinkClass[] {
new FromLinkClass {
                    関係 = "",
                    オブジェクト = "ジャーナル
                }
            };
            query.Where = new RuleClass[] {
new RuleClass()
                {
                    フィールド = "IncidentNumber"、
                    条件 = "="、
                    値 = "10001"
                },
new RuleClass()
                {
                    フィールド = "Journal.Category"、
                    条件 = "="、
                    値 = "受信メール"
                },
            };
            query.OrderBy = new OrderByClass[] {
新しい OrderByClass()
                {
                    名前 = "インシデント番号",
                    方向 = "ASC"
                },
新しい OrderByClass()
                {
                    名前 = "Journal.Subject",
                    方向 = "ASC"
                }
            };

FRSHEATIntegrationSearchResponse searchResponse = frSvc.Search(authSessionKey, tenantId, query);

if (searchResponse.status == "成功")
            {
WebServiceBusinessObject[][] objList = searchResponse.objList;
foreach (WebServiceBusinessObject[] objOuterList in objList)
                {
foreach (WebServiceBusinessObject obj を objOuterList に含めます)
                    {
WebServiceFieldValue[] objFieldList = obj.FieldValues;
Console.WriteLine("{0} と {1} {2} が選択条件に一致します", obj.BusinessObjectName, objFieldList[0].Name, objFieldList[0].Value);
                    }
                }
            }
```

インシデント番号が 10001 で、カテゴリが「€受信メール」€ である **Journal.Email** レコード (つまり、メール リスナー経由でインシデント レコードに添付されたメール) が関連付けられているインシデント レコードを検索しています。

検索では、最上位オブジェクト (インシデント) だけでなく、関連する **Journal.Email** レコードも考慮する必要があるため、追加のコード行を記述する必要があります。

F**romLinkClass&#x20;**&#x30AF;ラスを指定する必要があります:

```bash
            query.From.Links = new FromLinkClass[] {
new FromLinkClass {
                    関係 = "",
                    オブジェクト = "ジャーナル
                }
            };
```

ここでは、インシデントから Journal.Email への関係を指定する **FromLinkClass** クラスの新しいインスタンスを作成します。 既存の **IncidentContainsJournal** 関係 (ジャーナル ベース オブジェクトを指す) を使用して、インシデントを子ジャーナル レコードに関連付けることができます。

リレーションシップには内部参照名パラメータに指定された値がないため、上記の **リレーション** メンバーの **リレーション** 値は空の文字列のままになります。 検索対象となる実際のオブジェクト (この場合は Journal.Email) は、上記の **Object** メンバーで指定する必要があります。

F**romClass&#x20;**&#x30AF;ラスに指定された L**inks&#x20;**&#x30D7;ロパティを使用すると、関連するビジネス オブジェクトのフィールドにアクセスできます。 たとえば、インシデントのインシデント番号フィールドにアクセスするだけでなく、Journal.Email の件名にもアクセスできます。

```bash
FieldClass[] fieldObjects = new FieldClass[] {
new FieldClass()
                {
                    名前 = "インシデント番号",
                    タイプ = "テキスト"
                },
new FieldClass()
                {
                    名前 = "Journal.Subject",
                    タイプ = "テキスト"
                }
            };
```

J**ournal.Email&#x20;**&#x30D3;ジネス オブジェクトの件名フィールドを参照するには、フィールド名を "€Journal.Subject"€ として指定する必要があります。

J**ournal.Email&#x20;**&#x30D3;ジネス オブジェクト (カテゴリなど) 内のフィールドを使用してルール条件を指定するには、フィールド名を "€Journal.Category"€ として指定する必要があります。

```bash
            query.Where = new RuleClass[] {
new RuleClass()
                {
                    フィールド = "IncidentNumber"、
                    条件 = "="、
                    値 = "10001"
                },
new RuleClass()
                {
                    フィールド = "Journal.Category"、
                    条件 = "="、
                    値 = "受信メール"
                },
            };
```

例のシナリオでは、テナントにインシデント 10001 が存在し、それに 4 つの Journal.Email が添付されており、件名の値が "€Email 1"€、"€Email 2"€、"€Email 3"€、および "€Email 4"€ であると想定します。

上記のサンプル コードを実行すると、コンソール ウィンドウに次の結果が表示されます。

```bash
インシデント番号「10001」のインシデントが選択基準に一致します
Journal.Subject「Email 1」のJournal.Emailが選択基準に一致します
インシデント番号「10001」のインシデントが選択基準に一致します
Journal.Subject「Email 2」のJournal.Emailが選択基準に一致します
インシデント番号「10001」のインシデントが選択基準に一致します
Journal.Subject「Email 3」のJournal.Emailが選択基準に一致します
インシデント番号「10001」のインシデントが選択基準に一致します
Journal.Subject「Email 4」のJournal.Emailが選択基準に一致します
```

親子の組み合わせごとに結果が返されます。 4 つの **Journal.Email** レコードは同じインシデント レコード (インシデント 10001) に関連付けられているため、この同じインシデント レコードは、関連付けられている **Journal.Email** 子レコードごとに 1 回ずつ、合計 4 回表示されます。

下の図は、検索結果の 2 次元配列を介して、親子の組み合わせ内の各項目に個別にアクセスする方法を示しています。

*シナリオ3検索結果*

::Image[]{src="https://api.archbee.com/api/optimize/parib0MC3hVoUNdfQdnac/1dwcuyeiGIQ2ME-dgvoh6_03000006.png" position="flex-start" size="83" width="579" height="277" initialPath="../../Resources/Images/help-images/03000006.png" githubPath="Admin-User-Jpn/Content/Resources/Images/help-images/03000006.png" showCaption="false" indent="1"}

### シナリオ 4: 単一のビジネス オブジェクトとそれに関連する子ビジネス オブジェクトを検索し、親ビジネス オブジェクトに一致する複数のオブジェクトを返す

一致する **Journal.Email** レコードを持つインシデントを検索していると仮定します。 検索によって 2 つの一致するインシデント レコードが返され、その中に 6 つの関連する **Journal.Email** レコードが含まれているとします。最初のインシデント レコード (インシデント 10001 など) が 4 つ、2 番目のインシデント レコード (インシデント 10008 など) が 2 つになります。

現在のオブジェクトと関連オブジェクトに対して検索を実行する場合、2 次元配列の各項目は一致する親子の組み合わせを表します。

このシナリオでは、一致する親インシデント レコードが 2 つあり、関連する **Journal.Email** レコードが 6 つあるため、検索では 6 つの結果が返されます。

最初のインシデント レコードは、 **objList\[0]\[0]**、 **objList\[1]\[0]**、 **objList\[2]\[0]**、および **objList\[3]\[0]**&#x306E;いずれかを使用して表示され、それに対応する **Journal.Email** レコードは、 **objList\[0]\[1]**、 **objList\[1]\[1]**、 **objList\[2]\[1]**、および **objList\[3]\[1]**&#x3092;介して表示されます。

2番目のインシデントレコードは、 **objList\[4]\[0]** と **objList\[5]\[0]** のいずれかを使用して表示され、それに対応する **Journal.Email** レコードは、 **objList\[4]\[1]** と **objList\[5]\[1]**&#x3092;介して表示されます。

```bash
ObjectQueryDefinition query = new ObjectQueryDefinition();

FieldClass[] fieldObjects = new FieldClass[] {
new FieldClass()
                {
                    名前 = "インシデント番号",
                    タイプ = "テキスト"
                },
new FieldClass()
                {
                    名前 = "Journal.Subject",
                    タイプ = "テキスト"
                }
            };

            query.Select = new SelectClass();
            query.Select.Fields = fieldObjects;

            query.From = new FromClass();
            query.From.Object = "Incident";
            query.From.Links = new FromLinkClass[] {
new FromLinkClass {
                    関係 = "",
                    オブジェクト = "ジャーナル
                }
            };
            query.Where = new RuleClass[] {
new RuleClass()
                {
                    フィールド = "IncidentNumber"、
                    条件 = "<="、
                    値 = "10010"
                },
new RuleClass()
                {
                    フィールド = "Journal.Category"、
                    条件 = "="、
                    値 = "受信メール"
                },
            };
            query.OrderBy = new OrderByClass[] {
新しい OrderByClass()
                {
                    名前 = "インシデント番号",
                    方向 = "ASC"
                },
新しい OrderByClass()
                {
                    名前 = "Journal.Subject",
                    方向 = "ASC"
                }
            };

FRSHEATIntegrationSearchResponse searchResponse = frSvc.Search(authSessionKey, tenantId, query);

if (searchResponse.status == "成功")
            {
WebServiceBusinessObject[][] objList = searchResponse.objList;
foreach (WebServiceBusinessObject[] objOuterList in objList)
                {
foreach (WebServiceBusinessObject obj を objOuterList に含めます)
                    {
WebServiceFieldValue[] objFieldList = obj.FieldValues;
Console.WriteLine("{0} と {1} {2} が選択条件に一致します", obj.BusinessObjectName, objFieldList[0].Name, objFieldList[0].Value);
                    }
                }
            }
```

シナリオ 3 のコードと比較すると、次の部分のみが更新されています。

```bash
            query.Where = new RuleClass[] {
new RuleClass()
                {
                    フィールド = "IncidentNumber"、
                    条件 = "<="、
                    値 = "10010"
                }
            };
```

インシデント番号が 10010 以下で、受信メールのカテゴリに関連付けられた **Journal.Email** レコード (つまり、メール リスナー経由でインシデント レコードに添付されたメール) を持つインシデント レコードを検索しています。

したがって、この例のシナリオでは、テナントにインシデント 10001 が存在し、それに 4 つの **Journal.Email** レコードが添付されており、件名の値が "€Email 1"€、"€Email 2"€、"€Email 3"€、および "€Email 4"€ であると想定します。

テナントにインシデント 10008 も存在し、件名の値が "€Email 5"€ と "€Email 6"€ である 2 つの **Journal.Email** レコードが添付されているとします。

上記のサンプル コードを実行すると、コンソール ウィンドウに次の結果が表示されます。

```bash
インシデント番号「10001」のインシデントが選択基準に一致します
Journal.Subject「Email 1」のJournal.Emailが選択基準に一致します
インシデント番号「10001」のインシデントが選択基準に一致します
Journal.Subject「Email 2」のJournal.Emailが選択基準に一致します
インシデント番号「10001」のインシデントが選択基準に一致します
Journal.Subject「Email 3」のJournal.Emailが選択基準に一致します
インシデント番号「10001」のインシデントが選択基準に一致します
Journal.Subject「Email 4」のJournal.Emailが選択基準に一致します
インシデント番号「10008」のインシデントが選択基準に一致します
Journal.Subject「Email 5」のJournal.Emailが選択基準に一致します
インシデント番号「10008」のインシデントが選択基準に一致します
Journal.Subject「Email 6」のJournal.Emailが選択基準に一致します
```

親子の組み合わせごとに結果が返されます。

インシデント 10001 には 4 つの **Journal.Email** レコードが関連付けられているため、この同じインシデント レコードは、関連付けられている 4 つの **Journal.Email** 子レコードごとに 1 回ずつ、計 4 回表示されます。 その後、インシデント 10008 に関連付けられた 2 つの **Journal.Email** レコードが存在するため、この同じインシデントが、関連付けられた 2 つの **Journal.Email** 子レコードごとに 1 回ずつ、計 2 回表示されます。

合計で、このような親子の組み合わせは 6 つあるため、返されるオブジェクト レコードは 12 個になります (インシデント用に 6 個、個別の **Journal.Email** レコード用に 6 個)。

下の図は、検索結果の 2 次元配列を介して、親子の組み合わせ内の各項目に個別にアクセスする方法を示しています。

*シナリオ4 検索結果*

::Image[]{src="https://api.archbee.com/api/optimize/parib0MC3hVoUNdfQdnac/ZUIjhdQNfu_uDDLTRmUqv_03000007.png" position="flex-start" size="83" width="579" height="633" initialPath="../../Resources/Images/help-images/03000007.png" githubPath="Admin-User-Jpn/Content/Resources/Images/help-images/03000007.png" showCaption="false" indent="1"}

## 関連検索例

このセクションでは、前のセクションで説明した関連検索機能を拡張する完全なコード例を示します。 以下のサンプル コードは、ログイン ID によって指定された従業員に関連付けられているロールを検索する方法を示しています。

```bash
文字列ログインID = "管理者";

ObjectQueryDefinition query = new ObjectQueryDefinition();

// ここでは、現在の従業員に関連するロール レコードを照会しています。 クエリを実行する場合
// 関連するビジネスオブジェクトの特定のフィールドに対して、フィールド名は
// 最初にビジネスオブジェクト名、次にピリオド、そして
// フィールドの名前。 例えば "Frs_def_role.RoleID"

// この例では、関連するRoleIDフィールドとDisplayNameフィールドをクエリしています。
// "Frsdefrole"ビジネス オブジェクト

// 現在のビジネスオブジェクトに対してフィールドをクエリする場合、
//（例えば 「従業員」の場合、
// ビジネスオブジェクトの先頭にフィールド名を付ける必要はありません（例： 「ログインID」
// "Employee.LoginID" の代わりに)
フィールドクラス[] フィールドオブジェクト = 新しいフィールドクラス[] {
新しいフィールドクラス()
{
名前 = "Frsdefrole.RoleID"、
タイプ = "テキスト"
},
新しいフィールドクラス()
{
名前 = "Frsdefrole.DisplayName",
タイプ = "テキスト"
}
};

クエリー.Select = 新しい SelectClass();
クエリーを選択します。

// ここでは、クエリの対象となるビジネスオブジェクトとして従業員を指定し、
// FromLinkClass 経由で検索する関係を指定します

// オブジェクトを指定することに加えて、関係プロパティの値は
// 関係の内部参照名になります。

// 従業員とFrsdefroleの関係の場合、
// 内部参照名が空なので、次のように指定する必要があります。
// ここは空文字列

クエリ.From = 新しい FromClass();
query.From.Object = "Profile.Employee";
query.From.Links = 新しいFromLinkClass[] {
新しいFromLinkClass{
関係 = "",
オブジェクト = "Frsdefrole
}
};

// 特定の従業員レコードを照会するための条件を指定します
// (例: ログインIDが「管理者」の従業員)
query.Where = 新しいルールクラス[] {
new RuleClass()
{
フィールド = "ログインID"、
条件 = "="、
値 = ログインID
}
};

FRSHEATIntegrationSearchResponse searchResponse = frSvc.Search(authSessionKey, tenantId, query);

if (searchResponse.status == "Success")
{
// 検索が成功したと仮定すると、objListの検索結果は次のようになります。
// 2 次元配列を介して返されます。 結果の各項目は
// 特定の親子の組み合わせに適用します。 この例では、それぞれが返されました
// objList の結果は一致する <Employee, Role> の組み合わせです
WebServiceBusinessObject[][] objList = searchResponse.objList;

// objListの各項目の最初の項目は親項目です
// オブジェクトであり、2 番目のオブジェクトは子オブジェクトです。 この例では、
// objOuterList[0]は従業員に対応し、
// objOuterlist[1]はロールに対応します

Console.WriteLine("\n次のロールは \\"{0}\\" ユーザーに関連付けられています:\n", loginID);

foreach (WebServiceBusinessObject[] objOuterList in objList)
{
WebServiceBusinessObject obj = objOuterList[1];

// ここでobjはロールレコードを指しているので、objFieldListには
// 一致するロール レコードから使用可能なフィールド。 この例では、
// Role の 2 つのフィールド (RoleID と DisplayName) が照会されます

WebServiceFieldValue[] objFieldList = obj.FieldValues;

Console.WriteLine("* {0} ({1})", objFieldList[0].Value、objFieldList[1].Value);
}
}
```

以下のサンプル コードは、ログイン ID によって指定された従業員に関連付けられているチームを検索する方法を示しています。

```bash
文字列ログインID = "管理者";

ObjectQueryDefinition query = new ObjectQueryDefinition();

// ここでは、現在の従業員の関連チームレコードをクエリしています
// 関連するビジネスオブジェクトの特定のフィールドに対してクエリを実行する場合、フィールド名は
// 最初にビジネスオブジェクト名、次にピリオド、そして最後に
// フィールド名（例） 「StandardUserTeam.チーム」

// この例では、関連するチームとTeamEmailフィールドをクエリしています。
// "StandardUserrTeam" ビジネス オブジェクト

// 現在のビジネスオブジェクトに対してフィールドをクエリする場合（例： 「従業員」の場合、
// ビジネスオブジェクトの前にフィールド名を付ける必要がある（例： 「ログインID」の代わりに
// "従業員.ログインID")

フィールドクラス[] フィールドオブジェクト = 新しいフィールドクラス[] {
新しいフィールドクラス()
{
名前 = "StandardUserTeam.Team",
タイプ = "テキスト"
},
新しいフィールドクラス()
{
名前 = "StandardUserTeam.TeamEmail",
タイプ = "テキスト"
}
};
クエリー.Select = 新しい SelectClass();
クエリーを選択します。


// ここでは、クエリの対象となるビジネスオブジェクトとして従業員を指定し、関係を指定します。
// FromLinkClass 経由で検索します。 オブジェクトを指定するだけでなく、
// リレーションプロパティの値は内部参照名である必要があります
// 関係の。

// wmployeeとStandardUserTeamの関係の場合、内部参照
// 名前は「Rev2」

クエリ.From = 新しい FromClass();
query.From.Object = "Profile.Employee";
query.From.Links = 新しいFromLinkClass[] {
新しいFromLinkClass{
関係 = "Rev2"、
オブジェクト = "StandardUserTeam
}
};
// 特定の従業員レコードを照会するための条件を指定します（例： ログインIDが
// "管理者")

query.Where = 新しいルールクラス[] {
new RuleClass()
{
フィールド = "ログインID"、
条件 = "="、
値 = ログインID
}
};
FRSHEATIntegrationSearchResponse searchResponse = frSvc.Search(authSessionKey, tenantId, query);

if (searchResponse.status == "成功")
{

// 検索が成功したと仮定すると、objList検索結果は2つの方法で返されます。
// 次元配列。 結果の各項目は特定の親子に対応している
// 組み合わせ。 この例では、返される結果ごとに
// objList には一致する <Employee, Team> の組み合わせがあります

WebServiceBusinessObject[][] objList = searchResponse.objList;

// objListの各項目について、最初の項目は親オブジェクト、2番目の項目は
// オブジェクトは子オブジェクトです。 この例では、objOuterList[0]は
// 従業員に対応し、objOuterlist[1]はチームに対応します

Console.WriteLine("\n次のチームは、\\"{0}\\" ユーザーに関連付けられており、対応するチームの電子メール アドレスは:\n", loginID);
foreach (WebServiceBusinessObject[] objOuterList in objList)
{
WebServiceBusinessObject obj = objOuterList[1];

// ここでobjはロールレコードを指しているので、objFieldListには
// 一致するロール レコードから使用可能なフィールド。 この例では、2つの
// ロールのフィールドが照会されます - チームと TeamEmail

WebServiceFieldValue[] objFieldList = obj.FieldValues;

Console.WriteLine("* {0} ({1})", objFieldList[0].Value、objFieldList[1].Value);
}
}
```

## ルール基準のグループ化

前のセクションでは、現在のビジネス オブジェクト (インシデント) とそれに関連する子ビジネス オブジェクト (Journal.Email) に基づいてレコードを検索する方法について説明しました。 前の例では、次のようなクエリを作成する方法について説明しました。

```bash
カテゴリが「€受信メール」€ の関連 Journal.Email レコードを含む、インシデント番号が 10010 未満のすべてのインシデント レコードを取得します。
```

S**earch&#x20;**&#x57;eb メソッドは、ルール条件のグループ化を通じて検索を表現できるほど柔軟です。 たとえば、 **Search** Web メソッドを使用すると、次のようなクエリを表現できます。

```bash
関連するJournal.Emailレコードを含む、IncidentNumberが10010未満のすべてのインシデントレコードを取得します。
（ジャーナルメールのカテゴリは「受信メール」です）
または
ジャーナルメールの件名は「€緊急リクエスト」です。
```

上記の検索により、ユーザーは、Journal.Email のカテゴリが「€Incoming Email」€ である場合 (つまり、電子メール リスナーによって作成された場合)、または電子メールのカテゴリが「€œIncoming Email」€ または「€œOutgoing Email」€ であるかどうかに関係なく、Journal.Email の件名が「€œUrgent Request」€ である場合に、 **Journal.Email** レコードを含むインシデントを検索できます。

上記の検索を表現するには、次のコードサンプルを検討してください。

```bash
ObjectQueryDefinition query = new ObjectQueryDefinition();

FieldClass[] fieldObjects = new FieldClass[] {
new FieldClass()
                {
                    名前 = "インシデント番号",
                    タイプ = "テキスト"
                },
new FieldClass()
                {
                    名前 = "Journal.Category",
                    タイプ = "テキスト"
                }
            };

            query.Select = new SelectClass();
            query.Select.Fields = fieldObjects;

            query.From = new FromClass();
            query.From.Object = "Incident";
            query.From.Links = new FromLinkClass[] {
new FromLinkClass
                {
                    関係 = "",
                    オブジェクト = "ジャーナル
                }
            };
            query.Where = new RuleClass[] {
new RuleClass
                {
                    結合 = "AND"、
                    フィールド = "IncidentNumber"、
                    条件 = "<="、
                    値 = "10010"
                },
new RuleClass
                {
                    ルール = 新しいルールクラス[] {
new RuleClass
                        {
                            フィールド = "Journal.Category"、
                            条件 = "="、
                            値 = "送信メール"
                        },
new RuleClass
                        {
                            結合 = "OR"、
                            フィールド = "Journal.Subject",
                            条件 = "="、
                            値 = 「緊急リクエスト」
                        }
                    }
                }
            };

FRSHEATIntegrationSearchResponse searchResponse = frSvc.Search(authSessionKey, tenantId, query);

if (searchResponse.status == "成功")
            {
WebServiceBusinessObject[][] objList = searchResponse.objList;
foreach (WebServiceBusinessObject[] objOuterList in objList)
                {
foreach (WebServiceBusinessObject obj を objOuterList に含めます)
                    {
WebServiceFieldValue[] objFieldList = obj.FieldValues;
Console.WriteLine("{0} と {1} \\"{2}\\" が選択条件に一致します", obj.BusinessObjectName, objFieldList[0].Name, objFieldList[0].Value);
                    }
                }
            }
```

このコード サンプルは、前のセクションのサンプルのバリエーションであり、いくつかの重要な違いがあります。 O**bjectQueryDefinition&#x20;**&#x30AA;ブジェクトの W**here&#x20;**&#x30D7;ロパティの更新に注意してください。

```bash
            query.Where = new RuleClass[] {
new RuleClass
                {
                    結合 = "AND"、
                    フィールド = "IncidentNumber"、
                    条件 = "<="、
                    値 = "10010"
                },
new RuleClass
                {
                    ルール = 新しいルールクラス[] {
new RuleClass
                        {
                            フィールド = "Journal.Category"、
                            条件 = "="、
                            値 = "送信メール"
                        },
new RuleClass
                        {
                            結合 = "OR"、
                            フィールド = "Journal.Subject",
                            条件 = "="、
                            値 = 「緊急リクエスト」
                        }
                    }
                }
            };
```

トップレベルには 2 つの **RuleClass** オブジェクトがあります。1 つは、前のセクションで説明したように、IncidentNumber が 10010 以下の Incident レコードを検索する条件を表す式です。

```bash
new RuleClass
                {
                    結合 = "AND"、
                    フィールド = "IncidentNumber"、
                    条件 = "<="、
                    値 = "10010"
                },
```

2 番目の **RuleClass** オブジェクトは、 **RuleClass** クラスの **Rules** メンバーを設定するためにのみ使用されます。

```bash
new RuleClass
                {
                    ルール = 新しいルールクラス[] {
                        ...
                        ...
                        ...
                    }
                }
```

2 番目の **RuleClass** クラス内では、別の **RuleClass** 配列が 2 つの内部 **RuleClass** クラスを使用してインスタンス化されています。

```bash
new RuleClass
                        {
                            フィールド = "Journal.Category"、
                            条件 = "="、
                            値 = "送信メール"
                        },
new RuleClass
                        {
                            結合 = "OR"、
                            フィールド = "Journal.Subject",
                            条件 = "="、
                            値 = 「緊急リクエスト」
                        }
```

したがって、内部の **RuleClass** 配列を使用すると、基本的に検索の次の部分を表現できます。

```bash
関連するJournal.Emailレコードを取得します。
（ジャーナルメールのカテゴリは「受信メール」です）
または
ジャーナルメールの件名は「€緊急リクエスト」です。
```

次の関連クエリを表現するには:

```bash
関連するJournal.Emailレコードを取得します。
（ジャーナルメールのカテゴリは「受信メール」です）
そして
ジャーナルメールの件名は「緊急リクエスト」です。
```

J**oin&#x20;**&#x30E1;ンバーは、次のように「€œOR」€ から「€œAND」€ に変更する必要があります。

```bash
new RuleClass
                        {
                            フィールド = "Journal.Category"、
                            条件 = "="、
                            値 = "送信メール"
                        },
new RuleClass
                        {
                            結合 = "AND"、
                            フィールド = "Journal.Subject",
                            条件 = "="、
                            値 = 「緊急リクエスト」
                        }
```

上記の例は、 **RuleClass** オブジェクトの **Rules** メンバーを設定することで、ルールをグループ化する方法を示しています。 R**uleClass&#x20;**&#x30AF;ラスは、コンポジションを使用して、 J**oin&#x20;**&#x30D7;ロパティを介して AND または OR 演算子を使用して、 R**uleClass&#x20;**&#x30AF;ラスを任意にグループ化できるようにします。

## 全文検索について

通常の Microsoft SQL スタイルの検索に加えて、 **Search** Web メソッドは、ビジネス オブジェクトに対するフルテキスト検索の実行もサポートします。  例としては、インシデント ビジネス オブジェクトの全文カタログに対して、「Email Down」という用語を含むレコードを検索することが挙げられます。

R**uleClass&#x20;**&#x30AF;ラスには、SearchConditionType 型の C**onditionTypeと**いうメンバーが含まれています。 これは、次の 2 つの許容値を持つ列挙です。

- ByField - 0 (通常の Microsoft SQL 検索)
- ByText - 1 (全文 Microsoft SQL 検索)

```bash
パブリック列挙型 SearchConditionType
    {
        ByField = 0,
        ByText = 1
    }
```

通常の検索は、 **SearchConditionType** を **ByField**に設定して実行されます。  これは検索のデフォルト モードなので、 **RuleClass** のインスタンス化中にこれを明示的に設定する必要はありません。 全文検索を実行するには、 **RuleClass** クラスの条件タイプを **ByText**に明示的に設定する必要があります。

```bash
new RuleClass()
                {
                    結合 = "AND"、
                    条件 = "="、
                    ConditionType = SearchConditionType.ByText,
                    値 = "メールダウン"
                }
```

F**ield&#x20;**&#x30E1;ンバー (以前の検索例に存在) は、 R**uleClass&#x20;**&#x30AF;ラスで指定されていません。検索は、( B**yText&#x20;**&#x306E; C**onditionType値**により) フルテキスト カタログに対して実行されるため、 R**uleClass&#x20;**&#x30AF;ラスで F**ield&#x20;**&#x30E1;ンバーも指定するとエラーになります。

次のコード サンプルは、一致する用語「€œEmail Down」€ を含むインシデント レコードを検索する方法を示しています。

```bash
ObjectQueryDefinition query = new ObjectQueryDefinition();
            query.Select = new SelectClass();
// IncidentからIncidentNumberフィールドの値のみを取得します。
// 検索を呼び出すとき
FieldClass[] incidentFieldObjects = new FieldClass[] {
new FieldClass()
                {
                    名前 = "インシデント番号",
                    タイプ = "テキスト"
                },
new FieldClass()
                {
                    名前 = "サービス"、
                    タイプ = "テキスト"
                }
            };
            query.Select.Fields = incidentFieldObjects;
            query.From = new FromClass();
            query.From.Object = "Incident";

            query.Where = new RuleClass[] {
new RuleClass()
                {
                    結合 = "AND"、
                    条件 = "="、
                    ConditionType = SearchConditionType.ByText,
                    値 = "メールダウン"
                },
            };

FRSHEATIntegrationSearchResponse searchResponse = frSvc.Search(authSessionKey, tenantId, query);

if (searchResponse.status == "成功")
            {
WebServiceBusinessObject[][] incidentList = searchResponse.objList;
foreach (WebServiceBusinessObject[]incidentOuterList inincidentList)
                {
foreach (incidentOuterList 内の WebServiceBusinessObject インシデント)
                    {
// 選択基準の1つのフィールドだけを取得するので
// （つまり IncidentNumber）に対応します。
// 結果を取得するときのincident.FieldValues[0].Value
Console.WriteLine("インシデント {0} は選択基準に一致します",incident.FieldValues[0].Value);
                    }
                }
            }
```

## 検索ウェブメソッドで使用されるクラスの正式な説明

S**earch&#x20;**&#x57;eb メソッドを適切に実行するには、Web メソッドが呼び出される前に、いくつかのクラスからオブジェクトを適切に作成して設定する必要があります。

- [ObjectQueryDefinition クラスについて](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#About_the_ObjectQueryDefinitionClass)
- [FromClass クラスについて](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#About_the_FromClass_Class)
- [SelectClass クラスについて](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#About_the_SelectClass_Class)
- [RuleClass クラスについて](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#About_the_RuleClass_Class)
- [OrderByClass クラスについて](https://docs.ivanti.com/neurons-for-itsm/admin-user-help/jpn/latest/gwDk90FrlW3RUF2m6Rpnc#About_the_OrderByClass_Class)

### ObjectQueryDefinition クラスについて

O**bjectQueryDefinition&#x20;**&#x30AF;ラスは次のように定義されます。

```bash
クラス ObjectQueryDefinition
    {
int トップ;
bool 一意;
        FromClass From;
        SelectClass Select;
        List<RuleClass> Where;
        List<OrderByClass> OrderBy;
    }
```

O**bjectQueryDefinition&#x20;**&#x30AF;ラスは、一般的な Microsoft SQL SELECT ステートメントのさまざまな部分をモデル化するために使用されます。具体的には、次のようになります。

- **FROM**: クラス FromClass
- **SELECT**: クラス SelectClass
- **WHERE**: クラス RuleClass (リストとして実装)
- **ORDER BY**: クラス OrderByClass (リストとして実装)

R**uleClass&#x20;**&#x30AF;ラス (Microsoft SQL SELECT ステートメントの WHERE 句をモデル化するために使用されます) を除き、他のクラスは Microsoft SQL SELECT ステートメントの対応する句に従って名前が付けられます。

これらのクラスの他に、 **Top**と呼ばれる整数メンバーもあります。 これを使用して、 **Search** Web メソッドによって返されるレコードの数を制限できます。 たとえば、一致する最初の 1000 件の結果のみを返したい場合があります。

D**istinctと**呼ばれるブール型メンバーもあります。 これを使用すると、検索結果内の重複する値を排除して、個別の結果を返すことができます。

### FromClass クラスについて

F**romClass&#x20;**&#x30AF;ラスは、一般的な Microsoft SQL SELECT ステートメントの FROM 句をモデル化するために使用され、次のように定義されます。

```bash
クラスFromClass
    {
文字列オブジェクト;
        List<FromLinkClass> Links;
    }
```

オ**ブジェクト&#x20;**&#x30E1;ンバーには、検索対象となるビジネス オブジェクトの名前を入力する必要があります。

```bash
            query.From = new FromClass();
            query.From.Object = "Incident";
```

保存された検索を特定の子オブジェクトに対して実行する必要がある場合は、 **FromLinkClass** オブジェクトのリストを使用して、 **Links** メンバーも設定する必要があります。

```bash
クラス FromLinkClass
    {
文字列関係;
文字列オブジェクト;
    }
```

F**romLinkClass&#x20;**&#x30AF;ラスには 2 つのメンバー変数が含まれています。

- **リレーション**: 親オブジェクトと子オブジェクト間のリレーションシップの内部参照名を指定します。 たとえば、 **IncidentContainsJournal** 関係の場合、関係の内部参照名は空白なので、この関係を使用するには、 **Object** メンバーに子ビジネス オブジェクトの名前を入力し、 **Relation** メンバーを空の文字列のままにします。
- **オブジェクト**: 子ビジネスオブジェクトの名前を指定します（ジャーナルなど）

現在のビジネス オブジェクトに関連する **Journal.Email** レコードを検索するには、 **FromClass** クラスの **Links** メンバーを次のように設定する必要があります。

```bash
            query.From.Links = new FromLinkClass[] {
new FromLinkClass {
                    関係 = "",
                    オブジェクト = "ジャーナル
                }
            };
```

### SelectClass クラスについて

一般的な Microsoft SQL SELECT ステートメントの SELECT 句をモデル化するには、 **SelectClass** クラスを使用します。  次のように定義されます。

```bash
クラス SelectClass
    {
bool すべて;
        List<FieldClass> Fields;
    }
```

ビジネス オブジェクト内のすべてのフィールドを選択するには、新しい **SelectClass** オブジェクトを作成し、オブジェクトの **All** メンバー変数を true に設定します。

```bash
            query.Select = new SelectClass();
            query.Select.All = true;
```

メイン ビジネス オブジェクト (incident) とそれに関連する子ビジネス オブジェクト (Journal.Email) に対して検索を行う場合、 **All** メンバー変数を true に設定すると、メイン ビジネス オブジェクト内のすべてのフィールドと子ビジネス オブジェクト内のすべてのフィールドが返されます。

S**earch&#x20;**&#x57;eb メソッドによって返されるフィールドのセットを制限するには、 F**ieldClass&#x20;**&#x30AA;ブジェクトの新しいリストを作成し、対象のフィールドに対応する F**ieldClass&#x20;**&#x30AA;ブジェクトで初期化します。

インシデント ビジネス オブジェクトのインシデント番号フィールドと、子 **Journal.Email** オブジェクトのカテゴリ フィールドを返すには、次のステートメントを使用します。

```bash
FieldClass[] fieldObjects = new FieldClass[] {
new FieldClass()
                {
                    名前 = "インシデント番号",
                    タイプ = "テキスト"
                },
new FieldClass()
                {
                    名前 = "Journal.Category",
                    タイプ = "テキスト"
                }
            };

            query.Select = new SelectClass();
            query.Select.Fields = fieldObjects;
```

メイン ビジネス オブジェクトのフィールドの場合、フィールド名をそのまま指定できますが、子ビジネス オブジェクトのフィールドの場合、フィールド名の前に、関係内の子ビジネス オブジェクトの名前を付ける必要があります。

たとえば、 **IncidentContainsJournal** 関係を使用する場合、関係はインシデントおよびジャーナル (ベース) オブジェクトに対して定義されます。 カテゴリ フィールドを「€Journal.Category」€ として指定します。

### RuleClass クラスについて

R**uleClass&#x20;**&#x30AF;ラスは、一般的な Microsoft SQL SELECT ステートメントの WHERE 句をモデル化するために使用され、次のように定義されます。

```bash
クラス RuleClass
{
文字列結合;
文字列条件;
検索条件タイプ条件タイプ;
文字列フィールド;
ブール値 IsClosingBracket();
Int ブラケットレベル;
文字列値;
リスト<RuleClass> ルール;
}
```

**IsClosingBracket** - IsClosingBracket 関数は、文字が閉じ括弧であるかどうかを確認するために使用されます。 この関数は通常、ブール値を返します。文字が閉じ括弧 ( )、}、] など) の場合は true、それ以外の場合は false を返します。

**BracketLevel** - bracketLevel 関数は、文字列内の角括弧の深さを追跡するために使用されます。 bracketLevel が 0 の場合、現在の文字が括弧の外側にあることを意味します。

フ**ィールド&#x20;**&#x30E1;ンバーはフィールドの名前を指定し、 値 メンバーはフィールドに対応する値を指定します。

メイン ビジネス オブジェクトのフィールドの場合、フィールド名をそのまま指定できますが、子ビジネス オブジェクトのフィールドの場合、フィールド名の前に、関係内の子ビジネス オブジェクトの名前を付ける必要があります。 たとえば、 **IncidentContainsJournal** 関係を使用する場合、関係はインシデントおよびジャーナル (ベース) オブジェクトに対して定義されます。  カテゴリ フィールドを「€Journal.Category」として指定します。

たとえば、次のステートメントを使用して、優先度値が 1 で、関連する **Journal.Email** レコードのカテゴリ値が "€Incoming Email"€ に等しいインシデント レコードを検索します。

```bash
query.Where = 新しいルールクラス[] {
new RuleClass()
       {
結合 = "AND"、
              Condition = "=",
              フィールド = "優先度"、
              値 = "1"
},
new RuleClass()
       {
結合 = "AND"、
              Condition = "=",
              フィールド = "Journal.Category"、
              値 = "受信メール"
}
};
```

J**oin&#x20;**&#x30D7;ロパティには、 R**uleClass&#x20;**&#x30AA;ブジェクトが互いにどのように関連付けられるかを指定するために、「€AND」€ / 「€OR」€ のいずれかの値を含めることができます。

条**件&#x20;**&#x30E1;ンバーは、フィールドと指定された値を関連付けるために使用される比較演算子を指定します。 条**件&#x20;**&#x30E1;ンバーに許容される値は次のとおりです。

| オペレーター | 意味        |
| ------ | --------- |
| =      | 等しい       |
| !=     | 等しくない     |
| >      | より大きい     |
| \<     | 未満        |
| >=     | より大きいか等しい |
| \<=    | 以下        |

ルール条件をグループ化するために、 **RuleClass** クラス内に、 **RuleClass** オブジェクトのリストをオプションで保持できる **Rules** メンバーがあります。 R**ules&#x20;**&#x30E1;ンバーを使用すると、 R**uleClass&#x20;**&#x30AA;ブジェクトを構成することによって、関連する R**uleClass&#x20;**&#x30AA;ブジェクトをグループ化できます。

```bash
            query.Where = new RuleClass[] {
new RuleClass
                {
                    結合 = "AND"、
                    フィールド = "IncidentNumber"、
                    条件 = "<="、
                    値 = "10010"
                },
new RuleClass
                {
                    ルール = 新しいルールクラス[] {
new RuleClass
                        {
                            フィールド = "Journal.Category"、
                            条件 = "="、
                            値 = "送信メール"
                        },
new RuleClass
                        {
                            結合 = "OR"、
                            フィールド = "Journal.Subject",
                            条件 = "="、
                            値 = 「緊急リクエスト」
                        }
                    }
                }
            };
```

トップ レベルの 2 番目の **RuleClass** クラス内では、 **Rules** メンバーが、Journal.Email の条件が表現される別の **RuleClass** オブジェクトの内部リストで初期化されます。

通常の Microsoft SQL スタイルの検索が実行され、条件タイプは **SearchConditionType.ByField**の列挙値に設定されます。  これは検索のデフォルト モードであり、 **RuleClass** インスタンス化で明示的に指定する必要はありません。

全文検索をサポートするには、条件タイプを **SearchConditionType.ByText** の列挙値に設定し、ルール クラスをインスタンス化するときに **Field** メンバーを含めないでください。

### OrderByClass クラスについて

O**rderByClass&#x20;**&#x30AF;ラスは、一般的な Microsoft SQL SELECT ステートメントの O**rder By&#x20;**&#x53E5;をモデル化するために使用され、次のように定義されます。

```bash
クラス OrderByClass
    {
パブリック文字列の名前;
パブリック文字列方向;
    }
```

N**ame&#x20;**&#x30E1;ンバーは、順序付けするフィールドを指定し、 D**irection&#x20;**&#x30E1;ンバーは、それぞれ "€ASC"€ または "€DESC"€ の値を使用して、レコードを昇順で指定するか降順で指定するかを指定します。

たとえば、検索によってインシデントと関連する **Journal.Email** レコードが返されるとします。 インシデント レコードをインシデント番号に基づいて昇順で並べ替え、関連する **Journal.Subject** レコードを件名に基づいて昇順で並べ替える必要がある場合は、次のコードを使用できます。

```bash
            query.OrderBy = new OrderByClass[] {
新しい OrderByClass()
                {
                    名前 = "インシデント番号",
                    方向 = "ASC"
                },
新しい OrderByClass()
                {
                    名前 = "Journal.Subject",
                    方向 = "ASC"
                }
            };
```
