Uygulama ayarlarını bir Windows Forms uygulamasına nasıl kaydedebilirim?


582

Ne elde etmek istiyorum çok basit: Bilgi okumak için bir yol kullanan bir Windows Forms (.NET 3.5) uygulaması var. Bu yol, sağladığım seçenekler formu kullanılarak kullanıcı tarafından değiştirilebilir.

Şimdi, yol değerini daha sonra kullanmak üzere bir dosyaya kaydetmek istiyorum. Bu, bu dosyaya kaydedilen birçok ayardan biri olacaktır. Bu dosya doğrudan uygulama klasöründe bulunur.

Üç seçeneğin mevcut olduğunu anlıyorum:

  • ConfigurationSettings dosyası (appname.exe.config)
  • Kayıt
  • Özel XML dosyası

Değerleri geri kaydetmek için .NET yapılandırma dosyasının öngörülmediğini okudum. Kayıt gelince, mümkün olduğunca ondan almak istiyorum.

Bu, yapılandırma ayarlarını kaydetmek için özel bir XML dosyası kullanmam gerektiği anlamına mı geliyor?

Eğer öyleyse, bunun kod örneğini görmek istiyorum (C #).

Bu konuda başka tartışmalar gördüm, ancak bu hala net değil.


Bu bir .NET WinForms uygulaması mı? Öyleyse, .NET'in hangi sürümünü geliştiriyorsunuz?
Portman

1
Evet, bir .NET framework sürüm 3.5 WinForms uygulamasıdır.
Yakıtlı

1
şifreleri veya sır değerlerini kaydetmeniz mi gerekiyor ? Belki herhangi bir şifreleme
Kiquenet

Yanıtlar:


593

Visual Studio ile çalışıyorsanız, görünür ayarları almak oldukça kolaydır. Solution Explorer'da projeye sağ tıklayın ve Özellikler'i seçin. Ayarlar sekmesini seçin ve ayarlar yoksa köprüyü tıklayın.

Uygulama ayarları oluşturmak için Ayarlar sekmesini kullanın. Visual Studio dosyaları oluşturur Settings.settingsve Settings.Designer.settingsbu tekil sınıfını ihtiva Settingsmiras ApplicationSettingsBase . Uygulama ayarlarını okumak / yazmak için kodunuzdan bu sınıfa erişebilirsiniz:

Properties.Settings.Default["SomeProperty"] = "Some Value";
Properties.Settings.Default.Save(); // Saves settings in application configuration file

Bu teknik hem konsol, Windows Forms hem de diğer proje türleri için geçerlidir.

Ayarlarınızın scope özelliğini ayarlamanız gerektiğini unutmayın . Uygulama kapsamını seçerseniz Ayarlar.Default. <Mülkünüz> salt okunur olacaktır.

Başvuru: Nasıl Yapılır: C # ile Çalışma Zamanında Kullanıcı Ayarlarını Yazma - Microsoft Docs


2
bir çözümüm varsa, tüm çözüm için mi yoksa her proje için mi geçerli olacak?
franko_camron

8
@ Dört: Burada bir .NET 4.0 WinApp projem var ve SomeProperty'im salt okunur değil. Settings.Default.SomeProperty = 'value'; Settings.Default.Save();tıkır tıkır çalışıyor. Yoksa Kullanıcı ayarlarım olduğu için mi?
doekman

4
@ Dört: Bir ayarı Kullanıcı'dan Uygulama kapsamına değiştirip dosyayı kaydettiğimde, oluşturulan kodda ayarlayıcının kaybolduğunu gördüm. Bu, İstemci profili 4.0 ile de olur ...
doekman

3
@ Dört: harika bir bağlantı, Settings.Default.Save()hiçbir şey yanlış olmadığını ifade rağmen . @Aku yanıtta belirtildiği gibi, uygulama kapsamı ayarları salt okunurdur: kaydetme onlar için etkisizdir. Kullanıcı kapsamı ayarlarını, exe'nin kullanıcının AppData klasöründeki yerine app.config dosyasına kaydetmek için bu özel PortableSettingsProvider öğesini kullanın . Hayır, genellikle iyi değil, ancak geliştirme sırasında derlemeden derlemeye aynı ayarları kullanmak için kullanıyorum (w / o, her derleme ile yeni benzersiz kullanıcı klasörlerine gidiyorlar).
minnow

7
Şu andan itibaren .NET 3.5 ile bir değer atamak ve güçlü tipleme almak için Settings.Default.SomeProperty'yi kullanabilirsiniz. Ayrıca, başkalarına zaman kazandırmak için (bunu çözmem biraz zaman aldı), ya Properties.Settings.Default yazmanız ya da dosyanızın en üstüne YourProjectNameSpace.Settings öğesini kullanarak eklemeniz gerekir. "Ayarlar" tek başına tanımlanmamış / bulunamadı.
eselk

95

Yürütülebilir dosya ile aynı dizindeki bir dosyaya kaydetmeyi planlıyorsanız, JSON biçimini kullanan hoş bir çözüm aşağıdadır :

using System;
using System.IO;
using System.Web.Script.Serialization;

namespace MiscConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            MySettings settings = MySettings.Load();
            Console.WriteLine("Current value of 'myInteger': " + settings.myInteger);
            Console.WriteLine("Incrementing 'myInteger'...");
            settings.myInteger++;
            Console.WriteLine("Saving settings...");
            settings.Save();
            Console.WriteLine("Done.");
            Console.ReadKey();
        }

        class MySettings : AppSettings<MySettings>
        {
            public string myString = "Hello World";
            public int myInteger = 1;
        }
    }

    public class AppSettings<T> where T : new()
    {
        private const string DEFAULT_FILENAME = "settings.json";

        public void Save(string fileName = DEFAULT_FILENAME)
        {
            File.WriteAllText(fileName, (new JavaScriptSerializer()).Serialize(this));
        }

        public static void Save(T pSettings, string fileName = DEFAULT_FILENAME)
        {
            File.WriteAllText(fileName, (new JavaScriptSerializer()).Serialize(pSettings));
        }

        public static T Load(string fileName = DEFAULT_FILENAME)
        {
            T t = new T();
            if(File.Exists(fileName))
                t = (new JavaScriptSerializer()).Deserialize<T>(File.ReadAllText(fileName));
            return t;
        }
    }
}

Evet, başka bir dizine kaydetmek istiyorsanız DEFAULT_FILENAME öğesini mutlak bir yola değiştirin. Dosyayı uygulama ile aynı dizine veya bir alt dizine kaydetmek en yaygın olanıdır.
Trevor

Oh, belki de daha iyi bir seçenek, ayarlar dosyasını kullanıcının appdata klasöründe saklamak olabilir.
Trevor

1
Değiştirmeye gerek yok DEFAULT_FILENAME, sadece arayın settings.Save(theFileToSaveTo); Tüm kapaklar olmak, DEFAULT_FILENAMEbir sabit olması gerekiyordu . Bir okuma-yazma özelliği istiyorsanız, bir tane yapın ve yapıcıyı bu değere ayarlayın DEFAULT_FILENAME. Ardından varsayılan bağımsız değişken değerini alın null, bunu test edin ve mülkünüzü varsayılan değer olarak kullanın. Biraz daha yazıyor, ancak size daha standart bir arayüz sağlıyor.
Jesse Chisholm

10
System.Web.Extensions.dllHenüz yapmadıysanız başvurmanız gerekir .
TEK

9
Pek çok iyileştirme ile bu cevaba dayalı bir kütüphane oluşturdum ve nuget'te mevcut hale getirdim: github.com/Nucs/JsonSettings
NucS

67

Kayıt bir no-go. Uygulamanızı kullanan kullanıcının kayıt defterine yazmak için yeterli haklara sahip olup olmadığından emin değilsiniz.

Kullanabilirsiniz app.configDosyayı uygulama düzeyindeki ayarları (uygulamanızı kullanan her kullanıcı için aynı olan) kaydetmek için .

İzole Depolama veya SpecialFolder.ApplicationData kaydedilecek bir XML dosyasında kullanıcıya özgü ayarları depolamak istiyorum dizininde .

Bunun yanında, .NET 2.0'dan itibaren değerleri app.configdosyaya geri kaydetmek mümkündür .


8
Her oturum açma / kullanıcı ayarını istiyorsanız kayıt defterini kullanın.
thenonhacker

19
Kayıt defteri taşınamaz
Kb.

10
@thenonhacker: Veya Environment.GetFolderPath (Environment.SpecialFolder.ApplicationData) kullanın
Kenny Mann

4
Kullanıcı kayıt defterine yazılabilir (birçok program orada bilgi yazar ve kullanıcı izinleri asla sorun değildir). Kayıt defterini ayarları kullanmanın üzerinde kullanmanın avantajı, aynı klasörü paylaşan birden fazla uygulamanız varsa (örneğin, bir kurulum programı ve bir uygulama programı), aynı ayarları paylaşmayacaklarıdır.
Kesty

3
Kayıt Defteri'nin ana dezavantajı, ayarları diğer PC'ye aktarmanın / kopyalamanın zor yoludur. Ama kabul etmiyorum "Uygulamanızı kullanan kullanıcının kayıt defterine yazmak için yeterli haklara sahip olup olmadığından emin değilsiniz" - HKEY_CURRENT_USER içinde her zaman yazma haklarına sahipsiniz. Reddedilebilir ancak dosya sistemine geçerli kullanıcı için (tüm olası TEMP klasörleri vb.) Erişilemez.
i486

20

ApplicationSettingsSınıf için ayarları kaydedilirken desteklemez app.config dosyası. Bu çok tasarım gereği; düzgün güvenli bir kullanıcı hesabıyla (Vista UAC düşünüyorum) çalışan uygulamaların programın yükleme klasörüne yazma erişimi yoktur.

Sistemle ConfigurationManagersınıfla savaşabilirsiniz . Ancak önemsiz çözüm, Ayarlar tasarımcısına gidip ayarın kapsamını Kullanıcı olarak değiştirmektir. Bu zorluklara neden oluyorsa (örneğin, ayar her kullanıcı için geçerlidir), ayrıcalık yükselmesi istemini sorabilmeniz için Seçenekler özelliğinizi ayrı bir programa koymalısınız. Veya bir ayar kullanmayı bırakın.


Lütfen son cümlenizi genişletebilir misiniz? App.config yazmak veya tüm kullanıcıların ev katmanlarından geçecek ayrı bir uygulama yazmak, user.config dosyasını aramak ve bunları düzenlemek için yükseklik isteyin?
CannibalSmith

2
Ayrı program, yükseklik istemek için bir bildirim gerektirir. Google 'asinvoker yöneticisinin' uygun sözdizimini bulmasını gerektirir. User.config dosyasını düzenlemek ne pratik ne de gerekli.
Hans Passant

18

Registry / configurationSettings / XML argümanı hala çok aktif görünüyor. Teknoloji ilerledikçe hepsini kullandım, ancak favorim Threed'in İzole Depolama ile birleştirilmiş sistemine dayanıyor .

Aşağıdaki örnek, özellikler adlı nesnelerin yalıtılmış depolamadaki bir dosyaya depolanmasına izin verir. Gibi:

AppSettings.Save(myobject, "Prop1,Prop2", "myFile.jsn");

Özellikler aşağıdakiler kullanılarak kurtarılabilir:

AppSettings.Load(myobject, "myFile.jsn");

Bu sadece bir örnektir, en iyi uygulamaları düşündürmez.

internal static class AppSettings
{
    internal static void Save(object src, string targ, string fileName)
    {
        Dictionary<string, object> items = new Dictionary<string, object>();
        Type type = src.GetType();

        string[] paramList = targ.Split(new char[] { ',' });
        foreach (string paramName in paramList)
            items.Add(paramName, type.GetProperty(paramName.Trim()).GetValue(src, null));

        try
        {
            // GetUserStoreForApplication doesn't work - can't identify.
            // application unless published by ClickOnce or Silverlight
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForAssembly();
            using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(fileName, FileMode.Create, storage))
            using (StreamWriter writer = new StreamWriter(stream))
            {
                writer.Write((new JavaScriptSerializer()).Serialize(items));
            }

        }
        catch (Exception) { }   // If fails - just don't use preferences
    }

    internal static void Load(object tar, string fileName)
    {
        Dictionary<string, object> items = new Dictionary<string, object>();
        Type type = tar.GetType();

        try
        {
            // GetUserStoreForApplication doesn't work - can't identify
            // application unless published by ClickOnce or Silverlight
            IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForAssembly();
            using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(fileName, FileMode.Open, storage))
            using (StreamReader reader = new StreamReader(stream))
            {
                items = (new JavaScriptSerializer()).Deserialize<Dictionary<string, object>>(reader.ReadToEnd());
            }
        }
        catch (Exception) { return; }   // If fails - just don't use preferences.

        foreach (KeyValuePair<string, object> obj in items)
        {
            try
            {
                tar.GetType().GetProperty(obj.Key).SetValue(tar, obj.Value, null);
            }
            catch (Exception) { }
        }
    }
}

1
Ya da daha iyisi; DataContractJsonSerializer kullanın
Boczek

16

Bunun için inşa ettiğim bir kütüphaneyi paylaşmak istedim. Küçük bir kütüphane, ancak .settings dosyaları üzerinde büyük bir gelişme (IMHO).

Kütüphaneye Jot (GitHub) adı verilir . İşte bu konuda yazdığım eski bir Kod Projesi makalesi .

Bir pencerenin boyutunu ve konumunu izlemek için onu nasıl kullanacağınız aşağıda açıklanmıştır:

public MainWindow()
{
    InitializeComponent();

    _stateTracker.Configure(this)
        .IdentifyAs("MyMainWindow")
        .AddProperties(nameof(Height), nameof(Width), nameof(Left), nameof(Top), nameof(WindowState))
        .RegisterPersistTrigger(nameof(Closed))
        .Apply();
}

.Settings dosyalarına kıyasla avantajı: Çok daha az kod var ve her özellikten sadece bir kez bahsetmeniz gerektiğinden hataya daha az eğilimli .

Bir ayar dosyaları ile her bir özellikten beşini belirtmeniz gerekir kez : bir kez özelliği açıkça oluşturduğunuzda ve kodda değerleri ileri geri kopyalayan dört kez daha.

Depolama, serileştirme vb. Tamamen yapılandırılabilir. Hedef nesneler bir IoC tarafından oluşturulduğunda kapsayıcısı , çözdüğü tüm nesnelere otomatik olarak izleme uygulayabilmesi için [bağlayabilir] [] yapabilirsiniz, böylece bir mülkü kalıcı hale getirmek için yapmanız gereken tek şey bir tokat atmaktır öznitelik.

Oldukça yapılandırılabilir ve şunları yapılandırabilirsiniz: - veriler küresel olarak veya her izlenen nesne için kalıcı olarak uygulandığında - nasıl serileştirildiği - depolandığı yerde (örn. Dosya, veritabanı, çevrimiçi, yalıtılmış depolama, kayıt defteri) - uygulamayı iptal edebilen kurallar / bir mülke ait kalıcı veriler

Güven bana, kütüphane birinci sınıf!


14

Basit bir yol, bir yapılandırma veri nesnesi kullanmak, onu yerel Klasördeki uygulamanın adıyla bir XML dosyası olarak kaydetmek ve başlangıçta onu tekrar okumaktır.

Formun konumunu ve boyutunu saklamak için bir örnek.

Yapılandırma veri nesnesi güçlü bir şekilde yazılmıştır ve kullanımı kolaydır:

[Serializable()]
public class CConfigDO
{
    private System.Drawing.Point m_oStartPos;
    private System.Drawing.Size m_oStartSize;

    public System.Drawing.Point StartPos
    {
        get { return m_oStartPos; }
        set { m_oStartPos = value; }
    }

    public System.Drawing.Size StartSize
    {
        get { return m_oStartSize; }
        set { m_oStartSize = value; }
    }
}

Kaydetme ve yükleme için bir yönetici sınıfı:

public class CConfigMng
{
    private string m_sConfigFileName = System.IO.Path.GetFileNameWithoutExtension(System.Windows.Forms.Application.ExecutablePath) + ".xml";
    private CConfigDO m_oConfig = new CConfigDO();

    public CConfigDO Config
    {
        get { return m_oConfig; }
        set { m_oConfig = value; }
    }

    // Load configuration file
    public void LoadConfig()
    {
        if (System.IO.File.Exists(m_sConfigFileName))
        {
            System.IO.StreamReader srReader = System.IO.File.OpenText(m_sConfigFileName);
            Type tType = m_oConfig.GetType();
            System.Xml.Serialization.XmlSerializer xsSerializer = new System.Xml.Serialization.XmlSerializer(tType);
            object oData = xsSerializer.Deserialize(srReader);
            m_oConfig = (CConfigDO)oData;
            srReader.Close();
        }
    }

    // Save configuration file
    public void SaveConfig()
    {
        System.IO.StreamWriter swWriter = System.IO.File.CreateText(m_sConfigFileName);
        Type tType = m_oConfig.GetType();
        if (tType.IsSerializable)
        {
            System.Xml.Serialization.XmlSerializer xsSerializer = new System.Xml.Serialization.XmlSerializer(tType);
            xsSerializer.Serialize(swWriter, m_oConfig);
            swWriter.Close();
        }
    }
}

Artık bir örnek oluşturabilir ve formunuzun yükleme ve kapatma etkinliklerinde kullanabilirsiniz:

    private CConfigMng oConfigMng = new CConfigMng();

    private void Form1_Load(object sender, EventArgs e)
    {
        // Load configuration
        oConfigMng.LoadConfig();
        if (oConfigMng.Config.StartPos.X != 0 || oConfigMng.Config.StartPos.Y != 0)
        {
            Location = oConfigMng.Config.StartPos;
            Size = oConfigMng.Config.StartSize;
        }
    }

    private void Form1_FormClosed(object sender, FormClosedEventArgs e)
    {
        // Save configuration
        oConfigMng.Config.StartPos = Location;
        oConfigMng.Config.StartSize = Size;
        oConfigMng.SaveConfig();
    }

Ve üretilen XML dosyası da okunabilir:

<?xml version="1.0" encoding="utf-8"?>
<CConfigDO xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <StartPos>
    <X>70</X>
    <Y>278</Y>
  </StartPos>
  <StartSize>
    <Width>253</Width>
    <Height>229</Height>
  </StartSize>
</CConfigDO>

1
Bu geliştirme harika çalışıyor var, ama uygulamayı dağıttığınızda ortalama kullanıcı c:\program files\my applicationklasöre erişim yok , bu yüzden ayarların kaydedilmesi bir hata atar. Bunun yerine xml dosyasını AppData'da kaydetmeye bakıyorum, ancak bu yaklaşımın sizin için çalıştığı görülüyor, çünkü bu sorunun etrafında bariz bir yol olup olmadığını merak ettim.
Philip Stratford

@PhilipStratford Yalnızca normal bir dosya olduğundan, istediğiniz yere kaydedebilirsiniz. Sadece yazma erişimi olan bir yer bulun.
Dieter Meemken

@PhilipStratford AppData klasörü sizin için bir seçenek olabilir, bkz. C # uçurtma tarafından belirtildiği gibi % AppData% yolunu alıyor .
Dieter Meemken

Teşekkürler, xml dosyasını AppDate klasörüne kaydederek bunu zaten uyguladım. Sadece örnek olarak uygulamanın klasörüne kaydetmek için kolay bir yol olup olmadığını merak ettim, çünkü çalıştığını kabul etti. Endişelenmeyin, AppData klasörü muhtemelen daha iyi bir konumdur!
Philip Stratford


5

Diğer seçenekler, özel bir XML dosyası kullanmak yerine daha kullanıcı dostu bir dosya biçimi kullanabiliriz: JSON veya YAML dosyası.

  • .NET 4.0 dinamik kullanıyorsanız, bu kitaplığın kullanımı gerçekten kolaydır (serileştirme, serileştirme, iç içe geçmiş nesneler desteği ve çıktıyı istediğiniz gibi birleştirme + birden çok ayarı bir araya getirme ) JsonConfig (kullanım ApplicationSettingsBase ile eşdeğerdir)
  • .NET YAML yapılandırma kitaplığı için ... JsonConfig kadar kullanımı kolay bir tane bulamadım

(Tüm kullanıcılar için ve her kullanıcı için) Burada listelenen gibi birden özel klasörlerde ayarları dosyasını saklayabilirsiniz Environment.SpecialFolder Numaralama ve birden fazla dosya (varsayılan kullanıcı başına, rol başına, sadece vs. okunur)

Birden çok ayar kullanmayı seçerseniz, bu ayarları birleştirebilirsiniz: Örneğin, varsayılan + BasicUser + AdminUser için ayarları birleştirme. Kendi kurallarınızı kullanabilirsiniz: sonuncusu değeri geçersiz kılar vb.


4

"Bu, yapılandırma ayarlarını kaydetmek için özel bir XML dosyası kullanmam gerektiği anlamına mı geliyor?" Hayır, ille de değil. Bu tür işlemler için SharpConfig kullanıyoruz.

Örneğin, bir yapılandırma dosyası böyle ise

[General]
# a comment
SomeString = Hello World!
SomeInteger = 10 # an inline comment

Bunun gibi değerleri alabiliriz

var config = Configuration.LoadFromFile("sample.cfg");
var section = config["General"];

string someString = section["SomeString"].StringValue;
int someInteger = section["SomeInteger"].IntValue;

.NET 2.0 ve üstü ile uyumludur. Anında yapılandırma dosyaları oluşturabilir ve daha sonra kaydedebiliriz.

Kaynak: http://sharpconfig.net/
GitHub: https://github.com/cemdervis/SharpConfig


3

Anlayabildiğim kadarıyla, .NET yerleşik uygulama ayarları özelliğini kullanarak kalıcı ayarları destekliyor:

Windows Forms'un Uygulama Ayarları özelliği, istemci bilgisayarda özel uygulama ve kullanıcı tercihleri ​​oluşturmayı, depolamayı ve bakımını kolaylaştırır. Windows Forms uygulama ayarlarıyla, yalnızca veritabanı bağlantı dizeleri gibi uygulama verilerini değil, aynı zamanda kullanıcı uygulama tercihleri ​​gibi kullanıcıya özgü verileri de saklayabilirsiniz. Visual Studio veya özel yönetilen kod kullanarak, yeni ayarlar oluşturabilir, bunları okuyabilir ve diske yazabilir, formlarınızdaki özelliklere bağlayabilir ve yükleme ve kaydetmeden önce ayar verilerini doğrulayabilirsiniz. - http://msdn.microsoft.com/tr-tr/library/k4s6c3a0.aspx


2
Doğru değil .. yukarıdaki aku'nun cevabına bakınız. Ayarlar ve ApplicationSettingsBase kullanarak mümkün
Gishu

2

Bazen geleneksel web.config veya app.config dosyasında tutulan ayarlardan kurtulmak istersiniz. Ayar girişlerinizin ve ayrı veri tasarımının konuşlandırılması üzerinde daha hassas bir kontrol istiyorsanız. Veya gereksinim, çalışma zamanında yeni girdiler eklemeyi etkinleştirmektir.

İki iyi seçenek hayal edebiliyorum:

  • Güçlü yazılmış sürüm ve
  • Nesneye yönelik sürüm.

Güçlü yazılan sürümün avantajı, güçlü yazılan ayar adları ve değerleridir. Adları veya veri türlerini karıştırma riski yoktur. Dezavantajı, daha fazla ayarın kodlanması gerektiğidir, çalışma zamanında eklenemez.

Nesneye yönelik sürümde avantaj, çalışma zamanında yeni ayarların eklenebilmesidir. Ancak, güçlü bir şekilde yazılmış adlarınız ve değerleriniz yok. Dize tanımlayıcılarına dikkat etmelisiniz. Bir değer alınırken daha önce kaydedilen veri türünü bilmelidir.

Her iki tamamen işlevsel uygulamanın kodunu BURADA bulabilirsiniz .


2

Evet, yapılandırmayı kaydetmek mümkündür - ancak hemen hemen bunu nasıl yapacağınıza bağlıdır. Sahip olduğunuz seçenekleri anlayabilmeniz için teknik farklılıkları açıklayayım:

Kullanmak isteyip İlk olarak, ayırt etmek gerekir applicationSettings veya AppSettings'i sizin de *.exe.config(aka App.configvardır - Visual Studio içinde) dosyası temel farklılıklar, burada nitelendiriliyor .

Her ikisi de değişiklikleri kaydetmenin farklı yollarını sunar:

  • AppSettings'i okuyup (aracılığıyla yapılandırma dosyasında doğrudan yazmak için izin config.Save(ConfigurationSaveMode.Modified);yapılandırma olarak tanımlanır, config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);).

  • ApplicationSettings okumasına izin, ancak (aracılığıyla değişiklikleri yazarsanız Properties.Settings.Default.Save();) özel bir yerde (örneğin saklanan bir başına kullanıcı bazında yazılacaktır C:\Documents and Settings\USERID\Local Settings\Application Data\FIRMNAME\WindowsFormsTestApplicati_Url_tdq2oylz33rzq00sxhvxucu5edw2oghw\1.0.0.0). As Hans Passant sözü onun cevabını genellikle kullanıcı Program Files haklarını kısıtladı ve hızlı UAC yürütmesini olmadan kendisine yazamıyor çünkü, bu. Bir dezavantajı, gelecekte yapılandırma anahtarları ekliyorsanız, bunları her kullanıcı profiliyle senkronize etmeniz gerekir.

Not: Soruda belirtildiği gibi, 3. bir seçenek vardır: Yapılandırma dosyasını XML belgesi olarak ele alırsanız, System.Xml.Linq.XDocumentsınıfı kullanarak yükleyebilir, değiştirebilir ve kaydedebilirsiniz . Özel bir XML dosyası kullanmak gerekmez, mevcut yapılandırma dosyasını okuyabilirsiniz; öğeleri sorgulamak için Linq sorgularını bile kullanabilirsiniz. Burada bir örnek verdim GetApplicationSetting, cevabın içindeki işleve bakın .

Değerlerinizi korumak için şifrelemeye ihtiyacınız varsa bu cevaba göz atın .


Bu mükemmel cevap için teşekkürler.
NoChance

2
@NoChance - Rica ederim, sana yardım edebildiğim için memnunum!
Matt

Güzel! Sonunda hepsini anladım Mom
Momoro

1
@Momoro - duymak güzel! ;-)
Matt

1
public static class SettingsExtensions
{
    public static bool TryGetValue<T>(this Settings settings, string key, out T value)
    {
        if (settings.Properties[key] != null)
        {
            value = (T) settings[key];
            return true;
        }

        value = default(T);
        return false;
    }

    public static bool ContainsKey(this Settings settings, string key)
    {
        return settings.Properties[key] != null;
    }

    public static void SetValue<T>(this Settings settings, string key, T value)
    {
        if (settings.Properties[key] == null)
        {
            var p = new SettingsProperty(key)
            {
                PropertyType = typeof(T),
                Provider = settings.Providers["LocalFileSettingsProvider"],
                SerializeAs = SettingsSerializeAs.Xml
            };
            p.Attributes.Add(typeof(UserScopedSettingAttribute), new UserScopedSettingAttribute());
            var v = new SettingsPropertyValue(p);
            settings.Properties.Add(p);
            settings.Reload();
        }
        settings[key] = value;
        settings.Save();
    }
}
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.