C # équivalent pour le mot clé Visual Basic: 'Avec' ... 'End With'?

Question

Dans Visual Basic, si vous allez changer plusieurs propriétés d'un objet unique, il y a une déclaration de With/End With:

Dim myObject as Object

// ' Rather than writing:
myObject.property1 = something
myObject.property2 = something2

// ' You can write:

with myObject
   .property1 = something
   .property2 = something2
   ...
End With

Je sais que C # peut le faire lors de la création d'un nouvel objet:

Object myObject = new Object { property1 = something, property2 = something2, ...};

Mais comment dois-je faire que si myOject est déjà créé (comme ce que fait Visual Basic)?

Answer 1

Vous ne pouvez pas le faire en C #.

Cette fonction est spécifique à VB et le plus proche vous pouvez venir en C # est l'objet initialiseur comme vous décrivez.

Answer 2

Comment cela?

static class Extension
{
    public static void With<T>(this T obj, Action<T> a)
    {
        a(obj);
    }    
}

class Program
{
    class Obj
    {
        public int Prop1 { get; set; }
        public int Prop2 { get; set; }
        public int Prop3 { get; set; }
        public int Prop4 { get; set; }
    }

    static void Main(string[] args)
    {
        var detailedName = new Obj();
        detailedName.With(o => {
            o.Prop1 = 1;
            o.Prop2 = 2;
            o.Prop3 = 3;
            o.Prop4 = 4;
        });
    }
}

Answer 3

Si vous essayez d'éviter beaucoup de taper, vous pouvez donner à votre objet un nom plus court:

var x = myObject;
x.property1 = something;
x.property2 = something2;

Answer 4

  

Pourquoi pas C # VB.NET ont de 'avec' opérateur?

     

Beaucoup de gens, y compris les concepteurs de langage C #, estiment que « avec » nuit souvent la lisibilité, et est plus une malédiction qu'une bénédiction. Il est plus clair de déclarer une variable locale avec un nom significatif, et utiliser cette variable pour effectuer plusieurs opérations sur un seul objet, qu'il est d'avoir un bloc avec une sorte de contexte implicite.

     

Skeet @ Jon

Answer 5

VB.NET comprend quelques-uns des défauts de conception de VB6 pour des raisons de compatibilité descendante. Alors que Javascript a la même conception défaut (en effet une même pire, comme ses with conduit à plus ambigus constructions), la plupart des autres langues C-syntaxe ne sont pas, donc il n'y a aucun avantage rétrocompatibilité en ajoutant à C #.

Answer 6

Byers @ Mark répondre est bonne, mais la x variable habitera après les propriétés sont définies. Et vous ne pouvez pas utiliser à nouveau x nom (dans un même bloc).

Essayez ceci ( et l'objet doit être de type de référence dans cet exemple ):

void Main()
{
    var myObject1 = new Foo();
    var myObject2 = new Hoo();

    //elided...

    {
        var _ = myObject1;
        _.MyPropertyA = 2;
        _.MyPropertyB = "3";
    }

    {
        var _ = myObject2;
        _.MyPropertyX = 5;
        _.MyPropertyY = "asd";
    }
}

Answer 7

Si le « avec » l'expression est un type de classe, la « Avec » déclaration équivaut à la création d'une nouvelle variable temporaire de ce type, initialisé à la « Avec » l'expression, et avant chaque premier « » avec cette variable. S'il est un type de structure, cependant, les choses sont plus compliquées. Considérez le code (évidemment pas le sens unique quelque chose normalement écrire, mais écrit comme il est de faire un point:

  With MyPoints(N) ' Array of Point
    N=SomeNewValue
    .X = MyPoints(N).X
    .Y = MyPoints(N).Y
  End With

La déclaration « Avec » verrouille en fait une référence à MyPoints (N). Même si MyPoints est changé à un autre tableau, ou N est modifié, la référence verrouillée pointeront toujours au même élément du même tableau qu'il a fait quand la déclaration a été exécutée avec. Si l'on a déclaré une variable locale P de type Point et MyPoints (N) attrapé, puis écrire à P.X et P.Y, les écritures n'atteindraient la copie locale P, plutôt que de mettre à jour le tableau. Pour obtenir une sémantique similaire en C #, il faudrait soit utiliser des variables locales pour tenir les deux MyPoints et N, ou autre endroit où le contenu de l'instruction With dans une fonction anonyme qui a un paramètre ref de type Point. Pour éviter d'avoir à créer une fermeture à l'exécution, la fonction anonyme doit également accepter, probablement par référence, toutes les variables locales dont il aura besoin du champ d'application externe.