In this example, a new task is created using the Task.Run() method, which accepts a delegate that performs an operation asynchronously. The Result property of the task is used to wait for the task to complete and get the result.

The System.Threading.Tasks namespace provides a powerful toolset for writing asynchronous code in C#. With these classes and interfaces, you can create efficient and responsive applications that utilize system resources more effectively.

var webSocketListener = new HttpListener(); komutu, sunucu tarafındaki WebSocket özelliği için HTTP isteklerini dinlemek için kullanılır. Bu özellik aynı zamanda gelen bağlantıları kabul etmek için de kullanılabilir. Sunucu tarafı, HttpListener sınıfını kullanarak bir HTTP adresini dinleyebilir ve gelen bağlantılar WebSocket sunucusuna bağlanır. Bu özellik sayesinde, sunucu istekleri dinleyebilir ve gerekli eylemleri gerçekleştirebilir.

HttpListener sınıfı, sunucu tarafında oluşturulması gereken birkaç sınıftan biridir. Sunucu tarafının hazırlanması için ayrıca WebSocket sınıfı kullanılmalıdır. WebSocket sınıfı, istemciden gelen isteklerin yanıtlanmasını ve iletilen mesajların alınmasını sağlar. Bir HTTP bağlantısının kurulabilmesi için öncelikle sunucunun HTTP isteklerini dinleyebilmesi gerekir. var webSocketListener = new HttpListener(); ile sunucu, istekleri dinleyebilir ve istemci ile iletişime geçebilir.

WebSocket teknolojisi sayesinde anında bildirimler göndermek, web uygulamaları için oldukça önemlidir. Bu amaçla .NET Core kullanılarak da bu işlem gerçekleştirilebilir. Sunucu tarafında WebSocket kullanarak HTTP istekleri alınmasını sağlayan bir yapı, istemci tarafında ise WebSocket özelliğini kullanarak verilerin alınmasını sağlayan bir program oluşturulabilir.

Sunucu tarafında WebSocket özelliğini kullanarak HTTP isteği elde etmek için webSocketListener.Prefixes.Add() yöntemi kullanılabilir. Bu yöntem ile HTTP isteği alınacağı adres belirtilir. Oluşturulan HTTP dinleyicisi, gelen talepleri doğru şekilde yönlendirir ve bağlantı kurulması sağlanabilir.

using System.Net;using System.Net.WebSockets;using System.Threading;using System.Threading.Tasks;var webSocketListener = new HttpListener();webSocketListener.Prefixes.Add(    http://localhost:8080/);webSocketListener.Start();while(true) {    HttpListenerContext context = await webSocketListener.GetContextAsync();    if (context.Request.IsWebSocketRequest) {        var webSocket = await context.AcceptWebSocketAsync(subProtocol: null);        // WebSocket işlemleri yapılır    }    else {        context.Response.StatusCode = 400;        context.Response.Close();    }}

Bu kod örneğiyle sunucu tarafında HTTP istekleri dinlenir ve WebSocket istemcisinin bağlanması için gerekli olan tüm adımlar atılır. Bu sayede sunucu tarafındaki WebSocket yapısı hazır hale gelir ve istemci tarafından gelen bildirimler doğru şekilde iletilir.

Bir WebSocket sunucusu oluşturmak için, öncelikle HttpListener sınıfını kullanarak bir HTTP adresi dinleyen bir kaynak oluşturmanız gerekmektedir. Sunucu tarafı kodlarını oluşturduktan sonra, istemci tarafında WebSocket özelliğini kullanarak sunucuya bağlanabilirsiniz.

Örnek olarak, sunucu tarafında kullanılacak WebSocket kodları aşağıdaki şekilde olabilir:

Sunucu tarafı hazır olduktan sonra, istemci tarafında WebSocket bağlantısı kurmak için System.Net.WebSockets isim alanından oluşturulacak bir istemci kullanılabilir. Örnek kodlar aşağıdaki gibidir:

Bu şekilde, WebSocket teknolojisi kullanılarak http://localhost:8080/ adresinde bir websocket sunucusu oluşturulmuş ve istemci tarafında bağlantı kurularak gerçek zamanlı veri iletimi sağlanmıştır.

Bu makalede, WebSocket teknolojisi ve .NET Core kullanarak nasıl anlık bildirimler gönderilebileceği hakkında detaylı bilgi verilmiştir. WebSocket, gerçek zamanlı veri iletimi için oldukça faydalıdır ve .NET Core tarafından sunulan WebSocket özelliği, projelerde kullanımı oldukça kolay hale getirilmiştir. WebSocket sunucusu ve istemci tarafı oluşturulması gerekmekte ve bağlantının kurulması için HTTP bağlantısı kullanılmaktadır. WebSocket ve .NET Core'u kullanarak anlık bildirimler gönderebileceğiniz öğrendiniz.

WebSocket sunucusunun çalışması için webSocketListener.Start() metodu çağrılmalıdır. Bu metod, sunucunun HTTP isteklerini dinlemeye başlar ve gelen istekleri WebSocket protokolüyle dinlemeye hazır hale getirir. Daha sonra, sunucu WebSocket isteklerini dinlemeye hazır hale gelir ve gelen bağlantıları kabul etmeye başlar.

Bu metodu çağırmadan önce, HttpListener örneğinin doğru yapılandırıldığından emin olmak önemlidir. Prefixes özelliği, sunucunun dinleyebileceği HTTP adresini belirlemek için kullanılabilir. Örneğin, webSocketListener.Prefixes.Add("http://localhost:8080/") kullanarak sunucuyu "localhost" adında ve 8080 numaralı portta dinlemeye başlayabilirsiniz.

Ayrıca, bu metot çağrıldığında sunucunun durumunda bir değişiklik olur. Artık, sunucu belirtilen adreslerde HTTP isteklerini dinleyebilir ve WebSocket isteklerini kabul edebilir. Bu nedenle, webSocketListener.Stop() yöntemi çağrılmadan önce webSocketListener.Start() yöntemi kullanılmak zorundadır.

WebSocket kullanımı aslında oldukça basittir. WebSocket sunucusunu oluşturmak için ilk adım, bir HTTP isteği elde etmektir. Bu amaç için HttpListener sınıfı kullanılabilir. Ardından, gelen bağlantılar WebSocket sunucusuna kabul edilir.

Bununla birlikte, sunucu tarafında birkaç konfigürasyon yapmanız gerekmektedir. WebSocket sınıfını kullanarak, sunucu tarafında bir bağlantı başlatmanız gerekmektedir. Ardından, gelen bağlantıların dinleneceği bir HTTP adresi ayarlamalısınız. Herhangi bir uygun port numarası belirleyebilirsiniz.

Aşağıdaki örnek kodda, sunucu ve istemci tarafında kullanılabilecek bir yapının oluşturulması gösterilmektedir:

while(true) {    HttpListenerContext context = await webSocketListener.GetContextAsync();    if (context.Request.IsWebSocketRequest) {        var webSocket = await context.AcceptWebSocketAsync(subProtocol: null);        // WebSocket işlemleri yapılır    }    else {        context.Response.StatusCode = 400;        context.Response.Close();    }}

ClientWebSocket webSocketClient = new ClientWebSocket();await webSocketClient.ConnectAsync(new Uri(ws://localhost:8080/), CancellationToken.None);byte[] buffer = new byte[1024];var result = await webSocketClient.ReceiveAsync(new ArraySegment(buffer), CancellationToken.None);

WebSocket kullanarak anlık bildirimler göndermek oldukça popülerdir ve WebSocket, gerçek zamanlı iletişim gerektiren projeler için oldukça faydalıdır. .NET Core tarafından sunulan WebSocket özelliği, bağlantıyı kurmak oldukça kolaydır ve sunucu ve istemci tarafında kullanılabilir. Bu nedenle, .NET Core kullanarak anlık bildirimler gönderme konusunda oldukça esnek bir seçenek sunar.

HttpListenerContext context = await webSocketListener.GetContextAsync(); kod satırı, sunucu tarafında HTTP istekleri alındığında gerçekleştirilen işlemleri kapsar. Bu satır, sunucu üzerinde yeni bir HTTP isteği yapıldığında, istemci ve sunucu arasındaki iletişimi başlatmak için gelen bağlantının kabul edilmesini sağlar. Bu bağlantı gerçek zamanlı veri iletimini sağlamak amacıyla WebSocket ile bağlanacaktır, bu nedenle önce bir HTTP bağlantısı kurulması gereklidir.

Eğer HTTP isteği bir WebSocket isteği ise, sunucu tarafında IsWebSocketRequest özelliği kullanılarak kontrol edilir. WebSocket isteği kabul edilir ve gelen bağlantılar WebSocket sunucusuna bağlanır.

Burada kullanılan HttpListener sınıfı, belirtilen URL'yi dinler ve gelen bağlantıların WebSocket sunucusuna bağlanmasını sağlar. Bu sayede sunucu tarafında WebSocket iletişimi için gerekli ayarlamalar yapılır.

WebSocket işlemleri yapmak için, ClientWebSocket sınıfı kullanılabilir. Sunucu tarafı ile aynı protokol ile WebSocket istemcisi oluşturulur ve iletişim başlatılır. Sunucu tarafından gönderilen veriler de istemci tarafında kullanılabilir.

WebSocket protokolü sayesinde, .NET Core ile anlık bildirimler göndermek oldukça kolaydır. Bu makalede, sunucu tarafında yer alan kod örneği sayesinde, WebSocket sunucusu ve istemci arasındaki bağlantı başlatıldıktan sonra, bağlantıyı kabul eden kod parçası olan “var webSocket = await context.AcceptWebSocketAsync(subProtocol: null);” incelenecektir.

Bu kod parçası, sunucunun istekleri dinlerken, HTTP isteğiyle birlikte bağlantıyı kurmak isteyen bir istemcinin bağlantı isteğini kabul etmektedir. Bu kabul işlemi sonucunda, sunucu tarafında WebSocket örneği oluşmaktadır ve bu örnekle birlikte iletişim kurulabilir.

WebSocket bağlantısı kurulduktan sonra, iletişimin gerçekleştirilmesi için belirli işlemler yapılması gerekmektedir. WebSocket ile gönderilebilecek veri türleri arasında metin, binary, JSON, XML v.b. gibi veri türleri yer almaktadır. Bu veri türleri gönderilirken, belirli protokoller kullanılarak gönderim gerçekleştirilir.

WebSocket üzerinden veri göndermek için çeşitli gönderim metodları mevcuttur. Bunlar; SendAsync, SendAsyncReadOnlyMemory, SendAsyncArraySegment, SendStringAsync metodları olabilir. Bu metodlardan dilediğiniz kullanarak veri gönderimi yapabilirsiniz.

```csharpawait webSocket.SendAsync(new ArraySegment(buffer, 0, result.Count), WebSocketMessageType.Binary, true, CancellationToken.None);```

WebSocket üzerinden gönderilen veri karşı tarafta alınırken, belirli metodlar kullanılarak alınabilir. Alınan veri türüne göre farklı metodlar kullanılır. Bu metodlar; ReceiveAsync, ReceiveAsyncArraySegment, ReceiveAsyncMemory, ReceiveStringAsync metodları olabilir. Bu metodlardan dilediğiniz kullanarak alınan veri türüne göre işlemler yapabilirsiniz.

```csharpbyte[] buffer = new byte[1024];var result = await webSocket.ReceiveAsync(new ArraySegment(buffer), CancellationToken.None);```

WebSocket kullanarak gerçek zamanlı veri gönderimi yapmak oldukça kolaydır. .NET Core üzerinde WebSocket özelliği sayesinde, basitçe bir sunucu kurup, istemci bağlantısı oluşturduktan sonra, anında bildirimler göndermek mümkündür.

WebSocket kullanarak anlık bildirimler göndermek için birkaç adımı takip etmeniz gerekmektedir. Öncelikle sunucu tarafında HttpListener sınıfıyla bir HTTP adresi dinlenir ve gelen bağlantılar WebSocket sunucusuna bağlanır. Daha sonra, istemci tarafında ClientWebSocket sınıfı kullanılarak WebSocket istemcisine bağlanılır. Aşağıdaki kod örnekleri ile WebSocket kullanarak anlık bildirimler göndermeniz mümkün hale gelir:

'else' bloğu, sunucu tarafından gelen isteklerde WebSocket protokolünün kullanılmadığı durumlarda çalışır. Bu blok, 'if' bloğunun tamamlayıcısıdır ve HTTP hatası durumunda çalışır. 400 kodu, istek yapan sunucuya isteğin geçersiz olduğunu bildirir ve işlem sonlandırılır. Bu durum, WebSocket kullanılmayan normal HTTP isteklerinde meydana gelebilir.

Bir HTTP bağlantısına yanıt olarak, sunucunun cevap kodunu ayarlama ihtiyacı olabilir. Bu kodlar, istemciye sunucu tarafındaki olayların bir özetini sunabilir. Ayrıca, hata ayıklama yapmak istediğimizde de kullanışlı olabilirler. Örneğin, 400 Bad Request kodu, istemci tarafındaki bir problemin olduğunu ve isteğin sunucu tarafından anlaşılmadığını belirtir.

context.Response.Close(); komutu, istemci tarafından gönderilen talebi sonlandırır. Bu komut, sunucu tarafından kullanıldığında, istemciye bir yanıt döndürülür ve bağlantı sonlandırılır. Bu işlem, gereksiz kaynak tüketimini önlemek ve sunucu kaynaklarını açmak için önemlidir.

Kod örneği bölümleri oldukça önemlidir. Öğrenilen bilgilerin tam olarak kavranması ve hemen uygulamaya geçilebilmesi için kod örnekleri yazmak oldukça faydalıdır. Örnekler, öğrenilen konunun somut bir şekilde uygulanmasını sağlayarak öğrenmeyi pekiştirir. Dolayısıyla, bu makalede de kod örneklerine yer verilmiştir. Kod örneklerinde anlatılanlar, ayrıntılı şekilde açıklanarak her adımın anlaşılabilir olması hedeflenmiştir.

Sunucu tarafında, WebSocket özelliğini kullanarak bir HTTP isteği elde etmek gerekmektedir. Bazı sınıflar oluşturmanız gerekecektir. WebSocket sınıfı sunucu tarafından kullanılmaktadır. HttpListener sınıfıyla bir HTTP adresi dinlenir ve gelen bağlantılar WebSocket sunucusuna bağlanır. Bu ayarlamaları yaptıktan sonra, sunucu tarafında WebSocket özelliklerini kullanarak anlık bildirimler gönderebilirsiniz.

      using System.Net;    using System.Net.WebSockets;    using System.Threading;    using System.Threading.Tasks;    var webSocketListener = new HttpListener();    webSocketListener.Prefixes.Add("http://localhost:8080/");    webSocketListener.Start();    while(true) {        HttpListenerContext context = await webSocketListener.GetContextAsync();        if (context.Request.IsWebSocketRequest) {            var webSocket = await context.AcceptWebSocketAsync(subProtocol: null);            // WebSocket işlemleri yapılır        }        else {            context.Response.StatusCode = 400;            context.Response.Close();        }    }  

Sunucu tarafında, WebSocket özelliğini kullanarak bir HTTP isteği elde etmek gerekmektedir. Oluşturulması gereken sınıflar arasında WebSocket sınıfı sunucu tarafından kullanılırken, HttpListener sınıfıyla bir HTTP adresi dinlenir ve gelen bağlantılar WebSocket sunucusuna bağlanır. Aşağıdaki tabloda, WebSocket sunucusu tarafında kullanılan sınıfların açıklamaları verilmiştir.

WebSocket sunucusu, HTTP bağlantısını WebSocket protokolüne geçirmek için kullanılan bir anahtarlama protokolü sunar. Aşağıdaki kod örneği, sunucu tarafında WebSocket özelliğinin kullanımını göstermektedir.

  using System.Net;using System.Net.WebSockets;using System.Threading;using System.Threading.Tasks;var webSocketListener = new HttpListener();webSocketListener.Prefixes.Add("http://localhost:8080/");webSocketListener.Start();while(true) {    HttpListenerContext context = await webSocketListener.GetContextAsync();    if (context.Request.IsWebSocketRequest) {        var webSocket = await context.AcceptWebSocketAsync(subProtocol: null);        // WebSocket işlemleri yapılır    }    else {        context.Response.StatusCode = 400;        context.Response.Close();    }}  

İstemci Tarafı Ayarları

.NET Core kullanarak WebSocket özelliğini kullanmak isteyenler, istemci tarafında da WebSocket özelliği için System.Net.WebSockets isim alanından öğeler kullanmaları gerekmektedir. Bu öğeleri kullanarak, WebSocket istemcisine bağlanan bir program yazabilirsiniz. Aşağıdaki örnek kodda WebSocket istemcisine bağlanmak için gereken adımlar gösterilmiştir:

using System.Net.WebSockets;using System.Threading.Tasks;using System.Threading;ClientWebSocket webSocketClient = new ClientWebSocket();await webSocketClient.ConnectAsync(new Uri(ws://localhost:8080/), CancellationToken.None);byte[] buffer = new byte[1024];var result = await webSocketClient.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

Bu kod örneği, istemcinin WebSocket sunucusuna bağlantı kurmasını ve sunucunun gönderdiği veriyi okumasını sağlar. WebSocket istemcisine özgü özellikler, System.Net.WebSockets isim alanında bulunmaktadır ve bu özelliklerin kullanımı oldukça basittir. İstemci tarafında gereken yapılandırma adımları tamamlandıktan sonra, sunucu tarafından gönderilen veriler anlık olarak güncellenir.

Kod Örneği

```csharp
using System.Net;
using System.Net.WebSockets;
using System.Threading;
using System.Threading.Tasks;
var webSocketListener = new HttpListener();
webSocketListener.Prefixes.Add("http://localhost:8080/");
webSocketListener.Start();
while(true) {
    HttpListenerContext context = await webSocketListener.GetContextAsync();
    if (context.Request.IsWebSocketRequest) {
        var webSocket = await context.AcceptWebSocketAsync(subProtocol: null);
        // WebSocket işlemleri yapılır
    }
    else {
        context.Response.StatusCode = 400;
        context.Response.Close();
    }
}
```

Yukarıdaki örnekte, sunucu tarafı için HttpListener sınıfı kullanılmaktadır. Kod, istekleri dinlemek üzere bir HTTP adresi ayarlar ve gelen bağlantıları WebSocket sunucusuna yönlendirir. İstemci tarafında ise ClientWebSocket sınıfıyla WebSocket istemcisine bağlanılır. Bu sayede, iki yönlü iletişim sağlanarak gerçek zamanlı veri akışı mümkün hale gelir.

WebSocket, gerçek zamanlı iletişimi mümkün hale getiren bir ağ protokolüdür. .NET Core tarafından kullanılan WebSocket özelliği için de System.Net.WebSockets isim alanından yararlanılır. System.Net.WebSockets, .NET Core tarafından desteklenen birkaç farklı WebSocket sınıfı ve öğesi içermektedir.

WebSocket sınıfı, sunucu tarafında kullanılır ve System.Net.WebSockets isim alanında bulunur. İstemci tarafında ise ClientWebSocket sınıfı kullanılır. Bu sınıf, WebSocket sunucularına bağlanmak için kullanılır.

System.Net.WebSockets ayrıca WebSocket özelliğini kullanarak veri iletimi için de birkaç özellik ve yapı içermektedir. WebSocketReceiveResult sınıfı, istemci veya sunucu tarafındaki veri alımını yönetir. WebSocketState, WebSocket bağlantısının durumunu takip etmek için kullanılır. WebSocketException sınıfı, olası hatalar için bir hata iletisi döndürür.

Sistemin çalışmasını izlemek ve işlemlerle etkileşim kurmak için System.Threading.Tasks (Görevler) sınıfı kullanılır. Bu sınıf, bir iş parçacığının ardışık olarak birçok işlemi yapmasını önlüyor ve sistem kaynaklarının daha etkili bir şekilde yönetilmesini sağlıyor. Bu sınıf, sunucu tarafında web sayfalarının paralel yüklenmesi veya hesaplama yoğunluğu olan işlemlerin daha hızlı yapılması gibi alanlarda önemli bir rol oynamaktadır.

System.Threading.Tasks sınıfı, System.Threading.Tasks.Task sınıfı tarafından yönetilir. Task nesneleri, senkronizasyon nesneleri veya başka Task nesneleriyle ilişkili olabilir. Ayrıca, TaskFactory sınıfı da birçok farklı görevi oluşturmak ve ağaç yapısı oluşturmak için kullanılabilir. Görevler, ilgili işlem bitene kadar bekleyebilir ve bir sonraki işlem yapılana kadar sistem kaynaklarını boşaltabilir.

System.Threading.Tasks sınıfı, uygun bir yöntemle kullanıldığında iyi bir çok görevli bir uygulama için önemli bir performans ve kullanılabilirlik avantajı sunar. Aynı zamanda, programlama hatalarını sınırlamak ve kimlik doğrulama ile ilgili sorunları gidermek için özelleştirilmiş eylemler de kullanabilirsiniz.

Bu sınıfın en yaygın kullanım alanlarından biri, iş parçacığı anahtarının değiştirilmesini gerektirecek uzun çalışma süreleri için Task sınıfını kullanmaktır. Örneğin, bir veri kaynağından veri okumanız gerekiyorsa ve bu veriler, bir kullanıcının beklemek için çok uzun süreler de sorgulanması gerekiyorsa, Task sınıfı yardımıyla asenkron bir işlem gerçekleştirebilirsiniz. Ayrıca, Task sınıfı, kullanıcılara paralel ve eş zamanlı bir olayın yönetilmesinde de yardımcı olabilir.

System.Threading, .NET Core'daki çoklu iş parçacığı desteğini sağlamak için kullanılan bir işlem kitaplığıdır. Bu kitaplık, zamanlayıcılar ve süreçler oluşturma, senkronize etme, iş parçacığı havuzları yönetme ve diğer çoklu iş parçacığı görevlerini gerçekleştirmek için kullanılır.

System.Threading.Tasks isim alanında, geçerli işlemi temsil eden bir Task sınıfı bulunur. Bu sınıf, async/await anahtar kelimeleri kullanılarak ve CancellationToken parametresiyle birlikte kullanılabilir. CancellationToken, işlemi iptal etmek için kullanılır.

Aşağıdaki kod örneğinde, Task sınıfı kullanılarak senkronize Sonraki(List<int> numbers) metodu oluşturulmuştur. Method adı, "numbers" listesindeki her sayıyı bir sonraki sayıyla toplar:

public static async Task<List<int>> Sonraki(List<int> numbers, CancellationToken cancellationToken){  var sonuclar = new List<int>();  for (var i = 0; i < numbers.Count; i++)  {    await Task.Delay(1000, cancellationToken);    sonuclar.Add(numbers[i] + 1);  }  return sonuclar;}

Yukarıdaki örnekte olduğu gibi, CancellationToken kullanarak bir işlemi iptal etmek mümkündür. İptal sinyali, CancellationTokenSource örneği kullanılarak üretilir. Bu nesne, CancellationToken nesnesi tarafından beklenen sinyali üretir.

Bu nedenle, System.Threading ve System.Threading.Tasks isim alanları, aynı anda birden fazla işlemi yönetmek için çok kullanışlıdır.

İstemci tarafında WebSocket özelliğini kullanmak için System.Net.WebSockets isim alanından ClientWebSocket sınıfı kullanılabilir. İstemci örneği oluşturmak ve sunucuya bağlanmak için ConnectAsync yöntemi kullanılabilir. Aşağıdaki kod örneği, WebSocket istemcisine nasıl bağlanılacağını göstermektedir.

using System.Net.WebSockets;using System.Threading.Tasks;using System.Threading;ClientWebSocket webSocketClient = new ClientWebSocket();await webSocketClient.ConnectAsync(new Uri(ws://localhost:8080/), CancellationToken.None); byte[] buffer = new byte[1024]; var result = await webSocketClient.ReceiveAsync(new ArraySegment(buffer), CancellationToken.None); 

ClientWebSocket sınıfı, istemci tarafında WebSocket özelliklerini kullanmanıza izin verir. Bağlantıyı kurmak için ConnectAsync yöntemi kullanılır. Daha sonra, gelen verileri okumak için ReceiveAsync yöntemi kullanılabilir. Bu yöntem, belirtilen bir arabelleğe veri yazacaktır. Gelen verileri okumak için bu arabellek kullanılabilir.

WebSocket teknolojisi sayesinde .NET Core ile anlık bildirimler göndermek oldukça kolaydır. WebSocket kullanıcıları, gerçek zamanlı veri iletimi sağlamak için tasarlanmıştır. Bu nedenle, sunucu ve istemci arasındaki iletişimin başlaması için bir HTTP isteği yapılması gerekir. WebSocket'in .NET Core ile kullanımı için öncelikle sunucu tarafında bir HTTP dinleyicisi ve istemci tarafında bir WebSocket öğesi oluşturmanız gerekir. Bu sayede gerçek zamanlı veri iletimi oldukça kolaylaşır.

WebSocket istemcisi tarafında, await webSocketClient.ConnectAsync(new Uri(...)) komutunu kullanarak istemci sunucuya bağlanır. Komut yeni bir URI oluşturabilir, sunucu kabul edildiğinde URI bağlantı noktasının açıldığından ve WebSocket ile bağlantı sağlandığından emin olur. Burada kullanılan CancellationToken.None, işlemin iptalinde kullanılır.

ws://localhost:8080/, WebSocket protokolünün kullanılmasıyla sunucu ve istemci arasındaki iletişimin sağlanacağı adresi belirtir. Bu adres, sunucu tarafında belirtilen prefix değerine bağlı olarak belirlenir. İstemci, bağlantı kurmak istediği sunucunun WebSocket adresini ws:// veya wss:// ön eki ile belirtir. Bu ön ek, protokolün kullanılacağı bilgisini ifade eder.

ws://localhost:8080/ adresi, örnek bir adres olup, kullanılacak olan sunucunun adresine göre değişebilir. Öncelikle sunucu tarafında bir HTTP bağlantısı yapılandırıldıktan sonra, bu bağlantı üzerinden WebSocket bağlantısı kurulabilir. İstemci, belirtilen adresi kullanarak sunucuyla bağlantı kurduğunda, gerçek zamanlı veri alışverişi sağlanır.

Kod örneğinde görülen CancellationToken.None parametresi, bağlantınızı durdurmak için kullanabileceğiniz bir belirteçtir. WebSocket bağlantınızı durdurmak için CancelationToken.None yerine ona verilecek olan bir CancellationToken örneği oluşturabilirsiniz. Bu şekilde bağlantınızı istediğiniz zaman durdurabilmeniz mümkün hale gelir.

Kod örneğinde görebileceğiniz gibi, istemci tarafında byte tipinde yeni bir dizi oluşturulmuştur. Bu diziye, ön tanımlı olarak 1024 boyutu verilmiştir. Buffer, gelen verileri depolamak için kullanılır ve WebSocket iletişimi sırasında verileri okumak için kullanılır. İstemci tarafından veri gönderildiğinde, buffer dizisi bu verileri depolar ve sonrasında işlemek için sunucu tarafına gönderilir.

WebSocket yapısı kullanılarak gerçek zamanlı bildirimler göndermek mümkündür. İstemci tarafından bağlanılması sonrasında, web soketi üzerinden veri alışverişi gerçekleştirilebilir. Bu amaçla, WebSocketClient tarafından sağlanan ReceiveAsync fonksiyonu kullanılarak veri akışı yönetimi gerçekleştirilir. ReceiveAsync fonksiyonu, istemci tarafından alınacak olan verilerin okunması ve gerekli işlemlerin yapılması amacıyla kullanılır. Fonksiyon, CancellationToken.None ile belirlenir ve kullanılırken ArraySegment tipinde bir parametre alır. Bu parametre, istemci tarafından alınan verinin nereye yazılacağına dair bilgi içerir.

Bu örnek kodda, web soketi istemcisi tarafından ConnectAsync fonksiyonu kullanılarak sunucuya bağlanılır. Daha sonra ReceiveAsync fonksiyonu kullanılarak veri akışı gerçekleştirilir. var result değişkeni, geri dönen akış verisini tutmak için kullanılır. Alınan veriler, byte tipinde bir diziye yazılır ve kullanılmak üzere hazır hale getirilir.

Sunucu tarafında, WebSocket özelliğini kullanarak bir HTTP isteği elde etmek gerekmektedir. Oluşturulması gereken birkaç sınıf vardır. WebSocket sınıfı sunucu tarafından kullanılmaktadır. HttpListener sınıfıyla bir HTTP adresi dinlenir ve gelen bağlantılar WebSocket sunucusuna bağlanır. WebSocket protokolü, HTTP'den farklı olarak, sunucunun istemciden önceden haber alması ve istek yapması veya veri göndermesi gerektiğinde istemci sunucuya bir istek yapması gerekmediği için daha hızlı bir iletişim sağlar.

Görüldüğü üzere WebSocket API, bağlantı yönetimi ve veri gönderme/alma işlemlerinde kullanılabilecek bir dizi metot sunar.

Sonuç

Bu makalede yer alan bilgiler sayesinde WebSocket protokolünü ve .NET Core kullanarak anlık bildirim göndermenin nasıl mümkün hale getirileceğini öğrendiniz. WebSocket gerçek zamanlı iletişim gerektiren projelerde oldukça faydalı bir teknolojidir. Ayrıca .NET Core tarafından sunulan WebSocket özelliği, hem sunucu hem de istemci tarafında kullanılabiliyor ve bağlantıyı kurmak oldukça kolay. WebSocket kullanarak geliştirilecek projeler, kullanılacakları alanlarda oldukça işlevsel ve etkili olabilirler.