https://buraksenyurt.com/Burak Selim Şenyurt - Biztalk2017-01-18T06:53:53+00:00Matematik Mühendisi Bir Bilgisayar Programcısının NotlarıBurak Selim SenyurtBlogEngine.Net Syndication Generatorhttps://buraksenyurt.com/opml.axdBurak Selim SenyurtMatematik Mühendisi Bir Bilgisayar Programcısının Notlarıtr-TRBurak Selim Şenyurt0.0000000.000000https://buraksenyurt.com/post/Business-Rule-Engine-ile-Programlama(Biztalk-Server-2006)Business Rule Engine ile Programlama(Biztalk Server 2006)2009-07-15T13:30:00+00:00bsenyurt<p><img style="float: right;" src="/pics/2009%2f7%2fblg46_1.jpg" alt="" width="255" height="184" />Merhaba Arkadaşlar,</p>
<p>Yıllardır yazılım projelerinde görev almaktayım. Çeşitli projelerde pek çok zorlukla karşılaştım. Özellikle enterprise seviyedeki projelerde karşılaştığım en büyük zorluklar arasında, müşterinin uygulama içerisinde tanımladığı iş kurallarını istediği gibi ve görsel arayüzler yardımıyla değiştirmek istemesi yer almaktaydı. Burada geliştirme açısından bakıldığında zafer, söz konusu iş kurallarını uygulama kodu üzerinde herhangibir güncelleme yapılmasına gerek bırakmadan entegre edebilen sistemleri geliştirmektir aslında. <img title="Wink" src="/editors/tiny_mce3/plugins/emotions/img/smiley-wink.gif" alt="Wink" border="0" /> </p>
<p>Tabiki burada müşterinin kastettiği iş kurallarının nasıl tanımlandığından tutunda dile getiriliş şekli daha çok büyük öneme sahiptir. Nitekim öyle kurallar olabilir ki, yada bu kurallar öyle şekillerde dile getirilebilirki, yorumlayabilmek veya uygulatabilmek için yapay zeka stratejilerinin ele alınması zorunlu hale gelir. Ben tabiki konunun bu kısmına en azından şu an için girmemeyi tercih etmekteyim <img title="Smile" src="/editors/tiny_mce3/plugins/emotions/img/smiley-smile.gif" alt="Smile" border="0" /> Özetle büyük çaplı uygulamalarda karşılaştığımız en büyük sorunlardan birisinin, müşterinin kullandığı ürün ile ilişkili olaraktan tanımlamış olduğu <strong>iş kurallarının(Business Rules)</strong> koda müdahele etmeden yönetilebilmesi olarak düşünebiliriz. Bazı durumlarda, ürüne ait iş kuralları baştan bellidir ve değişmezdir. Bu tip senaryolara az rastlanmakla birlikte geliştirilmesi kolaydır. Nitekim kod içerisinde konulacak katı kurallar ile söz konusu geliştirme pekala yapılabilir.</p>
<p>Ancak, müşterinin uygulama üzerindeki iş kurallarını yeri geldiğinde değiştirebilmesi isteği(çok sık olmasa bile) geliştirme sürecinde bizleri bir çıkmaza düşürebilir. Öyleki, çalışmakta olan sistem içerisindeki kuralların esnetilebilmesi, değiştirilebilmesi ve hatta yenilerinin eklenebilmesi demek, kodu <strong>geliştirmeye</strong> devam etmek<strong>(Development), </strong>yeniden <strong>test(Testing) </strong>ve tekrardan <strong>dağıtım(Deployment)</strong> anlamına gelmemelidir. Her geliştirici takımı bu tip durumlara karşın, uygulamasının kodunu tekrardan güncellemeye gerek bırakmadan yeni kuralları kolayca öğrenebilmesi üzerine tasarlamak ister. Lakin bu sanıldığı kadar kolay bir süreç olmayabilir. Bir noktada <strong>XML</strong> tabanlı olaraktan söz konusu kuralların saklanması ve kod içerisine ele alınması düşünebilir.</p>
<p>Hatta daha önceden çalıştığım çok değerli bir şirketin iş akışları üzerine geliştirdiği bir ürün, akış tasarımları, yönetimi ve geliştirilmesi için <strong>XML</strong> tabanlı olan ve basit <strong>IDE</strong> ile çalışan sistemi, Web tabanlı uygulama olarak başarılı bir şekilde dağıtabilmiştir. Hatta <strong>Workflow tabanlı WCF servislerinde(Workflow Based WCF Services)</strong> bile gelinen nokta, içeriğin <strong>XAML</strong> olarak ifade edilebilmesi ve bu nedenle koda müdahele etmeden de değiştirilebilmesi değil midir? <img title="Wink" src="/editors/tiny_mce3/plugins/emotions/img/smiley-wink.gif" alt="Wink" border="0" /> Tüm bunlar bir yana dursun Biztalk ailesinde, kuralları kolayca geliştirebileceğimiz, <strong>veritabanı(database)</strong>, <strong>XML </strong>veya <strong>.NET </strong>tipleri gibi kaynaklardan kural verilerini alıp değerlendirebileceğimiz bir <strong>IDE</strong> zaten mevcuttur<strong>(Business Rule Composer). </strong>Hatta kendi uygulamalarımız için <strong>Biztalk'</strong> un hazır kural moturunuda<strong>(Business Rule Engine-BRE)</strong> kullanabiliriz. Sanıyorum ki artık sadede gelsem iyi olacak. Bu yazımızda giriş seviyesininde altında kalmak üzere,<strong> Biztalk Server 2006 </strong>ile birlikte gelen <strong>Business Rule Engine</strong> kütüphanesini nasıl kullanabileceğimizi ve iş kurallarını tanımlamak için <strong>Business Rule Composer</strong> aracını nasıl ele alabileceğimizi incelemeye çalışıyor olacağız.</p>
<p><strong>Biztalk Server </strong>ile birlikte gelen <strong>Business Rule Engine' </strong>in, kendi geliştirdiğimiz .Net uygulamalarında kullanılabilmesi için, <span style="text-decoration: underline;">sunucu lisansına</span> sahip ürünün yanlızca <strong>Business Rules Components</strong> özelliğinin kurulması yeterlidir. Tabiki burada önemli olan noktalardan birisi lisans konusudur. Lisanslı olan bir <strong>Biztalk Server</strong> ürünü üzerinden kurulum yapılmalıdır. Bu nedenle, kendi uygulamalarımızdan kasıt çoğunlukla sunucu tarafında çalışan servis uygulamalarıdır. Böylece, servis tabanlı <strong>.Net</strong> uygulamalarımız içerisinde istersek, <strong>Biztalk Server</strong> ile birlikte gelen kural motorunu kullanabiliriz. <strong>Business Rule Engine</strong> uzun uzun yıllar önce<strong>(1974)</strong> geliştirilmiş <a title="RETE" href="http://en.wikipedia.org/wiki/Rete_algorithm" target="_blank"><strong>RETE</strong> </a>algoritmasını kullanmaktadır. Tabi başlamadan önce önem arz eden bazı kavramlardan bahsetmekte yarar olduğu kanısındayım. Bunlar;</p>
<p><strong><img style="float: right;" src="/pics/2009%2f7%2fblg46_4.jpg" alt="" />Business Rule Composer :</strong> İlkeleri(Policy), içerisindeki kuralları(Rules) ve daha fazlasını tasarlayabileceğimiz bir arabirim olarak düşünülebilir. Kısaca iş kurallarını görsel olarak oluşturduğumuz programdır.</p>
<p><strong>Policy : </strong>İçinde, iş kurallarını barındıran nesnedir. Bu nesne istenildiğinde versiyonlandırılabilir. Bu sayede, aynı policy'nin farklı kurallar içeren yada aynı kuralları farklı şekillerde yorumlayan birden çok versiyonu tasarlanabilir ve kullanılabilir.</p>
<p><strong>Policy State : Policy' </strong>ler temel olarak <strong>Editable, Saved, Published </strong>ve <strong>Deployed </strong>durumlarında bulunabilir. Bir Policy ilk kez oluşturulduğunda zaten otomatik olarak Editable moda geçer. Policy' nin kaydedilmesi sonrası Saved moda atanır. Saved modda düzenlemeler ve testler yapılabilir. Eğer Policy, publish edilirse artık <span style="text-decoration: underline;">düzenlenemez</span>, <span style="text-decoration: underline;">değiştirilemez</span>. Yani read-only olarak düşünülebilir. Bu aşama, söz konusu Policy Deploy edilmeden önceki zamandır. Policy, Deploy edildiğindeyse artık versiyonlanmış ve kullanılabilir hale gelmiştir. Ne varki bu moddada üzerinde düzenleme <span style="text-decoration: underline;">yapılamamaktadır</span>. Dolayısıyla bu aşamadan sonra, Policy içerisinde yazılmış olan kurallarda değişim yapılamaz. Ancak yeni bir versiyonlama veya yeni bir Policy oluşturulması ile sorunlar ortadan kaldırılabilir.</p>
<p><strong>Rules : </strong>Çok doğal olarak konunun ana fikri bir takım iş kurallarının uygulanmasıdır. İş kuralları, Policy' ler içerisinde Rule nesneleri ile ifade edilir. Rule' lar kendi içlerinde, koşullandırılacak olan verileri(Fact), bunlarla ilişkili Predication' ları ve aksiyonları(Action) içermektedir.</p>
<p><strong>Facts : </strong>Aslında Rule içerisinde yer alan koşullar, karşılaştırmalar ve aksiyonlarda kullanılan veri birimlerini temsil etmektedir. Çok doğal olarak bu nesnenin uygulanan koşul sonrası yapılacak bir takım işlemler ile kuralın bütünü oluşturulmaktadır.</p>
<p><strong>Fact Source : </strong>Fact nesnelerinin içeriği, XML ve veritabanı gibi kaynaklardan gelebileceği gibi, sistemin <strong>Global Assembly Cache(GAC) </strong>alanında yüklü bir assembly içerisindeki .Net tipide olabilir. </p>
<p>Peki bir .Net tipini, <strong>BRE</strong> içerisinde kullanmak ve herhangibir uygulamada bu tipe ait nesne örneklerini Rules Engine içerisinde tanımlı ilkelere dahil etmek istiyorsak nasıl bir yol izlemeliyiz.</p>
<p><strong>1 -</strong> İlk olarak .Net tipini içeren bir <strong>Class Library </strong>geliştirilir. Bu library içerisinde BRE managed nesnelerini kullanabilmek için varsayılan olarak <strong>C:\Program Files\Microsoft BizTalk Server 2006 </strong>adresinde yer alan <strong>Microsoft.RuleEngine.dll</strong> assembly' ının projeye referans edilmesi gerekir. </p>
<p><img src="/pics/2009%2f7%2fblg46_5.gif" alt="" /></p>
<p>Oluşturduğumuz CompanyRules isimli sınıf kütüphanesinde yer alan kod içeriğimiz ise ilk etapta aşağıdaki gibidir.</p>
<pre class="brush:csharp;auto-links:false;toolbar:false" contenteditable="false">namespace CompanyRules
{
public class Product
{
public int ProductId { get; set; }
public int Count { get; set; }
public bool StockLevelOk { get; set; }
}
}</pre>
<p>Product isimli sınıf içerisinde yer alan Count özelliğinin değerine göre bir takım kurallar tanımlayacağımızı şimdiden söyleyebilirim. Örneğin Count' un belirli bir değerin altında olması halinde StockLevelOk özelliğine false değerinin atanması bir kural olarak düşünülebilir.</p>
<p><strong>2 - </strong>Yazılan .Net tipi için mutlaka bir test tipi geliştirilmelidir. Daha önceden de bahsedildiği üzere, <strong>Policy, Published</strong> veya <strong>Deployed</strong> modlarına geçildiğinde değiştirilemez. Dolayısıyla test edilebilir olması önemlidir. Nitekim test sonuçlarına bakılarak Fact' lerin tanımlanan Rule' lar için doğru çalışıp çalışmadığı değerlendirilmelidir. Bu amaçla, yine <strong>Microsoft.RuleEngine </strong>isim alanı altında yer alan <strong>IFactCreator </strong>arayüzünden(Interface) türeyen bir tip kullanılır. CompanyRules sınıf kütüphanesinde yer alan Product tipi için, IFactCreator arayüzünde türeyen aşağıdaki tip tasarlanmıştır.</p>
<pre class="brush:csharp;auto-links:false;toolbar:false" contenteditable="false">using System;
using Microsoft.RuleEngine;
namespace CompanyRules
{
public class ProductFactCreator
:IFactCreator
{
#region IFactCreator Members
public object[] CreateFacts(RuleSetInfo ruleSetInfo)
{
Product prod = new Product
{
Count=100,
ProductId=10001
};
return new object[] { prod };
}
public System.Type[] GetFactTypes(RuleSetInfo ruleSetInfo)
{
return null;
}
#endregion
}
}</pre>
<p>Burada yapılan aslında <strong>Product</strong> biriminin belirtilen bir kural için test edilebilir olmasını sağlamaktır. Bu nedenle, <strong>CreateFacts</strong> metodu içerisinde örnek bir <strong>Product</strong> nesne örneği oluşturulmuş ve geriye döndürülmüştür. Aslında burada işleyiş şekli tam anlamıyla ders niteliğindedir. <strong>IFactCreator</strong> arayüzü, <strong>BizTalk</strong> tarafında tanımlanmıştır. Bu arayüz, <strong>Business Rule Composer </strong>programındaki testler için önemlidir. Nitekim dışarıdan bir tipin, var olan Biztalk uygulamasına entegre edilmesini sağlamaktadır. Yani bildiğimiz Plug-In mantığı söz konusudur.</p>
<p><strong>3 -</strong> Geliştirilen tiplerin yer aldığı .Net assembly' ının, Business Rule Composer içerisinde kullanılabilmesi için <strong>Strong Name Key </strong>ile imzalanıp <strong>Global Assembly Cache </strong>alanına atılmış olması gerekmektedir. Aksi takdirde <strong>Business Rule Composer</strong> içerisinde kullanılamaz. Tahmin edileceği üzere uygulamamızı Strong Name ile imzalamak için Visual Studio ortamında proje özelliklerinden gerekli ayarlamaları yapabiliriz.</p>
<p><img src="/pics/2009%2f7%2fblg46_7.gif" alt="" /></p>
<p>Bu işlemin ardındada derlenen assembly, komut satırından <strong>GacUtil </strong>ile veya basit bir şekilde <strong>Windows\Assembly </strong>klasörü altına sürükle bırak yöntemi ile install edilir.</p>
<p><img src="/pics/2009%2f7%2fblg46_8.gif" alt="" /></p>
<p><strong>4 -</strong> <strong>Business Rule Composer </strong>aracından yararlanılarak <strong>Policy</strong> ve içerisinde yer alan kurallar oluşturulur. Aslında bu adımı çok fazla dert etmemiz gerek yok. Bu konuyu görsel derstede ele alacağımızdan aşağıdak şekilde görülen basit kuralları oluşturmaya çalışsak yeterli olacaktır. Tabiki unutulmaması gereken önemli noktalardan biriside, Fact Explorer kısmında, aşağıdaki ekran görüntüsünde olduğu gibi CompanyRules assembly' ının seçilmesi gerekliliğidir ki bu sayede Rule içerisindeki Fact' ler için kullanılacak özellikler ele alınabilecektir.</p>
<p><img src="/pics/2009%2f7%2fblg46_10.gif" alt="" /></p>
<p>Ve örnek kurallarımız;</p>
<p>Policy2 içerisnde tanımlanan ilk kuralımız Rule1 ismindedir. Bu kurala göre Product nesne örneğinin Count özelliğinin değerinin 5000' in altında olması halinde StockLevelOk özelliğine False değeri atanmaktadır.</p>
<p><img src="/pics/2009%2f7%2fblg46_13.gif" alt="" /></p>
<p>İkinci kuralımız(Rule 2)' da ise, birinci kuralın zıttı olan durum söz konusudur. Bu kez Count değerinin 5000' den büyük veya eşit olması halinde StockLevelOk özelliğine true değeri atanmaktadır.</p>
<p><img src="/pics/2009%2f7%2fblg46_14.gif" alt="" /></p>
<p><strong>5 -</strong> Kurallar test edilir ve herşey beklendiği gibiyse, <strong>dağıtım(Deployement)</strong> aşamasına geçilir. <strong>Test</strong> için yapılması gereken ilk adım, tanımlanan <strong>Rule'</strong> lar üzerinde testi gerçekleştirecek olan <strong>.Net</strong> tipinin seçilmesidir. Buda <strong>Test</strong> düğmesine basıldığında bize sorulmaktadır ki yine <strong>GAC</strong> içerisinde duran <strong>assembly</strong> kütüphanemiz zaten söz konusu <strong>IFactCreator</strong> türevini içermektedir.</p>
<p><img src="/pics/2009%2f7%2fblg46_17.gif" alt="" /></p>
<p><strong>6 -</strong> Test edilen ve test sonuçları beklediğimiz gibi çıkan <strong>Policy</strong> sırasıyla <strong>Publish</strong> ve <strong>Deploy</strong> işlemlerinden geçirilerek kullanıma hazır hale getirilir.</p>
<p><img src="/pics/2009%2f7%2fblg46_15.gif" alt="" /></p>
<p><strong>7 -</strong> Deploy edilen Policy' lerin ve içerdiği kuralların herhangibir .Net uygulamasında kullanılabilmesi için, söz konusu uyulamaya yine <strong>Microsoft.RuleEngine</strong><strong>.dll assembly' </strong>ının referans edilmesi gerekir. Bu adıma gelinmeden önce, 5nci adımda yaptığımız testlerin sonuçlarının doğruluğundan emin olunmalıdır.</p>
<p><img src="/pics/2009%2f7%2fblg46_18.gif" alt="" /></p>
<p><strong>8 -</strong> Kural motorunu kullanacak olan .Net uygulamasında, <strong>Microsoft.RuleEngine</strong> isim alanı altında yer alan <strong>Policy</strong> tipinden yararlanılarak, <strong>Fact</strong> nesnesinin BRE içerisine atılması sağlanır. İşte Company isimli Console uygulamamızda yer alan kodlarımız.</p>
<pre class="brush:csharp;auto-links:false;toolbar:false" contenteditable="false">using System;
using CompanyRules;
using Microsoft.RuleEngine;
namespace Company
{
class Program
{
static void Main(string[] args)
{
Product prd = new Product { Count = 4999, ProductId = 1001 };
Policy policy = new Policy("Policy2", 1, 0);
policy.Execute(prd);
Console.WriteLine("{0} için , Stock Level Ok ? {1}",prd.ProductId,prd.StockLevelOk);
prd.Count += 10;
policy.Execute(prd);
Console.WriteLine("{0} için , Stock Level Ok ? {1}", prd.ProductId, prd.StockLevelOk);
}
}
}</pre>
<p>Görüldüğü üzere ilk olarak Product nesnesi örneklenmektedir. Sonrasında bir <strong>Policy</strong> nesnesi örneklenir. Burada önemli olan bir noktada <strong>Major </strong>ve <strong>Minor </strong>versiyon numalarınında belirtilmesidir. Bu bize şöyle bir avantaj sağlayabilir; bir <strong>Policy'</strong> nin birden fazla versiyonu olması halinde, program içerisinde hangisinin kullanılacağını seçmemize olanak tanır. Hatta söz konusu değerleri(<strong>Policy</strong> adı, <strong>Major</strong> ve <strong>Minor</strong> numaraları) uygulamaya ait <strong>konfigurasyon</strong> dosyasından çekilebilir. Böylece kodun içerisinde kesinlikle girilmeden, <strong>Policy </strong>versiyonlaması ve hangi ilkelerin kullanılacağına karar verilmeside sağlanmış olur. <em>(Konfigurasyon kullanımını bu konunun görsel anlatımında gösteriyor olacağım) </em>Uygulamamızı çalıştırdığımızda aşağıdaki sonuçlar ile karşılaşırız.</p>
<p><img src="/pics/2009%2f7%2fblg46_19.gif" alt="" /></p>
<p>Böylece geldik zevkli bir konunun daha sonuna. Umarım sizler içinde yararlı olmuştur. Geliştirdiğimiz örnek Biztalk Server 2006' ya ait Business Rule Engine' i kullanmaktadır. Ancak bildiğiniz üzere bir süre öncede Biztalk Server 2009 ürünü yayınlanmıştır. Dolayısıyla bu konu ile ilişkili araştırmalarımı 2009 sürümü üzerinden devam ettiriyor olacağım. Tekrardan görüşünceye dek hepinize mutlu günler dilerim.</p>
<p><a href="https://buraksenyurt.com/pics/2009%2f7%2fHelloBRE.rar">HelloBRE.rar (37,09 kb)</a></p>
<p><a title="BRE" href="http://en.wikipedia.org/wiki/Business_rules_engine" target="_blank">Meraklısı için Business Rule Engine kavramı ile ilişkili detaylı bilgi</a></p>2009-07-15T13:30:00+00:00biztalkbusiness rule enginec#bsenyurtYıllardır yazılım projelerinde görev almaktayım. Çeşitli projelerde pek çok zorlukla karşılaştım. Özellikle enterprise seviyedeki projelerde karşılaştığım en büyük zorluklar arasında, müşterinin uygulama içerisinde tanımladığı iş kurallarını istediği gibi ve görsel arayüzler yardımıyla değiştirmek istemesi yer almaktaydı...https://buraksenyurt.com/pingback.axdhttps://buraksenyurt.com/post.aspx?id=06189af6-a5fb-4a48-9204-ebeca03389145https://buraksenyurt.com/trackback.axd?id=06189af6-a5fb-4a48-9204-ebeca0338914https://buraksenyurt.com/post/Business-Rule-Engine-ile-Programlama(Biztalk-Server-2006)#commenthttps://buraksenyurt.com/syndication.axd?post=06189af6-a5fb-4a48-9204-ebeca0338914