C# RSA Kullanımı

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace RsaDemo
{
    public class RsaUtilities
    {
        public static void CreatePublicAndPrivateKeys()
        {
            using (var csp = new RSACryptoServiceProvider())
            {
                //Generate Key 
                //True:Public and Private Key, False: Just Public Key
                csp.ExportParameters(true);

                //Write Private Key 
                var publicKey = csp.ToXmlString(true);
                File.WriteAllText("private", publicKey);
                Console.WriteLine("Private key generated and saved to disk as 'private'");
                //Write Public Key
                var privateKey = csp.ToXmlString(false);
                File.WriteAllText("public", publicKey);
                Console.WriteLine("Public key generated and saved to disk as 'public'");
            }
        }
        private static string m_PublicKeyXml = string.Empty;
        public static string PublicKeyXml
        {
            get
            {
                if (string.IsNullOrWhiteSpace(m_PublicKeyXml))
                {
                    if (!File.Exists("public"))
                        throw new FileNotFoundException("public key not found for encrypting", "public");
                    else m_PublicKeyXml = File.ReadAllText("public");
                }
                return m_PublicKeyXml;   
            }
        }
        private static string m_PrivateKeyXml = string.Empty;
        public static string PrivateKeyXml
        {
            get
            {
                if (string.IsNullOrWhiteSpace(m_PrivateKeyXml))
                {
                    if (!File.Exists("private"))
                        throw new FileNotFoundException("private key not found for encrypting", "private");
                    else m_PrivateKeyXml = File.ReadAllText("private");
                }
                return m_PrivateKeyXml;
            }
        }

        public static string Encrypt(string plainText)
        {
            byte[] encryptedByteArray;

            using (var csp = new RSACryptoServiceProvider())
            {                
                csp.FromXmlString(PublicKeyXml);

                encryptedByteArray = csp.Encrypt(Encoding.UTF8.GetBytes(plainText), false);
            }
            return Convert.ToBase64String(encryptedByteArray);
        }

        public static string Decrypt(string encryptedText)
        {
            using (var csp = new RSACryptoServiceProvider())
            {
                csp.FromXmlString(PrivateKeyXml);
                var encryptedByteArray = Convert.FromBase64String(encryptedText);
                var decryptedByteArray = csp.Decrypt(encryptedByteArray, false);
                return Encoding.UTF8.GetString(decryptedByteArray);
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // RsaUtilities.CreatePublicAndPrivateKeys();
            string plainText = "foobar";
            Console.WriteLine($"Plain Text: {plainText}");
            string encryptedText = RsaUtilities.Encrypt(plainText);
            Console.WriteLine($"Encrypted Text: {encryptedText}");
            string decryptedText = RsaUtilities.Decrypt(encryptedText);
            Console.WriteLine($"Decrypted Text: {decryptedText}");

        }
    }
}

Erişim Tanımlayıcılar(Access Modifiers)

Bir tip veya bir tipin üyelerinin erişimindi diğer tipler veya assembliler için  erişimin seviyesini sağlayabileceğimiz 5 tanımlayıcı vardır. Bunlara access modifiers denir.

Public: Tam erişim sağlar.
Internal :Sadece bulunduğu assembly veya yakın assemblilerin erişimini sağlar.
Private: Sadece bulunduğu tipin içerisinde erişime açıktır. Class ve structlar için varsayılan (default) erişim özelliği budur.
Protected: Sadece bulunduğu tip yada alt clasın erişimi vardır.
Protected Internal : protected ve internal in birleşimidir. Eric Liper bunu şu şekilde açıklar:
"Herşey varsayılan(default) olarak mümkün olduğunca private seçilmeye çalışılır. Ve her modifier bir şeyi daha çok erişilebilir (accessible) yapmaya çalışır. Bu yüzden protected internal olan şeyler her iki yol içinde daha erişilebilir olmasını sağlar.

Örnekler.
namespace AccessibleModifier
{
    class Program
    {
        //Class1 e dışarıdan erişilebilir. Class2 ye erişilemez.
        class Class1{}//Class1 internal(default)
        public class Class2{}

        //ClassB içiersinde x' e aynı assembly deki tipler erişebiliri ClassA da erişemez.
        class ClassA{int x;}//x is private(default)
        class ClassB{internal int x;}

        class BaseClass
        {
            void Foo(){}//Foo is private(default)
            protected void Bar(){}
        }
        class Subclass : BaseClass
        {
            //void Test1() { Foo(); } // Hata Foo ya erişemez.
            void Test2() { Bar(); } // protected olduğu için alt class ta erişebilir.

        }
        static void Main(string[] args)
        {
            ClassA a=new ClassA();
            //a.x=10;//Hata aynı assembide değil.Eişim yok.
            ClassB b=new ClassB();
            b.x=10;//Aynu Assembli içerisinde olduğu için x'e erişebildik.

        }
    }
}