.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ğinnet6.0
veyanet7.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 ayardamytool
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ı
args
Parametresi:Main
metoduna gelenargs
dizisi, komut satırında verilen argümanları tutar. Örneğin, komut satırındamytool merhaba
yazarsanız,args[0]
değeri"merhaba"
olur.Komutların İşlenmesi:
İlk olarakargs
dizisinin uzunluğu kontrol edilir. Eğer kullanıcı herhangi bir komut vermezse, bir kullanım talimatı görüntülenir.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.
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 veToolCommandName
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.
Paket Dosyanızın Yolunu Belirleyin:
Derleme işleminden sonrabin/Release
dizininde oluşturulan.nupkg
dosyasının bulunduğu konuma gidin.Eklentiyi Lokal Olarak Kurun: Aşağıdaki komutla, eklentiyi makinenize global olarak kurun:
dotnet tool install --global --add-source ./bin/Release mytool
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!
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.
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.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
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:
Merhaba Komutu:
mytool merhaba
Çıktı:
Merhaba, dünya!
Zaman Komutu:
mytool zaman
Çıktı:
Şu anki saat: 2024-10-24 12:45:00
Topla Komutu: Kullanıcıdan iki sayı alarak toplamını hesaplar:
mytool topla 10 20
Çıktı:
Sonuç: 30
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