Einführung
Zuletzt habe ich mit der Arbeit an einem neuen Projekt begonnen, zu dem auch die Arbeit mit dem bereits bekannten Google-Dienst (AI) - DialogFlow - gehörte. Das Fazit war, dass wir einen Bot (Telegramm) hatten, der mit der API mehrerer Sites arbeitete, während DialogFlow uns half, die Kommunikation mit einer Person zu strukturieren, für die er im Grunde genommen erstellt wurde. Ich muss sagen, dass der Artikel für Personen gedacht ist, die gerade erst mit dem Dienst vertraut geworden sind oder bereits wenig Erfahrung haben. Daher sind die folgenden Begriffe möglich: Absicht, Kontext, Aktion, Ereignis und für das, was wir für - Entitäten gesammelt haben. Ich hoffe, dass der Artikel für diejenigen nützlich sein wird, die nicht ein wenig verstanden haben, wie genau durch den Code CRUD-Operationen mit Entitäten durchgeführt werden können.Entitäten in DialogFlow
In DialogFlow sind Entitäten einige Entitäten, die aus ReferenceValue und Synonymen bestehen. Ähnlich wie bei einem Schlüsselwert, nur mit dem Unterschied, dass es viele Synonyme geben kann, und je mehr es gibt, desto besser, weil es "das Leben des Bots vereinfacht" und es für ihn einfacher ist zu verstehen, über welchen Wert gesprochen wird, und das Häkchen Fuzzy Matching hilft dem Bot auch zu verstehen, worum es geht, selbst wenn Sie einen Buchstaben oder ein anderes Symbol übersehen. Es sieht ungefähr so aus:Moskau - Moskau, Moskau, Moskau ...Nach einem kurzen Ausflug möchte ich hinzufügen, dass es bei Entity viel Aufhebens gibt. Natürlich reduziere ich nicht die Bedeutung von Absichten und so weiter, aber die Tatsache bleibt.EntityTypes
Hier war die erste, wenn auch kleine Falle für mich. Schließlich enthält die Dokumentation Methoden für die Arbeit mit Entity, und es gibt Methoden für die Arbeit mit EntityType - welche davon ist was?Tatsächlich ist nicht alles so kompliziert, nur die Verwirrung entsteht aufgrund der Tatsache, dass in DialogFlow selbst die Registerkarte mit EntityTypes Entities heißt:
EntityType: 
Entitie: 
Obwohl in DialogFlow selbst angenommen wird, dass es Entity gibt und es Einträge hat (d. H. Das Wesen und die Einträge darin).Lass uns weitermachen.Sie können einen EntityType manuell direkt in DialoFlow erstellen, aber ich werde zeigen, wie dies über den Code erfolgen kann (schließlich müssen wir wissen, um welchen EntityType es sich handelt, um Entities zu erstellen).Aktivieren Sie zunächst das NuGet-Paket Google.Cloud.Dialogflow.V2. Zum Zeitpunkt des Schreibens wurde Version 1.1.0 installiert:
Zuerst erstellen wir eine Klasse und nennen sie EntityTypeManagement, in der grundlegende Operationen ausgeführt werden:using Google.Api.Gax;
using Google.Cloud.Dialogflow.V2;
public class EntityTypeManagement
{
public async Task Create(string projectId, string displayName, EntityType.Types.Kind kind =
EntityType.Types.Kind.Map)
{
var client = await EntityTypesClient.CreateAsync();
var entityType = new EntityType();
entityType.DisplayName = displayName;
entityType.Kind = kind;
var createdEntityType = client.CreateEntityType(
parent: new ProjectAgentName(projectId),
entityType: entityType
);
Console.WriteLine($"Created EntityType: {createdEntityType.Name}");
}
public async Task<PagedEnumerable<ListEntityTypesResponse,EntityType>> List(string projectId)
{
var client = await EntityTypesClient.CreateAsync();
var response = client.ListEntityTypes(
parent: new ProjectAgentName(projectId)
);
return response;
}
public async Task<string> GetEntityTypeId(string projectId,string targetEventTypeName)
{
var client = await EntityTypesClient.CreateAsync();
var response = client.ListEntityTypes(
parent: new ProjectAgentName(projectId)
);
string id = response.Where(x => x.DisplayName == targetEventTypeName).FirstOrDefault().Name;
string returningId = id.Replace($"projects/{projectId}/agent/entityTypes/", "");
return returningId;
}
public async Task Delete(string projectId, string entityTypeId)
{
var client = await EntityTypesClient.CreateAsync();
client.DeleteEntityType(new EntityTypeName(projectId, entityTypeId: entityTypeId));
Console.WriteLine($"Deleted EntityType: {entityTypeId}");
}
public async Task BatchDelete(string projectId, IEnumerable<string> entityTypeIds)
{
var client = await EntityTypesClient.CreateAsync();
var entityTypeNames = entityTypeIds.Select(
id => new EntityTypeName(projectId, id).ToString());
client.BatchDeleteEntityTypes(new ProjectAgentName(projectId),
entityTypeNames);
}
}
Hier muss sofort gesagt werden, dass es keine Update-Funktion gibt, nur weil Create seine Funktion bereits ausführt.Nachdem wir nun die grundlegenden Methoden für die Arbeit mit EntityTypes kennen, fahren wir mit Entity fort und erstellen sofort eine EntityManagement-Klasse:public class EntityManagement
{
using Google.Cloud.Dialogflow.V2;
public async Task Create(string projectId,
string entityTypeId,
string entityValue,
string[] synonyms)
{
var client = await EntityTypesClient.CreateAsync();
var entity = new EntityType.Types.Entity() { Value = entityValue};
entity.Synonyms.AddRange(synonyms);
var operation = await client.BatchCreateEntitiesAsync(
parent: new EntityTypeName(projectId, entityTypeId),
entities: new[] { entity }
);
operation.PollUntilCompleted();
}
public async Task CreateMany(string projectId,string entityTypeId, IEnumerable<Entity> entities)
{
var client = await EntityTypesClient.CreateAsync();
List<EntityType.Types.Entity> results = new List<EntityType.Types.Entity>();
foreach (var item in entities)
{
var entity = new EntityType.Types.Entity() { Value = item.value };
entity.Synonyms.AddRange(item.synonyms);
results.Add(entity);
}
var operation = await client.BatchCreateEntitiesAsync(
parent: new EntityTypeName(projectId, entityTypeId),
entities: results.ToArray());
operation.PollUntilCompleted();
}
public async Task Delete(string projectId, string entityTypeId, string entityValue)
{
var client = await EntityTypesClient.CreateAsync();
var operation = await client.BatchDeleteEntitiesAsync(
parent: new EntityTypeName(projectId, entityTypeId),
entityValues: new[] { entityValue }
);
Console.WriteLine("Waiting for the entity deletion operation to complete.");
operation.PollUntilCompleted();
Console.WriteLine($"Deleted Entity: {entityValue}");
}
public async Task<List<Entity>> List(string projectId, string entityTypeId)
{
var client = await EntityTypesClient.CreateAsync();
var entityType = await client.GetEntityTypeAsync(new EntityTypeName(
projectId, entityTypeId
));
List<Entity> EntitiesList = new List<Entity>();
foreach (var entity in entityType.Entities)
{
List<string> Synonyms = new List<string>();
foreach (var item in entity.Synonyms)
{
Synonyms.Add(item);
}
EntitiesList.Add(new Entity { value = entity.Value, synonyms = Synonyms.ToArray() });
Synonyms = null;
}
return EntitiesList;
}
}
Fügen Sie unser Modell hinzu, das die Entität darstellt:public class Entity
{
public string value { get; set; }
public string[] synonyms { get; set; }
}
Fertig, alle grundlegenden CRUD-Funktionen sind fertig. Wenn Sie wieder zu Update zurückkehren, kann es separat implementiert werden, wird jedoch einfach nicht benötigt, da Create auch wie Update funktioniert.Die Beispiele sind recht einfach und ich muss zustimmen, dass es immer noch einen "Hardcode" gibt, aber ich hoffe, dass der Artikel für diejenigen nützlich ist, die wie ich nicht herausfinden konnten, wie CRUD-Operationen durch Code korrekt ausgeführt werden können.static void Main(string[] args)
{
EntityTypesManagement entityTypesManagement = new EntityTypesManagement();
EntityManagement entityManagement = new EntityManagement();
string ProjectId = "Your Project`s id";
string EntityName = "Your EntityName";
var entityId = await entityTypesManagement.GetEntityTypeId(ProjectId, EntityName);
Entity entity = new Entity{value = "1", synonyms = new[]{"1","1"}};
entityManagement.Create(ProjectId,entityId,entity);
}