Die Umwandlung von Rohtext in polierten, SEO‑freundlichen Inhalt ist eine tägliche Herausforderung für viele .NET‑Entwickler, die content‑reiche Webanwendungen erstellen. GroupDocs.Rewriter Cloud SDK for .NET bietet eine leistungsstarke API, die Sätze umschreibt und dabei die Bedeutung bewahrt. Dieser Schritt‑für‑Schritt‑Leitfaden zur Integration mit ASP.NET Core MVC zeigt Ihnen, wie Sie die Bibliothek einrichten, Anmeldeinformationen konfigurieren, die Umschreiblogik in einem Controller implementieren und die Ergebnisse in einer Razor‑Ansicht rendern.

Die Anforderungen des Anwendungsfalls

Unternehmen, die benutzergenerierte Artikel, Produktbeschreibungen oder Marketingtexte erstellen, müssen häufig die Lesbarkeit verbessern, ohne manuell zu bearbeiten. Die Anforderungen für ein solches Szenario umfassen:

  • Echtzeit-Textumwandlung direkt aus einem Webformular.
  • Sichere Handhabung von API-Anmeldeinformationen auf der Serverseite.
  • Nahtlose Integration in die bestehende ASP.NET Core MVC-Pipeline.

Die Verwendung von generischem String‑Manipulationscode wird schnell fehleranfällig und skaliert nicht, weshalb eine dedizierte Bibliothek zum Umschreiben von Dokumenten unerlässlich ist.

Auswahl von GroupDocs.Rewriter Cloud SDK for .NET für den Job

GroupDocs.Rewriter Cloud SDK for .NET bietet eine REST‑basierte API, die mehrere Sprachen unterstützt, anpassbare Umschreibungsmodi bereitstellt und eine Hochleistungsverarbeitung ermöglicht. Seine wichtigsten Funktionen, die dem Anwendungsfall entsprechen, sind:

  • RewriteModeEnum.Rewrite - erzeugt eine natürlichsprachliche Umschreibung des Eingabetextes.
  • DI‑friendly client - kann als Singleton im ASP.NET Core Service-Container registriert werden.
  • Strong typing and async support - passt sich natürlich in moderne .NET asynchrone Muster ein.

Der Schritt‑für‑Schritt‑Leitfaden zur Integration mit ASP.NET Core MVC zeigt, wie diese Funktionen den Anforderungen entsprechen. Für detaillierte API‑Informationen siehe die offizielle Dokumentation und die API‑Referenz.

Implementierung Schritt‑für‑Schritt Anleitung zur Integration mit ASP.NET Core MVC

Dieser Schritt‑für‑Schritt‑Leitfaden zur Integration mit ASP.NET Core MVC führt Sie durch jeden erforderlichen Konfigurationsschritt.

SDK-Paket installieren

Fügen Sie das NuGet-Paket zu Ihrem Projekt hinzu.

dotnet add package GroupDocs.Rewriter-Cloud

Sie können die Binärdateien auch von der Download‑Seite herunterladen.

Konfiguration für Rewriter-Anmeldeinformationen hinzufügen

Platzieren Sie Ihre AppSid und AppKey in der Konfiguration. Das untenstehende Snippet fügt sie aus Gründen der Einfachheit im Speicher hinzu.

builder.Configuration.AddInMemoryCollection(new[]
{
    new KeyValuePair<string,string>("GroupDocsRewriter:AppSid", "YOUR_APP_SID"),
    new KeyValuePair<string,string>("GroupDocsRewriter:AppKey", "YOUR_APP_KEY")
});

Registrieren des Rewriter-API-Clients im DI

Der SDK-Client wird als Singleton registriert, damit er in Controller injiziert werden kann.

builder.Services.Configure<RewriterSettings>(builder.Configuration.GetSection("GroupDocsRewriter"));

builder.Services.AddSingleton<IRewriterApi>(sp =>
{
    var settings = sp.GetRequiredService<IOptions<RewriterSettings>>().Value;
    var config = new Configuration
    {
        AppSid = settings.AppSid,
        AppKey = settings.AppKey
    };
    return new RewriterApi(config);
});

Erstellen Sie den MVC-Controller und das ViewModel

Der Controller empfängt den Originaltext, ruft die Rewriter API auf und gibt das umgeschriebene Ergebnis zurück.

public class RewriterController : Controller
{
    private readonly IRewriterApi _rewriterApi;

public RewriterController(IRewriterApi rewriterApi)
    {
        _rewriterApi = rewriterApi;
    }

[HttpGet]
    public IActionResult Index()
    {
        return View(new RewriterViewModel());
    }

[HttpPost]
    public async Task<IActionResult> Index(RewriterViewModel model)
    {
        if (!ModelState.IsValid)
        {
            return View(model);
        }

var rewriteRequest = new RewriteRequest
        {
            Text = model.InputText,
            Language = "en",
            TargetLanguage = "en",
            RewriteMode = RewriteModeEnum.Rewrite
        };

RewriteResponse response = await _rewriterApi.RewriteAsync(rewriteRequest);
        model.OutputText = response?.Result?.Text ?? string.Empty;

return View(model);
    }
}

Das zugehörige ViewModel enthält die Eingabe‑ und Ausgabestrings.

public class RewriterViewModel
{
    [Required]
    [Display(Name = "Original Text")]
    public string InputText { get; set; } = string.Empty;

[Display(Name = "Rewritten Text")]
    public string OutputText { get; set; } = string.Empty;
}

Erstellen Sie die Razor-Ansicht für Texteingabe und -ausgabe

Die Razor‑Seite präsentiert ein einfaches Formular und zeigt den umgeschriebenen Text an, wenn er verfügbar ist.

@model RewriterViewModel
@{
    ViewData["Title"] = "Text Rewriter";
}
<h2>@ViewData["Title"]</h2>

<form asp-action="Index" method="post" class="form-horizontal">
    <div class="form-group">
        <label asp-for="InputText" class="control-label"></label>
        <textarea asp-for="InputText" class="form-control" rows="6"></textarea>
        <span asp-validation-for="InputText" class="text-danger"></span>
    </div>
    <div class="form-group">
        <button type="submit" class="btn btn-primary">Rewrite</button>
    </div>
</form>

@if (!string.IsNullOrWhiteSpace(Model.OutputText))
{
    <hr />
    <h4>Rewritten Text</h4>
    <textarea class="form-control" rows="6" readonly>@Model.OutputText</textarea>
}

@section Scripts {
    @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Vollständiges funktionierendes Beispiel für die Dokumentenumwandlung in ASP.NET Core MVC

Das Beispiel unten enthält die vollständigen Quelldateien, die zum Ausführen der Lösung erforderlich sind.

// ---------------------------------------------------
// Program.cs
// ---------------------------------------------------
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using GroupDocs.Rewriter.Cloud.Sdk.Api;
using GroupDocs.Rewriter.Cloud.Sdk.Client;
using GroupDocs.Rewriter.Cloud.Sdk.Model.Requests;
using GroupDocs.Rewriter.Cloud.Sdk.Model;
using System.Threading.Tasks;

var builder = WebApplication.CreateBuilder(args);

// Add configuration for GroupDocs Rewriter credentials
builder.Configuration.AddInMemoryCollection(new[]
{
    new KeyValuePair<string,string>("GroupDocsRewriter:AppSid", "YOUR_APP_SID"),
    new KeyValuePair<string,string>("GroupDocsRewriter:AppKey", "YOUR_APP_KEY")
});

builder.Services.Configure<RewriterSettings>(builder.Configuration.GetSection("GroupDocsRewriter"));

// Register GroupDocs Rewriter API client in DI
builder.Services.AddSingleton<IRewriterApi>(sp =>
{
    var settings = sp.GetRequiredService<IOptions<RewriterSettings>>().Value;
    var config = new Configuration
    {
        AppSid = settings.AppSid,
        AppKey = settings.AppKey
    };
    return new RewriterApi(config);
});

builder.Services.AddControllersWithViews();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
}
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Rewriter}/{action=Index}/{id?}");

app.Run();

// ---------------------------------------------------
// RewriterSettings.cs
// ---------------------------------------------------
public class RewriterSettings
{
    public string AppSid { get; set; } = string.Empty;
    public string AppKey { get; set; } = string.Empty;
}

// ---------------------------------------------------
// Models/RewriterViewModel.cs
// ---------------------------------------------------
using System.ComponentModel.DataAnnotations;

public class RewriterViewModel
{
    [Required]
    [Display(Name = "Original Text")]
    public string InputText { get; set; } = string.Empty;

[Display(Name = "Rewritten Text")]
    public string OutputText { get; set; } = string.Empty;
}

// ---------------------------------------------------
// Controllers/RewriterController.cs
// ---------------------------------------------------
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;

public class RewriterController : Controller
{
    private readonly IRewriterApi _rewriterApi;

public RewriterController(IRewriterApi rewriterApi)
    {
        _rewriterApi = rewriterApi;
    }

[HttpGet]
    public IActionResult Index()
    {
        return View(new RewriterViewModel());
    }

[HttpPost]
    public async Task<IActionResult> Index(RewriterViewModel model)
    {
        if (!ModelState.IsValid)
        {
            return View(model);
        }

// Build request for the Rewriter API
        var rewriteRequest = new RewriteRequest
        {
            Text = model.InputText,
            Language = "en",               // source language
            TargetLanguage = "en",         // target language (same for rewriting)
            RewriteMode = RewriteModeEnum.Rewrite // choose rewrite mode
        };

// Call the API
        RewriteResponse response = await _rewriterApi.RewriteAsync(rewriteRequest);

// Populate the view model with the rewritten text
        model.OutputText = response?.Result?.Text ?? string.Empty;

return View(model);
    }
}

// ---------------------------------------------------
// Views/Rewriter/Index.cshtml
// ---------------------------------------------------
@model RewriterViewModel
@{
    ViewData["Title"] = "Text Rewriter";
}
<h2>@ViewData["Title"]</h2>

<form asp-action="Index" method="post" class="form-horizontal">
    <div class="form-group">
        <label asp-for="InputText" class="control-label"></label>
        <textarea asp-for="InputText" class="form-control" rows="6"></textarea>
        <span asp-validation-for="InputText" class="text-danger"></span>
    </div>
    <div class="form-group">
        <button type="submit" class="btn btn-primary">Rewrite</button>
    </div>
</form>

@if (!string.IsNullOrWhiteSpace(Model.OutputText))
{
    <hr />
    <h4>Rewritten Text</h4>
    <textarea class="form-control" rows="6" readonly>@Model.OutputText</textarea>
}

@section Scripts {
    @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

Hinweis: Dieses Codebeispiel demonstriert die Kernfunktionalität. Bevor Sie es in Ihrem Projekt verwenden, stellen Sie sicher, dass Sie alle Dateipfade und Konfigurationswerte an Ihre tatsächliche Umgebung anpassen, überprüfen Sie, dass alle erforderlichen Abhängigkeiten ordnungsgemäß installiert sind, und testen Sie gründlich in Ihrer Entwicklungsumgebung. Wenn Sie auf Probleme stoßen, lesen Sie bitte die offizielle Dokumentation oder wenden Sie sich an das Support-Team für Unterstützung.

Ausführen der Dokumenten-Neuschreibung über die REST-API mit cURL

Unten finden Sie einen kurzen cURL‑Workflow, der dieselbe Umschreibungsoperation über die GroupDocs Rewriter REST‑Endpunkte ausführt.

Authentifizieren und Zugriffstoken erhalten

curl -X POST "https://api.groupdocs.cloud/v1/auth/token" \
     -H "Content-Type: application/json" \
     -d '{"client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET"}'

Die Antwort gibt ein access_token zurück, das Sie in nachfolgenden Aufrufen verwenden.

Quelltext hochladen (optional für große Dateien)

curl -X POST "https://api.groupdocs.cloud/v1/storage/file/upload" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -F "file=@input.txt"

Ausführen der Umschreiboperation

curl -X POST "https://api.groupdocs.cloud/v1/rewriter/rewrite" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "text": "Your original text goes here.",
           "language": "en",
           "targetLanguage": "en",
           "rewriteMode": "Rewrite"
         }'

Die JSON‑Antwort enthält den umgeschriebenen Text im Feld result.text.

Ergebnis herunterladen (wenn Sie es als Datei gespeichert haben)

curl -X GET "https://api.groupdocs.cloud/v1/storage/file/download?path=output.txt" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o rewritten.txt

Weitere Details zu Anfrageparametern und Antwortformaten finden Sie in der offiziellen API-Dokumentation.

Abschließende Gedanken

Die Integration des GroupDocs.Rewriter Cloud SDK for .NET in ein ASP.NET Core MVC‑Projekt ist unkompliziert, sobald Sie dieser Schritt‑für‑Schritt‑Anleitung zur Integration mit ASP.NET Core MVC folgen. Die Bibliothek übernimmt die schwere Arbeit des Umschreibens natürlicher Sprache, sodass Sie sich auf UI und Geschäftslogik konzentrieren können. Denken Sie daran, Ihren AppSid und AppKey zu sichern, die temporäre Lizenz für die Evaluierung zu verwenden und auf eine Voll‑Lizenz für Produktionslasten zu upgraden. Mit dem Code und den cURL‑Beispiele​n in der Hand können Sie nun intelligente Textumschreibungen zu jeder .NET‑Webanwendung hinzufügen.

FAQs

Wie behandelt die Schritt‑für‑Schritt‑Anleitung zur Integration mit ASP.NET Core MVC Fehlermeldungen der API?
Das Controller‑Beispiel prüft ModelState.IsValid, bevor es die API aufruft, und erfasst die RewriteResponse. Gibt die API einen Fehler zurück, ist das Objekt response null, und die Ansicht zeigt einfach eine leere Ausgabe. Für eine detaillierte Fehlerbehandlung konsultieren Sie die offizielle Dokumentation.

Kann ich Dokumente außer einfachem Text, wie DOCX oder PDF, mit demselben Ansatz umschreiben?
Ja. Die Rewriter‑API akzeptiert Rohtext, der aus unterstützten Formaten extrahiert wurde. Sie können zunächst GroupDocs.Parser oder GroupDocs.Conversion verwenden, um den Text zu extrahieren, und ihn dann an den Rewrite‑Endpunkt übergeben. Beide SDKs sind in der GroupDocs‑Produktfamilie aufgeführt.

Ist es möglich, die Rewrite‑Operation asynchron in einer stark frequentierten Website auszuführen?
Absolut. Der Controller verwendet await _rewriterApi.RewriteAsync(...), was vollständig asynchron ist und mit der async‑Pipeline von ASP.NET Core skaliert. Das entspricht dem im Schritt‑für‑Schritt‑Leitfaden gezeigten Muster zur Integration mit ASP.NET Core MVC.

Wo kann ich eine temporäre Lizenz für Tests erhalten?
Eine temporäre Lizenz ist auf der temporary license page verfügbar. Sie ermöglicht es Ihnen, das SDK zu evaluieren, ohne einen Kauf zu tätigen.

Weiterführende Lektüre