Arama Sonuçları: 'C#'

OAuth, açık-standart yetkilendirme anlamına gelen ve kimlik doğrulama ve yetkilendirme amacı ile kullanılan bir protokol diyebiliriz. Günümüzde web sitelerinde giriş yaparken veya kayıt olurken gördüğünüz Twitter, Facebook, Linkedin vb. kullanarak yap şeklindeki özellikler bunun örneğidir. Bu yazıda da github yetkilendirmesini kullanarak nasıl oauth yapabiliriz onu anlatacağım.

• Github uygulaması oluşturma

Öncelikle Github hesabınıza girerek "Settings/Developer settings" altında yeni bir oauth app oluşturmanız gerekiyor.
devamı için tıklayınız...

Bağlı listeler, dizilerden farklı olarak limitsiz eleman saklamaya yarar. Bağlı listenin başlıca temel özelliklerini aşağıdaki ara yüzde olduğu gibi liste sonuna eleman eklemek, herhangi bir sıradaki elemanı silmek, herhangi bir sıradaki elemanı okuyabilmek, herhangi bir indekse eleman eklemek olarak sayabiliriz. Aşağıdaki gibi bir ara yüzle belirttim:

    public interface ILinkedList<T>
    {
        void Add(T item);
        void Remove(int index);
        T Get(int index);
        void Insert(int index, T item);
        int GetCount();
    }

Bu ara yüzü aşağıdaki gibi Node sınıfını da kullanarak gerçekleştirdim.
devamı için tıklayınız...

Veri yapılarındaki temel öğelerden biri de yığınlardır. Yığınları, tıpkı altı kapalı koliler gibi düşünebiliriz. İlk eklediğiniz nesneyi çıkarabilmek için daha sonra eklediğiniz nesnelerin hepsini önce çıkarmanız gerekir. Özetle, ilk giren son çıkar, son giren ilk çıkar. Yığın için gerçekleştirmemiz gereken ara yüz aşağıdaki gibidir.

    public interface IStack<T>
    {
        void Push(T value);
        T Pop();
    }

Bu arayüzü iki farklı şekilde gerçekleştirebildim.
devamı için tıklayınız...

Veri yapılarının temel elementlerinden kuyruk (queue) elementini C# ile gerçekleştirmek istiyorum. Kuyruk, kuyruğa yeni bir eleman ekleme ve kuyruktan eleman çıkarma gibi 2 temel işleve sahip ve gerçek hayatta olduğu gibi kuyruğa ilk giren eleman ilk, son giren eleman son çıkmalı. Aşağıdaki gibi genel bir ara yüz (generic interface) yazıp gerçekleştirmeye çalıştım.

    public interface IQueue<T>
    {
        T Dequeue();
        void Enqueue(T value);
    }

Bu ara yüzü 2 farklı yaklaşımla gerçekleştirebiliriz:
devamı için tıklayınız...

Nesne yönelimli programlamada, akış zincirindeki hataların yakalanması ve yönetilmesi için metot seviyesinde temelde 2 yöntem mevcuttur. Bunlar:

1. Hata Kodları:

Basit bir örnekle anlatacak olursak,

    public class MethodResult
    {
        public MethodResult() { }

        public MethodResult(int errorCode, string errorMsg)
        {
            ErrorCode = errorCode;
            ErrorMessage = errorMsg;
        }

        public int ErrorCode { get; protected set; }
        public string ErrorMessage { get; protected set; }
        public bool HasError => ErrorCode != 0;
    }

    public class MethodResult<T> : MethodResult
    {
        public MethodResult(int errorCode, string errorMsg)
            : base(errorCode, errorMsg) { }

        public MethodResult(T data)
        {
            Data = data;
        }

        public T Data { get; protected set; }
    }

Yukarıdaki gibi bir sonuç sınıfı kullanarak tüm metot
devamı için tıklayınız...

Impersonation kimliğe bürünme anlamına gelir. Windows Service veya Web uygulaması gibi sistem, IIS veya farklı genel bir kullanıcıya ait olarak çalışan uygulamalar mevcuttur. Bu uygulamalar üzerinden spesifik bir windows kullanıcısı yetkilendirmesi ile işlem yapmak isteyebilirsiniz. Dosya okuma ve yazma buna bir örnektir. Yazmak istediğiniz (ağdaki veya lokal) klasör sadece belli bir kullanıcıya okuma-yazma izni vermiş olabilir ve sizin de o kullanıcı kimliği ile işlem yapmanız gerekebilir. .Net Framework üzerinde bu işi WindowsImpersonationContext ile yapabiliyorduk ancak gördüğüm kadarı ile .Net Core ve sonrası artık bu yapıyı desteklemiyor.

.NetCore platformunda herhangi bir kullanıcıya bürünerek işlem yapabilmek için WindowsIdentity.RunImpersonated metoduna aksiyon (delege) geçebiliyoruz. Ben aşağıdaki gibi bir yardımcı sınıf kullanıyorum.
devamı için tıklayınız...

Diskte yer almayan, diskten okuyamadığımız ya da çalışma sırasında üretilmiş doküman içeriklerini kullanarak sıkıştırılmış doküman oluşturma ihtiyacımız olduğunu varsayıyorum. .Net Core platformunda yer alan System.IO.Compression kütüphanesindeki klasik ZipArchive sınıfını kullanarak ikili veriden (binary data) aşağıdaki gibi bir metod yardımı ile sıkıştırılmış doküman verisi elde edebiliriz. Daha sonra bu veriyi diske yazdırarak diskte zip dokümanı elde edeceğiz.

/// <summary>
/// Compresses file binaries with names and returns zip file binary.
/// </summary>
/// <param name="files">File name and content</param>
/// <returns>Zip binary content</returns>
public static byte[] CompressFiles(Dictionary<string, byte[]> files)
{
  using (var zipArchiveMemoryStream = new MemoryStream())
  {
    using (var zipArchive = new ZipArchive(zipArchiveMemoryStream, ZipArchiveMode.Create, true))
    {
      foreach (var file in files)
      {
        var fileContent = file.Value;
        var fileName = file.Key;
        var zipArchiveEntry = zipArchive.CreateEntry(fileName);
        
        using (var zipArchiveEntryStream = zipArchiveEntry.Open())
        using (var binaryWriter = new BinaryWriter(zipArchiveEntryStream))
        {
          binaryWriter.Write(fileContent);
        }
      }
    }
    
    return zipArchiveMemoryStream.ToArray();
  }
}

Metot basitçe aşağıdaki gibi kullanılabilir. Çalışma zamanı (runtime) esnasında rastgele txt doküman içerikleri oluşturarak ziplenecek dosyalara ekledim.
devamı için tıklayınız...

Fabrika metodu yaratıcı desen grubuna girer. Oldukça yaygın kullanılmaktadır. Amacımız, bir nesneyi tanımlamak için bir arabirim veya soyut sınıf tanımlamak ancak hangi sınıftan nesne oluşturulacağı kararını alt sınıflara bırakmaktır.

Örneğin aşağıdaki gibi soyut bir enstrüman sınıfı ve bu sınıftan türeyen bazı enstrümanları tanımlayalım.

    public abstract class Instrument
    {
        public virtual void Play()
        {
            Console.WriteLine($"{GetType().Name} played.");
        }
    }

    public class BassGuitar : Instrument
    {
    }

    public class ClassicalGuitar : Instrument
    {
    }

    public class Drums : Instrument
    {
    }

    public class ElectricGuitar : Instrument
    {
    }

    public class Keyboard : Instrument
    {
    }

Daha sonra bu enstrümanları kullanacak olan müzik gruplarını temsil edecek bir soyut sınıf oluşturalım.
devamı için tıklayınız...

SOLID prensipleri Robert C. Martin tarafından tanımlanmış ve ismini 5 ana tasarım kuralının baş harflerinden alan tasarım kuralları bütünüdür. Bu beş kuralı aşağıdaki gibi anlatabiliriz.

1. Tekil Sorumluluk (Single Responsibility):

Bir sınıfın sadece tek bir sorumluluk alanı olması gerekir. Sadece tek bir sebeple değiştirilmeye ihtiyaç duymalı ve üstüne vazife olmayan görevler üstlenmemeli. Basit bir örnek;

internal class Rectangle : Shape
{
  private readonly double _a;
  private readonly double _b;
  
  public Rectangle(double a, double b)
  {
    _a = a;
    _b = b;
  }
  
  public override double GetArea()
  {
    return _a * _b;
  }
  
  public override double GetPerimeter()
  {
    return 2 * (_a + _b);
  }
}

Yukarıdaki Rectangle sınıfı dikdörtgeni temsil etmekte ve basitçe alan ve çevre değerlerini dönen fonksiyonlar içermektedir. Aşağıdaki ShapePrinter sınıfı ise bu şeklin alan ve çevre bilgisini yazdırma görevini üstlenmiştir.

internal class ShapePrinter
{
  private readonly IShape _shape;
  
  public ShapePrinter(IShape shape)
  {
  	_shape = shape;
  }
  
  public void Print()
  {
  	Console.WriteLine($"Shape:{_shape.GetType()}, Perimeter:{_shape.GetPerimeter()}, Area:{_shape.GetArea()}");
  }
}

Nereye, nasıl, hangi formatta yazdırılacağı sorumluluğu ShapePrinter sınıfına aittir. Eğer yazdırma fonksiyonunu da Rectangle sınıfı içerisinde gerçekleştirseydik, ilerde Console ile birlikte örneğin dokümana da yazdırmak istediğimizde Rectangle sınıfında da değişiklik yapmamız gerekecekti. Halbuki bu görev Rectangle sınıfı ile ilgili değil. Bu yüzden tekil sorumluluk prensibine uymamış olacaktık.

devamı için tıklayınız...

Operatör Aşırı Yükleme, birli (unary) "+, -, !, ~, ++, -- gibi", ikili (binary) "+, -, *, /, %, &, |, ^, <<, >>" ve karşılaştırma "==, !=, <, >, <=, >=" operatörlerinin, bizim tarafımızdan tanımlanmış karmaşık sınıflarda nasıl uygulanacağına dair yeniden tanımlanmasıdır. Basit bir örnek ile anlatacak olursak:

public class Matrix2D
{
  private readonly int _rowCount;

  private readonly int _columnCount;

  private readonly double[,] _matrix;

  public double this[int row, int column]
  {

    get { return _matrix[row, column]; }

    set { _matrix[row, column] = value; }

  }

  public Matrix2D(double[,] matrix)
  {
    _matrix = matrix;

    _rowCount = matrix.GetLength(0);

    _columnCount = matrix.GetLength(1);
  }

  public override string ToString()
  {
    var stringBuilder = new StringBuilder();

    for (var i = 0; i < _rowCount; i++)
    {
      for (var j = 0; j < _columnCount; j++)
      {
        stringBuilder.Append(_matrix[i, j].ToString("F1").PadLeft(5));
        stringBuilder.Append(" ");
      }

      stringBuilder.AppendLine();
    }

    return stringBuilder.ToString().TrimEnd('\r', '\n');
  }
}

Yukarıda Matrix2D adlı 2 boyutlu matrisleri temsil eden bir sınıf tanımladık. Bu matris sınıfının ikili toplama (+) işlemi için operatör önyüklemesini aşağıdaki şekilde yazabiliriz.

public static Matrix2D operator +(Matrix2D matrix1, Matrix2D matrix2)
{
  if (matrix1._rowCount != matrix2._rowCount || matrix1._columnCount != matrix2._columnCount)
  {
    throw new NotSupportedException();
  }

  var resultMatrix = new Matrix2D(new double[matrix1._rowCount, matrix1._columnCount]);

  for (var i = 0; i < matrix1._rowCount; i++)
  {
    for (var j = 0; j < matrix1._columnCount; j++)
    {
      resultMatrix._matrix[i, j] = matrix1._matrix[i, j] + matrix2._matrix[i, j];
    }
  }

  return resultMatrix;
}

Aynı şekilde matris çıkarma (-) işlemi için de aşağıdaki şekilde yazabiliriz.
devamı için tıklayınız...