ASP.NET Core Web API and Swagger

Hi everyone,

First of all this is my first English article so i am so excited. I hope it will explain you what i want. With my English 🙂

We can develop various projects with ASP.NET Core. The most important of these project types is API Projects i think. What is API? What does the ASP.NET Core Web API provide us? and how the API will relate to product named Swagger? We will try to examine them in this article.

What is this API they call?

API, with its long name Application Programming Interface, can basically be thought of as software that enables different types of applications to work together. The API enables data exchange between applications. Of course, during these data transfers all of the processes used in security, authorization, and general application logic are used. The most obvious difference is that API applications do not have an interface (GUI).

The results of this operations (database crud, getting data from other applications etc.) with the values received via the API (sometimes without any value) can be given in a readable form by other applications. Thus, all applications running on different platforms and with different technologies can send data to the same API and receive the results and evaluate them on their own structure.

Today, the most known use of API technologies is the backend of mobile applications. Whether the mobile application is on the IOS or Android platform, it can read and process data via same API.

What is going on with ASP.NET Core Web API then?

API is actually a technology, a concept that is mentioned as a structure. Of course, an API application can be written in different languages. In this article, we will examine how to create an API application with ASP.NET Core.

Let’s create our ASP.NET Core Web API project, then what is Swagger? How to use? Then continue our review.

We will use Visual Studio Code to work with our project. We are creating a new ASP.NET Core project. We will use .NET Core CLI for our project. First, we create our Web API project as follows.

Then run the dotnet run command to test our application and check our created API.

We can see the address of our application after the command is run. http://localhost:5000 We can control our application with our browser at this address. A Controller will come ready so that we can test it in the newly created skeleton application or as an example for beginners. (WeatherForecast) we can test our API through this controller.

Another test method is the POSTMAN application, which API developers often use. You can download the POSTMAN application here. POSTMAN is an application for working with APIs. POSTMAN is used to avoid the hassle of receiving API data or sending requests through browsers. The controller, which is available via the API via POSTMAN, brings us the data as follows.

If you wish, we can now proceed to write a code. Now we will create a controller ourselves and let the data (statically) come from there. Then we will be able to test this controller we created on the API and see how we work with Swagger.

We will use Visual Studio Code to create a new controller. To open our project with Visual Studio Code, we will use code . on the command line again.

When our project is first opened with Visual Studio Code, it will ask us if we want the requirements to be installed in order to build and debug our application project. In this section, we can complete the installation of the requirements with the Yes button.

The Controller we will create will serve basic vehicle information via API. For this, we must first create our vehicle model. We create a file called Car.cs by opening a new folder named Models via the file explorer on the left. Then we write our model to this file.

Then we create a new file under the Controllers folder and name it CarController.cs. Here we will perform operations related to a list of vehicles and serve these operations through the API.

Our CarController.cs file will be as follows.

Now you can test our API using the Controller you created.

Let’s run our application by typing dotnet run on the terminal that we will open via Visual Studio Code. We can access both the list and the vehicle information we want via POSTMAN.

So far, we have worked on the creation of our API. So how do we convey information about the API and its operation to the developers of the applications that will use this API? Let’s say we are developing backend services within a team that develops mobile applications. We need to inform team members who develop mobile applications about how these methods we developed work. It will be the healthiest method to both call the methods and document and transmit the returned response information.

In such a case, it would of course be tiring to write each method one by one in a certain format. Swagger is an ideal product to make this situation easier and more practical.

Swagger automatically documents the method information we created in our project that we added. This method information can be viewed by application developers who want to use our API with each request and response information.

Swagger consists of two parts. The first and most important of these is the Swagger Specification. Here is a swagger.json file that is automatically created by Swagger and every API update, this file is updated and contains the information of our methods in the API.

The second part is called Swagger UI. Here, we can get visual information of the methods on the API. The work of the methods, the answers they give and the parameter information they receive can be viewed. We can also simply run methods and get method responses from the UI. By specifically writing an application via Swagger UI, there will be no need to test methods via API.

Now let’s look at how we can adapt Swagger to our application that we have created.

Swagger consists of three components. It is possible to import all these components into our application as a single nuget package.

• Swashbuckle.AspNetCore.Swagger
• Swashbuckle.AspNetCore.SwaggerGen
• Swashbuckle.AspNetCore.SwaggerUI

Let’s install the Swagger package

To add the package to our project, it will be sufficient to type the following command from the Visual Studio Code terminal screen.

dotnet add package Swashbuckle.AspNetCore

Then the package will be downloaded and installed in our application.

In order to adapt Swagger to our application, we first need to add the following lines to the ConfigureServices method in Startup.cs.

Again, we add the following lines to the Configure method in Startup.cs.

Now we can run our application from the Visual Studio Code terminal and test the Swagger implementation. For this, we need to type dotnet run on the terminal screen.

Then, if we go to https://localhost:5001/swagger/v1/swagger.json from our browser or via POSTMAN, we can see that our Controller-based method information comes in json format.

Well, we talked about a UI component. Now let’s see how to use this UI component.

When our project is running, when we access https://localhost:5001/swagger/index.html via our browser, a page titled API Information will be opened and we will be able to view our method information.

We can get the information of the methods via Swagger UI by clicking on the method names.

Here we see the features of our method, where we list the vehicle information. The Parameters section gives information about the parameter information of our method, and the Responses section provides information about the response returned via the API method. With the Try it out button on the top right, we can run the API method and see the returned information.

It is also possible to view the descriptions of our methods on the Swagger UI. In this way, it is possible to explain the function of the method with meaningful explanations to application developers who examine our methods.

For this, we need to add the following lines to the csproj file of our application (the file name for our application is ASPNETCoreSwagger.csproj).

Then we add the following lines to the ConfigureServices method in the Startup.cs file.

Now we can add annotations to our API methods and have these annotations displayed through the Swagger UI. Below is an example of how we can annotate our methods. Then you can view the method description via Swagger UI.

When we run our project again and check it over Swagger UI, we can see that the method description comes.

As you can see, Swagger API solves the documentation processes for us quickly in our projects. Software developers who will benefit from the API will be more comfortable with Swagger to reach the right information.

See you again with another article.

https://www.yazilimbilisim.net/c-sharp/asp-net/api-nedir/
https://code-maze.com/swagger-ui-asp-net-core-web-api/

RabbitMQ İle İlk Adımlar

İmaj adresi : https://www.rabbitmq.com/img/home/banner/webinar/RabbitMQ-Hero-queues-desktop.svg

RabbitMQ’ya bağlanma, kanal ve kuyruk oluşturma, mesajlarımızı gönderip, okuma işlemlerini incelemeye çalıştım. Umarım anlaşılır olmuştur.

Projenin Github bağlantısı aşağıdaki gibidir.
https://github.com/onurkarakus/RabbitMQMessageApplication

Merhaba,

Çocukluğundan kalan bir anı sanırım. Büyüdüğüm zamanlarda artık çok gitmediğim şehrimizde olan fuarlar hep aklımda. Kalabalık olmasının yanı sıra farklı türde ve tarzda bir sürü eğlence yerinin olmasından dolayı seslerin siz gezerken kulağınızda zorlayıcı etkileri. Bir yandan çalan rock müziğin yanında diğer yandan gelen türkü seslerinin karışması. Tabii bunlara eklenen insanların konuşmaları, birbirlerine seslenmeleri ve çocukların neşeli sesleri. Aslında tam bir kaos ortamı. fuar alanından çıktıktan sonra aklınızda kalan tek şey karışıklığın verdiği yorgunluk oluyordu.

Uygulamalarımızda aslında bu şekilde bir yapıya sahip diye düşünüyorum. Bir sürü mesajın düzensiz bir şekilde gönderip alınması ile birlikte ciddi performans sorunlarının oluşması olası. Bu mesajların bu mesajları işleyen yapıların bu işlemlerini asenkron ve sırayla yapmasının sağlamak için de yapılar mevcut. Bunlardan son dönem en çok kullanılanı ise RabbitMQ.

Bir önceki yazımda RabbitMQ hakkında genel bilgileri vermeye ve kurulum işlemlerinin hem OnPremise hem de Docker üzerinde nasıl yapılacağını anlatmaya çalıştım. Bu yazıya aşağıdaki bağlantıdan ulaşabilirsiniz.

https://onnurkarakus.medium.com/nedir-bu-rabbitmq-28e3e9296ecd

Bu yazıda ise C# ile RabbitMQ’yu nasıl kullanacağız? konusunu incelemeye ve sizlere anlatmaya çalışacağım. C# ile iki Console uygulaması oluşturarak birinden gönderdiğimiz mesajların diğer uygulama üzerinden okunmasını sağlayacağız. Böylelikle temel olarak RabbitMQ işleyişini kontrol edebileceğiz. Uygulamamız için bir önceki yazımda anlatmaya çalıştığım Docker kurulumunu yaptığımız RabbitMQ yapısını kullanacağız.

O zaman başlayalım.

İlk önce Visual Studio üzerinden yeni bir Solution dosyası oluşturuyoruz. Daha sonrasında Console uygulamalarımızı bu Solution içerisinde oluşturacağız.

Uygulamalarımız Sender ve Receiver isminde iki console uygulaması olacak. Şimdi ilk olarak Sender uygulamamızı solution içerisinde oluşturalım. Uygulamamızın adı RabbitMQMessageApplication.Sender olsun.

Uygulamamızda RabbitMQ üzerinde oluşturacağımız kuyruğa bir sınıftan oluşturduğumuz nesnemizi göndereceğiz. Bu nesneyi RabbitMQ’ya göndermeden önce de Json ile serileştirmemiz gerekecektir.

Bu işlemleri yapabilmek için uygulamamıza aşağıda bulunan iki Nuget paketini eklememiz gerekmektedir.

• Newtonsoft.Json 13.0.1
• RabbitMQ.Client 6.2.1

Visual Studio içerisine bulunan Nuget Package Manager ile paketlerimizi ekleyebiliriz.

Şimdi uygulamamızı RabbitMQ üzerinde oluşturacağımız bir kuyruğa mesaj göndermesi için kodlarımızı ekleyelim.

İlk önce mesaj nesnemizi tanımlayalım. Bu nesnemiz kuyruğa gönderilecek ve başka bir uygulama üzerinden okunacak olan nesnemiz olacaktır. Sınıf ismini MessageInformation olarak veriyorum.

Daha sonrasında RabbitMQ için tanımları yaptığımız, kuyruk bilgilerini belirlediğimiz ve mesajımızı bu kuyruğa gönderdiğimiz kodları ekliyoruz.

Satır 12 : RabbitMQ bağlantımızı oluşturuyoruz. Burada kurulu olan adresimizi, kullanıcı adımızı ve şifremizi yazmamız yeterli olacaktır.

ConnectionFactory() RabbitMQ host uygulamasına bağlanmak için kullanılır.

Satır 13-14 : Burada RabbitMQ için bağlantımızı ve kanalımızı hazırlıyoruz.

CreateConnection() ConnectionFactory() ile tanımlarını yaptığımız host bağlantımızı oluşturuyor.

CreateModel() RabbitMQ üzerinden yeni bir kanal oluşturmak için kullanılır. Bu kanal sayesinde kuyruk bilgisi oluşturulacak ve mesajımız bu kuyruğa bırakılacaktır.

Satır 16 : Kanal tanımımız üzerinden kuyruk bilgilerimizi giriyoruz ve yeni bir kuyruk oluşturuyoruz.

QueueDeclare() Oluşturduğuz RabbitMQ tanımları içinde bir kuyruk oluşturmamızı sağlayacaktır.

durable : Kuyruğa gönderilecek mesajların saklama yöntemini belirler. Mesajlar InMemory olarak hafızada saklanabilirken istenirse fiziksel olarak da makine içerisinde saklanabilmektedir. Tabii burada hız, performans ve bilgilerin durumu önemli ölçüm değerleri olmaktadır. OnMemory kullanım eğer makine kapanırsa verilerin kaybolacağı anlamına gelmektedir. Bu yüzden kuyruk içinde iletilecek verilerin durumlarına göre bu tanım dikkatli bir şekilde kullanılmalı diye düşünüyorum.

exclusive : Kuyruğun bizim oluşturduğumuz bağlantı haricinde diğer Connectionlar ile de kullanılabileceğini belirler.

autodelete: Eğer kuyrukta bulunan mesaj bilgisini tüm tüketiciler (consumer) almış ise o zaman kuyruğun otomatik olarak silinmesi sağlanır. Yalnız burada dikkat edilmesi gereken konu eğer kuyruk içerisinden bilgiyi alacak bir consumer işlemi iptal edildi veya hata aldı ise o hakkının kaybedecektir. Bunun için autodelete özelliğini kapatıp kuyruk silme işlemi bir metot ile de yapılabilmektedir.

Satır 25 : Mesaj nesnemizi oluşturup gerekli bilgileri dolduruyoruz.

Satır 29 : Mesajımızı serileştirerek kuyruğa gönderilebilecek yapıya getiriyoruz.

Satır 32 : Mesajımızı RabbitMQ üzerinde oluşturduğumuz kuyruğa gönderiyoruz.

BasitPublish() : Hazırladığımız mesajın bir veya daha fazla kuyruğa aktarılmasını sağlar. Bir kuyruk tamam fakat birden fazla kuyruk konusu? Bu işlem için ExchangeType bilgileri kullanılmaktadır. ExchangeType bilgilerinin isimlerini aşağıda bulabilirsiniz. Kendileri ile ilgili yazıları da detaylı bir şekilde araştırdıktan sonra yazmaya çalışacağım.

• Direct
• Fanout
• Headers
• Topic

Uygulamamızı çalıştırdığımız zaman kullanıcıdan aldığımız mesaj bilgisinin RabbitMQ kuyruğuna gönderildiğini görebilmekteyiz.

Yine aynı şekilde RabbitMQ yönetim paneli içerisinden de kuyruk bilgilerimizi ve bu kuyruk içerisinde bulunan mesajların sayısal bilgilerine ulaşmamız mümkündür. Bunun için http://localhost:1360 adresine gidiyoruz ve guest@guest kullanıcı bilgileri ile login oluyoruz.

Burada da görebileceğiniz gibi MessageTest isminde bir kuyruğumuz ve onun içinde de Ready durumunda bekleyen bir adet mesajımız bulunmaktadır.

O zaman şimdi bu mesajı RabbitMQ üzerinden nasıl okuyacağımıza bakalım. Bunun için yine aynı solution içerisine RabbitMQMessageApplication.Receiver adından yeni bir console uygulaması ekliyoruz.

Projemize RabbitMQ işlemlerini yapabilmek için ve aldığımız mesajları geri açabilmek için aşağıdaki iki paketi Nuget ile ekliyoruz.

• Newtonsoft.Json 13.0.1
• RabbitMQ.Client 6.2.1

Şimdi yapmamız gereken RabbitMQ’ya bağlanarak Sender uygulaması ile oluşturduğumuz ve bir nesnemizi gönderdiğimiz kuyruğa bağlanarak mesajımızı almak. Serileştirilmiş bir şekilde bize gelen bu mesajı açarak artık istediğimiz yerde kullanabileceğiz.

Öncelikle Sender uygulaması içinde kullandığımız sınıfımızı buraya da tanımlayalım. Ortak bir proje içinden de alabilirdik ama benim tembelliğim oldu biraz.

Ardından Receiver uygulamamız için kuyruk bilgisini okuyan kod bloğumuz aşağıdaki gibi olacaktır.

Burada yine Sender uygulamamızdaki gibi ConnectionFactory üzerinden bağlantımızı oluşturduk. Kanal ve kuyruk tanımlarımızı yaptık.

Sender uygulamasından farklı olarak burada farklı olarak Received olayını (event) kullanıyoruz. Bu eventin kullanılma amacı sürekli olarak tanımlarının verdiğimiz kuyruğu dinleyerek yeni mesajların eklenmesi durumunda bu mesajları yakalayabilmektir.

BasicConsume() ile de gelen mesajımızı yakalayabiliriz. Burada kullandığımı autoAck parametresi uygulama içerisinden mesajı okuduktan sonra bu mesajın silinmesini sağlamaktadır.

İlk önce Receiver uygulamasının çalıştıralım ve Sender uygulamasının test ettiğimiz sırada eklediğimiz mesajın kuyruk üzerinden geldiğini görelim.

Şimdi isterseniz hem Sender hem de Receiver uygulamalarını aynı anda çalıştırarak gönderilen mesajın nasıl iletildiği kontrol edelim.

Kuyrukların Silinmesi
Oluşturduğumuz kuyrukların belirli durumlar karşısında silinmesini kendimiz metot kullanarak yapabiliriz. Daha önce de anlatmaya çalıştığım gibi otomatik bir silme mekanizması mevcut fakat bu consumer olan uygulamaların hataları karşısında mesajları almak haklarını kaybetmelerine sebep olabiliyor.

Kuyruk silme işlemini QueueDelete() ile yapabiliyoruz.

queue : Silmek istediğimiz kuyruk adıdır. 
ifUnused : Eğer kuyruk kullanılmıyor yani herhangi bir consumer yok ise o zaman silinsin anlamına gelmektedir. 
ifEmpty : Eğer kuyruk boş ise silinsin anlamına gelmektedir.

Evet bu yazımda RabbitMQ ile temel işlemlerin nasıl yapılacağı konusunu anlatmaya çalıştım. Umarım açıklayıcı olmuştur.

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

Kaynaklar :
https://www.rabbitmq.com/documentation.html
https://www.borakasmer.com/rabbitmq-nedir/
https://www.rabbitmq.com/dotnet-api-guide.html

Nedir bu RabbitMQ?

Merhaba,

Öğrenme isteği hem işimizin hem de hayatımızın önemli bir parçası. Bilgileri kovalamak, kovalayıp yakaladıkça işimize ve hayatımıza yenilikler katmak ve en önemlisi başarma duygusu. Bunların yeri çok önemli insan hayatında.

Tabii son yıllarda bilgiye ulaşmak özellikle internetin de yardımıyla kolaylaşmış durumda. Aradığımızı okumak için, okumak zor geliyorsa birilerinin anlatması için bir vidyo olarak bulmak artık çok kolay. Eskilere baktığımız zaman bir bilgiye ulaşmak, bir veriye ulaşmak o kadar kolay değildi. Yaşlıyım kabul edelim.

Benden büyüklerle (fakat çok büyüklerle) konuştuğum zaman bu bilgi alışverişinin zorluğunu bir nebze de olsa anlayabiliyorum. Örnek vermek gerekirse dedem. Aslında kendisi öğretmen fakat okuma aşkı yüzünden dışarıdan posta ile bir üniversite daha bitirmiş. Posta? Evet kitapların, sınavların ve diğer dokümanların posta ile gönderildiği bir üniversite yapısı.

Hem okuyan için zor bir süreç hem de okul için zor bir süreç aslında. Özellikle sınavlar konusu biraz karışık. Öğrencilere gönderilecek sınavların hazırlanması, bu sınavların öğrenciler tarafından tamamlandıktan sonra gönderilmesi ve okulda görevli kişiler tarafından kontrol edilip notlarının verilmesi. Şimdi baktığımız zaman elektronik ortamlarda bu işlemler kolay oluyor.

Fakat yazılımlarımız içerisinde de bu sorunlar yaşanmıyor mu? Yazılımların mesajlaşmaları, bu mesajların işlenmesi ve geriye cevaplarının dönülmesi tıpkı mektup ile yapılan sınavlar gibi zor olabilir mi? Dilerseniz bugün bu konuyu ve bu konu için sunulan güzel bir çözümü inceleyelim.

Geliştirdiğimiz uygulamalar, verilerin işlenmesinden sorumlu temel olarak. En küçük noktada düşünürsek uygulama genelinde mesajların işlenmesi (alınması ve cevaplanması) uygulama performansını etkileyen bir durumdur. Bu noktada bazı kullanılan işlemlerin anlık yapılması ihtiyacının olmadığının düşünerek bu işlemleri asenkron olarak yapmak isteyebiliriz. Bir örnekle konuyu açıklamaya çalışayım. Loglama. Bir API uygulamamızda gelen istek (request) ve cevapların (response) loglanması için middleware katmanın yazdığımız loglama işlemi her request ve response için uygulamıza bir yük oluşturacaktır. Peki, bu işlemleri asenkron bir şekilde yapsak? O zaman işte bize yardım için devreye RabbitMQ giriyor.

RabbitMQ açık kaynak kodlu bir mesaj kuyruk sistemidir. Şu an kullanılan RabbitMQ gibi farklı uygulamalar da mevcuttur. (Apache Kafka, Microsoft Azure Service Bus veya MSMQ)

Genel Özellikleri ile RabbitMQ?

• Erlang dili üzerinde geliştirilmiştir.
• Açık kaynak kodlu olduğu için yaygın bir kullanım alanına ulaşmıştır.
• Cross platform yapısından dolayı farklı işletim sistemlerinde de kullanılabilmektedir.
• Web arayüzü ile kullanım kolaylığı sağlamaktadır.

RabbitMQ Pusblish ve Subscriber mantığı ile çalışmaktadır. Bunun anlamı ise bir uygulamadan mesajı alıp sırası geldiği zaman bu mesajı başka bir uygulmaya iletmek olarak açıklanabilir.

RabbitMQ Genel Çalışması

Burada bazı terimlerin açıklamasına ihtiyaç olacağı için onları da açıklamaya çalışalım.

Publisher : Kuyruğa mesaj gönderen uygulamadır. 
Consumer : Kuyruktan gönderilmiş olan mesajı okuyan uygulamadır.
Queue : RabbitMQ içerisinde kullanılan mesajların alıp / verildiği kuyruk adıdır. 
Exchange : Routing Key bilgisine göre mesajların ilgili kuyruklara gönderilmesini sağlayan bilgidir. 
Exchange Type : Routing Key bilgisine göre mesajları hangi kuyruğa nasıl yönlendirilmesi gerektiğini belirleyen yapıdır.

RabbitMQ Kuralım

Ben iki farklı şekilde kurulum işlemlerini anlatmaya çalışacağım. İlk olarak her yerde karşımıza çıkan onpremise kurulumdan bahsetmek istiyorum.

RabbitMQ Erlang dilinde yazıldığından dolayı öncelikle bilgisayarımıza Erlang kurmamız gerekmektedir. Bunun için aşağıda bulunan bağlantıyı kullanabilirsiniz.

http://www.erlang.org/downloads

Erlang kurulumlarımızı tamamladıktan sonra RabbitMQ kurulum dosyaları için de aşağıdaki bağlantıyı kullanabilirsiniz.

http://www.erlang.org/downloads

Kurulumların ardından http://localhost:15672 adresi ile de RabbitMq yönetim panelini açabilirsiniz.

Bir başka kurulum yöntemi ise Docker kullanmak. Ben genellikle Docker üzerinde bu tarz uygulamalarımı kullanıyorum ve OnPremise kuruluma göre bir hayli avantajlı olduğunu düşünüyorum.

Gelin şimdi hep beraber Docker üzerinde RabbitMQ’yu nasıl kuracağımıza bakalım.

İlk olarak tabii ki Docker kurulumlarını tamamlamak gerekecek. Bu konu ile ilgili aşağıda bulunan makaleye bakabilir, kurulum işlemlerinin nasıl yapıldığını görebilirsiniz.

http://www.erlang.org/downloads

Docker kurulum işlemlerimizi tamamladıktan sonra RabbitMQ imajını indirmemiz gerekmektedir. Bunun için Powershell üzerinden aşağıdaki komutu yazmamız yeterli olacaktır.

docker pull rabbitmq

RabbitMQ imajını indirdikten sonra Container’ı hazırlamak ve çalışır hale getirmemiz gerekmektedir. Bunun için aşağıdaki komut satırının Powershell üzerinde çalışmamız yeterli olacaktır.

docker run -d -p 1360:15672 -p 5672:5672 — — name MyRabbitMQContainer rabbitmq:3-management

Bu komut ile iki farklı konfigürasyon düzenlemesi yapmaktayız. Bunlardan ilki Docker içerisinde çalışacak olan RabbitMQ 5672 portunun kendi lokal bilgisayarımızın 5672 portu ile eşliyoruz.

Yönetim uygulaması için de kullanılacak olan 15672 portunu da yine lokal bilgisayarımızın 1360 numaralı portuna eşiliyoruz. Böylelikle lokal bilgisayarımız üzerinden http://localhost:1360 adresine girdiğimiz zaman RabbitMQ yönetim paneline ulaşabileceğiz.

Daha sonra Docker Desktop uygulaması üzerinden çalıştırdığımız komutların hem imaj hem de container için çalıştığının görebiliriz.

RabbitMQ yönetim paneline giriş için ise lokal bilgisayarımızdan http://localhost:1360 adresine gitmemiz yeterli olacaktır. Açılan giriş ekranına aşağıdaki bilgiler ile giriş yapabilirsiniz.

Kullanıcı Adı: guest
Şifre: guest

Genel olarak RabbitMQ’nun ne olduğu ve kendi bilgisayarımız nasıl kurulacağı konusunda bilgiler aktarmaya çalıştım. Bir sonraki yazımda ise RabbitMQ ile mesajlarımızı nasıl yöneteceğimiz konusuna bakacağız.

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

Kaynaklar:
https://www.rabbitmq.com/
https://www.gencayyildiz.com/blog/dockerda-rabbitmq-ayaga-kaldirma/
https://www.borakasmer.com/rabbitmq-nedir/

ASP.NET Core Web Api ve Versiyonlama

Merhaba,

Uygulamalarımızın üretim ortamlarında çalışırken kontrolleri aslında genel olarak zor işlemler içeriyor. Tabii, bu işlemleri kolaylaştırmak için günümüzde önemli çözümler mevcut. Fakat en temel yaşadığımız sorunların başında yeni özelliklerin üretim ortamlarında devreye alınması gelmekte.

Aslında buraya kadar bir problem yok. Tamam, yeni özellikleri geliştir ve üretim ortamına al. Peki bu servisleri kullanan uygulamalar? Onların bu yaptığımıza tepkisi ne olur acaba? Büyük ihtimalle eğer ciddi değişiklikleri üretim ortamına çıkıyorsak hatalar alınacak ve projemiz belirli bir süre çalışmayacaktır. Böyle bir durumu da kimse istemez diye düşünüyorum.

Fakat, mevcut kullanıcıların bundan etkilenmemesini sağlamak tabii ki mümkün. Bu konuda kullanılan farklı çözümler ve yöntemler mevcut. Seçimin kişi, ekip, ekibin bilgisi ve tecrübesi ile doğru orantılı olduğunu düşünüyorum.

• Farklı bir metot olarak üretim ortamına alalım ? (Gerçekten mi? API’yi kullanan uygulamalara ne diyelim?)
• Bir parametreye bağlayabiliriz belki ?( Mevcut metodun kodlarında değişiklik mi? Ee test ihtiyacı? Hata olasılığı?)
• Özellik açma / kapama (Feature Toggling) yapabiliriz? (Evet belki olabilir fakat parametre gibi olmayacak mı bir nevi ? Farklı uygulamalar mevcut denenebilir.)
• Peki, versiyonlama yapsak ?

Versiyonlama, evet bugün bu konu hakkına bir şeyler yazmak istedim. ASP.NET Core Web API üzerinde versiyonlamayı nasıl yapabiliriz? Hangi yöntemler ile bu versiyonlama işlemlerini kullanabiliriz?

O zaman beraber ASP.NET Core Web API üzerinde versiyonlama işlemlerini nasıl yapıyoruz? Bakalım.

Önce yeni bir Web API projesi oluşturalım.

Visual Studio Code uygulamamızdan yeni bir terminal başlattıktan sonra aşağıdaki komut ile yeni WebApi projemizi oluşturalım.

Versiyonlama işlemlerimizi yapabilmek için bir Nuget paketine ihtiyacımız olacaktır. Aşağıdaki komut ile Microsoft.AspNetCore.Mvc.Versioning paketini projemize ekleyelim.

Paket kurulumundan sonra Startup.cs sınıfımızda aşağıda bulunan konfigurasyon tanımlarını yapmamız gerekmektedir.

Şimdi versiyonlama işlemlerimizi yapabiliriz.

Versiyonlama işlemleri birkaç yöntem ile yapılabilmektedir. Bu versiyonlama tekniklerini sırasıyla kontrol edelim.

API metodlarımızı değişikliğimizden sonra çağırdığımızda Header bilgileri içerisinde kullanılabilecek versiyon bilgilerini görüntüleme imkanına sahip oluyoruz.

URL Sorgusuna Dayalı Sürüm Oluşturma (URL Query Based Versioning)

Kullanılan URL adresi üzerinden versiyon bilgisi alınarak versiyonlama işlemleri yapılır. Aşağıda bulunan iki controller aynı API adresi üzerinden gelinen versiyon bilgisine göre çalışacaktır.

Göreceğimiz gibi burada farklı isimler ile tanımlanmış iki adet controller bulunmaktadır. Burada belirtilen route bilgileri ise aynıdır. API adresi olarak çağırdığımız api/home adresi bu farklılaştırmayı ApiVersion özelliği ile yapmaktadır. API adresine gönderilen query string bilgisi ile versiyon ayırımı yapılabilmektedir. Aşağıda iki versiyon için Postman üzerinden çağırım örneklerini bulabilirsiniz.

http://localhost:5000/api/home?api-version=2.0

Eğer API adresimizi bir versiyon bilgisi göndermeden çalıştırırsak o zaman varsayılan olarak 1.0 versiyonu gelecektir.

URL Yoluna Dayalı Sürüm Oluşturma (URL Path Based Versioning)

Genel yaygın kullanımlardan biri olan URL path kullanımı hem client uygulamaları için kullanımı kolay bir yöntemdir.

Postman üzerinden versiyon bazlı çağırımlarımız ise aşağıdaki gibi olacaktır.

http://localhost:5000/api/1.0/home

Http Başlık Tabanlı Sürüm Oluşturma (Http Header Based Versioning)

Görüldüğü gibi her versiyonlama yöntemi biraz daha kullanım bakımından daha iyi hale gelerek devam etmektedir. Tabii bu yöntemlerin client uygulama veya kullanılan yapıya uygun şekilde seçilmesi önemlidir. HTTP Header üzerinden versiyonlama kullanma yöntemi client uygulama tarafından gönderilen header bilgisi üzerinden versiyon bilgisini alarak çalışmaktadır.

Header üzerinden versiyon bilgisinin alınabilmesi için yapılandırmada ufak bir değişiklik yapmamız gerekecek. Bunun için Startup.cs sınıfımıza aşağıdaki kod satırını eklememiz gerekmektedir.

Kod değişikliğimiz ile API uygulamamızın versiyon bilgisini header üzerinden almasını sağlamış olduk.

Şimdi, Postman üzerinden header bilgisi olarak versiyon bilgimizi geçebilir ve sonuçları görebiliriz.

http://localhost:5000/api/home

Tek Controller Birden Fazla Action

Bazı durumlarda tek bir controller içerisinde bulunan action bilgilerinin de versiyonlanmasını isteyebiliriz. Böyle bir durumda controller içinde bulunan action metoduna MapToApiVersiyon özellik geçişini yapmamız yeterli olacaktır.

Header üzerinden alınan versiyon bilgisi ile yeni metodumuzun çalışması aşağıdaki gibi olacaktır.

API Versiyonlarını Kullanımdan Kaldırmak

API için hazırlanmış eski versiyonların kullanımdan kaldırılmasını (Deprecated) yine sınıf özelliği tanımları ile yapma imkanına sahibiz. Böyle bir durumda metodlarımızı API üzerinden çağırdığımızda kullanılmayan versiyon bilgilerine ulaşabiliriz.

Postman üzerinden metodumuzu çağırdığımız zaman ise Header alanında versiyonlar ile ilgili bilgileri görebiliriz.

Versiyon Tanımlarını Oluşturmak

Versiyon tanımlarının şimdiye kadar Controller veya Action bilgileri üzerinden tanımladık. Servis tanımlarını yaparken Controller versiyonlarının tanımlanmasını da sağlayabiliriz.

Eklediğimiz kod bloğunda hangi controller hangi versiyona sahip olacak bilgilerini tanımlayabiliyoruz. Controller bilgilerimiz ise aşağıdaki gibi olacaktır.

İstenilen API Versiyonunu Görüntüleyebilmek

Peki, böyle bir yapı içerisinde gelinen API versiyonunu nasıl alacağız? Versiyon bilgisini alarak istenilen durumlarda gelinen versiyon için de ayrı işlemler yapabiliriz. Bunun için GetRequestedApiVersion() metodundan yararlanabiliriz.

Postman çağırımlarımız ile metodların verdikleri cevaplar da aşağıdaki gibi olacaktır.

Bu yazımda API üzerinde nasıl versiyonlama yapabileceğimizi ve bu versiyonları nasıl yönetebileceğimizi biraz hem kendim anlamaya hem de sizlere açıklamaya çalıştım.

Versiyonlama yöntemleri birden fazla olduğundan dolayı ihtiyacımızı karşılayan uygun yöntem uygulamamızın yapısı, client kullanımları ve API kullanan diğer uygulamaların durumlarından dolayı farklılık gösterecektir.

Bir başka yazıda görüşmek üzere…

Nedir Bu Docker?

Merhaba, uygulamalarımızı hazırlarken iş akışlarının oluşturmak, dizayn ve kodlama süreçlerini tamamlamanın yanında en önemli sorunlarda biri de uygulamanın nerede ve nasıl çalışacağının belirlenmesi adımıdır. Uygulamanın host edilmesi, çalışma zamanı kontrollerinin sağlanması, çalışılan uzak makinenin teknik altyapısının uygunluğu veya zaman içinde uygulamanın performans ihtiyaçlarına göre bu teknik özelliklerin artış / düşüş göstermesi kodlama aşamasından daha yorucu hale gelebilmektedir.

Özellikle son zamanlarda sıkça duyduğumuz mikro servis mimarisinin de hayatımıza girmesi ile birlikte dağıtık yapıların ismini daha çok telaffuz eder olduk konuşmalarımızda. Böyle bir durumda uygulamalarımızı nasıl ve nerede barındıracağız ve yöneteceğiz?

Bu makalemizde bu soruların cevaplarını bulmaya çalışırken Docker uygulamasının ne olduğundan, avantajlarından ve kullanımından bahsedeceğiz. Tabii bu arada ASP.NET Core uygulamalarımızı Docker ile nasıl yayınlayacağımız konusuna da değineceğiz.

Barındırma, hosting ve büyük zorluklar.

Hayatımıza bulut teknolojileri girmeden önce – yaşımdan dolayıASP barındırma hizmetlerine kadar gidebilirim fakat bunlarla canınızı sıkmak istemiyorum – barındırma hizmetleri için anlaştığımız firmalar ile çoğu zaman bir savaş veriyorduk. Ana makinelerin konfigürasyon ayarları, ek bellek veya işlemci ihtiyaçlarının sağlanması konularında tam bir kaos yaşanabiliyordu. Ardından gelen bulut teknolojileri ile birlikte bu sorunların büyük kısmının önüne geçmiş olundu. Hatta artık bu gibi ihtiyaçlarımızı birilerini arayarak veya e-posta göndererek değil kendimiz bir, iki küçük araç ile halleder duruma geldik.

Bu yeniliklerin için inceleceğimiz konu olan Docker da barındırma işlerimizi kolaylaştırmak adına bir araç olarak bize sunuluyor. Şimdi dilerseniz kavramları biraz inceleyelim ardından bu işlemleri nasıl yapılıyor beraber bakalım.

Docker mı ?

Docker uygulamasının temel amacı geliştirdiğimiz uygulamaların yayınlama ve çalıştırma süreçlerini kendi yapısında bulunan konteynerler (container) üzerinde gerçekleştirmesidir. Docker bu işlemleri yaparken bizleri çalıştığı işletim sisteminden soyutlayarak, her biri ayrı konteynerler üzerinde çalışan ve birbirlerini etkilemeyen uygulama grupları oluşturmamıza izin vermektedir.

Docker Mimarisi

Docker ilk olarak Linux ortamlar için geliştirilmiş ve daha sonrasında Windows ve MacOS işletim sistemlerine yayılmış bir uygulamadır. Uygulama çalışma mantığı olarak iki bölümden oluşmaktadır. Bunlardan ilki Linux çekirdeği ile direkt iletişim halinde olan Docker Deamon. İkinci bölüm ise kullanıcının yani bizim Deamon ile iletişim kurmamızı sağlayan Docker CLI.

Linux işletim sistemlerinde bu için bölüm direkt Linux ile haberleşirken Windows ve MacOS işletim sistemlerin Deamon bir sanal makine üzerinde koşturulmaktadır. Docker CLI ise yine kullanılan işletim sistemi üzerinde çalışmaya devam etmektedir.

Docker Deamon ve CLI iletişimi istem – sunucu yapısında çalışmaktadır. Deamon ile CLI soket veya REST API üzerinden iletişim kurabilmektedir. Bu sayede Docker Windows ve MacOS işletim sistemlerinde de çalışabilmesinin yanı sıra bir Docker CLI ile istediğimiz bir Docker Deamon’a da bağlanabilmekteyiz.

Docker Mimarisi ile ilgili görseli aşağıda bulabilirsiniz.

Birazda Docker ile beraber hayatımıza girecek olan yeni terimlere bakalım.

İmaj (Image) :

Docker tarafından çalıştırılacak olan konteynerlerin şemalarını temsil ederler. Konteynerlerin içerisinde bulunan işletim sistemini, dosya sistemini veya konteyner içerisinde kullanılacak olan uygulamaları barındırır. Eğer mevcutsa bir imaj başka bir imajdan kalıtım alarak da tanımlanabilir. İmaj dosyasının içeriği Dockerfile adı verilen bir dosya içerisinde tutulmaktadır. Dosyalar Docker hub içerisinde veya yerel ortamınızda depolanabilmektedir.

Konteyner (Container) :

Konteynerler bir imaj dosyasında oluşturulan tek bir ana bilgisayar içerisinde birden çok uygulamayı çalıştırmak için kullanılan yapılardır. Aslında bu işlem sanallaştırmaya benzer, ancak birden çok işletim sistemi oluşturmak için bir sunucuyu sanallaştırmak yerine konteynerler, işletim sistemini esasen sanallaştırarak daha hafif bir alternatif sunar. Böylelikle birden çok iş yükünün tek bir ana bilgisayarda çalışmasına izin verir. Her konteyner kendi dosya, ağ ve uygulama yapısına sahiptir.

Docker CLI (Command-Line Interface) – Docker İstemcisi :

Docker ile çalışırken kullanacağımız komut setlerini barındırmaktadır. Aslında temel olarak Docker Deamon ile kullanıcı arasındaki iletişimi sağlar. İmajların indirilmesi, indirilen imajlardan konteynerlerin oluşturulması ve bu konteynerlerin yönetilmesi Docker CLI ile yapılmaktadır.

Docker Daemon :

Asıl işi yapan kısımdır. Burada imajlardan oluşturulan konteynerlerin tüm yaşam döngüsünden sorumlu bölümdür. Dosya sisteminin kontrolü ve kaynakların sınırlandırılması (CPU ve RAM) burada yapılmaktadır.

Docker Hub :

İmaj dosyalarını indirip kullanabildiğimiz, yeni imaj dosyalarını ayarlayarak yükleyebildiğimiz bir alan olarak kullanılmaktadır.

Haydi Docker ile çalışalım!

Yazının ilerleyen bölümlerinde Docker ile bir imajın oluşturulması, bu imajdan bir konteyner oluşturulması ve bunun oluşturacağımız bir ASP.NET Core uygulaması yayınlanması konularına bakacağız.

İlk önce Docker Deamon ve CLI kurulumlarının nasıl yapıldığını inceleyelim.

Docker Kurulumu

Eğer bir Linux makine için kurulum işlemlerini yapacaksanız bu adresten adımları takip edebilirsiniz.

Eğer macOS bir makine için kurulum işlemlerini yapacaksanız bu adresten adımları takip edebiliriniz.

Kurulum işlemlerini Windows işletim sistemi üzerinden anlatmaya çalışacağım. .NET Core SDK kurulum işlemlerinin tamamlanmasının ardından Docker kurulum adımlarına bakabiliriz.

Öncelikle bu adresten kurulum dosyasının indirerek kurulum aşamalarını tamamlıyoruz.

Kurulum aşamaları tamamlandıktan sonra Docker Desktop uygulaması aşağıdaki şekilde olacaktır.

Docker üzerinden oluşturacağınız konteynerler için ihtiyacınız olan imaj dosyalarına Docker Hub üzerinden ulaşabileceğinizden daha önce bahsetmiştik. Bu işlem için öncelikle hub.docker.com adresine kayıt olmanız ve bir DockerId almanız gerekmektedir.

.NET Core MVC Uygulamamızı hazırlayalım.

İlk önce uygulamamızı hazırlayacağımız klasörü ve dotnet cli ile projemizi oluşturmamız gerekmektedir. Bunun için projemizi oluşturmak istediğimiz klasörü oluşturduktan sonra komut satırı editöründen oluşturduğumuz klasöre giderek aşağıdaki komut satırının çalıştırmamız yeterli olacaktır.

dotnet new mvc

Böylece projemiz için gerekli temel yapıyı oluşturuyoruz. Projemizi test etmek için ise komut satırı editörüne aşağıdaki satırı yazarak uygulamamızın hazır olmasını sağlayabilir, ardından uygulamamızı kontrol ettiğimiz zaman aktif bir şekilde çalıştığını görebiliriz.

dotnet run

Dockerfile diyorduk. Ne oldu ona?

Evet, uygulamamızın çalıştığını da gördükten sonra makalemizin ana konusu olan Docker ile uygulamamızı nasıl yayınlayacağımız konusunu inceleyeceğiz.

Öncelikle uygulamamızın Docker ile bağlantılı olabilmesi için bir Dockerfile oluşturmamız ve bu dosyanın tanımlarının yapmamız gerekmektedir. Uygulamamızın bulunduğu bir kod editörü ile açıp ardından Dockerfile tanımlarımızı yapmaya başlayabiliriz. Makale içerisinde editör olarak Visual Studio Code kullanılacaktır. VS Code ile uygulamamızın bulunduğu klasörü açabilmek için komut satırından uygulamamızın bulunduğu klasöre giderek code . komut satırının çalıştırmamız yeterli olacaktır.

Projemizin kök dizininde Dockerfile (büyük, küçük uyumuna dikkat etmemiz gerekiyor.) isminde bir dosya oluşturarak içeriğini aşağıdaki gibi tanımlıyoruz.

Dockerfile (büyük küçük uyumu önemli) Docker tarafından okunarak imaj dosyalarının oluşturulması sağlayan bir komut dosyası olarak düşünülebilir. Dockerfile içerisinde yapmak istediklerimizi biraz açıklamak gerekirse;

FROM : Docker konteynerinin hangi imaj örnek alınarak (kalıtım) oluşturulacağının tanımlandığı yerdir. Burada dikkat edilmesi gereken konu uygulamanız hangi .NET Core versiyonunda ise o versiyona uygun bir baz imaj seçmeniz gerektiğidir.

WORKDIR : Konteynerin çalışma dizin bilgisidir.

COPY : Kaynaktan hedefe kopyalanacak dosya bilgilerini içerir. Bu örneğimizde csproj dosyasının imaj dosya sistemi içerisine kopyaladıktan sonra dotnet restore komut satırı ile uygulamamızın çalışması için gereklilikleri yüklemiş oluyoruz.

RUN : İmaj içerisinde çalıştırmak istediğimiz komut bilgisidir. Burada dotnet publish ile uygulamamızı yukarıda belirttiğimiz yol ve özelliklere göre yayınlamış olacağız.

ENTRYPOINT : Docker konteyneri için bir çalışma bilgisi (executable) tanımlarını içerir. Burada bizim oluşturduğumuz proje konteyner için başlangıç noktası olacaktır.

Ve Sahne Docker’da

Şimdi ise uygulamamızın Docker içerisinde yayınlanması konusuna bakalım. İlk olarak komut satırı editörümüzden yine uygulamamızın çalışma dizininde iken aşağıda komut satırının çalıştırarak imajımızı derleyelim.

docker build -t hellodocker . 

Bu komut ile birlikte Docker tanımlara uygun bir şekilde gerekli olan imaj dosyalarının indirecek ve yeni bize ait olan imaj dosyamızı oluşturacaktır.

Ardından imajımızın doğru oluşturup oluşturulmadığı kontrol etmek için aşağıda bulunan komut satırını kullanabiliriz.

docker images

Eğer önceki ekranda bir problem ile karşılamadıysanız burada oluşturduğumuz imajı görebileceğiz. İmajın boyutu, id bilgisi ve ismi liste içerisinde gelecektir.

Bu işlemleri de tamamladıktan sonra artık oluşturduğumuz imajdan bir konteyner oluşturarak çalışır hale getirebiliriz. Konteyner ile birlikte de uygulamamız Docker üzerinde barındırılıp, yayınlanmış olacaktır. Bu işlemi yapabilmek için yine komut satırı editöründe aşağıda bulunan komutu çalıştırıyoruz.

docker run -d -p 8080:80 --name HelloDocker hellodocker

Biraz önce oluşturduğumuz konteynerin ve şu an Docker ile yayınlanan diğer konteynerlerin durumlarını öğrenmek için ise aşağıdaki komut yeterli olacaktır.

docker ps

Burada oluşturduğumuz konteynerin STATUS bilgisinin Up olduğunu görebilmekteyiz. Evet şimdi de uygulamamızı konteynerimizi aktif ederken belirttiğimiz port ve özelliklere göre kontrol edelim.

Gördüğünüz gibi uygulamamız artık Docker üzerinden yayınlanmaya başladı ve özelliklerini belirttiğimiz port üzerinden de bu kontrolü yapabiliyoruz.

Konteynerler ile işimiz belli bir süre sonra bitebilir ve aktif olarak yayınlanmasını hatta bunların Docker Registery içinde bulunmamasını istemeyebilir. Peki, mevcut konteynerleri nasıl durdurup, silebiliyoruz? Son olarak bu komutlara da göz atalım. Aşağıda bulunan komut ile çalışan bir konteyneri durdurabiliyoruz. Bunun için daha önceden kullandığımız docker ps komutu ile konteyner listesini alarak durdurma işleminde bu liste üzerinden bize verilmiş olan isimleri kullanacağız.

docker stop hellodocker

docker rm HelloDocker komut satırı ile konteynerimizi silebiliyor ve docker rmi hellodocker komut satırı ile de daha önceden oluşturduğumuz imaj dosyamızı silerek sistemden kaldırabiliyoruz.

Komut satırı ile yaptığımız bu işlemleri de yine Docker kurulumu ile beraber gelen Docker Desktop uygulaması ile de yapmamız mümkündür.

Evet, bir makalenin daha sonunda geldik. Bu makalede Docker nedir ? Docker ile bir uygulamamızı nasıl konteyner olarak barındırırız ve nasıl yönetiriz? konularının anlatmaya çalıştım. Umarın yararlı olmuştur.

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

Kaynaklar :

https://gokhansengun.com/docker-nedir-nasil-calisir-nerede-kullanilir/
https://medium.com/@teo.levy/getting-started-with-asp-net-core-docker-guide-for-beginners-d62af654881a
https://kancerezeroglu.wordpress.com/2016/06/17/docker/
https://medium.com/devopsturkiye/temel-d%C3%BCzeyde-docker-mant%C4%B1%C4%9F%C4%B1-ve-kavramlar%C4%B1-bde5418858d4

ASP.NET Core Web API ve Swagger

Merhaba,

ASP.NET Core ile birlikte çeşitli projeler geliştirebiliyoruz. Bu proje tiplerinden en önemlisi ise API projeler. API nedir? ASP.NET Core Web API bize neler sağlar? ve Swagger isimli ürün ile API’nin nasıl bir ilgisi olacak bu makalede bunları incelemeye çalışacağız.

Nedir bu API dedikleri?

API uzun adıyla Application Programming Interface, temel olarak farklı türden uygulamaların beraber çalışmalarını sağlayan yazılımlar olarak düşünülebilir. API uygulamalar arasında veri alışverişlerini sağlar. Tabii bu veri transferleri sırasında güvenlik, yetkilendirme ve yine genel uygulama mantığında kullanılan işlemlerin hepsi kullanılmaktadır. En belirgin fark ise API uygulamalarının bir arayüzlerinin (GUI) olmamasıdır.

API üzerinden alınan değerler ile -bazen de değer almadan- yapılan işlemlerin sonuçları (database crud, başka uygulamalardan veri almak vb.) başka uygulamalar tarafından okunabilir şekilde verilebilmektedir. Böylelikle farklı platformlarda çalışan, farklı teknolojilere sahip uygulamaların tamamı aynı API’ye veri gönderebilir ve sonuçları alarak kendi yapıları üzerinde değerlendirebilirler.

API teknolojilerinin günümüzde en bilinen kullanım yeri mobil uygulamaların arka tarafında bulunan servisler (backend) olarak karşımıza çıkar. Mobil uygulama ister IOS ister Android platformunda olsun aynı API üzerinden verileri okur ve işlemlerini yapabilir.

ASP.NET Core Web API ne oluyor o zaman ?

API aslında bir teknoloji, bir yapı olarak bahsedilen bir kavram. Tabii ki bir API uygulaması farklı diller ile yazılabilmektedir. Biz bu makalemizde ASP.NET Core ile bir API uygulamasının nasıl oluşturulacağının inceleyeceğiz.

ASP.NET Core ile ilgili daha içerikli bilgi için Nedir bu ASP.NET Core ?makalesini inceleyebilirsiniz.

ASP.NET Core Web API projemizi oluşturalım ardından Swagger nedir ? Nasıl kullanılır? İncelememize devam edelim.

Projemiz ile çalışmak için Visual Studio Code kullanacağız. Yeni bir ASP.NET Core projesi oluşturuyoruz. Projemiz için .NET Core CLI’den yaralanacağız. İlk önce webapi projemizi aşağıdaki gibi oluşturuyoruz.

Ardından uygulamamızı test etmek için dotnet run komutunu çalıştıralım ve oluşturulmuş olan API’mizi kontrol edelim.

Uygulamızın adresini komut çalıştırıldıktan sonra görebilmekteyiz. http://localhost:5000 bu adres üzerinden tarayıcımız ile uygulamamızı kontrol edebiliriz. Yeni oluşturulan iskelet uygulama içerisinde test edebilmemiz veya yeni başlayanlar için örnek olması açısında bir Controller hazır bir şekilde gelecektir. (WeatherForecast) bu controller üzerinden API’mizi test edebiliriz.

Bir başka test yöntemi ise API geliştiricilerini sıklıkla kullandığı POSTMAN uygulamasıdır. POSTMAN uygulamasını buradan indirebilirsiniz. POSTMAN, API’ler ile çalışmak için kullanılan bir uygulamadır. Tarayıcılar üzerinden API verilerini almanın veya isteklerin gönderilmesinin zorluğunu yaşamamak için POSTMAN kullanılmaktadır. POSTMAN üzerinden de API üzerinden bulunan controller aşağıdaki şekilde bize verileri getirmektedir.

Dilerseniz şimdi bir kod yazmaya geçebiliriz. Şimdi kendimiz bir controller oluşturarak buradan verilerin (statik olarak) gelmesini sağlayacağız. Ardından API üzerinde oluşturduğumuz bu controller’ı test edip Swagger ile çalışmamıza bakabileceğiz.

Yeni controller oluşturmak için Visual Studio Code kullanacağız projemizi Visual Studio Code ile açmak için yine komut satırı üzerinde code . yazmamız yeterli olacaktır.

Projemiz Visual Studio Code ile ilk açıldığı zaman uygulama projemizi build ve debug edebilmek için gerekliliklerin yüklenmesini isteyip / istemediğimizi bize soracaktır. Bu kısımda Yes butonu ile gerekliliklerin yüklemesini tamamlayabiliriz.

Yeni oluşturacağımız Controller temel araç bilgilerini API üzerinden servis edecektir. Bunun için ilk önce araç modelimizi oluşturmalıyız. Sol dosya gezgini üzerinden Models isminde yeni bir klasör açarak Car.cs isminde bir dosya oluşturuyoruz. Ardından bu dosyaya modelimizi yazıyoruz.

namespace ASPNETCoreSwagger.Models
{
    public class Car
    {
        public int Id { get; set; }
        public string Brand { get; set; }
        public string Model { get; set; }
        public int Year { get; set; }
    }
}

Ardından Controllers klasörü altında yeni bir dosya oluşturarak adına CarController.cs veriyoruz. Burada bir araç listesi ile ilgili işlemler yapacağız ve bu işlemleri API üzerinden servis edeceğiz.

CarController.cs dosyamız ise aşağıdaki gibi olacaktır.

using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using ASPNETCoreSwagger.Models;
namespace ASPNETCoreSwagger.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class CarController : ControllerBase
    {
        [HttpGet]
        public IEnumerable<Car> Get()
        {
            return GetCars();
        }
        [HttpGet("{id}", Name = "Get")]
        public Car Get(int id)
        {
            return GetCars().Find(e => e.Id == id);
        }
        [HttpPost]
        [Produces("application/json")]
        public Car Post([FromBody] Car car)
        {
            return new Car() { Id = car.Id, Brand = car.Brand, Model = car.Model, Year = car.Year };
        }
        [HttpPut("{id}")]
        public void Put(int id, [FromBody] Car car)
        {
            
        }
        
        [HttpDelete("{id}")]
        public void Delete(int id)
        {
        }
        private List<Car> GetCars()
        {
            return new List<Car>()
            {
                new Car() { Id = 1, Brand = "Toyota", Model = "Auris", Year = 2012 },
                new Car() { Id = 2, Brand = "BMW", Model = "3.20", Year = 2019 },
                new Car() { Id = 3, Brand = "Renault", Model = "Clio", Year = 2020 }
            };
        }
    }
}

Şimdi oluşturduğunuz Controller’ı kullanarak API’mizi test edebiliriz.

Visual Studio Code üzerinden açacağımız terminal üzerinde dotnet run yazarak uygulamamızı çalıştıralım. POSTMAN üzerinden hem liste hem de istediğimiz araç bilgisine ulaşabilmekteyiz.

Buraya kadar API’mizin oluşturulması ile ilgili çalışmalar yaptık. Peki bu API’yi kullanacak olan uygulamaların geliştiricilerine API ve çalışması ile ilgili bilgiyi nasıl ileteceğiz ? Diyelim ki mobil uygulama geliştiren bir takımın içerisinde backend servislerini geliştiriyoruz. Mobil uygulamaları geliştiren ekip üyelerine bu geliştirdiğimiz metodların nasıl çalıştığı hakkında bilgi vermemiz gerekir. Hem metodların çağırılmaları hem de geri dönen cevap bilgilerinin doküman haline getirilip iletilmesi en sağlıklı yöntem olacaktır.

Böyle bir durumda her metodu tek tek belirli bir formatta yazmak elbette yorucu olacaktır. Bu durumu daha kolay ve pratik hale getirmek için Swagger ideal bir ürün olarak karşımıza çıkıyor.

Swagger eklediğimiz projemizde oluşturduğumuz metod bilgilerini otomatik olarak dokümante eder. Bu metod bilgileri her istekleri (request) hem de cevap (response) bilgileri ile birlikte API’mizi kullanmak isteyen uygulama geliştiriciler tarafından görüntülenebilir.

Swagger iki bölümden oluşmaktadır. Bunlardan ilki ve en önemlisi Swagger Specification‘dır. Burada Swagger tarafından otomatik olarak oluşturulan bir swagger.json dosyası mevcuttur ve her API güncellemesinde bu dosya güncellenerek API içerisinde bulunan metodlarımızın bilgilerini barındırır.

İkinci bölüm ise Swagger UI olarak adlandırılmaktadır. Burada da API üzerinde bulunan metodların görsel olarak bilgilerini alabiliriz. Metodların çalışmalarını, verdikleri cevapları ve aldıkları parametre bilgileri görüntülenebilir. Ayrıca basit bir şekilde metodları çalıştırabilir ve metod cevaplarının UI üzerinden alabiliriz. Swagger UI üzerinden özellikle bir uygulama yazarak API üzerinden metodların test edilmesine gerek kalmayacaktır.

Şimdi oluşturduğumuz uygulamamıza Swagger’ı nasıl uyarlarız ona bakalım.

Swagger üç bileşenden oluşmaktadır. Tüm bu bileşenleri tek nuget paketi şeklinde uygulamamıza almamız mümkündür.

Bu bileşenler;

• Swashbuckle.AspNetCore.Swagger
• Swashbuckle.AspNetCore.SwaggerGen
• Swashbuckle.AspNetCore.SwaggerUI

Swagger paketini yükleyelim

Paketi projemize eklemek için Visual Studio Code terminal ekranından aşağıdaki komutu yazmamız yeterli olacaktır.

dotnet add package Swashbuckle.AspNetCore

Ardından paket uygulamamıza indirilmiş ve yüklenmiş olacaktır.

Swagger’ın uygulamamıza uyarlanması için ilk önce Startup.cs içerisinde bulunan ConfigureServices metoduna aşağıdaki satırları eklememiz gerekmektedir.

Yine Startup.cs içerisinde bulunan Configure metoduna da aşağıdaki satırları ekliyoruz.

Şimdi Visual Studio Code terminal ekranından uygulamamızı çalıştırıp Swagger uyarlamasının test edebiliriz. Bunun için terminal ekranına dotnet run yazmamız gerekmektedir.

Ardından tarayıcımızdan veya POSTMAN üzerinden https://localhost:5001/swagger/v1/swagger.json adresine girersek Controller bazlı metod bilgilerimizin json formatında geldiğini görebiliriz.

Peki bir UI bileşeninden bahsetmiştik. Şimdi de bu UI bileşenini nasıl kullanacağımıza bakalım.

Projemiz çalışırken https://localhost:5001/swagger/index.html adresine tarayıcımız üzerinden girdiğimiz zaman API Bilgileri başlıklı bir sayfa açılacak ve metot bilgilerimizi görüntüleyebileceğiz.

Swagger UI üzerinden metodların bilgilerini metot isimlerine tıklayarak alabiliriz.

Burada araç bilgilerini listelediğimiz metodumuzun özelliklerini görüyoruz. Parameters bölümü metodumuzun parametre bilgilerini, Responses bölümü ise API metodu üzerinden dönen cevap (response) hakkında bilgi vermektedir. Sağ üst kısımda bulunan Try it out butonu ile API metodunu çalıştırabilir dönen bilgileri de görebiliriz.

Swagger UI üzerinde metodlarımızın açıklamalarını da görüntülememiz mümkündür. Bu şekilde metodlarımızı inceleyen uygulama geliştiricilere anlamlı açıklamalar ile metodun görevini anlatmamız mümkün olmaktadır.

Bunun için uygulamamızın csproj dosyasına (bizim uygulamamız için dosya adı ASPNETCoreSwagger.csproj) aşağıda bulunan satırları eklememiz gerekmektedir.

Ardından Startup.cs dosyasında bulunan ConfigureServices metoduna da aşağıdaki satırları ekliyoruz.

Artık API metodlarımıza açıklamalar ekleyebilir ve bu açıklamaların Swagger UI üzerinden görüntülenmesini sağlayabiliriz. Metodlarımıza nasıl açıklama ekleyeceğimizin örneğini aşağıda bulabilirsiniz. Ardından Swagger UI üzerinden metot açıklamasını görüntüleyebilirsiniz.

Projemizi yeniden çalıştırıp Swagger UI üzerinden kontrol ettiğimiz zaman metod açıklamasının geldiğini görebiliriz.

Görüldüğü gibi Swagger API projelerimizde dokümantasyon işlemlerini bizler için hızlı bir şekilde çözmektedir. API’den yararlanacak olan yazılım geliştiricilerin doğru bilgilere ulaşması Swagger ile daha rahat olacaktır.

Başka bir makale ile yeniden görüşmek üzere.

Kaynaklar:
https://www.yazilimbilisim.net/c-sharp/asp-net/api-nedir/
https://code-maze.com/swagger-ui-asp-net-core-web-api/

Visual Studio Code kullanarak ASP.NET Core Projesi Geliştirme

Gereksinimler ve kurulumlar

Visual Studio Code Microsoft tarafından ücretsiz olarak dağıtılan, cross-platform olarak çalışan, Windows, Mac ve Linux işletim sistemleri için geliştirilmiş bir kod editörüdür. Microsoft Visual Studio bir IDE olarak çalışırken Visual Studio Code bir kod editörüdür. Yalnız, VS Code da Visua Studio gibi uygulama geliştirme işlemleri için gayet kullanışlı bir üründür.

Bu makalemizde VS Code kullanarak bir ASP.NET Core uygulamasının geliştirme, debug, test ve dağıtım işlemlerinin nasıl yapıldığına bakacağız.

Visual Studio Code uygulamasının indirmek için aşağıdaki bağlantıyı kullanabilirsiniz.
https://code.visualstudio.com/

Visual Studio Code kurulumunu tamamladıktan sonra ASP.NET Core projelerimizi oluşturup kullanabilmemiz için bazı uzantıların (extension) kurulumlarını yapmamız gerekmektedir. Bunun için VS Code uygulamasının açtıktan sonra Ctrl + Shift + X tuş kombinasyonu ile veya sol menüde bulunan Extensions ikonuna tıklayarak açılan ekranda “C#” aramasının yaparak çıkan ilk uzantıyı Install butonu ile kurulum işlemini tamamlayabiliriz.

Ardından aynı şekilde Nuget Gallery için uzantı kurulumunu tamamlamamız gerekmektedir.

VS Code genel olarak ASP.NET Core projelerini oluşturmak için Visual Studio gibi bir komut yapısına sahip değildir. .Net Core CLI bu konuda yazılımcılara yardımcı olmaktadır. Biz de projemizi .Net Core CLI üzerinden oluşturacağız.

İlk ASP.NET Core Uygulamamız

İlk önce projemizin oluşturulacağı dizini oluşturmamız gerekmektedir.

Ardından oluşturduğumuz klasörü VS Code ile açmamız gerekmektedir. Bunun için File menüsünden Open Folder… komutu seçilmesi yeterli olacaktır.

VS Code kendi içerisinde bir terminal yapısı barındırmaktadır. Böylelikle komut satırı kullanmadan işlemlerimizi bu terminal yapısı ile gerçekleştirmemiz mümkün olacaktır. Terminal menüsünü açmak için Terminal menüsünden New Terminal (Ctrl + Shift + “) komutunu seçmemiz yeterli olacaktır.

Terminal alt kısımda açıldıktan sonra aşağıda bulunan komut ile ilk ASP.NET Core projemizi oluşturmaya başlayabiliriz.

dotnet new mvc

Yukarıda bulunan komut Terminal ekranı üzerinde çalıştırıldığı zaman bulunduğumuz klasör içerisinde yeni bir Asp.Net Core MVC projesi oluşturulacak ve dotnet restore komutu otomatik olarak çalıştırılıp paket bilgileri de güncellenecektir.

Projemizin çalıştırılması

Projemizi çalıştırmak için yine .NET Core CLI komutlarından faydalanacağız. Bunun için terminal ekranına aşağıdaki komut yazılarak çalıştırılabilir. Böylelikle projemiz bize bilgileri verilecek olan localhost adresi ve bir port üzerinden çalışmaya başlayacaktır.

dotnet run

http://localhost:5000 adresine bir web tarayıcı ile girdiğimiz zaman projemizin çalıştığının görebiliriz.

Uygulamamızın VS Code ile birlikte açılması için (F5) ve uygulamamızı debug edebilmek için launch.json ve tasks.json dosyalarının oluşturulmasına ihtiyacımız vardır. Bu dosyaları oluşturmak için VS Code’un bir özelliğini kullanabiliriz. Bunun için projemizin olduğu klasörü VS Code ile yeniden açmamız gerekmektedir. VS Code projemizi kontrol edecek ve bize gerekli dosyaların oluşturulup oluşturamayacağının soracaktır. Oluşturulan dosya örneklerini aşağıda bulabilirsiniz.

Artık Run menüsünde bulunan Start Debugging komutu ile de projemizi çalıştırma imkanına sahip olmaktayız. Böylelikle projemiz içerisinde break point’ler kullanarak projemizi debug edebiliriz.

tasks.json ve launch.json dosyalarının VS Code üzerinden oluşturmak istersek;

Komut panelini açtıktan sonra (Ctrl + Shift + P) ardından palet içerisinden Tasks: Configure Task komutunu seçmemiz gerekmektedir. Ardından Create tasks.json file from template komutu ve gelen liste üzerinden .NET Core seçmemiz yeterli olacaktır.

launch.json dosyası için de sol bölümde bulunan Run (Ctrl + Shift + D) ekranından create a launch.json file seçeneğini seçmemiz yeterli olacaktır. Ardından projemizi çalıştırabilir ve debug işlemlerimizi yapabiliriz.

Bir başka makale ile yeniden görüşmek üzere.

Nedir Bu Microsoft .NET Core ?

İşletim sistemleri, yazılım geliştiriciler açısından hem yarar hem de zarar sağlamıştır. Geliştirilen uygulamanın x86 ve x64 platformlarda bile farklı çalışması yıllardan beri yazılım geliştiriciler için bir engel olarak karşımıza çıkmıştır. “Aynı dili kullanarak birden fazla platforma yazılım geliştirmek.” her zaman istenilen bir özellik olarak öne çıkmıştır. İlk olarak Java tabanlı uygulamaların platform bağımsız çalışma özellikleri (applet vs.) yazılım teknolojilerinde bir farklılık getirdikten sonra geçen yıllarda son olarak .NET Core platformu ile Microsoft önemli gelişmeler kaydetti.

Microsoft yıllar boyunca öncelikle platform bağımsız bir yazılım dilinin çalışmalarını yaptı. En önemli gelişmelerden biri Mono ile birlikte geldi. Daha sonrasında Azure (Linux makinelerin kurulabilmesi) ve Xamarin ile birlikte son noktada .NET Core ortaya çıktı. Yazılımcıların temel ihtiyaçlarından biri olan platform bağımsız bir şekilde geliştirme yapma hayali böylelikle gerçekleşmiş oldu. Tek cümle ile açıklamak gerekirse .NET Core modern web uygulamaları, servisler, kütüphaneler, masaüstü uygulamalar ve konsol uygulamaları geliştirmek için kullanılan açık kaynak kodlu ve platform bağımsız (cross-platform) bir .NET platformudur.

27 Haziran 2016 yılında 1.0 ile hayatımıza giren .NET Core platformu yenilikçi yaklaşımı ile şu an için yazılımcıların büyük kısmının ihtiyaçlarını çözen bir durumdadır. Şu an .NET Core 2.1 versiyonu ile yayında olan platform yeni özellikleri ile bundan sonra uzun süreler boyunca kullanılacak olan popüler bir platform olmaya devam edecektir. Microsoft üzerinden .NET Core bilgilerine buradan ulaşabilirsiniz.

En önemli özellik olarak Windows, Linux, MacOS işletim sistemlerinde ve .NET Core destekleyen cihazlar, gömülü sistemler (IoT) ve bulut platformlarında (Azure) çalışabilme özelliğine sahiptir.

Aşağıda .NET Core platformunu destekleyen işletim sistemlerini görebilirsiniz.

Windows Client / 7 SP1+, 8.1 / x64, x86
Windows 10 Client / Version 1607+ / x64, x86
Windows Server / 2008 R2 SP1+ / x64, x86
Mac OS X /10.12+ / x64
Red Hat Enterprise Linux / 6 / x64
Red Hat Enterprise Linux / 7 / x64
CentOS / 7 / x64
Oracle Linux /7 / x64
Fedora / 27, 28 / x64
Debian / 9, 8.7+ / x64, ARM32*
Ubuntu / 18.04, 17.10, 16.04, 14.04 / x64, ARM32*
Linux Mint / 18, 17 / x64
openSUSE / 42.3+ / x64
SUSE Enterprise Linux (SLES) / 12 SP2+ / x64
Alpine Linux / 3.7+ / x64

.NET Core’un temel özelliklerin göz atarsak;

• Platform bağımsız çalışma (Cross-Platform): Windows, Linux ve MacOS işletim sistemleri ve .NET Core destekleyen ortamlarda çalışabilmektedir.
• Komut satırı aracı (Command-line tools): .NET Core ile birlikte gelen CLI aracı ile yeni proje oluşturmak, derleme ve yaygınlaştırma işlemlerini rahat bir şekilde yapabilme olanağı sağlar.
• Uyumluluk (Compatible): .NET Standard platformu ile birlikte .NET Framework, Mono ve Xamarin ile uyumlu bir şekilde çalışabilmektedir.
• Açık kaynak kod (Open Source): .NET Foundation projesi olan .NET Core açık kaynak kod olması sebebi ile hızlı bir gelişim sürecine de tabii konumdadır. Github üzerinden tüm yazılımcıların yorumları ve istekleri doğrultusunda geliştirilmeye devam etmektedir.
• Esnek yaygınlaştırma (Flexible deployment): .NET Core ile geliştirdiğimiz uygulamamızın yaygınlaştırılması açısından kolaylıklar sağlamaktadır. Platform bağımsız çalışma özelliği ile her ortamda birbirine yakın yaygınlaştırma özellikleri ile de karışıklığı önlemektedir.

.NET Core tıpkı .NET Framework gibi temel bileşenlere sahiptir. Bu bileşenler;

• .NET Runtime: Garbage collector, type system ve temel servislerin dahil olduğu bileşendir.
• .NET Framework Kütüphaneleri: Temel ve karmaşık değişken tiplerini ve diğer servisleri içeren yapıdır.
• .NET Core SDK: Dil derleyicilerini içeren ve uygulamaların çalışmasından önceki işlemleri gerçekleştiren bileşendir.
• .NET Core App Host: .NET Core projelerinin çalışması için gerekli olan alt yapıyı sunmaktadır.

.NET Core Mimarisine bir göz atacak olursak. .NET Core mevcutta şimdiye kadar kullandığımız .NET Framework’ten farklı ve ayrık bir yapıda çalışmaktadır. Bu da bize platform bağımsız bir yazılım geliştirme ortamının kapılarını açmaktadır. Yeni bir framework ve yeni bir yapı ile .NET Core ile geliştirilen uygulamaların performans ve yapılarında büyük gelişmeler olmuştur.

.NET Core ile daha hafif ve hızlı bir framework;

.NET Core, .NET Framework’e göre daha hafif ve daha hızlı bir yazılım geliştirme ve daha performanslı bir uygulama işletimi sağlamaktadır. (%2300 daha fazla saniyede karşılanan istek sayısı)

ASP.NET Core MVC’yi varsayılan olarak kullanmaktadır.

Daha önceleri Web Forms ile geliştirdiğimiz uygulamalarımızı artık ASP.NET MVC ile geliştirmekteyiz. (Web Forms’tan kopamadığımız projelerimizin olmadığını düşünerek) Daha önceden hem WEb Forms hem de MVC’yi destekleyen ASP.NET yerine ASP.NET Core sadece MVC desteği sunmaktadır. Hem MVC yapısının hızı hem de .NET Core alt yapısının sunduğu hız düşünüldüğü zaman uygulamaların performansında büyük artışlar sağlanmaktadır.

Web API ve MVC yapılarının beraber sunulması ile birlikte geliştirdiğimiz web servislerimizin temiz ve anlaşılabilir kod yapılarına sahip olması ve uygulama performanslarında artış vazgeçilemez bir hal almaktadır.

ASP.NET Core projeleri NPM (Node Package Manager) desteği sunmaktadır.

Daha önceden de ASP.NET MVC5 ile birlikte kullanılabilen bir yapı aslında NPM. Fakat bu yapıyı kullanabilmek için belirli konfigurasyonları yapmamız gerekmekteydi. Artık ASP.NET Core projelerinde bu desteği hazır halde bulabiliyoruz. Angular için de destek mevcut 🙂

ASP.NET Core kendi “Dependency Injection” yapısını sunmaktadır.

Daha önceden DI/IoC yapılarını kullananlar için (anlatmak için bir makale yazmayı düşünüyorum) bu yapıları kurmak biraz zahmetli olmaktaydı. (Ninject, Unity Container) Fakat .NET Core ile birlikte bu biraz değişti. ASP.NET Core projeleri kendi içlerinde hazır halde bir DI/IoC yapısını geliştiricilere sunmaktadır. DI/IoC yapılarını kullanmak için sunulan rahatlık da ayrı bir güzel diye düşünüyorum. ASP.NET Core Web uygulamamızda çok büyük konfigurasyonlar yapmadan tüm controller ve repository yapılarımızda bu özelliği kullanabiliyoruz.

public void ConfigureServices(IServiceCollection services)
{
    services.ConfigureCors();
    services.ConfigureIISIntegration();
    services.ConfigureLogggerService();
    services.ConfigureMySqlContext(Configuration);
    services.ConfigureRepositoryWrapper();
    services.AddMvc();
}

Böylelikle daha ayrık yapılara sahip (loosely coupled), temiz ve anlaşılabilir yapılar kurarak uygulamalarımızı geliştirebiliriz.

Evet, genel olarak .NET Core nedir ? nasıldır ? konularına değinmeye çalıştık. Devamında ise proje tiplerine ve örnek projelere bakıyor olacağız.

SPFieldLookupValue Unable to cast object of type ‘System.String’ to type ‘Microsoft.SharePoint.SPFieldLookupValue’. hatası

Visual Web Part geliştirirken SPFieldLookupValue kullanımında yukarıdaki hatayı alıyorsanız birde şu şekilde deneyin:

 

SPFieldLookupValue _gelendeger = new SPFieldLookupValue(items1[items1.Fields.GetFieldByInternalName(“Sablon_x0020_Tipi”).Title].ToString());

Sharepoint 2010 Caml Query Distinct Olayları

Caml Query ile Distinct alamamaktayız fakat iki datatable ile bu işi çözebiliyoruz.Burada önemli nokta camlquery içerisinde order by aldığımız alanı (ki bu distinct edilecek alan) dizi içerisinde tanımlayarak iki datatable içerisinde döndürmek.

using (SPSite sp = new SPSite(“http://sp2010dev/site”))

{

using (SPWeb web = sp.OpenWeb())

{

SPQuery query = new SPQuery();

query.Query = string.Concat(

“<Where><And><And><Eq><FieldRef Name=’Portfoy_x0020_Tipi’ LookupId=’True’ />”,                   “<Value Type=’Lookup’>”+yapitipiID+”</Value></Eq><Eq><FieldRef Name=’Sat_x0131__x015f__x0020_Tipi’ LookupId=’True’ /><Value Type=’Lookup’>”+satistipiID+”</Value>”,                   “</Eq></And><Neq><FieldRef Name=’Portfoy_x0020_Detay_x0020_S_x013′ LookupId=’True’ /><Value Type=’Lookup’>14</Value>”,                   “</Neq></And></Where><OrderBy><FieldRef Name=’Portfoy_x0020_Detay_x0020_S_x013′ /></OrderBy>”

);

string listUrl = web.ServerRelativeUrl + “/Lists/Portfoy_Detay_Sablon”;

SPList list = web.GetList(listUrl);

DataTable dtbl = list.GetItems(query).GetDataTable();

DataView dv = new DataView(dtbl);

string[] columns = { “Portfoy_x0020_Detay_x0020_S_x013” };

DataTable tbl = dv.ToTable(true, columns);

foreach (DataRow item in tbl.Rows)

{

foreach (DataColumn dc in tbl.Columns)

{

string aaa = item[dc].ToString();

}

}

}

}