Kann ich mit einem auflistungsinitialisierer für ein Attribut?

Kann ein Attribut in C# verwendet werden, mit einem auflistungsinitialisierer?

Zum Beispiel, würde ich mag, um etwas zu tun, wie die folgenden:

[DictionaryAttribute(){{"Key", "Value"}, {"Key", "Value"}}]
public class Foo { ... }

Ich weiß, können Attribute besitzen benannte Parameter, und da scheint ziemlich ähnlich zu Objekt-Initialisierungen, ich Frage mich, ob die auflistungsinitialisierer wurden ebenfalls angeboten.

Scott, es tut mir Leid - meine Antwort ist fehlgeschlagen. Ich nicht verdienen Sie bis Stimme. Bitte Stimmen Sie unten cos seine fair-play.
Sie sollten nicht Ihre Antwort gelöscht! Manchmal ist die falsche Antwort ist noch hilfreich ... nur aktualisieren Sie Ihre Antwort nächste Zeit, so dass die Menschen verstehen, warum es falsch ist.
Ok. 🙂 Ich habe es wiederherstellen.

InformationsquelleAutor Scott Rippey | 2011-08-03

attributes c#collection-initializer custom-attributes object-initializers

6

Update: tut mir Leid das ich mich Irre - array von benutzerdefinierten Typ ist unmöglich 🙁
Den Arten von positionale und benannte Parameter für das Attribut Klasse
beschränkt sich auf das Attribut parameter-Typen, die sind:
1. Eine der folgenden Arten: bool, byte, char, double, float,
  int, long, short, string.
2. Das type-Objekt.
3. Das Typ-System.Typ.
4. Eines Enum-Typs, vorausgesetzt, es hat die öffentliche Zugänglichkeit und die Arten
  in dem es verschachtelt ist (wenn überhaupt) auch haben öffentliche Zugänglichkeit (Abschnitt
  17.2).
5. Eindimensionalen arrays der oben Arten.
  Quelle
Quelle: stackoverflow.

KÖNNEN Sie DEKLARIEREN ein array übergeben, von einem benutzerdefinierten Typ:
```
class TestType
{
  public int Id { get; set; }
  public string Value { get; set; }

  public TestType(int id, string value)
  {
    Id = id;
    Value = value;
  }
}

class TestAttribute : Attribute
{
  public TestAttribute(params TestType[] array)
  {
    //
  }
}
```
aber der Kompilierung Fehler auftreten, auf die Attribut-Deklaration:
```
[Test(new[]{new TestType(1, "1"), new TestType(2, "2"), })]
public void Test()
{

}
```
- Da haben Sie die params in es, lassen Sie sich die new[]{...} für eine viel schönere syntax. Jedoch sind Sie sicher, dass dies kompiliert? Ich denke Attribut Argumente haben Grenzen -- konstanter Ausdruck, typeof-Ausdruck oder ein array creation expression -- wie erwähnt wurde von @Jason nach Unten.
- das ist ein array-creation-expression. 🙂 (By the way, werde ich löschen meine Antwort; als Jason wies darauf hin, dass es nicht gut ist.)
- Im sorry, Im failed 🙁
- Vielen Dank für das update und für den Hinweis auf die große MSDN-Referenz!
InformationsquelleAutor vladimir
5

Abschnitt 17.1.3 der C# - 4.0-Spezifikation, die speziell die nicht für mehrdimensionale arrays innerhalb der Attribut-Parameter, so dass während Foo(string[,] bar) erlauben könnte, Sie zum Aufruf von Foo(new [,] {{"a", "b"}, {"key2", "Wert2"}}), ist es leider nicht verfügbar für Attribute.

Also, denken Sie daran, ein paar Möglichkeiten, um Ungefähre, was Sie wollen, sind:
1. Benutzen ein eindimensionales array mit alternierenden Schlüssel-Wert-Paare. Der offensichtliche Nachteil dieses Ansatzes ist, dass es nicht gerade die Durchsetzung der Namen und Werte.
2. Ermöglichen, Ihre parameter angezeigt, die mehrere Male durch tagging Ihre Attribut-definition mit dem folgenden Attribut:
```
[AttributeUsage(AllowMultiple=true)]
```
  In diesem way, Sie können nun definieren:
```
[KeyVal("key1","val1"), KeyVal("key2","val2")]
public class Foo { ... }
```
  Dies ist ein bisschen wordier als das, was ich bin sicher, dass Sie wurden Hoffnung für, aber es macht eine klare Unterscheidung zwischen dem Namen und Werte.
3. Finden Sie eine JSON-Paket und bieten einen Initialisierer für das Attribut. Die Leistung trifft, ist belanglos, da diese während der code-Initialisierung. Mit Newtonsoft.Json zum Beispiel könnten Sie ein Attribut wie so:
```
    public class JsonAttribute : Attribute
    {
      Dictionary<string, string> _nameValues = 
          new Dictionary<string, string>();
      public JsonAttribute(string jsoninit)
      {
        var dictionary = new Dictionary<string, string>();
        dynamic obj = JsonConvert.DeserializeObject(jsoninit);
        foreach(var item in obj)
          _nameValues[item.Name] = item.Value.Value;
      }
    }
```
  Die es erlaubt, dass Sie instanziieren ein Attribut wie so:
```
[Json(@"{""key1"":""val1"", ""key2"":""val2""}")]
public class Foo { ... }
```
  Ich weiß, es ist ein kleines Zitat-happy, viel mehr beteiligt, aber es gibt Sie. Unabhängig davon, in dieser verrückten dynamischen Welt, zu wissen, wie Sie initialisiert werden die Objekte mit JSON ist keine schlechte Fähigkeit zu haben, in Ihrer Hosentasche.
- Vielen Dank für Ihre Anregungen! #1 scheint wie eine menschenwürdige Abhilfe. #2 ist eine großartige Lösung für einige Szenarien, funktioniert aber nicht für alle Szenarien. Und #3 ... reden über overkill, aber vielen Dank für denken außerhalb der box!
- Interessanterweise Lösung #3 wird wahrscheinlich den test der Zeit stehen, sowie alle zusätzlichen Attribute, für die Sie möchten, um diese Technik zu verwenden, kann direkt abgeleitet werden aus JsonAttribute. Aber wenn einer nicht kompilieren-Lösung ist das, was Sie sind nach, ich bin mir sicher, dass einer der anderen Antworten werden mehr nach Ihren wünschen. 😉
- Das stimmt, Ihre Lösungen sind die einzigen, die kompilieren 🙂
- Ich habe laufen in diesem als auch, ich landete mit 2 Einzel-dimensionale arrays, eins für die Schlüssel und einem Vordergrund die Werte. Beide waren string-arrays im Konstruktor hatte ich einen Scheck, um sicherzustellen, dass die Längen der arrays abgestimmt, um zu verhindern, dass einige rudimentäre Fehler. [IsRequired(new[] {"CountryId"}, new[]{"1"})]
InformationsquelleAutor Michael Hays
3

Die kurze Antwort ist Nein.

Längere Antwort: In Ordnung für eine Klasse zu unterstützen, die auflistungsinitialisierer, die es braucht, um IEnumerable implementieren und es muss eine add-Methode. So zum Beispiel:
```
public class MyClass<T,U> : IEnumerable<T>
{
    public void Add(T t, U u)
    {
    }

    public IEnumerator<T> GetEnumerator()
    {
        throw new NotImplementedException();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}
```
Kann ich dann dies tun:
```
var mc = new MyClass<int, string> {{1, ""}, {2, ""}};
```
Also mit diesem, lassen Sie uns versuchen, es zu machen, arbeiten für ein Attribut. (Randbemerkung, da Attribute nicht unterstützen, Generika, ich bin nur hartzucodieren es mit strings zum testen) :
```
public class CollectionInitAttribute : Attribute, IEnumerable<string>
{
    public void Add(string s1, string s2)
    {

    }

    public IEnumerator<string> GetEnumerator()
    {
        throw new NotImplementedException();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}
```
Und jetzt, um es zu testen:
```
[CollectionInit{{"1","1"}}]
public class MyClass
{

}
```
ist, und das nicht kompilieren 🙁 ich bin nicht sicher, wo die Begrenzung ist genau, ich vermute Attribute sind nicht newed denselben Weg auf ein reguläres Objekt ist und daher dies nicht unterstützt. Ich würde gespannt sein, ob dies theoretisch möglich ist, unterstützt von einer zukünftigen version der Sprache....
- Vielen Dank für Ihre kurze Antwort und Ihre langen! Das ist genau das, was ich versucht habe auch, aber wenn es nicht kompilieren, ich war nicht sicher, ob es wurde eine fehlerhafte syntax oder ein nicht unterstütztes feature. Ich wusste nicht, dass Generika nicht durften.
- FYI, ich mag deine Antworten sehr, aber ich entschied mich zu akzeptieren, @vladimir77 Antwort nur, weil es eine definitive Antwort zitiert aus der MSDN-Website, und es scheint die beste Antwort für die Frage.
- keine große Sache. Ich möchte nur darauf hinweisen, dass dies nicht ein Problem der benannte Parameter, wie das ist, NICHT das, was Sie zu tun versuchten. Sie waren versucht, die Sammlung intializer syntax, das ist eine seperate Sache...
- Ja, das ist wahr, benannte Parameter sind völlig unabhängig voneinander zu auflistungsinitialisierer. Aber ich denke, der Grund, warum ich gern @Vladimir77 die Antwort ist, weil es besagt, was genau für ein Attribute unterstützt.
InformationsquelleAutor BFree

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.