Hızlı başlangıç: .NET Framework Redsıs için Azure önbelleğini kullanma

bu hızlı başlangıçta, azure 'daki herhangi bir uygulamadan erişilebilen güvenli, ayrılmış bir önbelleğe erişim sağlamak için redsıs için azure önbelleğini bir .NET Framework uygulamasına katabilirsiniz. .NET konsol uygulamasında C# kodu ile StackExchange. Redo istemcisini özellikle kullanırsınız.

GitHub koda atlayın

koda doğrudan atlamak istiyorsanız GitHub .NET Framework hızlı başlangıç bölümüne bakın.

Önkoşullar

• Azure aboneliği- ücretsiz olarak bir tane oluşturun
• Visual Studio 2019
• stackexchange. redsıs istemcisi için gerekli olan 4 veya daha yüksek .NET Framework.

Bir önbellek oluşturma

1. Önbellek oluşturmak için Azure Portal oturum açın ve kaynak oluştur' u seçin.

   

2. Yeni sayfada veritabanları ' nı seçin ve ardından redsıs için Azure önbelleği' ni seçin.

   

3. Yeni Redis Cache sayfasında, yeni önbelleğiniz için ayarları yapılandırın.

   Ayar	Değer seçme	Açıklama
   Abonelik	Açılır ve aboneliğinizi seçin.	Redsıs örneği için bu yeni Azure önbelleğinin oluşturulacağı abonelik.
   Kaynak grubu	Açılır ve bir kaynak grubu seçin veya Yeni oluştur ' u seçin ve yeni bir kaynak grubu adı girin.	Önbelleğinizin ve diğer kaynaklarınızın oluşturulacağı kaynak grubunun adı. Tüm uygulama kaynaklarınızı tek bir kaynak grubuna yerleştirerek, bunları birlikte kolayca yönetebilir veya silebilirsiniz.
   DNS adı	Benzersiz bir ad girin.	Önbellek adı yalnızca rakam, harf veya kısa çizgi içeren 1 ile 63 karakter arasında bir dize olmalıdır. Ad bir sayı veya harfle başlamalı ve bitmeli ve ardışık kısa çizgi içeremez. Önbellek örneğinizin ana bilgisayar adı <DNS name> . Redis.cache.Windows.net olacaktır.
   Konum	Açılır ve bir konum seçin.	Önbelleğinizi kullanacak diğer hizmetlerin yakınında bir bölge seçin.
   Önbellek türü	Açılır ve bir Katmanseçin.	Katman, önbellek için kullanılabilen boyut, performans ve özellikleri belirler. Daha fazla bilgi için bkz. redsıs Için Azure önbelleği 'Ne genel bakış.

4. Ağ sekmesini seçin veya sayfanın altındaki ağ düğmesini seçin.

5. Ağ sekmesinde, bağlantı yönteminizi seçin.

6. İleri: Gelişmiş sekmesini seçin veya sayfanın altındaki İleri: Gelişmiş düğmesini seçin.

7. Bir temel veya standart önbellek örneğinin Gelişmiş SEKMESINDE, TLS olmayan bir bağlantı noktasını etkinleştirmek istiyorsanız geçişi etkinleştir ' i seçin. Ayrıca, 4 veya 6 ' da kullanmak istediğiniz redo sürümünü seçebilirsiniz.

   

8. Premium önbellek örneğinin Gelişmiş SEKMESINDE, TLS olmayan bağlantı noktası, kümeleme ve veri kalıcılığı için ayarları yapılandırın. Ayrıca, 4 veya 6 ' da kullanmak istediğiniz redo sürümünü seçebilirsiniz.

9. Sonraki: Etiketler sekmesini seçin veya sayfanın altındaki Sonraki: Etiketler düğmesini seçin.

10. İsteğe bağlı olarak, Etiketler sekmesinde, kaynağı sınıflandırmak istiyorsanız ad ve değeri girin.

11. Gözden geçir ve oluştur’u seçin. Azure 'un yapılandırmanızı doğruladığı, gözden geçir + Oluştur sekmesine götürülürsünüz.

12. Yeşil doğrulama başarılı iletisi göründüğünde Oluştur' u seçin.

Önbelleğin oluşturulması biraz zaman alır. Redsıs genel bakış sayfasında ilerlemeyi izleyebilirsiniz. Durum çalışıyor olarak görüntülendiğinde, önbellek kullanıma hazırdır.

Azure portal ana bilgisayar adı, bağlantı noktaları ve erişim anahtarlarını alın

Redsıs örneği için bir Azure önbelleğine bağlanmak üzere önbellek istemcilerinin, önbellek için ana bilgisayar adı, bağlantı noktaları ve bir anahtar olması gerekir. Bazı istemciler bu öğelere biraz daha farklı adlarla başvurabilir. Ana bilgisayar adı, bağlantı noktaları ve anahtarları Azure Portaledinebilirsiniz.

• Önbellek sol gezininizden erişim anahtarlarını almak için erişim tuşları' nı seçin.

  

• Ana bilgisayar adını ve bağlantı noktalarını, önbellek sol gezininizden almak için Özellikler' i seçin. Ana bilgisayar adı <DNS name> . Redis.cache.Windows.net biçimindedir.

  

Bilgisayarınızda CacheSecrets.config adlı bir dosya oluşturun ve örnek uygulamanızın kaynak kodu ile denetlenmeyecek bir konuma yerleştirin. Bu hızlı başlangıç için CacheSecrets.config dosyası şu konumda bulunur: C:\AppSecrets\CacheSecrets.config.

CacheSecrets.config dosyasını düzenleyin ve aşağıdaki içerikleri ekleyin:

<appSettings>
    <add key="CacheConnection" value="<host-name>,abortConnect=false,ssl=true,allowAdmin=true,password=<access-key>"/>
</appSettings>

<host-name> adını, önbellek ana bilgisayar adınızla değiştirin.

<access-key> adını, önbelleğinizin birincil anahtarıyla değiştirin.

Konsol uygulaması oluşturma

Visual Studio ' de dosya > yeni > Project' ni seçin.

uygulamanızı yapılandırmak için konsol uygulaması (.NET Framework) ve ileri ' yi seçin. Project bir ad yazın, .NET Framework 4.6.1 veya üzeri ' ın seçili olduğunu doğrulayın ve ardından oluştur ' u seçerek yeni bir konsol uygulaması oluşturun.

Önbellek istemcisini yapılandırma

Bu bölümde, .NET için StackExchange.Redis istemcisini kullanmak üzere konsol uygulamasını yapılandıracaksınız.

Visual Studio ' de araçlar > NuGet Paket Yöneticisi > Paket Yöneticisi konsolu' nu seçin ve Paket Yöneticisi konsol penceresinden aşağıdaki komutu çalıştırın.

Install-Package StackExchange.Redis

Yükleme tamamlandıktan sonra StackExchange.Redis önbellek istemcisi, projenizle kullanılabilir olur.

Önbelleğe bağlanma

Visual Studio’da, App.config dosyanızı açın ve CacheSecrets.config dosyasına başvuran bir appSettings file özniteliği içerecek şekilde güncelleştirin.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
    </startup>

    <appSettings file="C:\AppSecrets\CacheSecrets.config"></appSettings>
</configuration>

Çözüm Gezgini ' de, Başvurular ' a sağ tıklayın ve Başvuru Ekle' yi seçin. System.Configuration bütünleştirilmiş koduna bir başvuru ekleyin.

Aşağıdaki using deyimlerini Program.cs dosyasına ekleyin:

using StackExchange.Redis;
using System.Configuration;

Redo için Azure önbelleği bağlantısı, sınıfı tarafından yönetilir ConnectionMultiplexer . Bu sınıf, istemci uygulamanız genelinde paylaşılmalı ve yeniden kullanılmalıdır. Her işlem için yeni bir bağlantı oluşturmayın.

Kimlik bilgilerini asla kaynak kodunda depolamayın. Bu örneği basit tutmak için, yalnızca bir dış gizli diziler yapılandırma dosyası kullanıyorum. Daha iyi bir yaklaşım Sertifikalar ile Azure Key Vault kullanmaktır.

Program.cs dosyasında, konsol uygulamanızın Program sınıfına aşağıdaki üyeleri ekleyin:

private static Lazy<ConnectionMultiplexer> lazyConnection = CreateConnection();

public static ConnectionMultiplexer Connection
{
    get
    {
        return lazyConnection.Value;
    }
}

private static Lazy<ConnectionMultiplexer> CreateConnection()
{
    return new Lazy<ConnectionMultiplexer>(() =>
    {
        string cacheConnection = ConfigurationManager.AppSettings["CacheConnection"].ToString();
        return ConnectionMultiplexer.Connect(cacheConnection);
    });
}

Uygulamanızda bir ConnectionMultiplexer örneğini paylaşmaya ilişkin bu yaklaşım, bağlı bir örnek döndüren bir statik özelliği kullanır. Kod yalnızca tek bir bağlı ConnectionMultiplexer örneği başlatmak için iş parçacığı güvenli bir yol sağlar. abortConnect , false olarak ayarlanır, bu da çağrının başarılı olduğu anlamına gelen redin için Azure önbelleğine bir bağlantı kurulamazsa. ConnectionMultiplexer temel özelliklerinden biri ağ sorunu ya da diğer nedenler çözümlendiğinde önbellek bağlantısını otomatik olarak geri yüklemesidir.

CacheConnection appSetting değeri parola parametresi olarak Azure portalından önbellek bağlantısı dizesine başvurmak için kullanılır.

Yeniden bağlanarak RedisConnectionException ve SocketException işleme

Üzerinde Yöntemler çağrılırken önerilen en iyi yöntem ConnectionMultiplexer , RedisConnectionException SocketException bağlantıyı kapatıp yeniden kurarak otomatik olarak özel durumları çözmeyi denemeleridir.

Aşağıdaki using deyimlerini Program.cs dosyasına ekleyin:

using System.Net.Sockets;
using System.Threading;

Program. cs' de aşağıdaki üyeleri Program sınıfa ekleyin:

private static long _lastReconnectTicks = DateTimeOffset.MinValue.UtcTicks;
private static DateTimeOffset _firstErrorTime = DateTimeOffset.MinValue;
private static DateTimeOffset _previousErrorTime = DateTimeOffset.MinValue;
private static SemaphoreSlim _reconnectSemaphore = new SemaphoreSlim(initialCount: 1, maxCount: 1);
private static SemaphoreSlim _initSemaphore = new SemaphoreSlim(initialCount: 1, maxCount: 1);
private static ConnectionMultiplexer _connection;
private static bool _didInitialize = false;
// In general, let StackExchange.Redis handle most reconnects,
// so limit the frequency of how often ForceReconnect() will
// actually reconnect.
public static TimeSpan ReconnectMinInterval => TimeSpan.FromSeconds(60);
// If errors continue for longer than the below threshold, then the
// multiplexer seems to not be reconnecting, so ForceReconnect() will
// re-create the multiplexer.
public static TimeSpan ReconnectErrorThreshold => TimeSpan.FromSeconds(30);
public static TimeSpan RestartConnectionTimeout => TimeSpan.FromSeconds(15);
public static int RetryMaxAttempts => 5;
public static ConnectionMultiplexer Connection { get { return _connection; } }
private static async Task InitializeAsync()
{
    if (_didInitialize)
    {
        throw new InvalidOperationException("Cannot initialize more than once.");
    }
    _connection = await CreateConnectionAsync();
    _didInitialize = true;
}
// This method may return null if it fails to acquire the semaphore in time.
// Use the return value to update the "connection" field
private static async Task<ConnectionMultiplexer> CreateConnectionAsync()
{
    if (_connection != null)
    {
        // If we already have a good connection, let's re-use it
        return _connection;
    }
    try
    {
        await _initSemaphore.WaitAsync(RestartConnectionTimeout);
    }
    catch
    {
        // We failed to enter the semaphore in the given amount of time. Connection will either be null, or have a value that was created by another thread.
        return _connection;
    }
    // We entered the semaphore successfully.
    try
    {
        if (_connection != null)
        {
            // Another thread must have finished creating a new connection while we were waiting to enter the semaphore. Let's use it
            return _connection;
        }
        // Otherwise, we really need to create a new connection.
        string cacheConnection = ConfigurationManager.AppSettings["CacheConnection"].ToString();
        return await ConnectionMultiplexer.ConnectAsync(cacheConnection);
    }
    finally
    {
        _initSemaphore.Release();
    }
}
private static async Task CloseConnectionAsync(ConnectionMultiplexer oldConnection)
{
    if (oldConnection == null)
    {
        return;
    }
    try
    {
        await oldConnection.CloseAsync();
    }
    catch (Exception)
    {
        // Ignore any errors from the oldConnection
    }
}
/// <summary>
/// Force a new ConnectionMultiplexer to be created.
/// NOTES:
///     1. Users of the ConnectionMultiplexer MUST handle ObjectDisposedExceptions, which can now happen as a result of calling ForceReconnectAsync().
///     2. Call ForceReconnectAsync() for RedisConnectionExceptions and RedisSocketExceptions. You can also call it for RedisTimeoutExceptions,
///         but only if you're using generous ReconnectMinInterval and ReconnectErrorThreshold. Otherwise, establishing new connections can cause
///         a cascade failure on a server that's timing out because it's already overloaded.
///     3. The code will:
///         a. wait to reconnect for at least the "ReconnectErrorThreshold" time of repeated errors before actually reconnecting
///         b. not reconnect more frequently than configured in "ReconnectMinInterval"
/// </summary>
public static async Task ForceReconnectAsync()
{
    var utcNow = DateTimeOffset.UtcNow;
    long previousTicks = Interlocked.Read(ref _lastReconnectTicks);
    var previousReconnectTime = new DateTimeOffset(previousTicks, TimeSpan.Zero);
    TimeSpan elapsedSinceLastReconnect = utcNow - previousReconnectTime;
    // If multiple threads call ForceReconnectAsync at the same time, we only want to honor one of them.
    if (elapsedSinceLastReconnect < ReconnectMinInterval)
    {
        return;
    }
    try
    {
        await _reconnectSemaphore.WaitAsync(RestartConnectionTimeout);
    }
    catch
    {
        // If we fail to enter the semaphore, then it is possible that another thread has already done so.
        // ForceReconnectAsync() can be retried while connectivity problems persist.
        return;
    }
    try
    {
        utcNow = DateTimeOffset.UtcNow;
        elapsedSinceLastReconnect = utcNow - previousReconnectTime;
        if (_firstErrorTime == DateTimeOffset.MinValue)
        {
            // We haven't seen an error since last reconnect, so set initial values.
            _firstErrorTime = utcNow;
            _previousErrorTime = utcNow;
            return;
        }
        if (elapsedSinceLastReconnect < ReconnectMinInterval)
        {
            return; // Some other thread made it through the check and the lock, so nothing to do.
        }
        TimeSpan elapsedSinceFirstError = utcNow - _firstErrorTime;
        TimeSpan elapsedSinceMostRecentError = utcNow - _previousErrorTime;
        bool shouldReconnect =
            elapsedSinceFirstError >= ReconnectErrorThreshold // Make sure we gave the multiplexer enough time to reconnect on its own if it could.
            && elapsedSinceMostRecentError <= ReconnectErrorThreshold; // Make sure we aren't working on stale data (e.g. if there was a gap in errors, don't reconnect yet).
        // Update the previousErrorTime timestamp to be now (e.g. this reconnect request).
        _previousErrorTime = utcNow;
        if (!shouldReconnect)
        {
            return;
        }
        _firstErrorTime = DateTimeOffset.MinValue;
        _previousErrorTime = DateTimeOffset.MinValue;
        ConnectionMultiplexer oldConnection = _connection;
        await CloseConnectionAsync(oldConnection);
        _connection = null;
        _connection = await CreateConnectionAsync();
        Interlocked.Exchange(ref _lastReconnectTicks, utcNow.UtcTicks);
    }
    finally
    {
        _reconnectSemaphore.Release();
    }
}
// In real applications, consider using a framework such as
// Polly to make it easier to customize the retry approach.
private static async Task<T> BasicRetryAsync<T>(Func<T> func)
{
    int reconnectRetry = 0;
    int disposedRetry = 0;
    while (true)
    {
        try
        {
            return func();
        }
        catch (Exception ex) when (ex is RedisConnectionException || ex is SocketException)
        {
            reconnectRetry++;
            if (reconnectRetry > RetryMaxAttempts)
                throw;
            await ForceReconnectAsync();
        }
        catch (ObjectDisposedException)
        {
            disposedRetry++;
            if (disposedRetry > RetryMaxAttempts)
                throw;
        }
    }
}
public static Task<IDatabase> GetDatabaseAsync()
{
    return BasicRetryAsync(() => Connection.GetDatabase());
}
public static Task<System.Net.EndPoint[]> GetEndPointsAsync()
{
    return BasicRetryAsync(() => Connection.GetEndPoints());
}
public static Task<IServer> GetServerAsync(string host, int port)
{
    return BasicRetryAsync(() => Connection.GetServer(host, port));
}

Önbellek komutlarını yürütme

Konsol uygulamanıza yönelik Program sınıfının Main yordamı için aşağıdaki kodu ekleyin:

static void Main(string[] args)
{
    IDatabase cache = GetDatabase();

    // Perform cache operations using the cache object...

    // Simple PING command
    string cacheCommand = "PING";
    Console.WriteLine("\nCache command  : " + cacheCommand);
    Console.WriteLine("Cache response : " + cache.Execute(cacheCommand).ToString());

    // Simple get and put of integral data types into the cache
    cacheCommand = "GET Message";
    Console.WriteLine("\nCache command  : " + cacheCommand + " or StringGet()");
    Console.WriteLine("Cache response : " + cache.StringGet("Message").ToString());

    cacheCommand = "SET Message \"Hello! The cache is working from a .NET console app!\"";
    Console.WriteLine("\nCache command  : " + cacheCommand + " or StringSet()");
    Console.WriteLine("Cache response : " + cache.StringSet("Message", "Hello! The cache is working from a .NET console app!").ToString());

    // Demonstrate "SET Message" executed as expected...
    cacheCommand = "GET Message";
    Console.WriteLine("\nCache command  : " + cacheCommand + " or StringGet()");
    Console.WriteLine("Cache response : " + cache.StringGet("Message").ToString());

    // Get the client list, useful to see if connection list is growing...
    // Note that this requires allowAdmin=true in the connection string
    cacheCommand = "CLIENT LIST";
    Console.WriteLine("\nCache command  : " + cacheCommand);
    var endpoint = (System.Net.DnsEndPoint)GetEndPoints()[0];
    IServer server = GetServer(endpoint.Host, endpoint.Port);
    ClientInfo[] clients = server.ClientList();

    Console.WriteLine("Cache response :");
    foreach (ClientInfo client in clients)
    {
        Console.WriteLine(client.Raw);
    }

    CloseConnection(lazyConnection);
}

Redsıs için Azure önbelleğinde, Redsıs için bir Azure önbelleğindeki verileri mantıksal olarak ayırmak üzere kullanılabilecek yapılandırılabilir sayıda veritabanı (varsayılan değer 16) vardır. Kod, DB 0 adlı varsayılan veritabanına bağlanır. Daha fazla bilgi için bkz. Redis veritabanı nedir? ve Varsayılan Redis sunucu yapılandırması.

StringSet ve StringGet yöntemleri kullanılarak önbellek öğeleri depolanabilir ve alınabilir.

Redis, Redis dizeleri kadar veri depolar, ancak bu dizeler önbellekte .NET nesneleri depolarken kullanılabilecek seri hale getirilmiş ikili veriler dahil, birçok veri türünü içerebilir.

Konsol uygulamasını derleyip çalıştırmak için Ctrl+F5'e basın.

Aşağıdaki örnekte, Message anahtarının Azure portalındaki Redis Konsolu kullanılarak ayarlanan, önceden önbelleğe alınmış bir değer içerdiğini görebilirsiniz. Uygulama, önbelleğe alınan bu değeri güncelleştirdi. Ayrıca uygulama, PING ve CLIENT LIST komutlarını da yürüttü.

Önbellekte .NET nesneleriyle çalışma

Redsıs için Azure Cache hem .NET nesnelerini hem de ilkel veri türlerini önbelleğe alabilir, ancak bir .NET nesnesi önbelleğe alınmadan önce serileştirilmelidir. Bu .NET nesne serileştirmesi uygulama geliştiricisinin sorumluluğundadır ve geliştiriciye seri hale getirici tercihinde esneklik sağlar.

Nesneleri seri hale getirmenin basit bir yolu, Newtonsoft.Json’da JsonConvert seri hale getirme yöntemlerini kullanmak ve JSON’a ve JSON’dan seri hale getirmektir. Bu bölümde, önbelleğe bir .NET nesnesi ekleyeceksiniz.

Visual Studio ' de araçlar > NuGet Paket Yöneticisi > Paket Yöneticisi konsolu' nu seçin ve Paket Yöneticisi konsol penceresinden aşağıdaki komutu çalıştırın.

Install-Package Newtonsoft.Json

Aşağıdaki using deyimini Program.cs dosyasının üst kısmına ekleyin:

using Newtonsoft.Json;

Aşağıdaki Employee sınıf tanımını Program.cs dosyasına ekleyin:

class Employee
{
    public string Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }

    public Employee(string employeeId, string name, int age)
    {
        Id = employeeId;
        Name = name;
        Age = age;
    }
}

Program.cs dosyasındaki Main() yordamının alt kısmına ve CloseConnection() için çağrı yapılmadan önce aşağıdaki kod satırlarını önbelleğe ekleyin ve seri hale getirilmiş bir .NET nesnesi alın:

    // Store .NET object to cache
    Employee e007 = new Employee("007", "Davide Columbo", 100);
    Console.WriteLine("Cache response from storing Employee .NET object : " + 
    cache.StringSet("e007", JsonConvert.SerializeObject(e007)));

    // Retrieve .NET object from cache
    Employee e007FromCache = JsonConvert.DeserializeObject<Employee>(cache.StringGet("e007"));
    Console.WriteLine("Deserialized Employee .NET object :\n");
    Console.WriteLine("\tEmployee.Name : " + e007FromCache.Name);
    Console.WriteLine("\tEmployee.Id   : " + e007FromCache.Id);
    Console.WriteLine("\tEmployee.Age  : " + e007FromCache.Age + "\n");

.NET nesnelerinin serileştirilmesini test etmek üzere konsol uygulamasını oluşturmak ve çalıştırmak için Ctrl+F5 tuşlarına basın.

Kaynakları temizleme

Sonraki öğreticiyle devam edecekseniz, bu hızlı başlangıçta oluşturulan kaynakları tutabilir ve sonraki öğreticide yeniden kullanabilirsiniz.

Aksi takdirde, hızlı başlangıç örnek uygulamasını tamamladıysanız ücret yansıtılmaması için bu hızlı başlangıçta oluşturulan Azure kaynaklarını silebilirsiniz.

Azure portalda oturum açın ve Kaynak grupları’nı seçin.

Ada göre filtrele... metin kutusuna kaynak grubunuzun adını girin. Bu makaledeki yönergelerde TestResources adlı bir kaynak grubu kullanılmıştır. Sonuç listesindeki kaynak grubunuzda . .. öğesini seçin ve kaynak grubunu silin.

Kaynak grubunun silinmesini onaylamanız istenir. Onaylamak için kaynak grubunuzun adını yazın ve Sil' i seçin.

Birkaç dakika sonra kaynak grubu ve içerdiği kaynakların tümü silinir.

Sonraki adımlar

Bu hızlı başlangıçta, bir .NET uygulamasından Redsıs için Azure önbelleğini nasıl kullanacağınızı öğrendiniz. bir ASP.NET web uygulamasıyla redsıs için Azure önbelleği 'ni kullanmak üzere bir sonraki hızlı başlangıca devam edin.

Bulut harcamalarınızı iyileştirmek ve kaydetmek istiyor musunuz?