.NET CLI Eklentisi Geliştirme: Kendi Komut Satırı Aracınızı Yazın

.NET CLI için kendi özel eklentinizi (plugin) geliştirmek, düşündüğünüzden daha kolaydır ve yazılım projelerinize esneklik kazandırır. CLI eklentileri, sık tekrarlanan görevleri otomatikleştirmek veya projelerinizi hızlandıracak özel komutlar oluşturmak için harika bir yoldur. Böylece, kendi iş akışınıza uygun araçlar geliştirip komut satırından rahatça kullanabilirsiniz.

Bu yazıda, sıfırdan bir .NET CLI aracı geliştirmenin tüm adımlarını birlikte inceleyeceğiz. Eklentinizi nasıl yapılandıracağınızı, paketleyeceğinizi ve ister lokal ister NuGet üzerinden dağıtabileceğinizi adım adım anlatacağım. Hazırsanız başlayalım!

1. Proje Oluşturma

İlk adım olarak, CLI eklentinizin temeli olacak bir .NET Console Application projesi oluşturmanız gerekiyor. Bu konsol uygulaması, komut satırından çağrıldığında çalışacak ve sizin tanımladığınız komutlara göre işlem yapacaktır.

Proje oluşturmak için aşağıdaki komutu terminalde (Command Prompt, PowerShell veya Bash) çalıştırın:

dotnet new console -n MyDotNetPlugin

Bu komut şu işlemleri yapar:

  • dotnet new console: Yeni bir konsol uygulaması oluşturur.
  • -n MyDotNetPlugin: Uygulamanın adını MyDotNetPlugin olarak belirler. Bu adı istediğiniz gibi değiştirebilirsiniz.

Komut çalıştıktan sonra, bulunduğunuz dizine bir MyDotNetPlugin klasörü oluşturulur ve proje dosyaları (örneğin Program.cs ve MyDotNetPlugin.csproj) buraya yerleştirilir.

Proje Klasörüne Girme

Projeyi oluşturduktan sonra terminalde proje klasörüne geçiş yaparak orada çalışmaya devam etmelisiniz:

cd MyDotNetPlugin

Bu aşamadan sonra, projenizin dosyalarını düzenlemeye başlayabilir ve CLI eklentisi olarak çalışması için gerekli ayarları yapabilirsiniz. Artık kodunuzu yazmak ve projenizi bir CLI aracı olarak paketlemek için hazırsınız.

2. Proje Yapısını Ayarlayın

Projenizi bir .NET CLI aracı (tool) olarak çalıştırabilmek için bazı ek yapılandırmalar yapmanız gerekiyor. Özellikle, projenizin bir konsol uygulamasından farkını belirlemek ve CLI komutu olarak paketlenmesini sağlamak için *.csproj dosyasına birkaç önemli ayar eklemelisiniz. Bu adım, eklentinizin komut satırında doğru şekilde tanınması için kritik önem taşır.

Öncelikle proje dizininizdeki MyDotNetPlugin.csproj dosyasını açın. İçeriğini aşağıdaki gibi düzenleyin:

MyDotNetPlugin.csproj:

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

  <PropertyGroup>
    <OutputType>Exe</OutputType>  <!-- Çıkış türü bir çalıştırılabilir dosya olacak -->
    <TargetFramework>net8.0</TargetFramework>  <!-- .NET sürümünü belirtiyoruz -->
    <PackAsTool>true</PackAsTool>  <!-- Projenin CLI aracı olarak paketlenmesini sağlar -->
    <ToolCommandName>mytool</ToolCommandName>  <!-- Komut satırında çalışacak komutun adı -->
  </PropertyGroup>

</Project>

Bu Yapılandırmalar Ne Anlama Geliyor?

  • <OutputType>Exe</OutputType>: Bu ayar, projenizin bir çalıştırılabilir uygulama (.exe veya ilgili platforma uygun format) olarak paketleneceğini belirtir. Eklentiniz, komut satırında bir komut olarak çalıştırılacak bir uygulama olacağı için bu gerekli.

  • <TargetFramework>net8.0</TargetFramework>: Bu satır, projenizin hangi .NET sürümünü kullanacağını tanımlar. En güncel sürümü kullanmak en iyisidir, ancak hedef platformunuza uygun farklı sürümler (örneğin net6.0 veya net7.0) da belirtebilirsiniz.

  • <PackAsTool>true</PackAsTool>: Bu ayar, projenin bir CLI aracı (tool) olarak paketlenmesini sağlar. Eğer bu ayar yoksa, dotnet komutuyla aracı paketleyemezsiniz.

  • <ToolCommandName>mytool</ToolCommandName>: Bu, projenizin komut satırında hangi isimle çalıştırılacağını belirler. Örneğin, bu ayarda mytool olarak belirttiğimiz için komut satırında aracı çalıştırmak için şunu kullanacağız:

    mytool
    

Proje Yapısını Test Etme

Yapılandırmayı tamamladıktan sonra, projede kodlama yapmadan önce yapılandırmanın doğru çalışıp çalışmadığını test edebilirsiniz. Önce, aşağıdaki komutla projenin derlenip derlenmediğini kontrol edin:

dotnet build

Herhangi bir hata görmüyorsanız, CLI eklentisi olarak paketleme ve dağıtım için gerekli tüm ayarları başarıyla tamamladınız. Şimdi sıradaki adımda Program.cs dosyasına komutlarınızı ekleyip projenizi paketlemeye geçebiliriz.

3. Kodunuzu Yazın

Artık projenizin kalbini oluşturacak kodu yazmaya başlayabilirsiniz. Eklentinizin davranışını tanımlayan kodlar, Program.cs dosyasında bulunur. Bu kod, kullanıcı komutu çalıştırdığında tetiklenir ve gerekli işlemleri yapar. Aşağıda, basit bir CLI aracının nasıl çalışacağını ve genişletilebileceğini adım adım inceleyelim.

Program.cs Dosyasının Yapısı

Öncelikle proje dizininizdeki Program.cs dosyasını açın. Varsayılan olarak içinde Hello, World! yazan bir kod görürsünüz. Bunu aşağıdaki gibi değiştirin:

Program.cs:

using System;

class Program
{
    static void Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine("Kullanım: mytool <komut> [parametreler]");
            Console.WriteLine("Örnek: mytool merhaba");
        }
        else
        {
            string command = args[0].ToLower();

            switch (command)
            {
                case "merhaba":
                    Console.WriteLine("Merhaba, dünya!");
                    break;
                case "zaman":
                    Console.WriteLine($"Şu anki saat: {DateTime.Now}");
                    break;
                case "topla":
                    if (args.Length == 3 && int.TryParse(args[1], out int a) && int.TryParse(args[2], out int b))
                    {
                        Console.WriteLine($"Sonuç: {a + b}");
                    }
                    else
                    {
                        Console.WriteLine("Kullanım: mytool topla <sayı1> <sayı2>");
                    }
                    break;
                default:
                    Console.WriteLine($"Bilinmeyen komut: {command}");
                    Console.WriteLine("Kullanılabilir komutlar: merhaba, zaman, topla");
                    break;
            }
        }
    }
}

Kod Açıklaması

  1. args Parametresi:
    Main metoduna gelen args dizisi, komut satırında verilen argümanları tutar. Örneğin, komut satırında mytool merhaba yazarsanız, args[0] değeri "merhaba" olur.

  2. Komutların İşlenmesi:
    İlk olarak args dizisinin uzunluğu kontrol edilir. Eğer kullanıcı herhangi bir komut vermezse, bir kullanım talimatı görüntülenir.

  3. switch Yapısı ile Komut Yönlendirme:
    Kullanıcının verdiği komuta göre, switch yapısı kullanılarak ilgili işlem yapılır:

    • merhaba Komutu: "Merhaba, dünya!" mesajını ekrana yazdırır.
    • zaman Komutu: Sistemin güncel saatini gösterir.
    • topla Komutu: Kullanıcıdan iki sayı alır ve toplamını ekrana yazdırır. Sayılar doğru girilmezse bir hata mesajı verir.
  4. Varsayılan Durum:
    Eğer kullanıcı bilinmeyen bir komut girerse, bu durumda eklenti mevcut komutları listeleyerek yardımcı olur.

CLI Aracınızı Test Etme

Kodunuzu yazdıktan sonra, her şeyin doğru çalışıp çalışmadığını test etmek için projeyi derleyip çalıştırabilirsiniz.

dotnet run -- merhaba

Bu komutun çıktısı:

Merhaba, dünya!

Başka bir örnek:

dotnet run -- topla 5 10

Bu komutun çıktısı:

Sonuç: 15

Hata Yönetimi ve Genişletme

Bu örnek, CLI aracınıza nasıl temel komutlar ekleyebileceğinizi göstermektedir. Ancak daha karmaşık bir araç oluşturmak isterseniz şunları ekleyebilirsiniz:

  • Hata yönetimi: Kullanıcıdan gelen hatalı girişleri yakalayıp detaylı hata mesajları gösterebilirsiniz.
  • Yeni komutlar: switch yapısına yeni komutlar ekleyerek aracınızı genişletebilirsiniz.
  • Dış bağımlılıklar: Örneğin, bir HTTP isteği göndermek için HttpClient kullanabilir veya veritabanına bağlanabilirsiniz.

Bu basit CLI uygulaması, projelerinizi otomatikleştiren, zaman kazandıran araçlar geliştirmek için size iyi bir başlangıç sağlar. Şimdi, bir sonraki adımda bu projeyi paketleyip çalıştırılabilir bir araç haline getireceğiz.

Komut Satırı Argümanlarını Yönetmek İçin Kütüphaneler

CLI projeleri büyüdükçe, komut satırı argümanlarını elle işlemek karmaşıklaşabilir. Neyse ki, argümanları daha kolay bir şekilde ayrıştırmak ve işlemek için çeşitli kütüphaneler mevcut. Aşağıda, en popüler ve işlevsel birkaç .NET kütüphanesini bulabilirsiniz:


1. System.CommandLine

  • Nedir?: Microsoft tarafından geliştirilen resmi bir kütüphanedir. Komutların, alt komutların ve seçeneklerin yönetilmesi için güçlü bir altyapı sunar.
  • Özellikler:
    • Alt komutlar ve çoklu argüman desteği sağlar.
    • Otomatik olarak komut yardım dökümünü (help) oluşturur.
    • Seçeneklerin kısa ve uzun sürümlerini destekler (örneğin, -v ve --version).

Örnek Kullanım:

dotnet add package System.CommandLine
using System.CommandLine;

var rootCommand = new RootCommand("MyTool - Komut satırı aracınız");

rootCommand.AddOption(new Option<string>("--isim", "Kullanıcının adı"));
rootCommand.SetHandler((string isim) => {
    Console.WriteLine($"Merhaba, {isim}!");
}, new Option<string>("--isim"));

await rootCommand.InvokeAsync(args);

2. CommandLineParser

  • Nedir?: Basit ve esnek bir komut satırı ayrıştırıcıdır. Küçük projelerde hızlıca kullanılabilir.
  • Özellikler:
    • Argümanları doğrudan bir sınıfa bağlayarak (binding) yönetmeyi sağlar.
    • Otomatik olarak hata mesajları ve yardım dökümü üretir.
    • Seçeneklerin tür dönüştürmesini otomatik olarak yapar.

Örnek Kullanım:

dotnet add package CommandLineParser
using CommandLine;

public class Options
{
    [Option('n', "name", Required = true, HelpText = "Kullanıcının adını belirtir.")]
    public string Name { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        Parser.Default.ParseArguments<Options>(args)
            .WithParsed<Options>(opts => Console.WriteLine($"Merhaba, {opts.Name}!"));
    }
}

3. McMaster.Extensions.CommandLineUtils

  • Nedir?: Komut satırı argümanlarıyla çalışan daha gelişmiş projeler için kullanışlıdır. ASP.NET tarzı attribute kullanımıyla komutları tanımlamayı sağlar.
  • Özellikler:
    • Alt komut ve seçenek desteği sunar.
    • attribute kullanarak komutlar arasında geçiş sağlar.
    • CLI projelerine doğal bir yapı kazandırır.

Örnek Kullanım:

dotnet add package McMaster.Extensions.CommandLineUtils
using McMaster.Extensions.CommandLineUtils;

[Command(Name = "mytool", Description = "Özel CLI Aracınız")]
class Program
{
    [Option("-n|--name <NAME>", "Kullanıcının adı", CommandOptionType.SingleValue)]
    public string Name { get; }

    public static int Main(string[] args) => CommandLineApplication.Execute<Program>(args);

    private void OnExecute()
    {
        Console.WriteLine($"Merhaba, {Name ?? "dünya"}!");
    }
}

Hangi Kütüphaneyi Seçmelisiniz?

  • Basit projeler için CommandLineParser hızlı bir başlangıç sağlar.
  • Alt komutlar ve detaylı seçenekler ile çalışmanız gerekiyorsa, System.CommandLine iyi bir tercihtir.
  • Daha karmaşık yapıya sahip büyük projeler için, McMaster.Extensions.CommandLineUtils kullanımı projelerinizi modüler hale getirebilir.

Bu kütüphanelerden biriyle çalışarak projenizi daha esnek, okunabilir ve sürdürülebilir hale getirebilirsiniz.

4. CLI Eklentisini Paketleme

Eklentinizi geliştirdikten sonra, onu .NET CLI aracı (tool) olarak paketlemeniz ve kullanıma hazır hale getirmeniz gerekiyor. Bu işlem, aracınızı hem lokal ortamda test etmenize hem de isterseniz NuGet üzerinden dağıtmanıza olanak tanır. Aşağıda adım adım bu süreci nasıl yapacağınızı anlatıyorum.


Paketleme İçin Projenizi Derleyin

Öncelikle projenizin sorunsuz bir şekilde derlendiğinden emin olun. Terminalde proje dizininde aşağıdaki komutu çalıştırın:

dotnet build -c Release

Bu komut, projenizi Release yapılandırmasında derler ve bin/Release/{framework} dizinine yerleştirir. Bu aşamada hata almıyorsanız, bir sonraki adımda eklentiyi paketleyebilirsiniz.


Eklentiyi Paketleme

CLI eklentisini kullanıma sunabilmek için bir NuGet paketi oluşturmanız gerekiyor. Aşağıdaki komutu kullanarak projenizi paketleyin:

dotnet pack -c Release

Bu komut, projenizi .nupkg uzantılı bir NuGet paketi haline getirir. Paket, bin/Release dizininde bulunacaktır. Örneğin, MyDotNetPlugin.1.0.0.nupkg şeklinde bir dosya oluşur.

Paket içeriği şu bilgileri barındırır:

  • Proje dosyası (.csproj) ayarları
  • Çalıştırılabilir dosya ve kodlar (.exe veya platforma uygun format)
  • CLI eklentisinin NuGet uyumlu paket tanımları

Lokal Olarak Eklentiyi Kurup Test Etme

Eklentinizi NuGet'e göndermeden önce lokal makinenizde test edebilirsiniz. Bunun için paket dosyasını dotnet ile global olarak kurun:

dotnet tool install --global --add-source ./bin/Release mytool

Bu komut, eklentinizi global araçlar (global tools) arasına ekler. Artık terminalde mytool komutunu doğrudan çalıştırarak test edebilirsiniz:

mytool merhaba

Eğer eklenti doğru çalışıyorsa, kurulum başarılı olmuştur.


NuGet Üzerinde Yayınlama (İsteğe Bağlı)

Eğer eklentinizi herkesin erişebileceği şekilde yayınlamak istiyorsanız, NuGet'e yüklemeniz gerekir. Bunun için önce bir NuGet API key edinmelisiniz. NuGet'e giriş yaparak buradan yeni bir API anahtarı oluşturabilirsiniz.

API anahtarını aldıktan sonra aşağıdaki komutla eklentinizi NuGet'e yükleyin:

dotnet nuget push bin/Release/MyDotNetPlugin.1.0.0.nupkg -k <API_KEY> -s https://api.nuget.org/v3/index.json

Bu komut, NuGet sunucusuna eklentinizi gönderir. Eğer yükleme başarılı olursa, eklentiniz kısa süre içinde NuGet galerisinde görünecektir.


Güncelleme ve Kaldırma

Kullanıcılar eklentinizi yükledikten sonra güncellemeleri ve kaldırmaları için aşağıdaki komutları verebilirler:

  • Güncelleme:

    dotnet tool update -g mytool
    
  • Kaldırma:

    dotnet tool uninstall -g mytool
    

Bu komutlar, eklentinizin yeni sürümlerini dağıttığınızda kullanıcıların kolayca güncelleme yapmasını sağlar.


Paketleme ve Yayınlama Sırasında Karşılaşılabilecek Sorunlar

  • "Tool 'mytool' was not found" hatası:
    Eklentiyi kurarken bu hatayı alırsanız, paket adının ve ToolCommandName ayarının doğru olup olmadığını kontrol edin.

  • NuGet API hataları:
    API anahtarınızın doğru olduğundan ve NuGet üzerindeki paket tanımlarınızın eksiksiz olduğundan emin olun.

  • Eksik bağımlılıklar:
    Eklentiniz başka kütüphanelere bağımlıysa, *.csproj dosyasında tüm bağımlılıkların tanımlandığından emin olun.


Bu adımlarla, CLI eklentinizi başarıyla paketleyebilir ve isterseniz NuGet galerisinde yayınlayabilirsiniz. Paketleme işlemi, aracınızı farklı sistemlerde kolayca kullanmanıza ve paylaşmanıza olanak sağlar.

5. NuGet Üzerinden Yayınlama veya Lokal Kurulum

CLI eklentinizi yayınladıktan sonra iki şekilde kullanılabilir hale getirebilirsiniz: lokal kurulum ile kendi makinenizde test edebilir veya NuGet galerisinde yayınlayarak herkesin kullanımına sunabilirsiniz. Bu adımda, her iki yöntemi de ayrıntılarıyla inceleyeceğiz.


Lokal Kurulum

Eklentinizi NuGet'e göndermeden önce lokal ortamda test etmek iyi bir fikirdir. Böylece paketleme işleminin başarılı olup olmadığını ve komutların beklediğiniz gibi çalışıp çalışmadığını görebilirsiniz.

  1. Paket Dosyanızın Yolunu Belirleyin:
    Derleme işleminden sonra bin/Release dizininde oluşturulan .nupkg dosyasının bulunduğu konuma gidin.

  2. Eklentiyi Lokal Olarak Kurun: Aşağıdaki komutla, eklentiyi makinenize global olarak kurun:

    dotnet tool install --global --add-source ./bin/Release mytool
    
  3. Kurulum Sonrası Test Edin:
    Eklentinizin çalışıp çalışmadığını görmek için komut satırında aşağıdaki gibi basit bir komut çalıştırın:

    mytool merhaba
    

    Çıktı:

    Merhaba, dünya!
    
  4. Kurulumu Kaldırmak:
    Test işlemi bittikten sonra eklentiyi kaldırmak isterseniz, şu komutu kullanın:

    dotnet tool uninstall -g mytool
    

NuGet Üzerinde Yayınlama

Eğer eklentinizi herkesin erişimine açmak istiyorsanız, NuGet üzerinde yayınlamanız gerekir. Aşağıda, NuGet yayınlama adımlarını bulabilirsiniz.

  1. NuGet API Anahtarını Alın:
    NuGet galerisinde oturum açın ve NuGet API Keys sayfasına gidin. Buradan yeni bir API anahtarı oluşturun.

  2. NuGet Paketini Gönderme:
    Aşağıdaki komutu kullanarak paket dosyanızı NuGet sunucusuna yükleyin:

    dotnet nuget push bin/Release/MyDotNetPlugin.1.0.0.nupkg -k <API_KEY> -s https://api.nuget.org/v3/index.json
    
  3. Paketin Yayınlandığını Kontrol Edin:
    Yükleme işlemi tamamlandığında, paketinizin NuGet galerisinde görünüp görünmediğini kontrol edin. Birkaç dakika içinde https://www.nuget.org adresinde eklentiniz listelenmiş olmalıdır.


NuGet Üzerinden Kurulum ve Güncelleme

Paketiniz NuGet galerisinde yayınlandıktan sonra, kullanıcılar aşağıdaki komutla eklentiyi kurabilirler:

dotnet tool install --global mytool

Eğer eklentinizin yeni bir sürümünü yayınladıysanız, kullanıcılar şu komutla güncelleyebilirler:

dotnet tool update -g mytool

Kurulumda veya güncellemede bir sorun olursa, kullanıcılar paketinizin NuGet adresini kontrol edebilir veya paket bağımlılıklarının doğru tanımlandığından emin olmalıdır.


Yayınlama ve Kurulum Sorunları

  • API Hatası: API anahtarınızı doğru şekilde girdiğinizden ve anahtarın süresinin dolmadığından emin olun.
  • Paket Bulunamıyor: Eğer kullanıcılar paketinizin adını bulamıyorsa, ToolCommandName ile paket adınızın uyumlu olduğundan emin olun.
  • Paket Versiyonları: NuGet sürümleme kurallarına uymak için her güncellemede versiyon numarasını artırmanız gerekir.

Bu adımlarla, eklentinizi hem lokal ortamda test edip hem de NuGet üzerinde tüm kullanıcılara açabilirsiniz. Bu süreç, aracınızın farklı platformlarda kullanılabilmesini ve güncel tutulmasını sağlar.

6. Kullanım

CLI eklentinizi başarıyla paketleyip kurduktan sonra, komut satırında kullanıma hazır hale gelir. Şimdi, eklentinizi nasıl kullanabileceğinizi, farklı komutları nasıl çalıştırabileceğinizi ve olası kullanım senaryolarını inceleyelim.


Kurulu Eklentiyi Çalıştırma

Eğer eklentinizi lokal olarak kurduysanız veya NuGet galerisinden yüklediyseniz, eklentinizi komut satırında kullanmaya hazırsınız. Eklentiyi şu şekilde çalıştırabilirsiniz:

mytool

Eğer komut satırında bir argüman vermeden çalıştırırsanız, eklentiniz varsayılan bir talimat veya bilgi mesajı dönecektir. Örneğin, aşağıdaki gibi:

Kullanım: mytool <komut> [parametreler]
Örnek: mytool merhaba

Komut Örnekleri

Eklentinizin içine yazdığınız komutlara göre farklı çıktılar alabilirsiniz. Örnek olarak, eklentinizde tanımlı olan komutların nasıl çalıştığını inceleyelim:

  1. Merhaba Komutu:

    mytool merhaba
    

    Çıktı:

    Merhaba, dünya!
    
  2. Zaman Komutu:

    mytool zaman
    

    Çıktı:

    Şu anki saat: 2024-10-24 12:45:00
    
  3. Topla Komutu: Kullanıcıdan iki sayı alarak toplamını hesaplar:

    mytool topla 10 20
    

    Çıktı:

    Sonuç: 30
    
  4. Hatalı Komut Girişi: Eklentiye tanımlanmayan bir komut verdiğinizde:

    mytool bilinmeyen
    

    Çıktı:

    Bilinmeyen komut: bilinmeyen
    Kullanılabilir komutlar: merhaba, zaman, topla
    

Eklentiyi Güncelleme ve Kaldırma

Güncelleme:
Eğer eklentinin daha yeni bir sürümü yayınlandıysa, kullanıcılar aşağıdaki komutla en son sürüme güncelleyebilir:

dotnet tool update -g mytool

Kaldırma:
Eklentiyi sisteminizden kaldırmak isterseniz, şu komutu kullanın:

dotnet tool uninstall -g mytool

Farklı Senaryolar İçin Kullanım

  • Komut satırı otomasyonu: Sık tekrarlanan işlemleri otomatikleştirmek için eklentiyi planlayıcılar veya CI/CD süreçlerinde kullanabilirsiniz.
  • Alt komutlarla modüler yapı: Komut satırına yeni alt komutlar ekleyerek eklentiyi modüler hale getirebilirsiniz.
  • Parametrelerle esnek yapı: İsteğe bağlı parametreler ekleyerek kullanıcıya daha fazla esneklik sağlayabilirsiniz.

7. Güncelleme ve Kaldırma

CLI eklentinizin kullanıcıların sistemlerinde sorunsuz çalışmaya devam etmesi için zaman zaman güncellemeler yapmanız gerekebilir. Ayrıca, kullanıcılar istedikleri zaman eklentiyi kaldırmak isteyebilirler. Bu bölümde, eklentinizin güncellenmesi ve kaldırılması süreçlerini inceleyeceğiz.


Güncelleme İşlemi

Eğer eklentinizin yeni bir sürümünü yayınladıysanız (örneğin, hata düzeltmeleri veya yeni özellikler eklediyseniz), kullanıcılar bu sürüme kolayca geçiş yapabilirler. Güncelleme işlemi aşağıdaki komut ile yapılır:

dotnet tool update -g mytool

Bu komut, NuGet üzerindeki en son sürümü kontrol eder ve otomatik olarak indirip kurar. Eğer güncelleme başarılı olursa, terminalde aşağıdaki gibi bir mesaj alırsınız:

Tool 'mytool' was successfully updated to version 1.1.0.

Not:

  • Kullanıcıların yeni sürümü edinebilmesi için, yayınlanan sürüm numarasının artırılmış olması gerekir (örneğin, 1.0.0’dan 1.1.0’a).
  • Eğer kullanıcı güncelleme sırasında hata alırsa, NuGet paket önbelleği veya ağ bağlantısını kontrol etmeleri gerekebilir.

Eklentiyi Kaldırma

Kullanıcılar herhangi bir nedenle eklentiyi sistemlerinden kaldırmak isterse, şu komutu kullanabilirler:

dotnet tool uninstall -g mytool

Bu komut, eklentiyi sistemden kaldırır ve global araçlar listesinden siler. Eğer işlem başarılı olursa, şu mesaj görüntülenir:

Tool 'mytool' was successfully uninstalled.

Not:

  • Eğer kullanıcı farklı bir versiyona sahip birden fazla kurulum yaptıysa (örneğin lokal ve global), her kurulum için ayrı ayrı kaldırma komutu çalıştırmaları gerekebilir.

Olası Sorunlar ve Çözümleri

  • “Tool not found” Hatası: Kullanıcı eklentiyi daha önce kurmamış olabilir veya doğru isimle kaldırma komutunu vermemiş olabilir. Bu durumda, şu komutla yüklü araçları kontrol edin:

    dotnet tool list -g
    
  • Güncelleme Hataları: Eğer güncelleme sırasında NuGet’e bağlantı sağlanamıyorsa, kullanıcının ağ bağlantısını kontrol etmesi veya NuGet kaynağını manuel olarak belirtmesi gerekebilir:

    dotnet tool update -g mytool --add-source https://api.nuget.org/v3/index.json
    

Güncelleme ve Kaldırma Sürecinin Önemi

  • Güncel kalmak: Eklentiyi düzenli olarak güncelleyerek hata düzeltmeleri ve performans iyileştirmeleri sunabilirsiniz.
  • Esnek kullanım: Kullanıcıların istedikleri zaman eklentiyi kaldırabilmesi, onların sistem yönetimini kolaylaştırır ve eklentinizin kullanıcı dostu olmasını sağlar.

Bu adımlarla, kullanıcılar eklentinizi kolayca güncelleyebilir ve gerekirse sistemlerinden kaldırabilirler. Eklentiyi düzenli olarak güncel tutarak daha iyi bir deneyim sunabilir ve kullanıcılarınıza ihtiyaçlarına uygun yeni özellikler sağlayabilirsiniz.

Özet

Bu makalede, .NET CLI için kendi eklentinizi nasıl geliştirebileceğinizi adım adım inceledik. Basit bir console application projesinden yola çıkarak, projenizi nasıl CLI aracı haline getirebileceğinizi, paketleyip lokal ortamda test edebileceğinizi ve NuGet üzerinden yayınlayabileceğinizi gördük. Ayrıca, eklentinize farklı komutlar ekleme, argümanları işleme için kullanışlı kütüphaneleri tanıma ve güncelleme-kaldırma işlemleri hakkında bilgi sahibi olduk.

CLI eklentileri, sık tekrarlanan görevleri otomatikleştirmenin ve yazılım geliştirme süreçlerinizi hızlandırmanın mükemmel bir yoludur. Kendi eklentilerinizi geliştirerek, hem projelerinize özel araçlar oluşturabilir hem de iş akışınızı optimize edebilirsiniz. NuGet üzerinde yayınladığınız araçlarla, hem kendinize hem de topluluğa katkıda bulunabilirsiniz.

Artık elinizde, temel CLI araçları geliştirmek ve yayınlamak için gereken tüm bilgiler var. Projelerinizi geliştirdikçe, yeni komutlar ekleyebilir, argüman işleme sürecini genişletebilir ve aracınızı daha modüler hale getirebilirsiniz. Hangi projede olursanız olun, bir CLI aracıyla işlerinizi daha hızlı ve verimli hale getirmek tamamen sizin elinizde!

Eklentinizi geliştirme ve paylaşma sürecinde başarılar!

Yorumlar

Popüler Yayınlar