Microsoft Dynamics CRM 2011 ve Microsoft Dynamics CRM Online'da programlama modeli .NET'in temel türlerini kullanacak şekilde değiştirildi.

Bu tabloda beni en çok şaşırtan ise Customer, Lookup, Owner nesnelerinin artık EntityReference türünden sadece bir değer almaları. CRM'i yeni öğrenler için işler gerçekten kolaylaştırılmış. Artık kod yazarken CRM ile başlayan nesnelerimiz yok.

Aşağıdaki tablo bize Microsoft Dynamics CRM 4.0 ile CRM 2011, 2013 ve 2015 arasındaki tür dönüşümünü göstermektedir.

OptionSetValue

OptionSetValue’a değer atamak için ilk önce OptionSetValue türünden bir nesne oluşturmanız gerekmektedir.  Burada dikkat çekmek istediğim konu ise eğer state alanı ile çalışacaksanız (yani firma için aktif/pasif, teklif için açık/kazanıldı/kaybedildi gibi) early-bound sınıflarda bunlar için mutlaka bir enumaration oluşturulmakta. Ama late bound sınıflarda bu durumu programcı yönetmektedir.

Örnek olarak adres üzerindeki bir optionset alana değer atama aşağıdaki şekilde olmaktadır;

OptionSetValue osv = new OptionSetValue(1);

contact.Attributes["address1_freighttermscode"] = osv;

EntityReference

CRM sisteminde iki entity’yi birbirine bağlamak için lookup nesnesini kullanmak zorundayız. Lookup’lar üzerinde programatik işlem yapabilmek için EntityReference nesnesini kullanmaktayız. Bu nesneye Lookup alana reference vermek istemiz nesnenin türü ve Id’sini vermemiz gerekmektedir.

Aşağıdaki örnekte parentAccountId atama yapılacak nesnenin guid cinsinden Id’si olmalı;

EntityReference parentaccountid = new EntityReference("account", parentAccountId));

accountEntity.Attributes["parentaccountid"] = parentaccountid;

ioService.Update(accountEntity);

Null Değer Atama

CRM 4.0’dan farklı olarak .Net Type türleri kullanıldığı için null değer atama işlemi artık sadece alana değer vermekten ibaret oldu. İşte birkaç örnek;

EntityAdi.IndustryCode = null;

EntityAdi.AccountId = Guid.Empty;

EntityAdi.AccountNumber ="";

EntityAdi.Address1_Country = String.Empty;

Dynamics CRM 2011 ve sonrasinda CRM içerisinde programcılar kendilerine birden fazla programlama biçimi seçebilirler. Dynamics CRM’de WSDL kullanarak early-bound tipleri ve Dynamics Entity sınıflarını kullanarak da late-bound programlama yapabilirsiniz. Plug-in ve Workflow yazabilmek için late-bound tipleri kullanmamız gerekmektedir.

Dynamics CRM 4.0’da entity sınıflarının duruşu aşağıdaki şekildeki gibiydi;

Şimdi ise Dynamics CRM 2011’de bu yapı şu şekilde değişti;

DynamicEntity sınıfı artık Entity sınıfı isimli bir sınıfla yer değiştirdi. Bunun anlamı ise build time yani early bound tiplerle, runtime yani late bound tiplerin artık tek sınıftan türemesinin gerçekleşmiş olduğudur.

Dynamics CRM’de artık WSDL’e direkt ulaşamıyoruz. Daha önceki makalemde de anlattığım gibi 2 tane dll’i referans olarak eklemek ve servise bağlantı kurmak gerekmektedir.

Late-Bound olarak isimlendiren mimaride siz Entity sınıfından bir nesne türetmeli ve bu nesnenin attribute collection’da da değerlere yer vermelisiniz. Tabii burada değer alanlarının crm içerisindeki logical name’lerini kesinlikle bilmeniz gerekmektedir.

Aşağıdaki örnek bize late-bindig yapısının nasıl işlediğini gösterecektir;

Entity lead = new Entity("lead");

lead.Attributes["subject"] = "Deneme Firmasi";

lead.Attributes["firstname"] = "Baris";

lead.Attributes["lastname"] = "KANLICA";

lead.Attributes["companyname"] = "Mawens Business Solutions";

lead.Attributes["numberofemployees"] = 20;

Guid leadid = service.Create(lead);

Entity sınıfını kullanmaya başladığımız zaman late-binding’e giriş yapmış oluyoruz. Entity türünden oluşturduğumuz nesneye biz Lead türünden bilgileri içine dolduracağız diyoruz. Contact, Opportunity gibi CRM içerisindeki bütün nesneleri bu şekilde oluşturabiliriz.

Daha sonra ise alanların logical name’lerini vererek bunların değerleri veriyoruz. Burada .net tabanlı türleri kullanabilmekteyiz. CRM 4.0’da CrmBoolean, CrmNumber gibi türlere çeviriler yaparak nesnelerin içini doldururken artık buna ihtiyacımız bulunmamaktadır.

service isimli WCF tabanlı servisimizden türemiş nesnenin Create Metodunu kullanarak nesnemizi CRM içerisinde bir kayıt olarak oluşturuyoruz.

Early-Bound olarak isimlendirilen mimaride de ise CrmSvcUtil.exe aracını kullanarak bir OrganizationServiceContext türetmelisiniz. Daha sonra ise bu aracın türettiği nesneleri kullanabilir hale gelebilirsiniz. Tabii burada her bir nesnenin şema isimleriyle hareket ettiğimiz unutulmamalıdır.

Aşağıdaki örnek bize early-binding yapısının nasıl işlediğini gösterecektir;

CrmDataContext orgContext = new CrmDataContext(ServiseBaglan());

var contact = new Contact()

{

    FirstName = "Alan",

    LastName = "Smith"

};

orgContext.AddObject(contact);

orgContext.SaveChanges();

Burada ServiseBaglan() daha önceki makelemde belirttiğim gibi IOrganizationService Interface’inden türemiş bir sınıfı teşkil  etmektedir. Yani CRM’in WCF servisine hazır ve açık bir bağlantıdır.

Contact ise CRM içerisinde kişiler entity’sidir, Account, Lead, Invoice,Quote gibi daha bir çok entity bulunmaktadır.

Firstname ve Lastname ise kişinin adı ve soyadı için değerleri temsil etmektedir  ve bu bilgi OrganizationContext’ten gelmektedir. Bir sonraki yazında CrmDataContext isimli bu OrganizationContext’in CrmSvcUtil.exe aracılığıyla nasıl oluşturulduğu göstereceğim.

Daha sonra ise bu doldurduğumuz contact nesnesini OrganizationContext’e teslim ediyoruz ve işlem yapılması için SaveChanges() metodumuzu çağırıyoruz.

Farklılıkları ise şu şekilde sıralayabiliriz;

·         Early-Bound Entity Sınıflarının en büyük avantajı compile time da bize bütün hataları göstermesidir. Yani uygulamamızı yazarken ya da derlerken türler arası uyumsuzluk ya da yanlış değer atama gibi bütün yanlışlıklarımızı gözler önüne sermektedir. 

·         CrmSvcUtil bize tüm CRM mimarisini örneklerken bütün nesneleri ve onun ilişkilerini de getirmektedir. Böylece nesne dönüşümleri ve tür güvenliği de sağlanmış olmaktadır.

·         Visual Studio içerisinde inteli sense özelliğini kullanmamızı sağlar.

·         Dynamics CRM 4.0’dan beri WSDL ile çalışan kişiler bu yeni yapıda hiçbir farklılık hissetmeyeceklerdir.

CrmSvcUtil.exe ile Early-Bound Sınıflar Oluşturmak

Early-Bound tiplerle çalışabilmek için obje modelini bilmeye ihtiyacımız vardır. İşte CrmSvcUtil.exe bize bu kodu üretecek olan programdır.

Program early-bound .Net Framework sınıflarını ve entity modellerini Microsoft Dynamics CRM 2015 içerisinden almakta ve bize bir .cs dosyası halinde vermektedir. Bu noktadan sonra üretilen bu .cs dosyasını ya Visual Studio ile kodunuzun bir parçası olarak kullanabilir ya da bir dll haline getirip projenize referans olarak ekleyebilirsiniz. Bu sayede Visual Studio içerisinde intelli-sense özelliği ile kod geliştirebilirsiniz.

Eğer isterseniz uygulama her bir entity için ayrı bir partial class’da oluşturabilir.

CRM’in SDK’sında bin klasörü içerisinde bulabileceğiniz bu aracı command prompt ile çalıştırabilirsiniz.
crmsvcutil.exe            

/url: buraya Organization Service’in adresi gelecek

/out: çıktının hangi dosyaya olacağı bilgisi

/username : servise bağlanılacak kullanıcı adı

/şifre : servise bağlanılacak şifre

Eğer CRM’de zaten kullanıcı olan bir kişi ile oturum açtıysanız k.adı ve şifre belirtmenize gerek yok.

Bu şekilde gerekli cümleyi command promt’a yazdığınızda yukarıdaki ekranda olduğu gibi .cs dosyanızı alabilirsiniz.

Ek olarak aşağıdaki parametreleri de verebilirsiniz;

/serviceContextName: Eğer .cs dosyanızı LINQ Service Context vasıtasıyla LINQ sorgularını da desteklemesini istiyorsanız bu özelliği kullanmalısınız. Buraya türetilecek servis context’inin adını girmelisiniz örneğin “CrmDataContext” gibi.

Burada ek olarak şunu da belirtmeliyim ki bu komutu varsayalında ben hep kullanıyorum. Bu komutu kullandığımız zaman  2 şeyi unutmamız gerekmekte;

1.      Bir OrganizationContext oluşmakta artık onu kullanmamız gerekmekte, aşağıdaki örnekte olduğu gibi;

CrmDataContext orgContext = new CrmDataContext(ServiseBaglan());

2.      Crm Servis çağrısına şu özelliği eklememiz gerekmekte;

_serviceproxy.EnableProxyTypes();

Bu iki maddenin detayını LINQ ile veri  sorgulama makalemde daha detaylı anlatacağım.

/namespace : Varsayılanda .cs dosyası bir namespace olmadan türetilir bu özelliği kullanarak kodu bir namespace altında toplayabilirsiniz.

 /language : CrmSvcUtil.exe varsayılanda C# kodu üretil eğer VB kodu üretmek istiyorsanız bu özelliğe VB değerini vermeniz gerekmekte.

Bu tool aşağıdaki örnekte olduğu gibi bir kod üretmektedir;

    /// <summary>

    /// Bir müşteriyi veya potansiyel müşteriyi temsil eden işletme. Ticari işlemlerde faturalanan şirket.

    /// </summary>

    [System.Runtime.Serialization.DataContractAttribute()]

    [Microsoft.Xrm.Sdk.Client.EntityLogicalNameAttribute("account")]

    [System.CodeDom.Compiler.GeneratedCodeAttribute("CrmSvcUtil", "5.0.9688.1244")]

    public partial class Account : Microsoft.Xrm.Sdk.Entity, System.ComponentModel.INotifyPropertyChanging, System.ComponentModel.INotifyPropertyChanged

    {

        /// <summary>

        /// Default Constructor.

        /// </summary>

        public Account() :

            base(EntityLogicalName)

        {

        }

        public const string EntityLogicalName = "account";

        public const int EntityTypeCode = 1;

        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

        public event System.ComponentModel.PropertyChangingEventHandler PropertyChanging;

        private void OnPropertyChanged(string propertyName)

        {

            if ((this.PropertyChanged != null))

            {

                this.PropertyChanged(this, new System.ComponentModel.PropertyChangedEventArgs(propertyName));

            }

        }

Dynamics CRM'in iş dünyasının parlayan yıldızı olan ve her türlü iş platfomunun temeline yerleştirebilecek bir mimaride olduğunu her fırsatta anlatmaya çalışıyorum. Bu mimari üzerinde bizim kod geliştirmemizi ve sistem ile entegre olmamızı sağlayan web servisleri ve dll'ler vasıtasıyla yazma ve okuma işlemlerimizi gerçekleştirmekteyiz. Bugün sizlere daha önceden eski versiyonlar için de bahsetmiş olduğum oluşturma,  güncelleme ve silme metodlarının yapısını tekrar anlatacağım ama sonunda bunları Process isimli bir class'da birleştirip tek bir yerden yönetilmelerini sağlayacağız.

CRM servis nesnesi bize kayıtlar üzerinde işlem yapma özelliği sağlamaktadır. Servis içinden yapmak istediğimiz harekete uygun metodu çağırmamız gerekmektedir.  Tabii burada unutulmaması gereken konu servisi çağıran kullanıcının çağrılan metodda işlem yapmaya yetkili olması gerekmektedir.

Create Metodu CRM 2011 içerisinde bir entity içerisinde yeni bir nesne oluşturmamıza olanak tanır. Metod parametre olarak entity türünden bir nesne alır ve yeni oluşturulmuş nesnenin GUID türünden değerini geri döndürür.

Aşağıdaki örnek bu metodun late-bound sınıfla kullanımını göstermektedir.

// Entity nesnesinin yeni bir instance’ini olusturuyoruz
Entity account = new Entity("account");
// Gerekli attribute’lara atama yapiyoruz.
account["name"] = "Örnek Firma";
// Örnek Firma adında bir firma karti olusturuyoruz.
_accountId = ioService.Create(account); 

Aşağıdaki örnek bu metodun early-bound sınıfla kullanımını göstermektedir.

Contact contact = new Contact()
{
    FirstName="Deneme",
    LastName="Kisisi",
    Address1_City="İstanbul",
};
Guid contactGuid =_service.Create(contact);

Update Metodu CRM 2011 içerisinde bir entity içerisinde bir nesneyi güncellememizi sağlar. Metod parametre olarak entity türünden bir nesne alır. Güncellenecek nesnenin id’si mutlaka parametre olarak verilmelidir.

Guid gContact = new Guid("7bE545CCD3-9A3A-E011-BA8B-78E7D1623F9D");
 
Contact contact = new Contact()
{
     ContactId = gContact,
     FirstName="Test",
     LastName="Kisisi",
     Address1_City="Ankara",
};
_service.Update(contact);

Delete Metodu CRM 2011 içerisinde Id’sini verdiğiniz bir nesneyi sistemden silmeye yarar. Metod parametre olarak silinecek nesnenin Id’si yanında bu nesnenin türünü ister.

Guid gContact = "7bE545CCD3-9A3A-E011-BA8B-78E7D1623F9D";
_service.delete("contact", gContact); 

Bir programcı olarak çok standart olan bu işlemleri isterseniz bir class mantığı altında birleştirelim. Bu sayede daha yönetilebilir bir CRUD (Create, Read, Update, Delete) yapısı oluşturabiliriz. Ben bu sınıf için Process adını kullandım ve Process sınıfı içerisinde şu anda Oluşturma, Güncelleme ve Silme işlerimi yapmaktayım. İlerleyen makalelerde Okuma yapılarını incelerken onları da bu sınıfa dâhil ederiz.

Burada öncelikle açıklamalıyım ki bir önceki makalede yer alan Singleton tasarım deseniyle CRM servisini oluşturma yazımdaki class’tan faydalanarak servisi çağırma işlemini gerçekleştirdim. O yazıyı okumak isterseniz buraya tıklayınız

Ek olarak hata olaylarını kontrol etmek için Result isimli bir class kullandım bu class’ın içeriği şu şekilde;

public class Result
    {
        public string Message { get; set; }
        public bool isError { get; set; }
        public Object BusinessObject { get; set; }
 
        public Result(string _Message, bool _isError, Object _BusinessObject)
        {
            Message = _Message;
            isError = _isError;
            BusinessObject = _BusinessObject;
        }
 
        public Result(string _Message, bool _isError)
        {
            Message = _Message;
            isError = _isError;
            BusinessObject = null;
        }
    }

Görüldüğü üzere çok basit bir class bize sonucun başarılı mı başarısız mı olduğunu döndürecek o kadar.

Bunun haricinde bir de Base isimli bir class’ım var ki Process sınıfını aslında bu class’dan türetmekteyim. Şu anda bu class’ı sadece ErrorNumber ve ErrorDetail gibi hata oluştuğunda bilgi almamızı sağlayacak iki property ile kullanmaktayım ama ileride farklı propertyler de eklenecek.

public class Base
{
    public int ErrorCode { get; set; }
    public string ErrorDetail { get; set; }
} 

Bu iki class’ımı açıkladıktan sonra asıl yapıda kullanacağımız metodlara gelelim. İlk önce create metodunu inceleyelim. Hatırlayacağınız üzere CRM servisinde Create metdonun Update metodundan tek farkı id’ye ihtiyaç duymamasıydı. Çünkü bu metod id’yi üretip bize geri döndürecek. Ben de kurguyu buna göre planladım.

public Result Create(Entity EntityForCreate)
       {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                Guid EntityID = service.OrganizationService.Create(EntityForCreate);
 
                DetailedLog.CreateLog("Entity Created! Type: " + EntityForCreate.LogicalName + ", ID : " + EntityID, 
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false, EntityID);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true);
            }
        }

Aslında yapı çok basit servis nesnemi çağırıyorum, servis oluşurken hata var mı diye bakıyorum eğer hata varsa hatayı fırlatıyorum. (bu noktada şunu belirtmeliyim ki catch bölümünde yer alan DetailLog ve ExceptionHandler benim daha önceden yazmış olduğum hata yönetimi ile ilgili class’lar catch bölümünü siz de istediğiniz gibi düzenleyebilirsiniz) Eğer hata yok ise OrganizationService metodumu kullanarak nesnemi oluşturuyorum. Bu noktada da bir hata yoksa servis bana oluşturduğu nesnenin id’sini döndürüyor yok eğer hata varsa zaten kod catch bloğuna düşüyor. İşte bu kadar.

Şimdi gelin diğer metodlara bir göz atalım;

public Result Update(Entity EntityForUpdate, Guid EntityID)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                service.OrganizationService.Update(EntityForUpdate);
 
                DetailedLog.CreateLog("Entity Updated! Type: " + EntityForUpdate.LogicalName + ", ID : " + EntityID,
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true);
            }
        }

Update metodu neredeyse Create metodunun aynısı tek fark daha önce de ifade ettiğim gibi güncellenecek nesnenin id’sini alması. Bunu almalı ki neyi güncellediğini bilebilsin. Aslında burada şöyle bir mantıksal kargaşa var update metodu ek olarak id’yi almamakta zaten sizin ona update edilmesi için vereceğiniz entity’nin Id alanına vermelisiniz. Benim burada ek olarak almamdaki amaç onu loglamak için.

Bir de Delete metoduna göz atalım;

public Result Delete(string EntityName, Guid EntityID)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                service.OrganizationService.Delete(EntityName, EntityID);
 
                DetailedLog.CreateLog("Entity Created! Type: " + EntityName + ", ID : " + EntityID,
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true, null);
            }
        }

Delete metodu entity’nin adını ve id’sini almakta. Bu iki veriyi de servise vermekteyiz.

Class’ın tamamına bakacak olursak;

public class Process : Base
    {
        public Result Create(Entity EntityForCreate)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                Guid EntityID = service.OrganizationService.Create(EntityForCreate);
 
                DetailedLog.CreateLog("Entity Created! Type: " + EntityForCreate.LogicalName + ", ID : " + EntityID, 
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false, EntityID);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true);
            }
        }
 
        public Result Update(Entity EntityForUpdate, Guid EntityID)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
                
                service.OrganizationService.Update(EntityForUpdate);
 
                DetailedLog.CreateLog("Entity Updated! Type: " + EntityForUpdate.LogicalName + ", ID : " + EntityID,
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true);
            }
        }
 
        public Result Delete(string EntityName, Guid EntityID)
        {
            try
            {
                Service service = Service.GetService();
 
                if (service == null)
                    throw new Exception("Service is null");
                if (service != null && service.ErrorCode > 0)
                    throw new Exception(service.ErrorDetail);
 
                service.OrganizationService.Delete(EntityName, EntityID);
 
                DetailedLog.CreateLog("Entity Created! Type: " + EntityName + ", ID : " + EntityID,
                    System.Diagnostics.EventLogEntryType.Information);
 
                return new Result("", false);
            }
            catch (Exception ex)
            {
                ErrorCode = 100;
                ErrorDetail = ExceptionHandler.HandleException(ex);
                DetailedLog.CreateLog(System.Reflection.Assembly.GetExecutingAssembly().GetName().Name
                    + " : " + System.Reflection.MethodBase.GetCurrentMethod().ToString()
                    + " : " + ErrorDetail, System.Diagnostics.EventLogEntryType.Error);
 
                return new Result(ErrorDetail, true, null);
            }
        }
    }

Class’ımızı bu şekilde oluşturduktan sonra gelin onu bir konsol uygulaması yardımıyla çağıralım ve iş başında görelim.

static void Main(string[] args)
        {
            try
            {
                Entity lead = new Entity("lead");
                lead.Attributes["subject"] = "Fuardan Gelenler";
                lead.Attributes["firstname"] = "Barış";
                lead.Attributes["lastname"] = "KANLICA";
                lead.Attributes["companyname"] = "Omerd Business Solutions";
 
                Process process = new Process();
                Result result = process.Create(lead);
                if (result.isError)
                    throw new Exception(result.Message);
 
                Console.WriteLine("Lead created : " + result.BusinessObject.ToString());
                Console.ReadLine();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error : " + ex.Message);
                Console.ReadLine();
            }
        }

Gördüğünüz üzere Entity nesnemi çağıyor ve ona lead adını veriyorum. İçerisi istediğim bilgiler ile dolduruyor ve Process class’ımın içindeki Create metodu vasıtasıyla CRM içerisinde oluşmasını sağlıyorum. İşte hepsi bu kadar :) 

Bütün bu işlemler sonunda tek bir noktadan yönetilebilir bir CRUD mimarisi yavaş yavaş ortaya çıkmakta. Sıra Okuma işlemlerinin detaylarına inmekte. Onu da artık başka bir makalede inceleyeceğiz.