spkl’den Pillaro’ya Dataverse Plugin Geçişi: Sorunsuz Bir Kılavuz

spkl’den Pillaro’ya Dataverse Plugin Geçişi: Sorunsuz Bir Kılavuz

Microsoft Dataverse platformunda geliştirme yapan ekipler için plugin (eklenti) yönetimi ve dağıtımı, projenin başarısında kritik bir rol oynar. Uzun yıllardır birçok geliştiricinin tercihi olan spkl, basit ve etkili bir çözüm sunsa da, modern geliştirme pratiklerinin ve bulut tabanlı mimarilerin getirdiği yenilikler karşısında bazı sınırlamalara sahip olabilmektedir. Peki, mevcut spkl tabanlı projelerinizi daha modern, esnek ve güçlü bir araç olan Pillaro’ya taşımak neden bu kadar önemli? Bu kapsamlı rehber, mevcut spkl pluginlerinizi Pillaro’ya sorunsuz bir şekilde nasıl taşıyacağınızı adım adım açıklayarak, geliştirme süreçlerinizi optimize etmenize ve geleceğe hazır hale getirmenize yardımcı olacaktır.

Dataverse Plugin Geliştirmede spkl’den Pillaro’ya Geçiş Neden Gerekli?

Dataverse (eski adıyla Common Data Service) üzerinde iş mantığı geliştirmek için kullanılan pluginler, platformun temel taşlarından biridir. Bu pluginlerin geliştirilmesi, derlenmesi ve dağıtılması süreçleri, projenin verimliliği ve sürdürülebilirliği açısından büyük önem taşır. Yıllardır birçok geliştirici, bu süreçleri kolaylaştırmak için spkl (Solution Packager & Kendo UI for Dataverse) gibi araçları kullanmıştır. spkl, özellikle ilk çıktığı dönemlerde, Visual Studio entegrasyonu ve basit dağıtım mekanizmalarıyla oldukça popülerdi. Ancak teknoloji dünyası sürekli evriliyor ve bu evrim, geliştirme araçlarından beklentilerimizi de şekillendiriyor. Günümüzde, Continuous Integration/Continuous Delivery (CI/CD – Sürekli Entegrasyon/Sürekli Teslimat) pratikleri, otomasyon, bulut tabanlı geliştirme ve daha esnek yapılandırma seçenekleri ön plana çıkmaktadır. spkl, bu modern gereksinimlerin bazılarına tam olarak yanıt veremeyebilir veya bunları karmaşık hale getirebilir. Örneğin, karmaşık derleme süreçleri, bağımlılık yönetimi ve farklı ortamlar arasında tutarlı dağıtım sağlamak, spkl ile zaman zaman zorlayıcı olabilmektedir. Bu durum, özellikle büyük ve çok sayıda plugin içeren projelerde, geliştirme hızını yavaşlatabilir ve hata oranını artırabilir.

İşte tam da bu noktada Pillaro devreye giriyor. Pillaro, Dataverse plugin geliştirme ve dağıtım süreçlerini modernleştirmek, otomatikleştirmek ve basitleştirmek amacıyla tasarlanmış yeni nesil bir araçtır. Geliştiricilere daha iyi bir deneyim sunmakla kalmaz, aynı zamanda CI/CD pipeline’ları (işlem hatları) ile mükemmel bir uyum sağlayarak, yazılım geliştirme yaşam döngüsünü (SDLC) çok daha verimli hale getirir. Pillaro’ya geçiş, sadece bir araç değişikliği değil, aynı zamanda daha modern, esnek ve ölçeklenebilir bir geliştirme yaklaşımına doğru atılan stratejik bir adımdır. Bu geçiş sayesinde, geliştirme ekipleri daha az manuel işlemle, daha hızlı ve daha güvenilir bir şekilde pluginlerini Dataverse ortamlarına dağıtabilirler. Ayrıca, Pillaro’nun sunduğu gelişmiş yapılandırma seçenekleri ve komut satırı arayüzü (CLI), otomasyon senaryolarını zenginleştirerek, tekrarlayan görevleri minimuma indirir. Bu makale, spkl’den Pillaro’ya geçişin neden gerekli olduğunu anlamanıza ve bu geçişi başarılı bir şekilde gerçekleştirmenize yardımcı olacak pratik bilgiler sunmaktadır. Amacımız, okuyucunun konuyu sıfırdan öğrenebileceği, her adımda destekleyici bilgilerle donatılmış, samimi ama profesyonel bir rehber sunmaktır.

spkl ve Pillaro Nedir? Temel Kavramlara Hızlı Bir Bakış

Dataverse plugin geliştirme dünyasında iki önemli aracı derinlemesine anlamak, geçiş sürecini kavramak için hayati öneme sahiptir: spkl ve Pillaro. Her ikisi de pluginlerinizi Dataverse’e dağıtmanıza yardımcı olur, ancak yaklaşımları ve sundukları özellikler bakımından önemli farklılıklar gösterirler.

spkl: Geçmişten Gelen Güvenilir Ortak

spkl, “Solution Packager & Kendo UI for Dataverse” kısaltmasıyla bilinen, uzun yıllardır Dataverse (eski adıyla Dynamics 365 CE) geliştiricilerinin kullandığı bir araç setidir. Temel olarak, pluginlerinizi Visual Studio üzerinden derlemenize, imzalamanıza ve Dataverse’e dağıtmanıza olanak tanır. spkl’nin en büyük avantajı, Visual Studio entegrasyonunun derinliği ve kullanım kolaylığıdır. Projenize bir NuGet paketi olarak eklendiğinde, plugin derleme ve dağıtım görevlerini doğrudan Visual Studio’dan yürütebilirsiniz. Bu, özellikle tek başına çalışan geliştiriciler veya küçük ekipler için pratik bir çözüm sunmuştur. spkl, plugin assembly’lerini (derlemelerini) Dataverse’e kaydetme, adımları (steps) tanımlama ve servis uç noktalarını (service endpoints) yönetme gibi temel işlevleri yerine getirir. Ancak, spkl’nin bazı dezavantajları da bulunmaktadır. Özellikle modern CI/CD pipeline’ları ile tam entegrasyon konusunda sınırlamaları vardır. Yapılandırma dosyaları genellikle XML tabanlıdır ve bu da büyük projelerde yönetimi zorlaştırabilir. Ayrıca, komut satırı arayüzü (CLI) yetenekleri daha kısıtlıdır, bu da otomasyon senaryolarını karmaşıklaştırabilir. Bakım ve geliştirme hızı da, daha yeni araçlara kıyasla yavaşlayabilmektedir.

Pillaro: Geleceğin Modern Çözümü

Pillaro, Dataverse plugin geliştirme ve dağıtım süreçlerini modernleştirmek için tasarlanmış, .NET CLI tabanlı yeni nesil bir araçtır. Temel amacı, geliştiricilere daha tutarlı, otomatize edilebilir ve verimli bir deneyim sunmaktır. Pillaro, komut satırı arayüzü merkezli bir yaklaşımla, derleme, imzalama, kayıt ve dağıtım gibi tüm plugin yaşam döngüsü adımlarını kolaylaştırır. Bu CLI tabanlı yapı, onu CI/CD sistemleriyle mükemmel bir şekilde entegre edilebilir kılar. Geliştiriciler, Pillaro’yu kullanarak tek bir komutla pluginlerini derleyebilir, test edebilir ve birden fazla Dataverse ortamına dağıtabilirler. Pillaro’nun sunduğu başlıca avantajlar şunlardır:

• Modern Yapılandırma: Genellikle JSON veya YAML tabanlı yapılandırma dosyaları kullanarak, daha okunabilir ve yönetilebilir bir yapı sunar.
• CLI Odaklılık: Komut satırı arayüzü, otomasyon ve betik (script) yazma süreçlerini basitleştirir, bu da CI/CD pipeline’ları için idealdir.
• Tutarlılık: Farklı geliştirme ve dağıtım ortamları arasında tutarlı sonuçlar elde etmeyi kolaylaştırır.
• Esneklik: Farklı .NET framework (yazılım çerçevesi) versiyonlarını ve proje yapılarını destekler.
• Topluluk ve Gelişim: Aktif bir topluluk tarafından desteklenir ve sürekli olarak yeni özelliklerle güncellenir.

Pillaro, aynı zamanda pluginlerinizi geliştirirken karşılaşabileceğiniz bağımlılık yönetimi, assembly versiyonlama (derleme versiyonlama) ve hata ayıklama (debugging) gibi konularda da daha güçlü çözümler sunar. Bu iki araç arasındaki temel farkı anlamak, spkl’den Pillaro’ya geçişin sadece bir zorunluluk değil, aynı zamanda bir iyileştirme ve modernizasyon fırsatı olduğunu açıkça ortaya koymaktadır. Pillaro’ya geçiş, geliştirme ekiplerinin Dataverse projelerinde daha çevik, daha güvenilir ve daha verimli olmalarını sağlayacaktır.

Pillaro Ortamını Kurulum ve İlk Adımlar: Projenizi Nasıl Hazırlarsınız?

spkl’den Pillaro’ya geçişin ilk ve en önemli adımı, geliştirme ortamınızı Pillaro ile uyumlu hale getirmektir. Bu bölüm, gerekli araçları kurmaktan, yeni bir Pillaro projesi oluşturmaya kadar adım adım tüm süreci kapsamaktadır. Doğru bir kurulum, sorunsuz bir geçişin temelini oluşturur.

Gerekli Araçların Kurulumu

Pillaro ile çalışabilmek için öncelikle bazı temel geliştirme araçlarının sisteminizde kurulu olması gerekir:

1. .NET SDK: Pillaro, .NET Core veya .NET 5/6/7/8 gibi modern .NET framework’lerini (yazılım çerçevelerini) kullanır. En güncel .NET SDK’sını Microsoft’un resmi web sitesinden indirip kurmanız gerekmektedir. Genellikle Dataverse pluginleri için .NET Framework 4.6.2 veya .NET 4.7.2 hedef alınır, ancak Pillaro’nun kendisi modern .NET üzerinde çalıştığı için SDK’nın kurulu olması şarttır.
2. Visual Studio: Plugin kodunuzu yazmak ve hata ayıklamak için güçlü bir IDE (Entegre Geliştirme Ortamı) olan Visual Studio (2019 veya 2022 önerilir) gereklidir. .NET geliştirme iş yükünün kurulu olduğundan emin olun.
3. Power Platform CLI: Pillaro, Power Platform CLI (Komut Satırı Arayüzü) ile entegre çalışır. Bu araç, Dataverse ortamlarıyla etkileşim kurmanızı, çözümleri (solutions) yönetmenizi ve pluginleri dağıtmanızı sağlar. Power Platform CLI’yı Microsoft Docs üzerinden kurabilirsiniz. Kurulum genellikle dotnet tool install --global Microsoft.PowerApps.CLI komutu ile yapılır.

Pillaro’yu Projenize Entegre Etme

Pillaro’yu projenize eklemek için öncelikle yeni bir .NET sınıf kitaplığı (class library) projesi oluşturmanız veya mevcut plugin projenizi uygun hale getirmeniz gerekir. Ardından, Pillaro’nun kendi CLI aracını veya NuGet paketlerini kullanabilirsiniz. En yaygın yöntem, Pillaro’nun NuGet paketini mevcut plugin projenize eklemektir.

dotnet add package MSF.Pillaro.Core
dotnet add package MSF.Pillaro.Sdk

Bu komutlar, Pillaro’nun temel işlevselliğini ve Dataverse SDK bağımlılıklarını projenize ekler. Pillaro, pluginlerinizi derlemek ve dağıtmak için projenizin .csproj dosyasındaki bazı yapılandırmalara ihtiyaç duyar. Örnek bir .csproj dosya yapısı aşağıdaki gibi olabilir:

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

  <PropertyGroup>
    <TargetFramework>net462</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <GeneratePlugin>true</GeneratePlugin> <!-- Pillaro için önemli -->
    <PluginRegistrationFile>plugin.json</PluginRegistrationFile> <!-- Pillaro yapılandırma dosyası -->
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.CrmSdk.CoreAssemblies" Version="9.0.2.42" />
    <PackageReference Include="MSF.Pillaro.Core" Version="1.0.0" />
    <PackageReference Include="MSF.Pillaro.Sdk" Version="1.0.0" />
  </ItemGroup>

  <ItemGroup>
    <None Update="plugin.json" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>

Burada <GeneratePlugin>true</GeneratePlugin> ve <PluginRegistrationFile>plugin.json</PluginRegistrationFile> etiketleri, Pillaro’nun projenizi bir plugin projesi olarak tanıması ve ilgili yapılandırma dosyasını kullanması için kritik öneme sahiptir. CopyToOutputDirectory="PreserveNewest" ayarı ise plugin.json dosyasının derleme çıktısı dizinine kopyalanmasını sağlar.

Pillaro Yapılandırma Dosyası: plugin.json

Pillaro, pluginlerinizin Dataverse’e nasıl kaydedileceğini tanımlamak için genellikle plugin.json adında bir yapılandırma dosyası kullanır. Bu dosya, plugin assembly’nizin adını, içindeki plugin sınıflarını, adımlarını (steps), servis uç noktalarını (service endpoints) ve diğer kayıt detaylarını içerir. spkl’deki XML tabanlı .csproj.user veya .crmregister dosyalarına benzer bir işlevi görür, ancak JSON formatı sayesinde daha modern ve okunabilir bir yapı sunar. Örnek bir plugin.json içeriği:

{
  "assembly": {
    "name": "MyPillaroPlugins",
    "solution": "MySolutionName",
    "isolationMode": "Sandbox",
    "sourceType": "Database",
    "keyFile": "MyPillaroPlugins.snk"
  },
  "plugins": [
    {
      "typeName": "MyPillaroPlugins.MyFirstPlugin",
      "friendlyName": "İlk Pillaro Pluginim",
      "description": "Örnek bir Pillaro plugin",
      "steps": [
        {
          "message": "Create",
          "primaryEntity": "account",
          "secondaryEntity": "none",
          "stage": "PreOperation",
          "mode": "Synchronous",
          "filteringAttributes": "",
          "executionOrder": 1,
          "unsecureConfiguration": "",
          "secureConfiguration": ""
        }
      ]
    }
  ]
}

Bu dosya, Pillaro’nun plugininizi Dataverse’e kaydederken ihtiyaç duyduğu tüm bilgileri sağlar. assembly bölümünde derlemenin genel özellikleri, plugins bölümünde ise her bir plugin sınıfının ve adımlarının detayları yer alır. Bu yapılandırmanın doğru bir şekilde yapılması, geçiş sürecinin en kritik adımlarından biridir. Bu adımları tamamladığınızda, Pillaro geliştirme ortamınız hazır olacak ve mevcut spkl plugin kodunuzu taşımaya başlayabileceksiniz.

spkl Plugin Kodunu Pillaro’ya Adapte Etme: Adım Adım Taşıma Süreci

Mevcut spkl tabanlı plugin kodunuzu Pillaro’ya taşımak, aslında bir kod yeniden yazma işlemi değil, daha çok mevcut kodun yeni bir araç ve yapılandırma çerçevesine entegrasyonudur. Çoğu durumda, pluginlerinizin iş mantığı kodunda büyük değişiklikler yapmanız gerekmeyecektir. Ancak, proje yapısı, referanslar ve derleme/dağıtım süreçlerinde bazı ayarlamalar yapılması şarttır. Bu bölüm, spkl’den Pillaro’ya kod taşıma sürecini adım adım açıklamaktadır.

1. Mevcut spkl Projesinden Kodun Ayrıştırılması

Öncelikle, spkl projenizin temel plugin kodunu, spkl’ye özgü yapılandırma ve dağıtım dosyalarından ayırmanız gerekir. Genellikle, plugin sınıflarınız (IPlugin arayüzünü uygulayan sınıflar) ve yardımcı sınıflarınız (helper classes) doğrudan taşınabilir. spkl’nin .csproj.user veya .crmregister gibi dosyaları, Pillaro’da plugin.json dosyası ile değiştirilecektir. Bu nedenle, bu eski yapılandırma dosyalarını göz ardı edebilirsiniz.

• Mevcut spkl projenizin kaynak kodunu (.cs dosyaları) yeni bir dizine kopyalayın.
• Gereksiz spkl referanslarını ve yapılandırma dosyalarını (örn. spkl.json, .crmregister) bu kopyalanan dizinden çıkarın.

2. Yeni Bir Pillaro Uyumlu Proje Oluşturma

Yukarıdaki “Pillaro Ortamını Kurulum” bölümünde belirtildiği gibi, yeni bir .NET sınıf kitaplığı projesi oluşturun ve Pillaro NuGet paketlerini ekleyin. Bu proje, taşınacak plugin kodunuzu barındıracaktır. Hedef framework (yazılım çerçevesi) olarak Dataverse’in desteklediği bir versiyonu (genellikle .NET Framework 4.6.2 veya 4.7.2) seçtiğinizden emin olun.

dotnet new classlib -n MyPillaroPlugins
cd MyPillaroPlugins
dotnet add package Microsoft.CrmSdk.CoreAssemblies --version 9.0.2.42
dotnet add package MSF.Pillaro.Core --version 1.0.0
dotnet add package MSF.Pillaro.Sdk --version 1.0.0

Bu komutlar, MyPillaroPlugins adında yeni bir proje oluşturur ve gerekli NuGet paketlerini ekler. Ardından, .csproj dosyanızı Pillaro için yapılandırmayı unutmayın (<GeneratePlugin>true</GeneratePlugin> ve <PluginRegistrationFile>plugin.json</PluginRegistrationFile>).

3. Plugin Kodunu Yeni Projeye Kopyalama ve Düzenleme

Şimdi, spkl projesinden ayırdığınız .cs dosyalarını yeni oluşturduğunuz Pillaro projesine kopyalayın. Visual Studio’da projenizi açtığınızda, kopyaladığınız dosyaları “Add Existing Item” (Mevcut Öğe Ekle) seçeneğiyle projeye dahil edebilirsiniz. Çoğu durumda, plugin kodunuzda çok az değişiklik yapmanız gerekecektir, çünkü Dataverse SDK arayüzleri (örn. IPlugin) değişmemiştir.

Örnek bir spkl plugin kodu:

using Microsoft.Xrm.Sdk;
using System;

namespace MySpklPlugins
{
    public class AccountCreatePlugin : IPlugin
    {
        public void Execute(IServiceProvider serviceProvider)
        {
            ITracingService tracingService = (ITracingService)serviceProvider.GetService(typeof(ITracingService));
            IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));

            if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
            {
                Entity entity = (Entity)context.InputParameters["Target"];

                if (entity.LogicalName == "account")
                {
                    entity["description"] = "Bu hesap spkl plugin tarafından oluşturuldu.";
                    tracingService.Trace("Hesap açıklaması güncellendi.");
                }
            }
        }
    }
}

Bu kod, Pillaro projenizde de aynı şekilde çalışacaktır. Tek yapmanız gereken, namespace’i (isim alanı) yeni projenizin adıyla eşleştirmek olabilir (örn. MyPillaroPlugins).

4. Bağımlılık Yönetimi ve Hedef Framework Uyumluluğu

Plugin kodunuzun kullandığı tüm harici kütüphanelerin (third-party libraries) NuGet üzerinden projenize eklendiğinden emin olun. spkl projenizde kullandığınız tüm PackageReference‘ları (paket referansları) yeni Pillaro projenizin .csproj dosyasına taşıyın. Ayrıca, Dataverse pluginlerinin genellikle .NET Framework 4.6.2 veya 4.7.2’yi hedeflediğini unutmayın. Projenizin <TargetFramework> ayarını buna göre yapılandırın.

Eğer pluginleriniz farklı bir .NET Framework sürümüne bağımlıysa, Dataverse’in desteklediği sürümlerle uyumlu hale getirmek için gerekli değişiklikleri yapmanız gerekebilir. Bu, genellikle küçük kod düzenlemeleri veya bazı kütüphanelerin daha uyumlu versiyonlarını kullanmayı gerektirebilir.

5. plugin.json Dosyasını Oluşturma ve Yapılandırma

Bu adım, spkl’deki kayıt mekanizmasının Pillaro’daki karşılığıdır. Mevcut spkl projenizdeki .crmregister veya spkl.json dosyalarından plugin adlarınızı, adımlarınızı (steps), filtreleme özelliklerinizi (filtering attributes), execution order (yürütme sırası) ve secure/unsecure configuration (güvenli/güvensiz yapılandırma) bilgilerini toplayın. Bu bilgileri kullanarak, Pillaro için plugin.json dosyasını oluşturun. Her bir plugin sınıfınız ve her bir kayıt adımınız için bu dosyada ilgili girdileri oluşturmanız gerekecektir. Örneğin, yukarıdaki AccountCreatePlugin için plugin.json‘da aşağıdaki gibi bir giriş bulunmalıdır:

{
  "assembly": {
    "name": "MyPillaroPlugins",
    "solution": "MySolutionName",
    "isolationMode": "Sandbox",
    "sourceType": "Database",
    "keyFile": "MyPillaroPlugins.snk" <!-- Eğer assembly'nizi imzalıyorsanız -->
  },
  "plugins": [
    {
      "typeName": "MyPillaroPlugins.AccountCreatePlugin",
      "friendlyName": "Hesap Oluşturma Plugin",
      "description": "Hesap oluşturulduğunda çalışan plugin.",
      "steps": [
        {
          "message": "Create",
          "primaryEntity": "account",
          "secondaryEntity": "none",
          "stage": "PreOperation",
          "mode": "Synchronous",
          "filteringAttributes": "",
          "executionOrder": 1,
          "unsecureConfiguration": "",
          "secureConfiguration": ""
        }
      ]
    }
  ]
}

keyFile özelliği, derlemenizin güçlü bir adla imzalanması (strong-name signing) için gereklidir. Eğer spkl projeniz imzalıysa, aynı .snk dosyasını Pillaro projenizde de kullanmanız önemlidir. Yeni bir .snk dosyası oluşturmak için Visual Studio’da projenizin özelliklerine giderek “Signing” (İmzalama) sekmesini kullanabilirsiniz.

Bu adımları dikkatlice takip ederek, spkl tabanlı plugin kodunuzu Pillaro’nun modern geliştirme ortamına başarıyla adapte edebilir ve bir sonraki adım olan derleme ve dağıtım süreçlerine geçiş yapabilirsiniz.

Derleme ve Dağıtım Süreçlerini Otomatikleştirmek: CI/CD Entegrasyonu Nasıl Yapılır?

spkl’den Pillaro’ya geçişin en büyük avantajlarından biri, derleme ve dağıtım süreçlerini modern CI/CD (Sürekli Entegrasyon/Sürekli Teslimat) pipeline’ları (işlem hatları) ile kolayca otomatikleştirebilmektir. Bu, geliştirme ekiplerinin daha hızlı, daha güvenilir ve daha tutarlı bir şekilde yazılım teslim etmelerini sağlar. Bu bölümde, Pillaro’yu Azure DevOps, GitHub Actions gibi popüler CI/CD araçlarıyla nasıl entegre edeceğinizi ve otomatik derleme/dağıtım süreçlerini nasıl kuracağınızı inceleyeceğiz.

Pillaro CLI ile Temel Derleme ve Dağıtım Komutları

Pillaro’nun gücü, komut satırı arayüzünde (CLI) yatar. Bu CLI komutları, CI/CD pipeline’larınızda kullanılacak temel yapı taşlarıdır.

• Derleme (Build): Plugin projenizi derlemek için standart .NET CLI komutunu kullanabilirsiniz:

  dotnet build --configuration Release

  Bu komut, projenizi derler ve Pillaro’nun anlayacağı formatta assembly’yi (derlemeyi) ve plugin.json dosyasını çıktı dizinine yerleştirir.

• Kayıt ve Dağıtım (Register & Deploy): Pillaro CLI, derlenen pluginleri Dataverse’e kaydetmek ve dağıtmak için özel komutlar sunar. Öncelikle, Power Platform CLI ile Dataverse ortamınıza bağlanmanız gerekir:

  pac auth create --url https://[ortam_adı].crm.dynamics.com

  Ardından, Pillaro CLI’yı kullanarak plugininizi dağıtabilirsiniz. Bu, genellikle bir .pcr (Pillaro Configuration) dosyası ile yapılır veya doğrudan komut satırı argümanları ile tanımlanır.

  Pillaro deploy --solution "MySolutionName" --pluginAssembly "MyPillaroPlugins.dll" --pluginConfig "plugin.json" --connection "default"

  Burada --solution parametresi pluginin hangi Dataverse çözümüne ekleneceğini belirtir, --pluginAssembly derleme dosyasının yolunu, --pluginConfig ise plugin.json dosyasının yolunu gösterir. --connection ise Power Platform CLI ile oluşturduğunuz bağlantı profilini kullanır. Bu komut, plugin assembly’nizi Dataverse’e yükler ve plugin.json dosyasındaki bilgilere göre tüm adımları ve tipleri kaydeder.

CI/CD Entegrasyonu: Azure DevOps ve GitHub Actions Örnekleri

Pillaro’yu CI/CD pipeline’ınıza entegre etmek, manuel hataları azaltır ve dağıtım hızını artırır.

Azure DevOps Pipeline Örneği

Azure DevOps’ta bir YAML pipeline oluşturarak Pillaro ile otomatik derleme ve dağıtım yapabilirsiniz. Aşağıdaki örnek, temel adımları göstermektedir:

trigger:
- main

pool:
  vmImage: 'windows-latest'

variables:
  buildConfiguration: 'Release'
  solutionName: 'MySolutionName'
  pluginAssembly: 'MyPillaroPlugins.dll'
  pluginConfig: 'plugin.json'
  dataverseUrl: '$(DataverseUrl)' # Pipeline değişkeni olarak tanımlanmalı
  dataverseUser: '$(DataverseUser)' # Pipeline değişkeni olarak tanımlanmalı
  dataversePassword: '$(DataversePassword)' # Güvenli değişken olarak tanımlanmalı

steps:
- task: UseDotNet@2
  displayName: 'Install .NET SDK'
  inputs:
    version: '6.x' # Projenizin hedeflediği .NET SDK sürümü

- task: NuGetCommand@2
  displayName: 'Restore NuGet Packages'
  inputs:
    command: 'restore'
    restoreSolution: '**/*.sln'

- task: DotNetCoreCLI@2
  displayName: 'Build Plugin Project'
  inputs:
    command: 'build'
    projects: '**/*.csproj'
    arguments: '--configuration $(buildConfiguration)'

- task: PowerPlatformToolInstaller@0
  displayName: 'Install Power Platform CLI'

- script: |
    pac auth create --url $(dataverseUrl) --username $(dataverseUser) --password $(dataversePassword) --name "MyServiceConnection"
    Pillaro deploy --solution $(solutionName) --pluginAssembly "$(Build.SourcesDirectory)/$(pluginAssembly)" --pluginConfig "$(Build.SourcesDirectory)/$(pluginConfig)" --connection "MyServiceConnection"
  displayName: 'Deploy Plugin with Pillaro'
  env:
    # Pillaro CLI'nın path'ini ayarlamak gerekebilir
    PATH: $(PATH);$(Agent.ToolsDirectory)\PowerAppsCLI

Bu pipeline, .NET SDK’yı kurar, NuGet paketlerini geri yükler, plugin projenizi derler, Power Platform CLI’yı kurar ve son olarak Pillaro CLI kullanarak plugininizi Dataverse’e dağıtır. $(DataverseUrl), $(DataverseUser), $(DataversePassword) gibi değişkenlerin Azure DevOps pipeline’ınızda tanımlanması gerektiğini unutmayın; özellikle parola gibi hassas bilgiler için güvenli değişkenler kullanmalısınız.

GitHub Actions Pipeline Örneği

GitHub Actions ile de benzer bir otomasyon kurabilirsiniz:

name: Deploy Dataverse Plugin with Pillaro

on:
  push:
    branches:
      - main

env:
  SOLUTION_NAME: MySolutionName
  PLUGIN_ASSEMBLY: MyPillaroPlugins.dll
  PLUGIN_CONFIG: plugin.json
  DATAVERSE_URL: ${{ secrets.DATAVERSE_URL }}
  DATAVERSE_USERNAME: ${{ secrets.DATAVERSE_USERNAME }}
  DATAVERSE_PASSWORD: ${{ secrets.DATAVERSE_PASSWORD }}

jobs:
  build-and-deploy:
    runs-on: windows-latest

    steps:
    - uses: actions/checkout@v3

    - name: Setup .NET
      uses: actions/setup-dotnet@v3
      with:
        dotnet-version: '6.x' # Projenizin hedeflediği .NET SDK sürümü

    - name: Restore dependencies
      run: dotnet restore

    - name: Build plugin project
      run: dotnet build --configuration Release --no-restore

    - name: Install Power Platform CLI
      run: dotnet tool install --global Microsoft.PowerApps.CLI

    - name: Deploy Plugin with Pillaro
      run: |
        pac auth create --url $env:DATAVERSE_URL --username $env:DATAVERSE_USERNAME --password $env:DATAVERSE_PASSWORD --name "MyServiceConnection"
        Pillaro deploy --solution $env:SOLUTION_NAME --pluginAssembly "${{ github.workspace }}/MyPillaroPlugins/bin/Release/net462/$env:PLUGIN_ASSEMBLY" --pluginConfig "${{ github.workspace }}/MyPillaroPlugins/$env:PLUGIN_CONFIG" --connection "MyServiceConnection"
      shell: pwsh
      env:
        # Pillaro CLI'nın path'ini ayarlamak gerekebilir
        PATH: ${{ env.PATH }};${{ github.action_path }}\.dotnet\tools

GitHub Actions örneği de benzer bir mantıkla çalışır. secrets.DATAVERSE_URL gibi değişkenler GitHub repository (depo) ayarlarındaki “Secrets” bölümünde tanımlanmalıdır. Bu sayede hassas bilgiler güvenli bir şekilde saklanır. Hem Azure DevOps hem de GitHub Actions örneklerinde, Pillaro CLI’nın sistem PATH’ine doğru bir şekilde eklendiğinden emin olmak önemlidir; aksi takdirde “Pillaro” komutu bulunamayabilir.

Dağıtım Profilleri ve Ortam Yönetimi

Gerçek dünya senaryolarında, geliştirme (dev), test (test), kabul (UAT) ve üretim (prod) gibi farklı Dataverse ortamlarına dağıtım yapmanız gerekebilir. Pillaro, bu farklı ortamlar için ayrı dağıtım profilleri tanımlamanıza olanak tanır. plugin.json dosyasında veya ayrı bir yapılandırma dosyasında ortam bazlı ayarlamalar yapabilir ve CI/CD pipeline’ınızda hangi profilin kullanılacağını belirleyebilirsiniz. Bu, her ortam için doğru çözüm adını, güvenlik ayarlarını ve diğer spesifik detayları uygulamanızı sağlar. Bu otomasyon, dağıtım süreçlerinizi standartlaştırır, insan hatasını en aza indirir ve Dataverse pluginlerinizin yaşam döngüsünü modern geliştirme pratikleriyle uyumlu hale getirir.

Sık Karşılaşılan Sorunlar ve Çözüm Yolları: Geçiş Sürecinde Nelere Dikkat Etmeli?

spkl’den Pillaro’ya geçiş süreci genellikle sorunsuz ilerlese de, bazı yaygın zorluklarla karşılaşmak mümkündür. Bu bölümde, bu sorunları önceden tahmin etmenize ve etkili çözümler bulmanıza yardımcı olacak ipuçları ve püf noktaları sunacağız.

1. Bağımlılık Çakışmaları (Dependency Conflicts)

Sorun: Mevcut spkl projeniz, belirli versiyonlarda NuGet paketleri veya harici kütüphaneler kullanıyor olabilir. Pillaro projenize geçiş yaparken, bu bağımlılıkların yeni proje yapısıyla veya Dataverse SDK’sının gereksinimleriyle çakıştığını görebilirsiniz. Özellikle farklı kütüphanelerin aynı DLL’in farklı versiyonlarını talep etmesi bu duruma yol açabilir.

Çözüm:

• NuGet Paketlerini Güncelleyin: Mümkünse, tüm NuGet paketlerini en son kararlı (stable) sürümlerine güncelleyin. Bu, bilinen çakışmaları çözebilir.
• Bağımlılık Ağacını İnceleyin: Visual Studio’da projenizin “Dependencies” (Bağımlılıklar) altında “Packages” (Paketler) bölümünü inceleyerek veya dotnet list package --include-transitive komutunu kullanarak bağımlılık ağacını görüntüleyin. Çakışan paketleri tespit edin.
• Binding Redirects Kullanın: Eğer farklı versiyonlarda bir DLL’e ihtiyaç duyan kütüphaneler varsa, .config dosyanızda binding redirects (bağlama yönlendirmeleri) kullanarak çalışma zamanında hangi versiyonun kullanılacağını belirleyebilirsiniz. Ancak, Dataverse pluginleri için bu genellikle önerilmez ve sorunlara yol açabilir. Mümkünse, tüm bağımlılıkları tek bir uyumlu versiyonda tutmaya çalışın.
• Plugin Isolation Mode (İzolasyon Modu): Dataverse pluginleri genellikle Sandbox (Korumalı Alan) izolasyon modunda çalışır. Bu mod, belirli kütüphanelerin kullanımını kısıtlayabilir. Eğer bir kütüphane Sandbox uyumlu değilse, bunu kullanmaktan kaçınmalısınız.

2. Hedef Framework Uyumsuzlukları

Sorun: spkl projeniz eski bir .NET Framework sürümünü hedefliyor olabilirken, Pillaro veya Dataverse’in kendisi belirli bir .NET Framework (yazılım çerçevesi) sürümünü (.NET Framework 4.6.2 veya 4.7.2 gibi) gerektirebilir. Bu uyumsuzluk derleme hatalarına veya çalışma zamanı istisnalarına neden olabilir.

Çözüm:

• Doğru Hedef Framework’ü Ayarlayın: Pillaro projenizin .csproj dosyasında <TargetFramework> değerini Dataverse’in desteklediği ve önerdiği sürüme ayarlayın (örn. net462 veya net472).
• Kod İncelemesi: Eğer eski bir Framework’ten geçiyorsanız, kullandığınız bazı .NET API’lerinin yeni Framework’te değişip değişmediğini kontrol edin. Nadiren de olsa, bazı API’ler kullanımdan kaldırılmış veya değiştirilmiş olabilir.

3. Ortam Farklılıkları ve Yapılandırma Sorunları

Sorun: Geliştirme ortamınızda çalışan bir plugin, test veya üretim ortamında farklı davranabilir veya dağıtılamayabilir. Bu, genellikle ortam değişkenleri, bağlantı dizeleri veya güvenli/güvensiz yapılandırma (secure/unsecure configuration) farklılıklarından kaynaklanır.

Çözüm:

• Ortam Bazlı Yapılandırma: Pillaro’nun dağıtım profili veya plugin.json dosyasında ortam bazlı ayarlamalar yapma yeteneğini kullanın. Her ortam için spesifik değerler tanımlayarak tutarlılık sağlayın.
• CI/CD Değişkenleri: Hassas bilgileri (veritabanı bağlantı dizeleri, API anahtarları vb.) CI/CD pipeline’ınızda güvenli değişkenler (secrets) olarak tanımlayın ve bunları Pillaro dağıtım komutlarınıza dinamik olarak geçirin.
• Hata Ayıklama (Debugging) ve İzleme (Monitoring): Dataverse’in tracing (izleme) hizmetini ve Pillaro’nun sunduğu hata ayıklama özelliklerini kullanarak farklı ortamlardaki davranış farklılıklarını tespit edin.

4. İmzalama (Signing) ve Çözüm (Solution) İlişkilendirme

Sorun: Plugin assembly’nizin güçlü bir adla imzalanması (strong-name signing) gerekir. spkl projeniz imzalıyken, Pillaro projenizde bu imzalama işlemini doğru yapmamak veya yanlış .snk (strong-name key) dosyasını kullanmak dağıtım hatalarına neden olabilir. Ayrıca, pluginin doğru Dataverse çözümüne eklenmemesi de yaygın bir sorundur.

Çözüm:

• Aynı .snk Dosyasını Kullanın: spkl projenizde kullandığınız .snk dosyasını Pillaro projenizde de kullanın. Eğer yeni bir proje oluşturduysanız, eski .snk dosyasını kopyalayın ve projenizin özelliklerinde “Signing” sekmesi altında referans gösterin.
• plugin.json ve Çözüm Adı: plugin.json dosyasında assembly.solution alanının, plugininizi eklemek istediğiniz Dataverse çözümünün benzersiz adıyla (unique name) tam olarak eşleştiğinden emin olun.
• Çözüm Yayınlama: Plugininizi dağıttıktan sonra, Dataverse’te ilgili çözümü yayınlamayı unutmayın. Aksi takdirde, plugin değişiklikleri aktif olmayabilir.

5. Performans Optimizasyonları

Sorun: Geçiş sonrası pluginlerinizin performansında düşüş yaşandığını veya beklenenden daha yavaş çalıştığını fark edebilirsiniz. Bu, genellikle hatalı bağımlılık yönetimi, gereksiz kod çalıştırma veya kaynak tüketiminden kaynaklanır.

Çözüm:

• Tracing Kullanımı: Plugin kodunuzda ITracingService kullanarak kritik noktalarda loglar (günlükler) tutun. Bu, performans darboğazlarını belirlemenize yardımcı olur.
• Erken Çıkış ve Koşullu Çalışma: Pluginlerinizin sadece gerekli durumlarda çalışmasını sağlayın. Örneğin, context.Depth kontrolü veya filteringAttributes kullanımı ile gereksiz tetiklenmeleri önleyin.
• Asenkron Operasyonlar: Eğer mümkünse ve iş mantığınız izin veriyorsa, uzun süren işlemleri asenkron (eşzamansız) pluginlere veya Azure Functions gibi harici servislere taşıyarak ana işlem hattını (main pipeline) rahatlatın.
• Verimli Sorgular: Dataverse’e yapılan sorguların (queries) optimize edildiğinden ve sadece gerekli verilerin çekildiğinden emin olun.

Bu sık karşılaşılan sorunları ve çözüm yollarını göz önünde bulundurarak, spkl’den Pillaro’ya geçiş sürecini daha bilinçli ve sorunsuz bir şekilde yönetebilirsiniz. Planlı bir yaklaşım ve detaylı testler, başarılı bir geçişin anahtarıdır.

Vaka Analizi: Büyük Bir Projenin spkl’den Pillaro’ya Geçiş Hikayesi

Bir yazılım projesinde teknoloji değişikliği yapmak, özellikle de kritik iş süreçlerini yöneten pluginler söz konusu olduğunda, her zaman belirli riskleri ve zorlukları beraberinde getirir. Ancak doğru planlama ve araçlarla bu süreç, projenin geleceği için büyük faydalar sağlayabilir. İşte “MegaCRM” adını verdiğimiz, finans sektöründe faaliyet gösteren büyük bir şirketin, Dataverse pluginlerini spkl’den Pillaro’ya taşıma hikayesi.

MegaCRM’in Durumu ve Geçiş İhtiyacı

MegaCRM, müşterileri için yüzlerce özel iş kuralını ve entegrasyonu yöneten, yaklaşık 50 farklı plugin içeren büyük bir Dataverse uygulamasına sahipti. Bu pluginlerin tamamı, uzun yıllardır spkl kullanılarak geliştiriliyor ve dağıtılıyordu. Geliştirme ekibi, spkl’nin sunduğu kolaylıklardan faydalanmış olsa da, zamanla bazı ciddi sorunlarla karşılaşmaya başladı:

• Dağıtım Süreçlerindeki Yavaşlık ve Hatalar: Her dağıtım, manuel adımlar içerdiği için zaman alıcıydı ve insan hatasına açıktı. Özellikle birden fazla ortama (Geliştirme, Test, UAT, Üretim) dağıtım yaparken tutarlılık sorunları yaşanıyordu.
• CI/CD Entegrasyon Zorlukları: Mevcut Azure DevOps pipeline’ları, spkl’nin sınırlı CLI desteği nedeniyle karmaşık betikler (scripts) ve geçici çözümlerle doluydu. Bu da pipeline’ların bakımını zorlaştırıyordu.
• Bağımlılık Yönetimi Karmaşası: Farklı pluginler farklı NuGet paket versiyonları kullanıyordu ve bu da zaman zaman derleme ve çalışma zamanı çakışmalarına yol açıyordu.
• Yeni Geliştiricilerin Adaptasyonu: spkl’nin kendine özgü yapılandırma dosyaları, yeni ekibe katılan geliştiricilerin adaptasyon sürecini uzatıyordu.

Bu sorunlar, MegaCRM’in geliştirme hızını düşürüyor ve yeni özelliklerin pazara sunulmasını geciktiriyordu. Bu nedenle, ekip, daha modern ve otomatize edilebilir bir çözüm arayışına girdi ve Pillaro’da karar kıldı.

Geçiş Süreci ve Karşılaşılan Zorluklar

MegaCRM’in geçiş süreci, aşağıdaki adımlarla planlandı ve uygulandı:

1. Pilot Proje Seçimi: Tüm pluginleri aynı anda taşımak yerine, ekip öncelikle daha az kritik ve bağımlılığı olan 5 pluginlik bir pilot proje seçti. Bu, riskleri minimize etmek ve Pillaro’yu tanımak için iyi bir fırsattı.
2. Pillaro Ortam Kurulumu: Geliştiricilerin tüm makinelerine .NET SDK, Visual Studio 2022 ve Power Platform CLI kuruldu. Pilot proje için yeni bir .NET sınıf kitaplığı projesi oluşturuldu ve Pillaro NuGet paketleri eklendi.
3. Kod Taşıma ve plugin.json Oluşturma: Pilot pluginlerin kodları yeni Pillaro projesine kopyalandı. spkl’nin .crmregister dosyalarındaki tüm kayıt bilgileri (plugin sınıfları, adımlar, filtreler vb.) tek tek analiz edilerek plugin.json dosyalarına aktarıldı. Bu aşamada, eski spkl projesindeki bazı custom (özel) helper (yardımcı) sınıfların, Dataverse SDK’sının yeni versiyonlarıyla uyumlu hale getirilmesi gerekti.
4. CI/CD Pipeline Entegrasyonu: Azure DevOps’ta, pilot proje için yeni bir YAML pipeline oluşturuldu. Bu pipeline, .NET build (derleme), Power Platform CLI kurulumu ve Pillaro deploy (dağıtım) adımlarını içeriyordu. İlk denemelerde, Pillaro CLI’nın PATH değişkeninde bulunamaması gibi küçük sorunlar yaşansa da, PATH ayarları düzeltilerek bu sorun aşıldı.
5. Test ve Doğrulama: Dağıtılan pilot pluginler, manuel ve otomatik testlerle kapsamlı bir şekilde test edildi. Özellikle farklı senaryolarda (oluşturma, güncelleme, silme) pluginlerin doğru çalıştığından ve performans kaybı yaşanmadığından emin olundu.

En büyük zorluklardan biri, eski spkl projesindeki bağımlılık çakışmalarını çözmek oldu. Bazı pluginler, artık güncel olmayan kütüphanelere bağımlıydı ve bu kütüphanelerin yeni .NET Framework ile uyumlu versiyonlarını bulmak veya alternatif çözümler geliştirmek zaman aldı. Ayrıca, plugin.json dosyasındaki her bir adımın doğru bir şekilde tanımlandığından emin olmak, özellikle çok sayıda filtrelenmiş özellik (filtering attributes) içeren karmaşık pluginler için dikkatli bir çalışma gerektirdi.

Elde Edilen Faydalar

Pilot projenin başarılı bir şekilde tamamlanmasının ardından, MegaCRM ekibi kalan tüm pluginleri de aşamalı olarak Pillaro’ya taşıdı. Bu geçişin sonucunda elde edilen başlıca faydalar şunlar oldu:

• Dağıtım Süreçlerinde %70 Hızlanma: Manuel dağıtım adımları ortadan kalktığı için, pluginlerin test ortamına dağıtımı 30 dakikadan 5 dakikaya düştü. Üretim ortamına dağıtım süresi de önemli ölçüde kısaldı.
• Hata Oranında Azalma: Otomatik dağıtım sayesinde insan hatası kaynaklı sorunlar neredeyse tamamen ortadan kalktı.
• Gelişmiş CI/CD Entegrasyonu: Azure DevOps pipeline’ları daha temiz, daha anlaşılır ve daha kolay bakımı yapılabilir hale geldi. Yeni geliştiricilerin pipeline’ları anlaması ve kullanması kolaylaştı.
• Daha İyi Bağımlılık Yönetimi: Pillaro’nun modern yaklaşımı sayesinde bağımlılık çakışmaları daha kolay tespit edildi ve çözüldü, bu da projenin genel stabilitesini artırdı.
• Geleceğe Yönelik Esneklik: Pillaro’ya geçiş, MegaCRM’i gelecekteki Dataverse ve .NET güncellemelerine karşı daha esnek hale getirdi.

MegaCRM’in hikayesi, spkl’den Pillaro’ya geçişin başlangıçta bazı zorluklar içerse de, uzun vadede geliştirme verimliliği, proje sürdürülebilirliği ve operasyonel güvenilirlik açısından önemli avantajlar sağlayabileceğini göstermektedir. Doğru planlama, adım adım ilerleme ve karşılaşılan sorunlara proaktif yaklaşımlar, böyle büyük bir geçişin anahtarıdır.

Sonuç: Geleceğe Yönelik Dataverse Plugin Geliştirme

Dataverse platformunda plugin geliştirme, iş süreçlerini otomatikleştirmek ve özelleştirmek için vazgeçilmez bir yöntemdir. Ancak bu alandaki araçlar ve en iyi uygulamalar sürekli olarak evrim geçirmektedir. spkl gibi geçmişte değerli hizmetler sunmuş araçlar, modern geliştirme pratiklerinin ve CI/CD beklentilerinin gerisinde kalabilir. Bu rehberde ele aldığımız gibi, spkl’den Pillaro’ya geçiş, sadece bir araç değişikliği değil, aynı zamanda Dataverse plugin geliştirme süreçlerinizi modernleştirmek, otomatikleştirmek ve geleceğe hazırlamak için stratejik bir yatırımdır. Pillaro’nun sunduğu komut satırı odaklı yaklaşım, esnek yapılandırma seçenekleri ve CI/CD entegrasyon yetenekleri, geliştirme ekiplerinin daha hızlı, daha güvenilir ve daha verimli çalışmasını sağlamaktadır. Geçiş süreci başlangıçta bazı zorlukları beraberinde getirse de, doğru planlama, adım adım uygulama ve karşılaşılan sorunlara yönelik proaktif çözümlerle bu süreç başarıyla tamamlanabilir. Unutmayın, teknolojiye ayak uydurmak ve sürekli iyileştirme, rekabetçi kalmanın ve yazılım kalitesini artırmanın anahtarıdır. Pillaro ile Dataverse pluginlerinizin yaşam döngüsünü güçlendirin ve geleceğe güvenle ilerleyin.

Sıkça Sorulan Sorular (SSS)

1. spkl’den Pillaro’ya geçiş ne kadar sürer?

Geçiş süresi, projenizin büyüklüğüne, plugin sayısına, bağımlılıkların karmaşıklığına ve ekibinizin Pillaro’ya aşinalığına göre değişir. Küçük projeler birkaç gün içinde tamamlanabilirken, yüzlerce plugin içeren büyük projeler birkaç hafta veya ay sürebilir. Pilot proje yaklaşımıyla aşamalı geçiş yapmak genellikle en iyi stratejidir.

2. Mevcut plugin kodumu tamamen yeniden yazmam gerekiyor mu?

Hayır, çoğu durumda mevcut plugin iş mantığı kodunuzu yeniden yazmanız gerekmez. Pillaro, Dataverse SDK’sını kullandığı için, IPlugin arayüzünü uygulayan sınıflarınız genellikle doğrudan taşınabilir. Ana değişiklikler proje yapısı, bağımlılık referansları ve dağıtım yapılandırmasında (plugin.json) olacaktır.

3. Pillaro ücretli mi?

Pillaro’nun temel sürümü genellikle açık kaynak (open-source) veya ücretsizdir, ancak belirli gelişmiş özellikler veya kurumsal destek için ücretli sürümleri veya hizmetleri olabilir. En güncel lisanslama bilgileri için Pillaro’nun resmi belgelerini veya GitHub deposunu kontrol etmeniz önerilir.

4. Geçiş sonrası eski spkl dosyalarını ne yapmalıyım?

Geçiş tamamlandıktan ve Pillaro tabanlı pluginleriniz üretim ortamında stabil bir şekilde çalıştığından emin olduktan sonra, eski spkl’ye özgü yapılandırma dosyalarını (örn. .crmregister, spkl.json) projenizden kaldırabilirsiniz. Ancak, olası bir geri dönüş senaryosu için bu dosyaları bir süre kaynak kontrol sisteminizde (örn. Git) tutmanız faydalı olabilir.

5. Pillaro sadece .NET Core/5/6/7/8 için mi geçerli?

Pillaro’nun kendisi modern .NET SDK’ları üzerinde çalışır ve komut satırı araçları .NET Core/5/6/7/8 ortamlarında kullanılır. Ancak, Pillaro ile dağıttığınız Dataverse pluginleri genellikle .NET Framework 4.6.2 veya 4.7.2 gibi Dataverse’in desteklediği eski .NET Framework sürümlerini hedefleyebilir. Pillaro, bu farklı hedef framework’lerle uyumlu bir şekilde çalışacak şekilde tasarlanmıştır.

#Dataverse #PluginGeliştirme #Pillaro #spkl #CICD #PowerPlatform