.NET Core 3.0 ile Gelen Yenilikler ve VS2019 Preview / What’s Coming With .NET Core 3.0

Merhaba Yazılım Meraklıları,

Bu yazıda .NET Core 3.0 ile gelen yenilikleri inceleyeceğiz ve genel bir inceleme yapacağız. Aynı zamanda C# 8.0 (preview) ile gelen yeniliklere ve kullanımlara da bakıyor olacağız.

Hemen hemen tüm örneklemeler MS Windows OS üzerinden anlatılmıştır.

Gerekli kurulumlar ile Başlayalım

– Öncelikle bu özelikleri kullanabilmek için Visual Studio 2019 ‘a (yazı tarihiyle preview version) ihtiyacınız olacak.

Visual studio 2019 download

VisualStudio2019 Preview Installing

Şimdilik sadece aşağıdaki workload’ları yükleyeceğim.

 

– Ardından linkten .Net Core 3.0 ‘ı indirip kurun.
.Net Core 3.0 SDK Installing

– Son olarak hazır kurulumlara ısınmışken şuradan .Net Framework 4.8 (early access) de indirip kurun.

Artık latest version IDE, Framework ve SDK’lara sahibiz. Bu yazının tarihi itibariyle tabi ki = )
O halde bizim için yeni oynayacak hangi oyuncakları koymuşlar incelemeye geçebiliriz.

WPF (Windows Presentation Foundation), Windows Forms -> Windows Desktop

.Net core 3.0 ile en çok göze çarpan yenilik WinDesktop tarafında gözüküyor.
Artık WPF ve WinForms applicationlarını .Net Core bu sürümü ile destekliyor. Bu da haliyle en major feature yapıyor bunu.

VS2019 üzerinden birer WPF ve WinForm application oluşturalım.

  • WPF Application

Tüm adımları aşağıdaki ekran görüntülerinde görebilirsiniz.
VS2019CreateProjectScreen

Yukarıdaki adımlarda sırasıyla Project Type’ımızı seçtik > ProjectName ve Location folder gibi bilgileri set edip > Basit bir text change ile Execute ettik.

Bu işlemleri komut satırı ile de yapabilirsiniz. Onun da kodu aşağıdadır.

dotnet new wpf -o wpfDotNetCore3Dot0Exm
  • Windows Form

Tüm adımları aşağıdaki ekran görüntülerinde görebilirsiniz.

Yukarıdaki adımlarda sırasıyla Project Type’ımızı seçtik > ProjectName ve Location folder gibi bilgileri set edip > Basit bir text change ile Execute ettik.

Bu işlemleri aşağıdaki komut satırı ile de yapabilirsiniz.

dotnet new winforms -o wfDotNetCore3Dot0Exm

ASP.Net Core Web Applications

  • Razor Componentler – UI.
  • gRPC Apps
  • Web Applicationlarımız için ekstra bir efor sarfetmemize gerek kalmadan Local’de HTTPS desteği veriyor.

ve daha saymadığım bir çok bir çok ince detay var. Derinlemesine girip bu makalede saatlerinizi almamak için başlıklar üzerinden hoşuma gidenlere değiniyorum.

Örneğin Razor Componentler’e ufaktan girebiliriz.
.Net Developer olarak UI’da çok efektif işler çıkarabileceğiniz bir template olmuş. DI tarafı dikkatimi çekti, UI’a Classlarınızı inject edebiliyorsunuz. Basit bir uygulama ile inceleyelim.

Create Razor Component Application

Yukarıdaki ekran görüntüsündeki sağ tarafta olan “Advanced” bölümünün altında “Configure for HTTPS” i seçip daha sonra CREATE yapın.

Razor Components Application’ımız oluştu hemen F5 ile çalıştırırsak aşağıdaki gibi HTTPS ile geldiğini göreceğiz.

Not: İlk defa çalıştırınlar, HTTPS için bir uyarı penceresi alacaklar. Onu onaylayıp devam edin.

Biraz code tarafını inceleyelim.

public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc()
                .AddNewtonsoftJson();

            services.AddRazorComponents();

            services.AddSingleton<WeatherForecastService>();
        }

Eğer bu projede “WeatherForecastService” ini incelersek. Startup.cs içerisinde yukarıda gibi “WeatherForecastService” i Singleton olarak set edilmiş ve aşağıdaki kod parçacağına baktığınızda ise “UI” olan FetchData.razor içerisinde nasıl inject edilip, nasıl kullanıldığını görüyorsunuz.

@page "/fetchdata"
@using WARazorComponents.Services
@inject WeatherForecastService ForecastService

<h1>Weather forecast</h1>

<p>This component demonstrates fetching data from a service.</p>

@if (forecasts == null)
{
    <p><em>Loading...</em></p>
}
else
{
    <table class="table">
        <thead>
            <tr>
                <th>Date</th>
                <th>Temp. (C)</th>
                <th>Temp. (F)</th>
                <th>Summary</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var forecast in forecasts)
            {
                <tr>
                    <td>@forecast.Date.ToShortDateString()</td>
                    <td>@forecast.TemperatureC</td>
                    <td>@forecast.TemperatureF</td>
                    <td>@forecast.Summary</td>
                </tr>
            }
        </tbody>
    </table>
}

@functions {
    WeatherForecast[] forecasts;

    protected override async Task OnInitAsync()
    {
        forecasts = await ForecastService.GetForecastAsync(DateTime.Now);
    }
}

Ayrıca örnek olarak oluşturduğumuz razor component web application’ın içerisindeki diğer page lerdeki kod yazımlarına da bakarsanız sanırım buna JavaScript duyarlıklı C# diyebiliriz. =)

.Net Core 3.0 ile Yürütülebilir Uygulamalar (Executable Applications)

Herhangi bir Tool kullanmadan direkt Command Prompt üzerinden uygulama oluşturup execute edebileceğiniz code lineları aşağıda paylaşıyorum. Hem Window için hem de Linux için.

Windows için / For Windows :

/*Komutları sırasıyla teker teker çalıştırın!*/
dotnet new console -o consoleDotNetCore3Dot0
cd consoleDotNetCore3Dot0
dotnet build
cd binDebugnetcoreapp3.0
dir /b     /*Bunu kullanmadan direkt aşağıdaki satırı da çalıştırabilirsiniz*/
consoleDotNetCore3Dot0.exe

Linux için / For Linux :

/*Komutları sırasıyla çalıştırın*/
root@123456789:/consoleDotNetCore3Dot0# dotnet build
root@123456789:/consoleDotNetCore3Dot0# cd bin/Debug/netcoreapp3.0/
root@123456789:/consoleDotNetCore3Dot0/bin/Debug/netcoreapp3.0# ls  /*Bunu çalıştırmaya bilirsiniz, görmeniz içindir.*/
root@123456789:/consoleDotNetCore3Dot0/bin/Debug/netcoreapp3.0# dotnet consoleDotNetCore3Dot0.dll

Ranges & Index

Belki de en çok hoşuma giden yeniliklerden birisi bu oldu.
Basitçe tanımlayacak olur ise bir dizi için tanımlayacağımız startIndex ve endIndex değişkenleriyle, ilgili dizi içerisinde bu indexlerimizin aralığında kalan itemları alabilmemizi sağlıyor.
endIndex’i için “^” prefixi kullanılıyor ve index aralığını belirtmek için ise “..” kullanılmaktadır.
Direkt aşağıdaki kod parçağını çalıştırıp inceleyebilirsiniz.

static void Main(string[] args)
{
    Index startIndex = 1;
    Index endIndex = ^3;
    string[] charSet = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" };
    var indexRange = charSet[startIndex..endIndex]; //"b".."w"
    var indexRangeResult = String.Join(",", indexRange.Select(s => s));
    Console.WriteLine(indexRangeResult);
    Console.ReadKey();
}

Async Streams

IEnumerable<> interface inin async kullanımı için “IAsyncEnumerable” bulunmaktadır. Yani Task<> kullanmadan async bir method oluşturabiliyoruz.  Bu oluşturduğumuz methodun listesini de “foreach” döngüsünün başına “await” getirerek kullanabiliyoruz. Aşağıda api aracılığıyla döviz verilerini getiren örnek kod parçaları üzerine uyguladım.

public async IAsyncEnumerable<string> DovizDataAsync()
{
    await foreach (var item in GetAsyncDovizData())
        yield return string.Join(", ", item.name, item.code, item.sellPrice);
}

public async IAsyncEnumerable<DovizDto> GetAsyncDovizData()
{
    var response = new WebClient().DownloadString("https://api.canlidoviz.com/web/items?marketId=1&type=0");
    var deObject = JsonConvert.DeserializeObject<List<DovizDto>>(response);
    foreach (var item in deObject)
        yield return item;
}


//Data Transfer Object
 public class DovizDto
{
    public string name { get; set; }
    public string code { get; set; }
    public float todayLowestBuyPrice { get; set; }
    public float todayHighestBuyPrice { get; set; }
    public float todayLowestSellPrice { get; set; }
    public float todayHighestSellPrice { get; set; }
    public float yesterdayClosingBuyPrice { get; set; }
    public float yesterdayClosingSellPrice { get; set; }
    public float buyPrice { get; set; }
    public float sellPrice { get; set; }
    public float dailyChange { get; set; }
    public float dailyChangePercentage { get; set; }
    public string lastUpdateDate { get; set; }
}

 

Son olarak herşeyi toparlarsak ve değinmediğimiz diğer özellikleri de ekleyecek olursak.

  • Visual Studio’ya farklı bir hava kazandırılmış. Beğenilir veya beğenilmez göreceğiz.
  • WinDesktop tarafına WPF ve WinForm Applicationlar getirildi. Aynı zamanda EF de destekleniyor.
  • Razor Componentler ile Server-Side & Client-Side mantığı artık bir .Net developer için aynı diyebiliriz.
  • IOT desteği
  • Linux üzerinde TLS 1.3 ve OpenSSL 1.1.1 destekleniyor
  • WinClientOS: Win7 ve üzeri için destekleniyor.
  • WinServerOS: 2012 R2 SP1 ve üzeri için destekleniyor.
  • .csproj içerisine <NullableContextOptions>enable</NullableContextOptions>” tagini ekleyerek null check kullanımı rahatlığından faydalanabilirsiniz.
  • Cryptography (Buna farklı bir yazıda değinebiliriz.)
  • JsonReader (Buna da farklı bir yazıda benchmark yaparak bakacağız. Linkini buraya koyarım.)
  • C# 8 özellikleri .Net Framework 4.8 ile kullanılabiliyor.

Bir başka yenilikte görüşmek üzere.

.Net Core ile Protobuf Kullanımı ve JSON Performans Karşılaştırması

Merhabalar,

Öncelikle eğer kemerlerinizi bağlamadıysanız hemen bağlayın, çünkü birazdan Protobuf-net ile uçuşa geçeceğiz. Nasıl mı?

Şöyle ki kodlara girmeden önce kısaca Protocol Buffers’dan bahsedelim.

Google tarafından geliştirilmiştir ve amacı ise yapılandırdığınız dataların serileştirilmesini(serialization) sağlamaktır.

Örnek olarak herkes tarafından bilinen XML Format’ını düşünebilirsiniz. Bu örnekteki handikap şudur. XML DOM’ları içerisinde gezinmek kompleksdir ve Serialize/Deserialize işlemlerinin de maliyeti biraz yüksektir. Buna alternatif olarak yine tüm geliştiriciler tarafından bilinen ve sektörde kabul görmüş JSON Format karşımıza çıkıyor. Bunların detaylarına girmeyeceğim. Çünkü asıl konumuzdan uzaklaşmak istemiyorum. Protobuf bize bu serileştirme işlemlerini birçok formata göre çok daha hızlı bir şekilde gerçekleştiriyor.

Şimdi, Protobuf’ın nasıl kullanıldığına ve JSON’a göre nasıl bir performans gösterdiğine bakacağımız uygulamamıza geçelim.

  • İlk olarak bir .Net Core Console Application oluşturun.
  • Ardından Package Manager Console’u açıp şu komutları çalıştırın.
 Install-Package protobuf-net
Install-Package Newtonsoft.json



 

Protobuf Contract Tanımlamaları

Contract based çalışan bir yapısı var ve ilgili model classlarımıza attribute olarak tek seferlik tanımlayıp kullanıyoruz.  Örnek için kendime şu contractları oluşturdum. Siz isterseniz farklı bir senaryo üretebilirsiniz.

using ProtoBuf;
using System;

namespace ProtobufnetVSNewtonsoftjson.Contracts
{
    [ProtoContract]
    [ProtoInclude(3, typeof(Order))]
    public class BaseContract
    {
        [ProtoMember(1)]
        public int CreatedBy { get; set; }
        [ProtoMember(2)]
        public DateTime CreatedDate { get; set; }
    }
}
namespace ProtobufnetVSNewtonsoftjson.Contracts
{
    public enum AddressType
    {
        Billing = 1,
        Delivery = 2
    }
}
using ProtoBuf;

namespace ProtobufnetVSNewtonsoftjson.Contracts
{
    [ProtoContract]
    public class Address
    {
        [ProtoMember(1)]
        public string City { get; set; }
        [ProtoMember(2)]
        public string Line1 { get; set; }
        [ProtoMember(3)]
        public string Line2 { get; set; }
        [ProtoMember(4)]
        public AddressType Type { get; set; }
    }
}
using ProtoBuf;
using System.Collections.Generic;

namespace ProtobufnetVSNewtonsoftjson.Contracts
{
    [ProtoContract]
    public class Customer
    {
        [ProtoMember(1)]
        public string FullName { get; set; }
        [ProtoMember(2)]
        public string Phone { get; set; }
        [ProtoMember(3)]
        public List<Address> Addresses { get; set; }
    }
}
using ProtoBuf;

namespace ProtobufnetVSNewtonsoftjson.Contracts
{
    [ProtoContract]
    public class Product
    {
        [ProtoMember(1)]
        public string ProductSKU { get; set; }
        [ProtoMember(2)]
        public string ProductName { get; set; }
        [ProtoMember(3)]
        public int Quantity { get; set; }
        [ProtoMember(4)]
        public decimal Price { get; set; }
    }
}
using ProtoBuf;
using System;
using System.Collections.Generic;

namespace ProtobufnetVSNewtonsoftjson.Contracts
{
    [ProtoContract]
    public class Order : BaseContract
    {
        [ProtoMember(1)]
        public string OrderNumber { get; set; }
        [ProtoMember(2)]
        public DateTime OrderDate { get; set; }
        [ProtoMember(3)]
        public decimal TotalPrice { get; set; }
        [ProtoMember(4)]
        public List<Product> Products { get; set; }
        [ProtoMember(5)]
        public Customer CustomerInfo { get; set; }
    }
}

Yukarıdaki Contract tanımlamalarında inheritance ve diğer caseler için kullanımlarını görebilirsiniz. Simple bir yapıya sahip. Her member Unique’dir.
Örnekte “ProtoContract, ProtoInclude ve ProtoMember(N)” attribute’leri kullanılmıştır.

ProtoInclude: Inheritance kullanılacaksa bu etiket eklenir.

ProtoContract: Object modelinin en tepesine eklenen etiketdir.

ProtoMember(N): Object modelindeki memberlara uygulanır ve N(=1,=2=3, vb.) değeri unique olmalıdır. Aksi halde runtimeda hata fırlatır.

  • Oluşturduğumuz contractlar ile program.cs->main method içerisine inMemory data ekliyoruz.
        #region inMemoryData
            var data = new Order
            {
                CreatedBy = 1,
                CreatedDate = DateTime.Now,
                OrderDate = DateTime.Now,
                OrderNumber = "MSTF123456789",
                TotalPrice = 150,
                Products = new List<Product>{
                                              new Product {
                                                            ProductName = "Test Product 1" ,
                                                            ProductSKU = "TP123456",
                                                            Quantity = 2,
                                                            Price = 25
                                                          },
                                              new Product {
                                                            ProductName = "Test Product 2" ,
                                                            ProductSKU = "TP123457",
                                                            Quantity = 1,
                                                            Price = 100
                                                          }
                                            },
                CustomerInfo = new Customer
                {
                    FullName = "Mustafa KOÇ",
                    Phone = "5551112233",
                    Addresses = new List<Address> {
                                                   new Address {
                                                                   City ="İstanbul",
                                                                   Line1 = "Maslak Mh.",
                                                                   Line2 = "Şişli",
                                                                   Type = AddressType.Delivery
                                                                },
                                                   new Address {
                                                                   City ="İstanbul",
                                                                   Line1 = "Maslak Mh.",
                                                                   Line2 = "Şişli",
                                                                   Type = AddressType.Billing
                                                               }
                                                  }
                }
            };
        #endregion
  • Hemen ardına aşağıdaki kod bloğunu ekleyin.
                byte[] serializedData;
                Order deserializedOrder = new Order();
    
                #region Protobuf-net
                var watchProtoBuf = System.Diagnostics.Stopwatch.StartNew();
                for (int i = 0; i < 1000000; i++)
                {
                    using (var mStream = new MemoryStream())
                    {
                        ProtoBuf.Serializer.Serialize(mStream, data);
                        serializedData = mStream.ToArray();
                    }
                    using (var mStream = new MemoryStream(serializedData))
                    {
                        deserializedOrder = ProtoBuf.Serializer.Deserialize<Order>(mStream);
                    }
                }
                watchProtoBuf.Stop();
                var elapsedMsProtoBuf = watchProtoBuf.ElapsedMilliseconds;
                Console.WriteLine($"ProtoBuf-net 1.000.000 row data Serialize/Deserialize ExecutionTime(ms): {elapsedMsProtoBuf}");
                #endregion
    
                #region  Newtonsoft.Json
                string jsonSerializedData = string.Empty;
                var watchJson = System.Diagnostics.Stopwatch.StartNew();
                for (int i = 0; i < 1000000; i++)
                {
                    jsonSerializedData = JsonConvert.SerializeObject(data);
                    deserializedOrder = JsonConvert.DeserializeObject<Order>(jsonSerializedData);
                }
                watchJson.Stop();
                var elapsedMsJson = watchJson.ElapsedMilliseconds;
                Console.WriteLine($"Newtonsoft.Json 1.000.000 row data Serialize/Deserialize ExecutionTime(ms): {elapsedMsJson}");
                #endregion

    Yukarıdaki kod bloğunda “Protobuf-net” c# dili ile kullanımı #region etiketleri içerisinde belirtilmiştir. Hemen altında ise Json kullanım örneği yine #region etiketleri arasında gösterilmiştir.

    ProtoBuf.Serializer.Serialize(mStream, data) satırında inMemory datasını stream ediyoruz ve sonrasında byte dizisine dönüştürüyoruz. Bu dönüşüp sonucu bize serialized datayı veriyor. Datayı deserialize etmek için ise serialized datayı stream edip ProtoBuf.Serializer.Deserialize<T>(mStream) methodunu kullanıyoruz. Burada T generic dönüşümün yapılacağı tür, mStream ise deserialize edilecek data.

Şimdi çalıştırıp performans analizini gözlemleyebiliriz.

Senaryo: Serialize/Deserialize for 1.000.000 object
Formatlar: Protobuf, Json

Result:

ProtoBuf-net 1.000.000 row data Serialize/Deserialize ExecutionTime(ms): 9715
Newtonsoft.Json 1.000.000 row data Serialize/Deserialize ExecutionTime(ms): 25840

Resultımızı görselleştirirsek performans farkını daha iyi görebiliriz.

 

Application Open Source Code: https://github.com/mustafa-koc/ProtobufnetVSNewtonsoftjson

Elasticsearch Kurulumu ve Giriş (+ Kibana)

Merhabalar,
Uzun  bir aradan sonra birşeyler yazmaya anca vakit bulabildim ve bu ilk fırsatımda sizinle Elasticsearch‘e, hemen ardından ise elastic ürünü olan Kibana‘ya giriş yapmış olacağız.

Elasticsearch’den biraz bahsetmek gerekirse basitçe tanım olarak
Full-Text search” imkanı veren, “Distributed NoSQL Database” diyebiliriz.

RDBMS’lerde Full-Text search yapmak istediğimizde bize yüksek costlar çıkabiliyor. Bu noktada da farklı arayış veya çözüm yoluna gitmek istediğimizde Elasticsearch bize alternatif bir yol olarak el kaldırıyor.

Bu konu başlığı altında, bu yazıda olmasa da ileride şu terimlerle bolca karşılaşacağız ve kullanacağız:

  • Index: Unique (tekil) ve lowercase (küçük karakterler) olmalıdır.
  • Type: Index’deki kriterler bunun için de geçerlidir.
  • API: Herhangi bir implementasyon kütüphanesine gerek kalmadan hızlıca REST API kullanımı ile ES’ye erişmeyi sağlar.
  • Mapping: Verilerin nasıl bir modelde tutulması gerektiğini ve bazı config bilgilerini yapılandırır.

Ön bilgilendirmelerden sonra artık kuruluma geçebiliriz.

İlk önce buradan ES kurulum dosyalarını indirebilirisiniz. Ben Windows için olan .zip dosyasını indirdim.

NOT:
ES(ElasticSearch), Java diliyle yazılmıştır. Bu yüzden kuruluma başlamadan önce bilgisayarınızda JAVA’nın latest version ve bilgisayarınıza uyumlu olan bit(32/64) sürümü olduğundan emin olun. Emin değilseniz tüm Java kurulumlarını bilgisayarınızdan kaldırarak şuradan indirip kurabilirsiniz.

– İndirdiğiniz .zip dosyasını C’ye çıkarın. Dilerseniz farklı bir path de kullanabilirsiniz. Ben bu şekilde kullanıyorum.

– Konfigürasyon için “C:\elasticsearch-6.4.2\config” dizinindeki “elasticsearch.yml” dosyasını editleyin.

cluster.name: mustafa-test
node.name: mustafa-test-1

– Daha sonra Powershell’i açıp sırasıyla aşağıdaki komutları çalıştırın.

cd C:\elasticsearch-6.4.2\bin
.\elasticsearch-service.bat install
.\elasticsearch-service.bat start

– Herşey yolundaysa şöyle bir sonuç göreceksiniz.


Elasticsearch kurulumu için giriş seviyesinde hepsi bu kadar.  = )

 

NOT: Eğer kurulumda bir hata alırsanız veya ES servisinizi başlatamazsanız aşağıdaki adımları uyguladıktan sonra tekrar deneyin.

– Sistem Özellikleri -> Ortam Değişkenleri’nden
Yeni Sistem Değişkeni olarak
Değişken= JAVA_HOME
Değer       = C:\Program Files\Java\jre1.8.0_191  (bilgisayarınızda kurulu olan JAVA dizini)
bilgilerini ekleyin.

Elasticsearch, default olarak 9200 portunu kullanır. Artık ES’miz ayakta ve çağırabiliriz.

Şimdi buraya kadar herşey tamamsa hızlıca Kibana’ya geçelim ve onu da ayaklandıralım.

Öncelikle Kibana ile ne yapacağız? Ne işimize yarayacak? gibi sorularınız var ise onları cevaplayayım.
Kibana, Elasticsearch’e attığımız dataları Monitorize ve Visualize edebilmemiz sağlayan bir yapı. Bu ikisi için birbirini çok iyi tamamladıkları için muhteşem ikili diyebiliriz.
Şuan sadece Kibana’nın ayağa kaldırılmasını göstereceğim. İleri ki aşamalarda detaylarına girip Dashboard, Chart, Map gibi özelliklerine girebilirim.

Buraya tıklayıp .zip dosyasını indirin.

– İndirdiğiniz .zip dosyasını C’ye çıkarın. Dilerseniz farklı bir path de kullanabilirsiniz.

– Config klasöründeki “kibana.yml” dosyası ile konfigürasyonlarınızı tamamlayabilirsiniz. Örneğin: Elasticsearch için custom bir url set edebilirsiniz.

– Daha sonra cmd’yi açıp aşağıdaki komutları çalıştırın.

cd C:\kibana-6.4.2\bin
kibana.bat

– ve sonuç şu şekilde olacaktır

– Ayaklandırdığımız Kibana Service’imize 5601 portuyla erişiyoruz.

 

Şu aşamada nihai olarak Elasticsearch ve Kibana kurulumlarını tamamlayıp ayağa kaldırmış durumdayız.
Makalenin daha fazla uzamaması için burada sonlandırıyorum.
Sorularınız olur ise her zaman sorabilirsiniz. Cevaplamaya çalışacağım.
Başka bir bilgide görüşmek üzere.

Ethereum – Solidity – Working with Smart Contracts – Akıllı Sözleşmeler ile Çalışmak (Example Project)

 

Uzun süredir yoğunluktan blog ile ilgilenemediğimi farkettim ve bayadır aklımda olan bir konu hakkında yazmak istedim. Bugün ki makalemin konusu günümüzün en popüler konularından olan Blockchain teknolojisini altyapı edinen kripto para birimi olan Ethereum’un “Akıllı Sözleşmeler”i üzerine olacak.

Şuanda bilinen en yaygın kripto para Bitcoin’dir. Bitcoin bu anlamda en iyi para birimidir. Fakat artık bunları sadece para birimi olarak değil dijitalleşen hayatımızda farklı alanlar için de işlevsel kılmak istiyoruz. Bu noktada da bize bu esnekliği en iyi sağlayanlardan biri Ethereum’dur.

Peki sağladığı bu şey nedir? Cevabı makalenin başlığından da anlaşılacağı üzere “Smart Contracts” değimiz olay Akıllı Sözleşmeler‘dir. Bu akıllı sözleşmeleri en basit tabir ile örnekleyecek olursak, dijitalleşen dünyanın Dijital Noter‘leri dersek yanılmış olmayız. Fakat işin en önemli yanı ise bu sözleşmeler tek bir noktada değil, merkezi olmayan bir ağ üzerinde tutuluyor olmasıdır.

Şimdi biz developerlar bu işin neresindeyiz? Nasıl bir ortamı var? Nereden başlayacağız? gibi sorularınızın cevabı için ön açıklamayı kısa tutup asıl işe geçelim ve basitçe bir akıllı sözleşme nasıl oluşturabileceğimize değineyim.

1- Create Blockchain Network (1 – Blok zinciri ağı oluştur)

Öncelikle bilgisayarımızda blok zinciri ağı oluşturmak için Ganache‘ı indirip yüklüyoruz. (Ganache-x.xx.appx adında bir dosya inecek.)

install tamamlandıktan sonra block zinciri ağımız otomatik olarak başlayacak.

Artık network’ümüz hazır.

Şimdi contractları programlamak için online bir IDE kullanacağız. Bu IDE bize  javascript benzeri bir dil olan solidity ile programlama ortamı sağlayacak.
https://remix.ethereum.org/  bu linki browserınız ile açın.

Ve şimdi aşağıdaki kod bloğunu buraya yapıştırın. Ayrıca “Auto compile” checkine de tıklayınız.

pragma solidity ^0.4.0;

contract Counter {
    //count değişkeni private olarak tanımlanmış 
    //ve sözleşme sahibi dışında başkası direk erişemez.
    int private count = 0;
    
    //Sayacı 1 arttırır.
    function plusOne() public {
        count += 1;
    }
    
    //Sayacın son halini döndürür.
    function getCount() public constant returns (int) {
        return count;
    }
}

NOT: Siz yukarıdaki kod yerine kendi ihtiyaçlarınıza ve gereksinimlerinize uygun kodu yazıyor olacaksınız. Bu örnek herhangi bir gereksinimi yerine getirmesi için değil tamamen size bu altyapının kullanımını göstermek amacıyla hazırlanmıştır.

Buraya kadar herşey tamamsa devam edelim. Son olarak wallet kaldı. Onu da buradan indiriyoruz. (Linkteki dosyalardan etherwallet-v3.xx.xx.zip dosyasını indirin.)
Download ettiğiniz dosyayı zip den çıkartın ve index.html dosyasını browserınız ile açın.

Cüzdanımızı da indirdik. Şimdi wallet’i makinemize kurduğumuz blockchain networküne bağlayacağız.
Sağ en üstteki dropdowna tıklayarak “Add Custom Network / Node” optionını seçiyoruz.

Ve Ganache’daki local network adres bilgilerimizi buraya girip tamamlıyoruz.

Save butonuna tıkladıktan sonra headerdaki menüden “Contracts” menüsüne tıklayıp ardından “Deploy Contract” sekmesini seçiyoruz.

 

Yukarıdaki “Byte Code” alanının datasını online IDE’miz üzerinden alacağız. IDE’yi açıp “Details” butonuna tıklıyoruz. Daha sonra ise byte code datasını kopyalayıp wallet’deki alana yapıştırıyoruz.

ve şimdi bytecode u yapıştırdıktan sonra yukarıdaki resimdeki gibi “Private Key” i seçip Ganache üzerinden keyimizi alıp buraya yapıştıracağız.

 

“Unlock” butonuna bastıktan sonra transactionımızı sign ediyoruz.

Ardından “Deploy” butonuna basıp açılan popup dan işlemi onaylıyoruz.

 

 

Buraya kadar herhangi bir sorun yoksa şuanda contractımızı deploy ettik. Şimdi bu contract ile etkileşime nasıl geçeceğimize geldi sıra.

Yine wallet üzerinde headerdaki menüden “Contracts”a tıklıyoruz. Ardından “Interact with Contracts” sekmesine tıklıyoruz.

“Contract Adress”imizi öğrenmek için Ganache üzerinden “Transtactions” menüsüne tıklıyoruz. Oradan açılan ekrandaki transactionın detayına gidip oradaki contract address alanını kopyalayıp wallet deki ekranda ilgili yere yapıştırıyoruz.

 

Daha sonra ise online IDE’miz üzerinden ABI/Json Interface datasını detail den kopyalayıp walletdeki ilgili alana yapıştırıp “Access” butonuna tıklıyoruz.

Gelen dropdowndan çağırmak istediğiniz function’ı seçip işlemi gerçekleştirebilirsiniz.

 

“plusOne” functionını run ettikten sonra tekrar “getCount”u çağırıyoruz.

 

Yaptığımız bu işlemleri blockchain network’ümüz üzerindeki kontrol edebilirsiniz.

Tüm işlemleri resimlerle olabildiğince detaylı göstermeye çalıştım. Günün sonunda sizinle simple olarak uçtan uca bir “Smart Contract” oluşturmuş olduk. Umarım faydalı olmuştur. Bir sonraki makalemizde görüşmek üzere. Güncel kalın. = )

SP(Stored Procedure)’lerin Hangi Tabloları Kullanıdığını Bulmak

Bazen uzunca business içeren procedure’ler ile karşılaştığımız oluyordur. Bu noktalarda hangi tablolara dependency edildiğini rahatlıkla analiz etmemize imkan tanıyan bir kodu aşağıda paylaşıyorum. Bir yerde denk geldiğim bir koddu. Unutmayayım diye buraya koyuyorum. İhtiyaç halinde iş görüyor.

DECLARE @temptableforSP TABLE  (spName varchar(100), tableName nvarchar(100))
DECLARE @SP_Name as NVARCHAR(100);
DECLARE @SP_Cursor as CURSOR;
 
SET @SP_Cursor = CURSOR FOR
    SELECT [name] FROM sys.objects WHERE name LIKE 'sp%' AND type='P' -- Gets SPs for specific names
 
OPEN @SP_Cursor;
FETCH NEXT FROM @SP_Cursor INTO @SP_Name;
WHILE @@FETCH_STATUS = 0
BEGIN
 --print(@SP_Name)
 INSERT INTO @temptableforSP
     SELECT 
        OBJECT_NAME(referencing_id) AS referencing_entity_name,    
        referenced_entity_name     
    FROM sys.sql_expression_dependencies AS sed  
    INNER JOIN sys.objects AS o ON sed.referencing_id = o.object_id  
    WHERE referencing_id = OBJECT_ID(@SP_Name); 

 FETCH NEXT FROM @SP_Cursor INTO @SP_Name;
END
 
CLOSE @SP_Cursor;
DEALLOCATE @SP_Cursor;       

-------Display temp. table for SP and Table relation
SELECT * FROM @temptableforSP
------------------

CSharp – Nesne Yönelimli Programlama (OOP) Nedir – Tüm Detaylarıyla

Bir önceki yazımızda OOP hakkında genel fikir verici şeylerden bahsedip aslında neye hizmet ettiğini, ne yaptığını ve ne için ortaya çıktığı gibi soruları cevaplandırmış olduk. Şimdi ise nesne yönelimli programlamanın detaylarına ineceğiz. 5 ana başlık altında anlatmaya çalışacağım.

1. Classes & Object (Sınıflar ve Nesneler)

Gerçek hayatta sorun olarak baz alınan modellemeyi ifade eder. Bu sınıflardan aldığımız instance’lar ile de objelerimizi elde ederiz.
Sınıf oluşturma;

class OrnekSinif 
{  
}  

Ayrıca class yerine struct terimi ile de böyle bir örnekleme yapabiliriz. Struct ise daha küçük kapsamlı bir öğeyi betimlemek istediğimizde kullanabiliriz. Örneğin bir kitap veya stok özellikleri gibi bilgiler için kullanılabilir. Büyük hacimler için tercih edilmez.

  • Encapsulation , Properties , Fields (Kapsülleme)

Encapsulation, bir fielda direk erişimi engelleyerek değimi yerindeyse onu sarmallar ve girdi çıktıları kontrol altına alır.

class OrnekSinif 
{  
    private string ornekField;
}
class OrnekSinif 
{  
    //Okuma veya Atama işlemlerinde herhangi bir aksiyon almak istediğinizde get/set'leri kullanırız.
    public string OrnekProperty { get; set; } 
}

Son olarak kapsülleme örneği ise aşağıdaki şekildedir.

class OrnekSinif 
{  
    private string _ornekField;
    public string OrnekProperty
    {  
        // Field'daki data döndürülüyor. 
        get { return _ornekField; }  
        // Field'a data set ediliyor. 
        set { _ornekField = value; }  
    }
}
  • Methods, Overload Methods

Metodlar, bir sınıfa veya nesneye bağlı olarak çalışıp ilgili eylemleri yerine getirirler. Method oluşturma şablonu şu şekildedir:
“Erişim belirleyicisi/dönüş tipi/Metod Adı/(optinal) Parametreler”.
Örnek method oluşturma.

class OrnekSinif 
{
    //Parametresiz
    int OrnekMethod()
    {  
        // kod parçacığı 
        // ... 
        // kod parçacığı 
    }
    
    //Parametreli
    int OrnekMethod(int sayi)
    {  
        // kod parçacığı 
        // ... 
        // kod parçacığı 
    }
}

Aynı method isminde ve farklı parametreler ile oluşturduğumuz methodlara ise Overload Method denir.

class OrnekSinif 
{
    int OrnekMethod(int sayi)
    {  
        // kod parçacığı 
        // ... 
        // kod parçacığı
    }
    
    int OrnekMethod(string a)
    {  
        // kod parçacığı 
        // ... 
        // kod parçacığı 
    }
    
    int OrnekMethod(int sayi, string a)
    {  
        // kod parçacığı 
        // ... 
        // kod parçacığı 
    }
}

Extension Methodlar ve daha fazla method detayını farklı başlıklar altında değineceğiz.

  • Constructor Methods (Yapılandırıcı/Kurucu Method)

Class’dan bir instance oluşturulurken ilk olarak Constructor tetiklenir ve çalışır. Bu instance’a ilişkin olarak alınması gereken aksiyonlar da burada yer alır. Ayrıca constructor methodlar overload da edilebilir.

public OrnekSinif 
{  
    public OrnekSinif()
    {  
        // ctor kod parçacığı 
        // ... 
        // ctor kod parçacığı 
    }

    //ctor overload
    public OrnekSinif(string a, string b)
    {  
        // ctor kod parçacığı 
        // ... 
        // ctor kod parçacığı 
    }
}
  • Finalizers (Sonlandırıcılar)

.Net Framework bu işlemi hali hazırda otomatik olarak yapıyor. Nesnelere destruct uygular, yani yıkar. Bellek yönetimi yapar. Fakat otomatik olarak yapılamayan nesneleriniz var ise bunların destruct yönetimini sizin yapmanız gerekir. Bu başlık kendi başına bir konu aslında GC namespace’i altında inceleyeceğiz.

  • Events (Olaylar)

Nesnelerimiz üzerindeki changed, click gibi olaylarda almak istediğimiz aksiyonlarımızda devreye girer. Bu başlık altında “Delegate”, “+=”, “Invoke” ifadeleri ile çokça karşılaşacaksınız.

  • Nested Classes (İç İçe Sınıflar)

Bir sınıf içerisine tanımlanmış başka bir sınıfı ifade eder. Basitçe şöyle tanımlanır:

class KapsayiciSinif  
{  
    class IcSinif  
    {  
        // kod parçacığı  
    }  
}
KapsayiciSinif.IcSinif icObje = new KapsayiciSinif.IcSinif()
  • Access Modifiers (Erişim Belirleyicileri)

Bir sınıf veya sınıf üyelerinin hangi erişim düzeyinde olacağını belirler.

public :
Bulunduğu class ve dışarıdan tam erişim.

private :
Dışarıdan hiçbir şekilde erişilemez. Sadece bulunduğu class içerisinde erişilebilir.

protected 
:
Bulunduğu class’dan ve bulunduğu class’da türetilen class’lardan erişilebilir.

internal 
:
Bulunduğu assembly(dll veya exe) içerisinden erişilebilir.

protected internal 
:
proctected özelliklerine tamamen sahip ve ayrıca bulunduğu assembly(dll veya exe) içerisinde olmasa dahi tanımlandığı class’dan türetilen tüm class’lardan erişilebilir.

private protected :
private özelliklerini aynen taşır. Artı olarak bulunduğu class’dan türetilen tüm class’lardan da erişilebilir.

  • Instantiating Classes

Sınıflardan obje oluşturmak instance oluşturmak gerekir.

class OrnekSinif 
{  
    public string Property1 { get; set; } 
    public string Property2 { get; set; }

    public int PlusOne(int a)
    {  
        return a + 1;
    }
}

Şimdi bu sınıftan bir instance alma ve kullanma şekillerine bakalım.

OrnekSinif ornekSinif = new OrnekSinif();//Instance oluşturduk.
ornekSinif.Property1 = "Hello";

OrnekSinif ornekSinif2 = new OrnekSinif{ Property1 = "Hello", Property2 = "World" };
//Property Set ederek instance oluşturduk.
  • Static Classes & Members (Statik Sınıflar)

Statik sözcüğü, sınıflar ve üyeleri için herhangi bir instance işlemine gerek duyulmadan direk erişilebilmesini sağlar.

public static class OrnekSinif 
{  
    public static string Property1 = "Hello";
    public static string Property2 = "World";

    public static int PlusOne(int a)
    {  
        return a + 1;
    }
}

kullanımı

//Herhangi bir instance oluşturmadan direk erişebildik.
string metin = OrnekSinif.Property1 + " " + OrnekSinif.Property2;
int sayi = OrnekSinif.PlusOne(1);
  • Anonymous Types (Anonim Tipler)

Herhangi bir veri türü veya class belirtmeksizin oluşturulur. Bu işlemi verilen sınıf veya veri türüne göre sistem otomatik olarak yapar. Fakat bizim bir tür belirtmemize gerek kalmaz tanımlama yaparken.

var obj = new { A = "Hello", B = "World" };

2. Inheritance (Kalıtım, Miras Alma, Devralma)

Bir sınıfın özelliklerinin kalıtım yolu ile başka bir sınıfa aktarılmasıdır.

Bir class yalnızca bir class’ı miras alabilir.

class A //Base class
{

}

class C
{

}

//B class'ı A class'ı özelliklerini devralıyor.
class B:A
{

}


//Bir de yanlış kullanımını gösterelim
class B : A, C // Böyle bir kullanım yoktur. Aynı anda 2 farklı class bu işlem için kullanılamaz.
{

}

NOT: Bu noktada iki farklı konu karşımıza çıkıyor. Birincisi “sealed class” , ikincisi ise “abstract class” kavramlarıdır.

sealed class: sealed olarak tanımlanan bir class, başka bir class’a inheritance(kalıtım, miras alma, devralma) için kullanılamaz. Sadece ilgili bussines’ı veya görevi yerine getirir. Bu sınıfta bulunan herhangi bir method veya member’ın ezilmesini istemeyiz.
abstract class: abstract şekilde tanımladığımız classları base olarak kullanırız. Yani “bir varlığın en temel özelliklerini en ilkel şekilde barındırır” diyebiliriz. Abstract class’lardan instance oluşturulamaz. İçerisine kod yazılabilir. Private olarak tanımlanamazlar. Interface’lerden ayrılan yanlarından birisi de budur.  Ayrıca belirlediğimiz bu temel özellikleri türetilen sınıfta override edip, türetilen class’a uygun şekil almasını sağlayabiliriz.

public sealed class A { } //Sealed class tanımlama

public abstract class B { } //Abstract class tanımlama
  • Overriding (ezme, geçersiz kılma, çiğnemek)

Base class’dan alınan default özellikleri, türetilen sınıfa göre değiştirmek/geçersiz kılmak istiyorsak bu işlemi uygularız.

C# Modifiers: virtual, override, abstract, new Modifier

virtual: Türetilen sınıfta override edilebilmesini sağlar.
override: Türeyen sınıfta override eder.
abstract: Türeyen sınıfta override etmek zorunludur.
new: Türetilen sınıftan devralınan member’ı gizler.

public class BaseClass
{
    public virtual void OzellikYazdir()
    {
        Console.WriteLine("Hello");
    }
}

public sealed Example:BaseClass
{
    public override void OzellikYazdir()
    {
        Console.WriteLine("Hello World!");
    }
}

3. Interfaces (Arabirimler)

Sınıfların kullanacağı özelliklerin sözleşmesinin yapıldığı ara birimlerdir. Bu arabirimleri referans alan tüm class’lar, ilgili sözleşmedeki tüm member’ları kullanmak zorundadır. Bir class birden fazla interface alabilir.

public interface IExample  
{  
    void OrnekMethod();
}


class OrnekSinif : IExample  
{  
    void OrnekMethod()  
    {  
        // kod
        // ...
        // kod
    }  
} 
public interface IEkle
{  
    void Ekle();  
}

public interface ISil
{  
    void Sil();  
}

public interface IDuzenle
{  
    void Duzenle();  
}

public interface IListele
{  
    void Listele();  
}


public class OrnekSinif : IEkle, ISil, IDuzenle, IListele
{  
    void Ekle()  
    {  
        // kod
        // ...
        // kod
    }
    
    void Sil()  
    {  
        // kod
        // ...
        // kod
    }
    
    void Duzenle()  
    {  
        // kod
        // ...
        // kod
    }
    
    void Listele()  
    {  
        // kod
        // ...
        // kod
    }
} 

4. Generics

Generic olarak oluşturulacak öğe, hangi türde oluşturulması isteniyorsa o türü parametre olarak alır ve o işlemi gerçekleştirir. Bize şunu sağlar: Tek seferde yazılan bir işlevi farklı obje türleri için de işlevsel hale getirebilme imkanı verir. Yani birçok iş için bir kere efor harcanır. Gereksiz kod tekrarının önüne geçer.

Generic Sınıf Tanımlama ve Kullanımı

public class ExampleGeneric<T>//T tipi alınıyor.
{
    public T Insert(T model)
    {
        //Insert işlemi
        //....
        return model;
    }
}
ExampleGeneric<TypeName> exam = new ExampleGeneric<TypeName>();

var resultItem = exam.Insert(new TypeName{ /*Properties*/ });

5. Delegates (Temsilciler)

Temsilciler (delegate), bir “t” zamanında, bir “y” aksiyonu dolayısıyla tetiklenmesini istediğimiz aksiyonları almamızı sağlar. Yani örnek vermek gerekecek olursak bir ekranda bir butona bastıktan sonra bu işlemin daha başka methodları da tetiklemesini istiyorsak bu yöntemi kullanabiliriz. Yordam saklamaya yarar. Parametre alması gereken durumlarda parametre de verilebiliyor. Ufak bir örnek kod yazalım.

//------------------------------------------
public delegate void ornekDelegate();

public void Method1()
{
    Console.WriteLine("Method 1");
}
public void Method2()
{
    Console.WriteLine("Method 2");
}
public void Method3
{
    Console.WriteLine("Method 3");
}
//------------------------------------------

//Kullanımı
ornekDelegate ornek = new ornekDelegate(Method1);
ornek += new testDelegate(Method2);
ornek += new testDelegate(Method3);
ornek();//Burası run edildiği zaman ekrana "Method 1", "Method 2" ve "Method 3" basacak.

Bu ve diğer tüm başlıklar hakkında talep ederseniz daha derinlemesine işleyebiliriz. Yazıyı çok uzatmak istemedim. Çünkü herşeyi tek bir başlık altında anlatmak çok uzun sürer.
Sorularınız veya değinmemi istediğiniz konular var ise sorabilirsiniz. Zaman bulabildikçe yanıt vermeye çalışacağım.

Q# (Quantum Sharp) Kullanımı – Proje Oluşturma ve İlk Uygulama

Q# ile ilgili olarak bir önceki makalede nedir, ne değildir ve DEVELOPMENT KIT kurulumundan bahsetmiştim. Şimdi ise yavaş yavaş işin içerisine girelim.

QSharp Uygulaması Oluşturma

  • Öncelikle Visual Studio 2017’yi açıp New Project diyoruz.
  • Açılan pencereden Visual C# sekmesine gidip “Q# Application“ı seçin.

  • Uygulamamıza “QSharpHello” ismini verip OK diyoruz.
  • Solution Explorer’dan Solution ismine sağ tıklayarak NuGet paketlerini Restore ediyoruz.

  • Referans DLL’lerimizi de toparladık. Şimdi Operation.qs içerisine gidip buraya methodumuzu ekliyoruz.
namespace Quantum.QSharpHello
{
    open Microsoft.Quantum.Primitive;
    open Microsoft.Quantum.Canon;

    operation Operation () : ()
    {
        body
        {
            
        }
    }
}
namespace Quantum.QSharpHello
{
    open Microsoft.Quantum.Primitive;  
      
    // İki sayıyı alıp toplamını verir
    operation Topla (a : Int, b : Int): (Int)  
    {  
        body  
        {  
            return (a + b);  
        }         
    }  
}
  • Bu işlem için bize Microsoft.Quantum.Primitive referansı yeterli. “open” kelimesiyle referansları tanımlayabiliyoruz.
  • Şimdi Driver.cs class’ımıza giderek oluşturmuş olduğumuz bu operation’ımızı simüle edeceğiz.
  • Driver.cs class’ı C# dilindedir.
using Microsoft.Quantum.Simulation.Core;
using Microsoft.Quantum.Simulation.Simulators;

namespace Quantum.QSharpHello
{
    class Driver
    {
        static void Main(string[] args)
        {

        }
    }
}
using System;
using Microsoft.Quantum.Simulation.Core;
using Microsoft.Quantum.Simulation.Simulators;

namespace Quantum.QSharpHello
{
    class Driver
    {
        static void Main(string[] args)
        {
            using (var sim = new QuantumSimulator())
            {
                var result = Toplam.Run(sim, 5, 7).Result;
                Console.WriteLine(result);
            }
            Console.ReadKey();
        }
    }
}

Artık ilk Quantum uygulamamızı oluşturmuş durumdayız ve RUN edebiliriz. =)

NOT: Eğer hatalar alırsanız Solution Explorer’dan sağ tıklayarak Properties>Build>Target Platform> x64 seçin. Hatalarınız devam ediyor ise Projenin .Net Framework’ünü 4.6.1 olarak değiştirip öyle çalıştırın bir de. Arada Visual Studio sapıtabiliyor. Klasikleşmiş “kapat aç düzelir” taktiğini deneyin. Baktınız hala olmuyor çok da zorlamayın =D Donanımsal problem veya kurulumlar esnasında eksik veya yanlış birşeyler yapmış olabilirsiniz.

Elimden geldiğince çok basit bir Quantum Application nasıl oluşturulur bunlardan bahsettim. Bir sonraki Q# makalesini QSharp Structure üzerine yapacağım.

Bilgiyle kalın. =)

Q# (Quantum Sharp) Kullanımı – Programlamaya Giriş ve Kurulum

Q# (QSharp) ‘ı eminim bu postun yazıldığı tarih itibari ile birçoğumuz daha duymadı veya yeni yeni duymaya başladı. Kuantum bilgisayarların gelişimi ve kuantum fiziğine olan ilgi ve alakanın küresel boyutta artmasından dolayı Microsoft Geçtiğimiz haftalarda önce prelease inin çıkardığı bu yeni programlama dilini tanıttı. İyi de bu “Q# (QSharp) nedir?” diye hala merak ediyorsunuz. O halde devam edelim.

Microsoft, Q# (QSharp) progralama dili ve Visual Studio IDE’si ile Kuantum biliminin ön gördüğü teknolojiyi bizler için simüle eden ve kuantum algoritmalar üretebileceğimiz altyapı ve toolları bize sağlıyor.
Buradaki en temel olay klasik olarak bizlere öğretilen “Bilgisayarlar 0 veya 1’ler ile çalışır.” cümlesidir. Buradaki 0 veya 1, bizim için Bit terimini ifade ediyor. bu da Binary Digit yani 2’li sayı sistemi anlamına geliyor. Kuantum bu sistemi yıkarak karşımıza QBit (Kubit) ‘leri getiriyor. QBit ‘ler ise ölçülene kadar “hem 0 hem de 1” olabiliyor.

Kuantum mekaniğinin ve bu modellemenin şuana kadar yaygınlaşamamasının tek sebebi, en basit bir sistemin bile kuantum modellemesinin yapılabilmesi için günümüzdeki bilgisayarların yetersiz kalması ve bu düzeye çıkamamasıydı. Oysa ki bu bilim 1900-1925’li yıllar arasında geliştirildi. Ki teknolojik gelişmelere bakar isek Dünya’nın varoluşundan bu yana son 100 yıl içerisindeki teknolojik anlamda yaşanılan gelişme kadar dünyanın hiç bir zamanında bir gelişme sağlanamamıştır. Öte yandan Son 50 sene içerisinde, geride bıraktığımız son 100 yıldan daha çok teknolojik gelişmeler olmuştur. Bu da aslında teknoloji çağında olduğumuz açık-seçik ortaya koymaktadır. Bu genel bilgileri verdikten sonra kısa kesip konumuzu tekrar toparlayalım.

Minimum Sistem Gereksinimleri

  • Microsoft, Quantum Development Kit için kullandığı ve kuantum simülatörü olan Advance Vector Extensions (AVX) destekli işlemciniz (CPU) olması gerekmektedir. (Bunu desteklemeyen CPU’lar için de çalışılıyor fakat şuan böyle bir destek yok.)
  • Bilgisayarınızda Microsoft OS (Operation System) olarak Windows’un 64 Bit’lik bir sürümü yüklü olması gerekiyor.
  • Visual Studio 2017 yüklü olmalı. Değil ise buradan ücretsiz Community  versiyonunu indirebilirsiniz.

Kurulum

Eğer Visual Studio 2017 yüklü ise de değil ise de yukarıdaki verdiğim linkten setup dosyasını indirin. Kurulu olanlar Modify’e tıklasın, yeni kurulum yapacak olanlar ise direk kuruluma geçecekler zaten. Burada şu “Universal Windows Platform development“, “.NET desktop development” başlıkları kesinlikle Checkleyip kurulumumuza eklemeliyiz.

Daha sonrasında Visual Studio 2017’mizin güncel olduğundan emin olmak için VS’yi başlatıp Tool>Extension & Updates ekranından Updates>Products sekmesinde güncelleme var ise yükleyin.

Bu işlemleri yaptıktan sonra yine hemen yukarıdaki resimdeki alandan Online sekmesine tıklayıp Arama çubuğuna “Quantum Development KIT” yazın. (veya buradan da indirip setup dosyasından da kurabilirsiniz.)

QSharp Dev KIT install

İlk çıkan sonuca tıklayarak kurulum işlemini gerçekleştirebilirsiniz.

Artık Quantum Programming yapabilmemiz için Microsoft’un sağlamış olduğu tüm ortam kurulumlarını tamamladık. Simülasyon ve algoritmalarımızı geliştirebiliriz. Q# ile alakalı bir sonraki yazımda giriş seviyesi olarak en afillisinden bir “Hello World” yapacağız =)
Akabinde de QSharp Structure ‘ın tüm detaylarını vakit buldukça sizlerle paylaşmaya devam edeceğim.

Nesne Yönelimli Programlama (OOP) Nedir

Merhabalar, bu yazımda başlıktan da anlaşılacağı üzere Nesne Yönelimli Programlama (Object Oriented Programming) nedir, ne yapar, ne eder biraz bu konulara değineceğim.

Nesne Yönelimli Programlama ‘nın temel amacı gün geçtikçe ilerleyen ve genişleyen yazılım sektöründeki bir takım problemlere ve tıkanıklıklara çözüm üretmektir.

Şirketlerin yazılım olarak hizmet ettikleri veya katma değer ürettikleri projelerinin büyümesiyle birlikte çalışanları da artmaktadır. Bunların akabinde geliştirilen yazılımların bakımı, geliştirilebilirliği ve de esnekliği gibi kavramlar büyük önem arz etmektedir. Ki zaten tam da bu noktalardaki sorunlar sebebiyle 1960-1970’li yıllarda bu konu gündeme gelmiştir. Özellikle yazılımdaki karmaşıklık ve düzensizlik projeleri geliştirilemez bir hale getirmiştir. İmdada ise OOP yetişmiştir.

Object Oriented Programming’de ana mantık, mevzu bahis konuların classlar ile soyutlanarak hem bilgisayarın hem de insanların anlayabileceği modeller oluşturmaktır.

İlerleyen yazılarımda OOP‘yi oluşturan class, inheritance, properties, Interface, vs. gibi temel alt başlıklara değinip örneklerle açıklamaya çalışacağım.