Hogyan kell parancssori előrejelzőt létrehozni

A PSReadLine 2.1.0 a prediktív IntelliSense funkció implementálásával bevezette az intelligens parancssori prediktor fogalmát. A PSReadLine 2.2.2 bővítménymodell hozzáadásával bővítette ezt a funkciót, amely lehetővé teszi saját parancssori prediktorok létrehozását.

A prediktív IntelliSense javítja a lapkiegészítést azáltal, hogy beíráskor javaslatokat ad a parancssorban. Az előrejelzési javaslat színes szövegként jelenik meg a kurzor után. Ez lehetővé teszi teljes parancsok felderítését, szerkesztését és végrehajtását a parancselőzmények vagy további tartományspecifikus beépülő modulok megfelelő előrejelzései alapján.

Rendszerkövetelmények

Beépülő modul-prediktor létrehozásához és használatához a következő szoftververziókat kell használnia:

PowerShell 7.2 (vagy újabb) – a parancselőjelező létrehozásához szükséges API-kat biztosítja
PSReadLine 2.2.2 (vagy újabb) – lehetővé teszi a PSReadLine konfigurálását a beépülő modul használatára

A prediktor áttekintése

A prediktor egy PowerShell bináris modul. A modulnak implementálnia kell a System.Management.Automation.Subsystem.Prediction.ICommandPredictor felületet. Ez az interfész deklarálja az előrejelzési eredmények lekérdezéséhez és visszajelzéshez használt módszereket.

A prediktormodulnak regisztrálnia kell egy CommandPredictor alrendszert a PowerShell SubsystemManager-ben, amikor be van töltve, és törölnie kell magát a regisztrációból, amikor ki van töltve.

Az alábbi ábra egy előrejelző architektúráját mutatja be a PowerShellben.

architektúra

A kód létrehozása

A prediktor létrehozásához telepítve kell lennie a .NET 6 SDK-nak a platformhoz. További információ az SDK-ról: .NET 6.0 letöltése.

Hozzon létre egy új PowerShell-modulprojektet az alábbi lépések végrehajtásával:

A dotnet parancssori eszközzel hozzon létre kezdő classlib-projektet.
```
dotnet new classlib --name SamplePredictor
```

Szerkesszük a SamplePredictor.csproj-t, hogy tartalmazza a következő információkat:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.PowerShell.SDK" Version="7.2.0" />
  </ItemGroup>

</Project>

Törölje a Class1.cs által létrehozott alapértelmezett dotnet fájlt, és másolja a következő kódot egy SamplePredictorClass.cs fájlba a projektmappában.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Management.Automation;
using System.Management.Automation.Subsystem;
using System.Management.Automation.Subsystem.Prediction;

namespace PowerShell.Sample
{
    public class SamplePredictor : ICommandPredictor
    {
        private readonly Guid _guid;

        internal SamplePredictor(string guid)
        {
            _guid = new Guid(guid);
        }

        /// <summary>
        /// Gets the unique identifier for a subsystem implementation.
        /// </summary>
        public Guid Id => _guid;

        /// <summary>
        /// Gets the name of a subsystem implementation.
        /// </summary>
        public string Name => "SamplePredictor";

        /// <summary>
        /// Gets the description of a subsystem implementation.
        /// </summary>
        public string Description => "A sample predictor";

        /// <summary>
        /// Get the predictive suggestions. It indicates the start of a suggestion rendering session.
        /// </summary>
        /// <param name="client">Represents the client that initiates the call.</param>
        /// <param name="context">The <see cref="PredictionContext"/> object to be used for prediction.</param>
        /// <param name="cancellationToken">The cancellation token to cancel the prediction.</param>
        /// <returns>An instance of <see cref="SuggestionPackage"/>.</returns>
        public SuggestionPackage GetSuggestion(PredictionClient client, PredictionContext context, CancellationToken cancellationToken)
        {
            string input = context.InputAst.Extent.Text;
            if (string.IsNullOrWhiteSpace(input))
            {
                return default;
            }

            return new SuggestionPackage(new List<PredictiveSuggestion>{
                new PredictiveSuggestion(string.Concat(input, " HELLO WORLD"))
            });
        }

        #region "interface methods for processing feedback"

        /// <summary>
        /// Gets a value indicating whether the predictor accepts a specific kind of feedback.
        /// </summary>
        /// <param name="client">Represents the client that initiates the call.</param>
        /// <param name="feedback">A specific type of feedback.</param>
        /// <returns>True or false, to indicate whether the specific feedback is accepted.</returns>
        public bool CanAcceptFeedback(PredictionClient client, PredictorFeedbackKind feedback) => false;

        /// <summary>
        /// One or more suggestions provided by the predictor were displayed to the user.
        /// </summary>
        /// <param name="client">Represents the client that initiates the call.</param>
        /// <param name="session">The mini-session where the displayed suggestions came from.</param>
        /// <param name="countOrIndex">
        /// When the value is greater than 0, it's the number of displayed suggestions from the list
        /// returned in <paramref name="session"/>, starting from the index 0. When the value is
        /// less than or equal to 0, it means a single suggestion from the list got displayed, and
        /// the index is the absolute value.
        /// </param>
        public void OnSuggestionDisplayed(PredictionClient client, uint session, int countOrIndex) { }

        /// <summary>
        /// The suggestion provided by the predictor was accepted.
        /// </summary>
        /// <param name="client">Represents the client that initiates the call.</param>
        /// <param name="session">Represents the mini-session where the accepted suggestion came from.</param>
        /// <param name="acceptedSuggestion">The accepted suggestion text.</param>
        public void OnSuggestionAccepted(PredictionClient client, uint session, string acceptedSuggestion) { }

        /// <summary>
        /// A command line was accepted to execute.
        /// The predictor can start processing early as needed with the latest history.
        /// </summary>
        /// <param name="client">Represents the client that initiates the call.</param>
        /// <param name="history">History command lines provided as references for prediction.</param>
        public void OnCommandLineAccepted(PredictionClient client, IReadOnlyList<string> history) { }

        /// <summary>
        /// A command line was done execution.
        /// </summary>
        /// <param name="client">Represents the client that initiates the call.</param>
        /// <param name="commandLine">The last accepted command line.</param>
        /// <param name="success">Shows whether the execution was successful.</param>
        public void OnCommandLineExecuted(PredictionClient client, string commandLine, bool success) { }

        #endregion;
    }

    /// <summary>
    /// Register the predictor on module loading and unregister it on module un-loading.
    /// </summary>
    public class Init : IModuleAssemblyInitializer, IModuleAssemblyCleanup
    {
        private const string Identifier = "843b51d0-55c8-4c1a-8116-f0728d419306";

        /// <summary>
        /// Gets called when assembly is loaded.
        /// </summary>
        public void OnImport()
        {
            var predictor = new SamplePredictor(Identifier);
            SubsystemManager.RegisterSubsystem(SubsystemKind.CommandPredictor, predictor);
        }

        /// <summary>
        /// Gets called when the binary module is unloaded.
        /// </summary>
        public void OnRemove(PSModuleInfo psModuleInfo)
        {
            SubsystemManager.UnregisterSubsystem(SubsystemKind.CommandPredictor, new Guid(Identifier));
        }
    }
}

Az alábbi példakód a "HELLO WORLD" sztringet adja vissza az összes felhasználói bemenet előrejelzési eredményéhez. Mivel a minta-előrejelző nem dolgoz fel semmilyen visszajelzést, a kód nem implementálja a visszajelzési módszereket a felületről. Módosítsa az előrejelzési és visszajelzési kódot a prediktor igényeinek megfelelően.

Jegyzet

A PSReadLine listanézete nem támogatja a többsoros javaslatokat. Minden javaslatnak egyetlen sornak kell lennie. Ha a kód többsoros javaslattal rendelkezik, a sorokat külön javaslatokra kell felosztania, vagy pontosvesszővel (;) kell összekapcsolnia a sorokat.

Futtassa a dotnet build programot a szerelvény elkészítéséhez. A fordított kód-összeállítás a projektmappa bin/Debug/net6.0 helyén található.

Jegyzet

A rugalmas felhasználói élmény biztosítása érdekében az ICommandPredictor felület 20 ms időtúllépést biztosít a prediktorok válaszaira. A prediktorkódnak kevesebb mint 20 ms alatt kell eredményeket visszaadnia ahhoz, hogy megjelenjenek.

A prediktor beépülő modul használata

Az új prediktor kipróbálásához nyisson meg egy új PowerShell 7.2-munkamenetet, és futtassa a következő parancsokat:

Set-PSReadLineOption -PredictionSource HistoryAndPlugin
Import-Module .\bin\Debug\net6.0\SamplePredictor.dll

Amikor az összeállítás be van töltve a munkamenetbe, a terminálba való írás közben megjelenik a "HELLO WORLD" szöveg. Az F2 lenyomásával válthat a Inline nézet és a List nézet között.

További információ a PSReadLine beállításairól: Set-PSReadLineOption.

A telepített prediktorok listáját az alábbi paranccsal szerezheti be:

Get-PSSubsystem -Kind CommandPredictor

Kind              SubsystemType      IsRegistered Implementations
----              -------------      ------------ ---------------
CommandPredictor  ICommandPredictor          True {SamplePredictor}

Jegyzet

Get-PSSubsystem a PowerShell 7.1-ben bevezetett kísérleti parancsmag. Engedélyeznie kell a PSSubsystemPluginModel kísérleti funkciót a parancsmag használatához. További információ: A kísérleti funkciók használata.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-02-05