Convertire testo grezzo in contenuti raffinati e ottimizzati per la SEO è una sfida quotidiana per molti sviluppatori .NET che costruiscono applicazioni web ricche di contenuti. GroupDocs.Rewriter Cloud SDK for .NET offre un’API potente che riscrive le frasi mantenendo il significato. Questa guida passo‑passo per l’integrazione con ASP.NET Core MVC ti mostra come configurare la libreria, impostare le credenziali, implementare la logica di riscrittura in un controller e visualizzare i risultati in una vista Razor.

Requisiti del caso d’uso

Le aziende che generano articoli generati dagli utenti, descrizioni di prodotti o testi di marketing spesso hanno bisogno di migliorare la leggibilità senza modifiche manuali. I requisiti per uno scenario del genere includono:

  • Riscrittura di testo in tempo reale direttamente da un modulo web.
  • Gestione sicura delle credenziali API sul lato server.
  • Integrazione fluida con la pipeline ASP.NET Core MVC esistente.

L’utilizzo di codice generico per la manipolazione di stringhe diventa rapidamente soggetto a errori e non è scalabile, motivo per cui è essenziale una libreria dedicata alla riscrittura dei documenti.

Scegliere GroupDocs.Rewriter Cloud SDK for .NET per il lavoro

GroupDocs.Rewriter Cloud SDK for .NET offre un’API basata su REST che supporta più lingue, modalità di riscrittura personalizzabili e un’elaborazione ad alte prestazioni. Le sue principali funzionalità che corrispondono al caso d’uso sono:

  • RewriteModeEnum.Rewrite - produce una riscrittura in linguaggio naturale del testo di input.
  • Client compatibile con DI - può essere registrato come singleton nel contenitore di servizi ASP.NET Core.
  • Strong typing and async support - si integra naturalmente nei moderni pattern asincroni di .NET.

La guida passo-passo per integrare con ASP.NET Core MVC dimostra come queste funzionalità si mappino ai requisiti. Per informazioni dettagliate sull’API, consulta la documentazione ufficiale e il riferimento API.

Guida passo‑a‑passo per l’implementazione dell’integrazione con ASP.NET Core MVC

Questa guida passo-passo per l’integrazione con ASP.NET Core MVC ti guiderà attraverso ogni passaggio di configurazione richiesto.

Installa il pacchetto SDK

Aggiungi il pacchetto NuGet al tuo progetto.

dotnet add package GroupDocs.Rewriter-Cloud

Puoi anche scaricare i binari dalla pagina di download.

Aggiungi configurazione per le credenziali del Rewriter

Inserisci il tuo AppSid e AppKey nella configurazione. Lo snippet qui sotto li aggiunge in‑memory per semplicità.

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

Registra il client API Rewriter in DI

Il client SDK è registrato come singleton in modo da poter essere iniettato nei controller.

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);
});

Crea il Controller MVC e il View Model

Il controller riceve il testo originale, chiama l’API Rewriter e restituisce il risultato riscritto.

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);
    }
}

Il modello di visualizzazione allegato contiene le stringhe di input e output.

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;
}

Crea la vista Razor per l’input e l’output di testo

La pagina Razor presenta un modulo semplice e visualizza il testo riscritto quando disponibile.

@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");}
}

Esempio completo funzionante per la riscrittura di documenti in ASP.NET Core MVC

L’esempio seguente contiene tutti i file sorgente necessari per eseguire la soluzione.

// ---------------------------------------------------
// 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");}
}

Nota: Questo esempio di codice dimostra la funzionalità di base. Prima di usarlo nel tuo progetto, assicurati di aggiornare tutti i percorsi dei file e i valori di configurazione per corrispondere al tuo ambiente reale, verifica che tutte le dipendenze richieste siano installate correttamente e testa accuratamente nel tuo ambiente di sviluppo. Se incontri problemi, consulta la documentazione ufficiale o contatta il team di supporto per assistenza.

Esecuzione della riscrittura del documento tramite API REST usando cURL

Di seguito è riportato un rapido flusso di lavoro cURL che esegue la stessa operazione di riscrittura tramite gli endpoint REST di GroupDocs Rewriter.

Autenticare e Ottenere il Token di Accesso

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"}'

La risposta restituisce un access_token che utilizzerai nelle chiamate successive.

Carica il testo sorgente (opzionale per file di grandi dimensioni)

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

Esegui l’operazione di riscrittura

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"
         }'

La risposta JSON contiene il testo riscritto nel campo result.text.

Scarica il risultato (se lo hai salvato come file)

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

Per ulteriori dettagli sui parametri di richiesta e sui formati di risposta, consulta la documentazione API ufficiale.

Considerazioni finali

Integrare il GroupDocs.Rewriter Cloud SDK for .NET in un progetto ASP.NET Core MVC è semplice una volta seguita questa guida passo‑passo per l’integrazione con ASP.NET Core MVC. La libreria gestisce il lavoro pesante della riscrittura del linguaggio naturale, permettendoti di concentrarti sull’interfaccia utente e sulla logica di business. Ricorda di proteggere il tuo AppSid e AppKey, di utilizzare la licenza temporanea per la valutazione e di passare a una licenza completa per i carichi di lavoro di produzione. Con il codice e gli esempi cURL a disposizione, ora puoi aggiungere la riscrittura intelligente del testo a qualsiasi applicazione web .NET.

FAQs

Come gestisce la guida passo-passo per l’integrazione con ASP.NET Core MVC le risposte di errore dall’API?
L’esempio del controller verifica ModelState.IsValid prima di chiamare l’API e cattura il RewriteResponse. Se l’API restituisce un errore, l’oggetto response sarà nullo e la vista mostrerà semplicemente un output vuoto. Per una gestione dettagliata degli errori, consulta la documentazione ufficiale.

Posso riscrivere documenti diversi dal semplice testo, come DOCX o PDF, usando lo stesso approccio?
Sì. L’API Rewriter accetta testo grezzo estratto dai formati supportati. È possibile utilizzare prima GroupDocs.Parser o GroupDocs.Conversion per estrarre il testo, quindi passarlo all’endpoint di riscrittura. Entrambi gli SDK sono elencati nella famiglia di prodotti GroupDocs.

È possibile eseguire l’operazione di rewrite in modo asincrono in un sito web ad alto traffico?
Assolutamente. Il controller utilizza await _rewriterApi.RewriteAsync(...), che è completamente asincrono e si adatta al pipeline asincrono di ASP.NET Core. Questo si inserisce nel modello mostrato nella guida passo‑passo per l’integrazione con ASP.NET Core MVC.

Dove posso ottenere una licenza temporanea per il test?
Una licenza temporanea è disponibile nella pagina della licenza temporanea. Ti consente di valutare l’SDK senza impegnarti in un acquisto.

Approfondimenti