C# file più impostazioni con la stessa interfaccia

Question

Sto cercando di creare un programma con due (o più) set discreti di impostazioni, che sono entrambi conformi alla stessa interfaccia. In particolare mi piacerebbe fare qualcosa come il seguente, usando le impostazioni generate dal designer:

IMySettings settings = Properties.A;
Console.WriteLine(settings.Greeting);
settings = Properties.B;
Console.WriteLine(settings.Greeting);

Questo sarebbe banale con le interfacce di Go perché qualsiasi classe (?) Che fornisce i metodi può essere assegnato, ma come posso implementarlo in C#, con le sue rigide regole di implementazione dell'interfaccia?

Nota: C#/. Net 2.0

Answer 1

La classe di proprietà. Imposti generati in VS non ti permetterà di farlo. Prendi in considerazione la definizione di una semplice classe DTO e segnarlo con xmlattribute in modo da poterlo deserializzare facilmente.

Answer 2

Puoi usare anche le interfacce in C#.

Tuttavia, dovrai scrivere una classe di facciata se vuoi comunque utilizzare le impostazioni generate dal designer.

Answer 3

Non sono sicuro se quello che stai chiedendo sia come implementare un'interfaccia in C#.

Se lo è, fai qualcosa di simile:

Public Interface IMySettings {
   Public string Greeting {get;set;}
}

Quindi basta avere la tua "A" e "B" implementa questa interfaccia e restituisce il saluto desiderato. Di conseguenza la tua classe Proprietà implementerà gli imyytting rispetto a una classe dritta:

Public class Properties {
   public IMySettings A {get;set;}
   public IMySettings B {get;set;}
}

Quindi, invece di usare "mysettings", il tuo codice sembrerebbe così:

IMySettings settings = Properties.A;

Answer 4

Non sono sicuro che tu possa fare quello che tu attraverso le impostazioni generate dal designer, ma non le uso spesso, quindi potrei sbagliarmi. Tuttavia, c'è un altro modo in cui potresti farlo: creare il tuo Configurazione.

Ecco un esempio:

public class MyProperties : ConfigurationSection {
    [ConfigurationProperty("A")]
    public MySettings A
    {
        get { return (MySettings )this["A"]; }
        set { this["A"] = value; }
    }

    [ConfigurationProperty("B")]
    public MySettings B
    {
        get { return (MySettings )this["B"]; }
        set { this["B"] = value; }
    }
}

public class MySettings : ConfigurationElement {
    [ConfigurationProperty("greeting")]
    public string Greeting
    {
        get { return (string )this["greeting"]; }
        set { this["greeting"] = value; }
    }
}

E poi il tuo app.config/web.config necessita di quanto segue:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="mySettings" type="Namespace.MyProperties, Assembly"/>
    </configSections>
    <mySettings>
        <A greeting="Hello from A!" />
        <B greeting="Hello from B" />
    </mySettings>
</configuration>

Ci possono essere errori di battitura, ma l'idea generale è lì. Spero possa aiutare.

Answer 5

È possibile utilizzare un generatore di codice personalizzato per inserire l'interfaccia nel codice generato (utilizzando il metodo qui: http://brannockdevice.blogspot.co.uk/2006_01_22_archive.html). È molto facile e molto ordinato, ma il problema è che se stai lavorando in un team, dovrebbero tutti aggiornare il loro registro per costruire la soluzione.

Un'altra opzione, e probabilmente la risposta più vicina alla tua domanda originale, è quella di creare una classe di proprietà generiche e quindi popolare, possibilmente tramite un cast esplicito -

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;

namespace ConsoleApplication6
{

    // use this class if you plan to add lots more settings files in future (low maintenance)
    class GenericProps1 
    {
        public string TestString { get; private set; }

        // single cast for all settings files
        public static explicit operator GenericProps1(ApplicationSettingsBase props)
        {
            return new GenericProps1() { TestString = props.Properties["TestString"].DefaultValue.ToString() };
        }
    }

    // use this class if you do NOT plan to add lots more settings files in future (nicer code)
    class GenericProps2 
    {
        public string TestString { get; private set; }

        // cast needed for settings1 file
        public static explicit operator GenericProps2(Properties.Settings1 props)
        {
            return new GenericProps2() { TestString = props.TestString };
        }

        // cast needed for settings 2 file
        public static explicit operator GenericProps2(Properties.Settings2 props)
        {
            return new GenericProps2() { TestString = props.TestString };
        }

        // cast for settings 3,4,5 files go here...
    }


    class Program
    {
        // usage
        static void Main(string[] args)
        {
            GenericProps1 gProps1_1 = (GenericProps1)Properties.Settings1.Default;
            GenericProps1 gProps1_2 = (GenericProps1)Properties.Settings2.Default;
            //or
            GenericProps2 gProps2_1 = (GenericProps2)Properties.Settings1.Default;
            GenericProps2 gProps2_2 = (GenericProps2)Properties.Settings2.Default;
        }
    }

}