Makale Özeti

Bu makalemde kendi ResourceManager'ımızı nasıl yazabileceğimizi inceleyeceğiz. Yazacağımız resource manager varsayılan olarak xml, veritabanı, resx veya bir class dosyasından resource'ları okuyor olabilecek. Ayrıca sağlayacağımız interface'leri implement ederek diğer yazılım geliştiriciler yeni resource tipleri oluşturabilecek.

Makale

         Merhaba,

         Bu makalemde kendi ResourceManager'ımızı nasıl yazabileceğimizi inceleyeceğiz. Yazacağımız resource manager varsayılan olarak xml, veritabanı, resx veya bir class dosyasından resource'ları okuyor olabilecek. Ayrıca sağlayacağımız interface'leri implement ederek diğer yazılım geliştiriciler yeni resource tipleri oluşturabilecek. Dolayısıyla genişletilebilir bir yapı hazırlayacağız ve tüm bunların yanısıra config dosyasından ayarlanabiliyor olacak. Bu makalede ayrıca kendi config section'ımızı nasıl yazabileceğimizi de inceleyeceğiz.

         Öncelikle oluşturacağımız yapının nasıl bir yapı olacağını inceleyelim.


Şimdi isterseniz kodumuzu yazmaya başlayalım. Öncelikle Resource dosyalarımızın çalışması için gerekli configuration section'u yazalım.

    public sealed class ResourcesConfig : ConfigurationSection
    {
 
        [ConfigurationProperty("Resources", IsRequired = true, IsDefaultCollection = false)]
        public ResourceConfigElementCollection Resources
        {
            get { return (ResourceConfigElementCollection)this["Resources"]; }
            set { this["Resources"] = value; }
        }
        [ConfigurationProperty("Languages", IsRequired = true, IsDefaultCollection = false)]
        public LanguageConfigElementCollection Languages
        {
            get { return (LanguageConfigElementCollection)this["Languages"]; }
            set { this["Languages"] = value; }
        }
 
        [ConfigurationProperty("DefaultResourceName", IsRequired = true)]
        public string DefaultResourceName
        {
            get { return base["DefaultResourceName"].ToString(); }
            set { base["DefaultResourceName"] = value; }
        }
Öncelikle ResourcesConfig ismindeki config section'umuzu oluşturuyoruz. Bir class'ı  config section olarak kullanmak için ConfigurationSection'dan nesnesinden inherit etmek gerekiyor. Section nesnemizin içine olası Resource tipleri için ResourceConfigElementCollection, olası dil tanımlamaları için LanguageConfigElementCollection ve kullanılacak varsayılan resporce tipi için DefaultResourceName isimlerinde property'ler oluşturuyoruz. Gördüğünüz gibi bu property'lere ConfigurationProperty attribute'ını tanımlamak gerekiyor ve bu tanımlamanın içinde config dosyasında kullanıclacak isim ve zorunlu bir property olup olmadığı belirtiliyor.

Şimdi isterseniz bu property'lerin taşıdıkları tipleri oluşturalım. 
        public class ResourceConfigElementCollection : ConfigurationElementCollection
        {
            protected override ConfigurationElement CreateNewElement()
            {
                return new ResourceConfigElement();
            }
            protected override object GetElementKey(ConfigurationElement element)
            {
                return ((ResourceConfigElement)element).Name;
            }
        }
        public class LanguageConfigElementCollection : ConfigurationElementCollection
        {
            protected override ConfigurationElement CreateNewElement()
            {
                return new LanguageConfigElement();
            }
            protected override object GetElementKey(ConfigurationElement element)
            {
                return ((LanguageConfigElement)element).Name;
            }
        }
Dikkat edeceğiniz üzere Collection nesnelerinin config section üzerinde property'ler olarak oluşturmak için ConfigurationElementCollection nesnesinden inherit etmek gerekmektedir. İnherit ettiğinizde CreateNewElement ve GetElementKey metodlarını override etmek gerekiyor.

Bu işlemleri tanımladıktan sonra isterseniz resource tiplerimizi ve dil tiplerimizi tanımlamamıza yardım edecek olan ResourceConfigElement ve LanguageConfigElement nesnelerimizi oluşturalım.
        public class LanguageConfigElement : ConfigurationElement
        {
            [ConfigurationProperty("Id", IsRequired = true)]
            public string Id
            {
                get { return base["Id"].ToString(); }
                set { base["Id"] = value; }
            }
            [ConfigurationProperty("Name", IsRequired = true)]
            public string Name
            {
                get { return base["Name"].ToString(); }
                set { base["Name"] = value; }
            }
            [ConfigurationProperty("Culture", IsRequired = true)]
            public string Culture
            {
                get { return base["Culture"].ToString(); }
                set { base["Culture"] = value; }
            }
        }
        public class ResourceConfigElement : ConfigurationElement
        {
            [ConfigurationProperty("Name", IsRequired = true)]
            public string Name
            {
                get { return base["Name"].ToString(); }
                set { base["Name"] = value; }
            }
 
            [ConfigurationProperty("ResourceType", IsRequired = true)]
            public string ResourceType
            {
                get { return base["ResourceType"].ToString(); }
                set { base["ResourceType"] = value; }
            }
 
            [ConfigurationProperty("ResxConfig", IsRequired = false)]
            public ResxConfigElement ResxConfig
            {
                get { return (ResxConfigElement)base["ResxConfig"]; }
                set { base["ResxConfig"] = value; }
            }
 
            [ConfigurationProperty("ClassConfig", IsRequired = false)]
            public ClassConfigElement ClassConfig
            {
                get { return (ClassConfigElement)base["ClassConfig"]; }
                set { base["ClassConfig"] = value; }
            }
 
            [ConfigurationProperty("DbConfig", IsRequired = false)]
            public DbConfigElement DbConfig
            {
                get { return (DbConfigElement)base["DbConfig"]; }
                set { base["DbConfig"] = value; }
            }
 
            [ConfigurationProperty("XmlConfig", IsRequired = false)]
            public XmlConfigElement XmlConfig
            {
                get { return (XmlConfigElement)base["XmlConfig"]; }
                set { base["XmlConfig"] = value; }
            }
 
            [ConfigurationProperty("DefaultLanguageId", IsRequired = true)]
            public string DefaultLanguageId
            {
                get { return base["DefaultLanguageId"].ToString(); }
                set { base["DefaultLanguageId"] = value; }
            }
 
        }
 
LanguageConfigElement ve ResourceConfigElement nesnelerimizi ilk kısımda olduğu gibi ConfigElement nesnesinden inherit ederek oluşturduk isterseniz şimdi içlerindeki property'lerde ne gibi bilgiler taşıyacağımızı inceleyelim.

LanguageConfigElement:
Id(string) : Oluşturulacak dil girdisinin id'si. Örn : 1
Name(string) : Oluşturulacak dil girdisinin adı. Örn: Türkçe
Culture(string) : Oluşturulacak dil girdisinin culture'ı. Örn : tr-TR

ResourceConfigElement:
Name(string):Oluşturulacak resource girdisinin adı. Örn:HataMesajlariXml
ResourceType(string) : Bu girdi için oluşturulacak Resource tipi. Örn : ClassResource
ResxConfıg(ResxConfigElement) : Tipin ResxResource olarak oluşturulması durumunda ayarların yapılacağı nesne.
ClassConfıg(ClassConfigElement): Tipin ClassResource olarak oluşturulması durumunda ayarların yapılacağı nesne.
DbConfıg(DbConfigElement): Tipin DbResource olarak oluşturulması durumunda ayarların yapılacağı nesne.
XmlConfıg(XmlConfigElement): Tipin XmlResource olarak oluşturulması durumunda ayarların yapılacağı nesne.
DefaultLanguageId(string) : Bu resource için resource'lara ulaşılırken spesifik bir dil belirtilmez ise kullanılacak varsayılan dil.

Şimdi yukarıda belirttiğimiz resource tipleri için elemanları tek tek oluşturalım.
        public class ResxConfigElement : ConfigurationElement
        {
            [ConfigurationProperty("Type", IsRequired = true)]
            public string Type
            {
                get { return base["Type"].ToString(); }
                set { base["Type"] = value; }
            }
        }
Bir resx dosyasından değerlerimizi okumak için tek ihtiyacımız olan bu resource dosyasının tipidir. Dolayısıyla ResxConfigElement için sadece Type isminde bir property tanımlamak yeterlidir.
 
        public class ClassConfigElement : ConfigurationElement
        {
            [ConfigurationProperty("Type", IsRequired = true)]
            public string Type
            {
                get { return base["Type"].ToString(); }
                set { base["Type"] = value; }
            }
            [ConfigurationProperty("LanguageSeperator", IsRequired = true)]
            public string LanguageSeperator
            {
                get { return base["LanguageSeperator"].ToString(); }
                set { base["LanguageSeperator"] = value; }
            }
        }
Bir class'dan değerlerinizi okumak için bu class'ın tipine ve class içerisinde bulunan bir değişkenin farklı diller için nasıl tanımlandığını belirten bir dil ayıracı bilgisine ihtiyacımız olacaktır.

Örnek bir class dosyası :
    public static class Resource
    {
        public  const string Password_1="Password c";
        public  const string Password_2="Sifre c";
    }
Bu yapıda, Type alanında class'ın tipi yani NameSpace.Resource,NameSpace LanguageSeperator kisminda ise _ bulunacaktır.
        public class DbConfigElement : ConfigurationElement
        {
            [ConfigurationProperty("Provider", IsRequired = true)]
            public string Provider
            {
                get { return base["Provider"].ToString(); }
                set { base["Provider"] = value; }
            }
 
            [ConfigurationProperty("ConnectionString", IsRequired = true)]
            public string ConnectionString
            {
                get { return base["ConnectionString"].ToString(); }
                set { base["ConnectionString"] = value; }
            }
 
            [ConfigurationProperty("TableName", IsRequired = true)]
            public string TableName
            {
                get { return base["TableName"].ToString(); }
                set { base["TableName"] = value; }
            }
 
            [ConfigurationProperty("KeyFieldName", IsRequired = true)]
            public string KeyFieldName
            {
                get { return base["KeyFieldName"].ToString(); }
                set { base["KeyFieldName"] = value; }
            }
 
            [ConfigurationProperty("LanguageFieldName", IsRequired = true)]
            public string LanguageFieldName
            {
                get { return base["LanguageFieldName"].ToString(); }
                set { base["LanguageFieldName"] = value; }
            }
 
            [ConfigurationProperty("ValueFieldName", IsRequired = true)]
            public string ValueFieldName
            {
                get { return base["ValueFieldName"].ToString(); }
                set { base["ValueFieldName"] = value; }
            }
        }
Bir veritabanından değerleri okumak için veritabanına hangi provider ile bağlanacağımız, connection string, tablo adı, resource'ların key'inin durduğu alanın adı, dil bilgisinin durduğu alanın adı ve değerin durduğu alanın adı bilgilerine ihtiyacımız olacaktır.

Örnek Veritabanı:

Bu durumda TableName:Resource, KeyFieldName : Key, LanguageFieldName : Language, ValueFieldName ise Value olarak belirlenmelidir.
 
        public class XmlConfigElement : ConfigurationElement
        {
            [ConfigurationProperty("XmlPath", IsRequired = true)]
            public string XmlPath
            {
                get { return (string)base["XmlPath"]; }
                set { base["XmlPath"] = value; }
            }
            [ConfigurationProperty("KeyAttribute", IsRequired = true)]
            public string KeyAttribute
            {
                get { return (string)base["KeyAttribute"]; }
                set { base["KeyAttribute"] = value; }
            }
            [ConfigurationProperty("LanguageAttribute", IsRequired = true)]
            public string LanguageAttribute
            {
                get { return (string)base["LanguageAttribute"]; }
                set { base["LanguageAttribute"] = value; }
            }
        }
    }
}
Bir xml dosyasından değerleri okumak için xml dosyasının yoluna ve resource adının ve dil tipinin tutulduğu attribute'ların adına ihtiyacımız var.

Örnek bir xml dosyası:
<?xml version="1.0" encoding="utf-8" ?>
<Resources>
  <Resource Key="UserName">
    <Language Id="1">User Name</Language>
    <Language Id="2">Kullanici Adi</Language>
  </Resource>
  <Resource Key="Password">
    <Language Id="1">Password</Language>
    <Language Id="2">Sifre</Language>
  </Resource>
</Resources>
Bu durumda KeyAttribute : Key ve LanguageAttribute ise Id olarak tanımlanmalıdır.

Resource Manager'ımızın config section ayarlarını yaptık. Örnek bir config dosyasını aşağıdaki gibi oluşturabiliriz.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="ResourceConfig" type="Infra.ResourcesConfig,Infra"/>
  </configSections>
  <ResourceConfig DefaultResourceName="Xml1">
    <Languages>
      <add Id="1" Name="English" Culture="en-US"></add>
      <add Id="2" Name="Turkish" Culture="tr-TR"></add>
    </Languages>
    <Resources>
      <add Name="Xml1" ResourceType="Infra.XmlResource,Infra" DefaultLanguageId="1">
        <XmlConfig XmlPath="ResourceDeneme.Xml" KeyAttribute="Key" LanguageAttribute="Id"></XmlConfig>
      </add>
      <add Name="Xml2" ResourceType="Infra.XmlResource,Infra" DefaultLanguageId="1">
        <XmlConfig XmlPath="ResourceDeneme2.Xml" KeyAttribute="Key" LanguageAttribute="Id"></XmlConfig>
      </add>
      <add Name="Class1" ResourceType="Infra.ClassResource,Infra" DefaultLanguageId="1">
        <ClassConfig Type="WindowsFormsApplication1.Resource,WindowsFormsApplication1" LanguageSeperator="_" ></ClassConfig>
      </add>
      <add Name="Resx1" ResourceType="Infra.ResxResource,Infra" DefaultLanguageId="1">
        <ResxConfig Type="WindowsFormsApplication1.Properties.Resources,WindowsFormsApplication1"></ResxConfig>
      </add>
      <add Name="Db1" ResourceType="Infra.DbResource,Infra" DefaultLanguageId="1">
        <DbConfig Provider="System.Data.SqlClient" ConnectionString="Data Source=.;IntegratedSecurity=SSPI" TableName="Resource" KeyFieldName="Key" LanguageFieldName="Language" ValueFieldName="Value"></DbConfig>
      </add>
    </Resources>
  </ResourceConfig>
</configuration>
Gördüğünüz gibi config dosyamıza birden fazla resource tipi tanımlayabiliyoruz.

Şimdi isterseniz config dosyamızdan okuyacağımız bu resource tiplerinin ResourceManager ile nasıl kullanacağımızı inceleyelim. İşe temelden başlamak gerekirse öncelikle kullanacağımız interface'leri inceleyelim.

    public interface IResource
    {
        Infra.ResourcesConfig.ResourceConfigElement Config { get; set; }
        string GetString(string key);
        string GetString(string key, string language);
    }
    public interface IResourceConfig<T> where T:ConfigurationElement
    {
        T ResourceConfig
        {
            get;
        }
    }
Uygulamamızda iki tane interface bulunuyor bunlardan biri resource tiplerimizi oluştururken kullanacağımız IResource tipinde ve diğer ise config dosyasından bir resource ile ilgili bilgileri okurken kullanacağımız IResourceConfig interface'i.

IResourceConfig interface'inde bulunan ResourceConfig Property'si ile bu interface'e generic olarak verdiğimiz ConfigurationElement tipinden nesnelere ulaşabileceğiz.

IResource interface'inde bulunan Config property'si ise tüm config bilgilerine ulaşabileceğiz.
IResource interface'inde bulunan GetString metodlarının içerisine ise resource kaynağımızdan belirttiğimiz key ve language değişkenlerine göre değer okumak için gerekli kodu yazacağız.

Şimdi isterseniz bu interfacelerimizi implement edeceğimiz class'larımıza geçelim.
    public class ClassResource : IResource, IResourceConfig<Infra.ResourcesConfig.ClassConfigElement>
    {
        #region IResource Members
        public string GetString(string key)
        {
            return GetString(key, Config.DefaultLanguageId);
        }
 
        public string GetString(string key, string language)
        {
            Type t = Type.GetType(ResourceConfig.Type);
            if (t == null)
            {
                throw new Exception("Type can not be found");
            }
            FieldInfo fi = t.GetField(key + ResourceConfig.LanguageSeperator + language);
            if (fi==null)
            {
                throw new Exception("Key Can not be found");
            }
            return fi.GetValue(null).ToString();
        }
        public ResourcesConfig.ResourceConfigElement Config
        {
            get;
            set;
        }
        #endregion
 
        #region IResourceConfig<ClassConfigElement> Members
 
        public ResourcesConfig.ClassConfigElement ResourceConfig
        {
            get
            {
                return this.Config.ClassConfig;
            }
        }
 
        #endregion
    }
Gördüğünüz gibi ClassResource nesnemizi IResource interface'inden ve IResourceConfig interface'inden implement ediyoruz. IResourceConfıg interface'ine ise generic olarak ClassConfigElement'i veriyoruz. Buda bu class'ımızı içerisinde ResourceConfig dediğimizde bize ClassConfigElement tipinden bir nesne geleceğini belirtiyor.

GetString metodlarını ineleyecek olursak sadece key alan overload'ın diğer overload'ı Config dosyasında tanımladığımız DefaultLanguage değerini okuyarak çağırdığını görüyoruz.

GetString metodunun 2. overloadında ise reflection ile class içerisinden değerlerin okunduğunu görüyoruz. Oluşturacağımız her Resource nesnesinde GetString metodunun 2. overload'ı farklı bir şekilde implement edilecektir. Bu implementasyonlar makalemizin konusu olmadığından tek tek anlatmayacağım ama kodu burada paylaşacağım.

Şimdi isterseniz diğer Resource nesnelerimizi oluşturalım.
    public class DbResource : IResource, IResourceConfig<Infra.ResourcesConfig.DbConfigElement>
    {
        DbProviderFactory insDbProviderFactory = null;
        #region IResource Members
 
        public string GetString(string key)
        {
            return GetString(key, Config.DefaultLanguageId);
        }
        public string GetString(string key, string language)
        {
            if (insDbProviderFactory == null)
            {
                insDbProviderFactory = DbProviderFactories.GetFactory(ResourceConfig.Provider);
            }
            DbConnection conn = insDbProviderFactory.CreateConnection();
            conn.ConnectionString=ResourceConfig.ConnectionString;
            DbCommand cmd = insDbProviderFactory.CreateCommand();
            cmd.CommandText = "SELECT [" + ResourceConfig.ValueFieldName + "] From [" + ResourceConfig.TableName + "] WHERE [" + ResourceConfig.KeyFieldName + "]=@Key AND [" + ResourceConfig.LanguageFieldName + "]=@Language";
            DbParameter paramKey = insDbProviderFactory.CreateParameter();
            paramKey.DbType = System.Data.DbType.String;
            paramKey.Direction = System.Data.ParameterDirection.Input;
            paramKey.ParameterName = "@Key";
            paramKey.Value = key;
 
            DbParameter paramLanguage = insDbProviderFactory.CreateParameter();
            paramLanguage.DbType = System.Data.DbType.String;
            paramLanguage.Direction = System.Data.ParameterDirection.Input;
            paramLanguage.ParameterName = "@Language";
            paramLanguage.Value = language;
 
            cmd.Parameters.Add(paramKey);
            cmd.Parameters.Add(paramLanguage);
            cmd.Connection = conn;
 
            string result = "";
            try
            {
                conn.Open();
                result = cmd.ExecuteScalar().ToString(); ;
                conn.Close();
            }
            catch (Exception)
            {
                conn.Close();
                throw;
            }
            return result;
 
        }
        public ResourcesConfig.ResourceConfigElement Config
        {
            get;
            set;
        }
        #endregion
 
 
 
        #region IResourceConfig<DbConfigElement> Members
 
        public ResourcesConfig.DbConfigElement ResourceConfig
        {
            get
            {
                return this.Config.DbConfig;
            }
        }
 
        #endregion
    }
    public class ResxResource : IResource, IResourceConfig<Infra.ResourcesConfig.ResxConfigElement>
    {
        #region IResource Members
 
        public string GetString(string key)
        {
            return GetString(key, Config.DefaultLanguageId);
        }
 
        public string GetString(string key, string language)
        {
            string culture = ResourceManager.GetLanguageCulture(language);
            Type t=Type.GetType(ResourceConfig.Type);
            System.Resources.ResourceManager rm = new System.Resources.ResourceManager(t);
            return rm.GetString(key,CultureInfo.GetCultureInfo(culture));
        }
        public ResourcesConfig.ResourceConfigElement Config
        {
            get;
            set;
        }
        #endregion
 
        #region IResourceConfig<ResxConfigElement> Members
 
        public ResourcesConfig.ResxConfigElement ResourceConfig
        {
            get
            {
                return this.Config.ResxConfig;
            }
        }
 
        #endregion
    }
    public class XmlResource : IResource, IResourceConfig<Infra.ResourcesConfig.XmlConfigElement>
    {
        XDocument doc = null;
        #region IResource Members
        public string GetString(string key)
        {
            return GetString(key, Config.DefaultLanguageId);
        }
        public string GetString(string key, string language)
        {
            if (doc == null)
            {
                doc = XDocument.Load(ResourceConfig.XmlPath);
            }
            var result = doc.Descendants("Resource")
                .Where(e => e.Attribute(ResourceConfig.KeyAttribute).Value == key)
                .Elements().Where(e=>e.Attribute(ResourceConfig.LanguageAttribute).Value==language);
            return result.FirstOrDefault().Value;
        }
 
        public ResourcesConfig.ResourceConfigElement Config
        {
            get;set;
        }
 
        #endregion
 
        #region IResourceConfig<XmlConfigElement> Members
 
        public ResourcesConfig.XmlConfigElement ResourceConfig
        {
            get
            {
                return this.Config.XmlConfig;
            }
        }
 
        #endregion
    }

Şimdi isterseniz tüm bu yazdıklarımızı wrap edecek olan ResourceManager sınıfımızı yazalım.
    public static class ResourceManager
    {
 
        private static ResourcesConfig _Config = null;
        public static ResourcesConfig Config
        {
            get
            {
 
                try
                {
                    if (_Config == null)
                    {
                        ResourcesConfig config = null;
                        foreach (ConfigurationSection cs in System.Configuration.ConfigurationManager.OpenExeConfiguration(System.Configuration.ConfigurationUserLevel.None).Sections)
                        {
                            if (cs.ElementInformation.Type == typeof(ResourcesConfig))
                            {
                                config = (ResourcesConfig)System.Configuration.ConfigurationManager.GetSection(cs.SectionInformation.Name);
                                break;
                            }
                        }
                        if (config == null)
                        {
                            throw new Exception("Resource configuration not found.");
                        }
                        _Config = config;
                    }
                    return _Config;
                }
                catch (Exception ex)
                {
 
                    throw;
                }
            }
        }
ResourceManager class'ımızı static olarak oluşturuyoruz ve içerisine Config tipinde private bir değişken ve bu değişkeni encapsulate eden readonly bir property yazıyoruz. Bu property'mizin get metodunda ise daha önceden bir config nesnesi oluşturulmamızsa config dosyasındaki bilgileri okuyarak bir config nesnesi oluşturuyoruz ve oluşturduğumuz nesneyi private değişkene atıyoruz.. Bu property'e daha sonraki erişmelerimizde config dosyasına erişilmeyecek değişkende sakladığımız config nesnesi kullanılacaktır. Dolayısıyla bir performans kazancı sağlanacaktır.
 
        private static Dictionary<string, IResource> Resources = new Dictionary<string, IResource>();
 
        public static string GetLanguageCulture(string languageId)
        {
            return Config.Languages.OfType<Infra.ResourcesConfig.LanguageConfigElement>().Where(l => l.Id == languageId).FirstOrDefault().Culture;
        }
        private static IResource GetResource(string name)
        {
            Type t = Type.GetType(name);
            if (t == null)
            {
                throw new Exception("Resource specified can not be found");
            }
            if (t.GetInterface("IResource") == null)
            {
                throw new Exception("Resource specified should implement IResource");
            }
            return (IResource)Activator.CreateInstance(t);
        }
        public static IResource Resource()
        {
            return Resource(Config.DefaultResourceName);
        }
        public static IResource Resource(string resourceName)
        {
            if (!Resources.ContainsKey(resourceName))
            {
                Infra.ResourcesConfig.ResourceConfigElement cfg = Config.Resources.OfType<Infra.ResourcesConfig.ResourceConfigElement>().Where(r => r.Name == resourceName).FirstOrDefault();
                Resources[resourceName] = GetResource(cfg.ResourceType);
                Resources[resourceName].Config = cfg;
            }
            return Resources[resourceName];
        }
    }
Config dosyasında tanımladığımız tüm resource'ları saklayabileceğimiz bir private değişken oluşturuyoruz ve adına Resources diyoruz.

GetResource metodunda ise string olarak verilen tipteki bir resource nesnemizi oluşturuyoruz. Burada önemli bir nokta bu metodun oluşturabileceği tüm resource nesnelerinin IResource interface'inden türemiş olması gerekliliğidir.

Resource metodlarında ise erişmek istediğimiz bir resource daha önceden oluşturulmuşsa bu nesneyi alıyor ve kullanıyoruz. Daha önceden oluşturulmamış ise GetResource metodu ile resource'umuzu oluşturuyoruz ve bu nesneyi kullanıyoruz.

Şimdi isterseniz resourcemanager nesnemizi nasıl kullanabileceğimizi inceleyelim. Config olarak yukarıda örnek verdiğimiz config'i kullandığımızı düşünürsek;
            //Varsayilan resource'a erismek. Varsayilan resource config de ResourceConfig nesnesinde DefaultResourceName property'sinde tutulmaktadır.
            Infra.IResource resource = Infra.ResourceManager.Resource();
 
            //Herhangi bir resource'a ResourceName kullanarak erismek. ResourceName Config dosyasinda resources collectionunda tanimlanmis resourcelarda bulunan name property'sinde bulunur.
            resource = Infra.ResourceManager.Resource("XML1");
 
            //Bir resourcedeki bir key icin varsayilan dil bilgisi degerini almak. Varsayilan dil bilgisi kullanilan resource icin DefaultLanguageId property'sinde bulunan degerdir
            string s = resource.GetString("UserName");
 
            //Bir resourcedaki bir key icin herhangi bir dil bilgisini almak. Dil parametresinde config dosyasindaki languages collection'unda ilgili dil icin bulunan Id degeri gecirilmelidir.
            s = resource.GetString("UserName", "2");

Siz de IResource ve IResourceConfig interfacelerini implement ederek kendi resource class'larınızın yazmış olduğumuz ResourceManager ile çalışmasını sağlayabilirsiniz.


Umarım faydalı olmuştur.
Tamer ÖZ
oztamer@hotmail.com
Ornek Kodlar