Explicit parameter names.

sergey-shandar · sergey-shandar · commit c6e89cac9c12 · 2017-12-05T22:17:43.000-08:00
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/Extensions.cs b/src/ResourceManager/Common/Commands.Common.Strategies/Extensions.cs
@@ -21,6 +21,12 @@ namespace Microsoft.Azure.Commands.Common.Strategies
 {
     public static class Extensions
     {
+        /// <summary>
+        /// Returns an empty sequence if the given parameter is null.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="value"></param>
+        /// <returns></returns>
         public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> value)
             => value ?? Enumerable.Empty<T>();
 
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/GetStateExtensions.cs b/src/ResourceManager/Common/Commands.Common.Strategies/GetStateExtensions.cs
@@ -39,7 +39,8 @@ public static async Task<IState> GetStateAsync<TModel>(
             return context.Result;
         }
 
-        static Task GetStateAsyncDispatch(this StateOperationContext context, IResourceConfig config)
+        static Task GetStateAsyncDispatch(
+            this StateOperationContext context, IResourceConfig config)
             => config.Accept(new GetStateAsyncVisitor(), context);
 
         static async Task GetStateAsync<TModel>(
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/IEntityConfig.cs b/src/ResourceManager/Common/Commands.Common.Strategies/IEntityConfig.cs
@@ -17,7 +17,7 @@
 namespace Microsoft.Azure.Commands.Common.Strategies
 {
     /// <summary>
-    /// Base interface for ResourceConfig and NestedResourceConfig.
+    /// Base interface for ResourceConfig[TModel] and NestedResourceConfig[TModel, TParentModel].
     /// </summary>
     public interface IEntityConfig
     {
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/IEntityConfigVisitor.cs b/src/ResourceManager/Common/Commands.Common.Strategies/IEntityConfigVisitor.cs
@@ -30,7 +30,8 @@ public interface IEntityConfigVisitor<TModel, TContext, TResult>
     {
         TResult Visit(ResourceConfig<TModel> config, TContext context);
 
-        TResult Visit<TParentModel>(NestedResourceConfig<TModel, TParentModel> config, TContext context)
+        TResult Visit<TParentModel>(
+            NestedResourceConfig<TModel, TParentModel> config, TContext context)
             where TParentModel : class;
     }
 }
diff --git a/src/ResourceManager/Common/Commands.Common.Strategies/ProgressMap.cs b/src/ResourceManager/Common/Commands.Common.Strategies/ProgressMap.cs
@@ -22,6 +22,9 @@ public class ProgressMap
         readonly Dictionary<IResourceConfig, Tuple<TimeSlot, int>> _Map 
             = new Dictionary<IResourceConfig, Tuple<TimeSlot, int>>();
 
+        /// <summary>
+        /// duration of all tasks (in seconds).
+        /// </summary>
         readonly int _Duration;
 
         public ProgressMap(Dictionary<IResourceConfig, Tuple<TimeSlot, int>> map, int duration)
diff --git a/src/ResourceManager/Compute/Commands.Compute/Strategies/Compute/ComputeStrategy.cs b/src/ResourceManager/Compute/Commands.Compute/Strategies/Compute/ComputeStrategy.cs
@@ -30,14 +30,14 @@ public static ResourceStrategy<TModel> Create<TModel, TOperations>(
             Func<TModel, int> createTime)
             where TModel : Resource
             => ResourceStrategy.Create(
-                type,
-                new[] { "Microsoft.Compute", header },
-                getOperations,
-                getAsync,
-                createOrUpdateAsync,
-                config => config.Location,
-                (config, location) => config.Location = location,
-                createTime,
-                true);
+                type: type,
+                headers: new[] { "Microsoft.Compute", header },
+                getOperations: getOperations,
+                getAsync: getAsync,
+                createOrUpdateAsync: createOrUpdateAsync,
+                getLocation: config => config.Location,
+                setLocation: (config, location) => config.Location = location,
+                createTime: createTime,
+                compulsoryLocation: true);
     }
 }
diff --git a/src/ResourceManager/Compute/Commands.Compute/Strategies/Compute/VirtualMachineStrategy.cs b/src/ResourceManager/Compute/Commands.Compute/Strategies/Compute/VirtualMachineStrategy.cs
@@ -24,14 +24,14 @@ static class VirtualMachineStrategy
     {
         public static ResourceStrategy<VirtualMachine> Strategy { get; }
             = ComputePolicy.Create(
-                "virtual machine",
-                "virtualMachines",
-                client => client.VirtualMachines,
-                (o, p) => o.GetAsync(
+                type: "virtual machine",
+                header: "virtualMachines",
+                getOperations: client => client.VirtualMachines,
+                getAsync: (o, p) => o.GetAsync(
                     p.ResourceGroupName, p.Name, null, p.CancellationToken),
-                (o, p) => o.CreateOrUpdateAsync(
+                createOrUpdateAsync: (o, p) => o.CreateOrUpdateAsync(
                     p.ResourceGroupName, p.Name, p.Model, p.CancellationToken),
-                c => c.OsProfile.WindowsConfiguration != null ? 240 : 120);
+                createTime: c => c.OsProfile.WindowsConfiguration != null ? 240 : 120);
 
         public static ResourceConfig<VirtualMachine> CreateVirtualMachineConfig(
             this ResourceConfig<ResourceGroup> resourceGroup,
@@ -43,9 +43,9 @@ public static ResourceConfig<VirtualMachine> CreateVirtualMachineConfig(
             Image image,
             string size)
             => Strategy.CreateResourceConfig(
-                resourceGroup,
-                name, 
-                subscription => new VirtualMachine
+                resourceGroup: resourceGroup,
+                name: name, 
+                createModel: subscription => new VirtualMachine
                 {
                     OsProfile = new OSProfile
                     {
@@ -80,6 +80,6 @@ public static ResourceConfig<VirtualMachine> CreateVirtualMachineConfig(
                         }
                     },
                 },
-                new[] { networkInterface });
+                dependencies: new[] { networkInterface });
     }
 }
diff --git a/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/NetworkInterfaceStrategy.cs b/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/NetworkInterfaceStrategy.cs
@@ -23,14 +23,14 @@ static class NetworkInterfaceStrategy
     {
         public static ResourceStrategy<NetworkInterface> Strategy { get; }
             = NetworkStrategy.Create(
-                "network interface",
-                "networkInterfaces",
-                client => client.NetworkInterfaces,
-                (o, p) => o.GetAsync(
+                type: "network interface",
+                header: "networkInterfaces",
+                getOperations: client => client.NetworkInterfaces,
+                getAsync: (o, p) => o.GetAsync(
                     p.ResourceGroupName, p.Name, null, p.CancellationToken),
-                (o, p) => o.CreateOrUpdateAsync(
+                createOrUpdateAsync: (o, p) => o.CreateOrUpdateAsync(
                     p.ResourceGroupName, p.Name, p.Model, p.CancellationToken),
-                _ => 5);
+                createTime: _ => 5);
 
         public static ResourceConfig<NetworkInterface> CreateNetworkInterfaceConfig(
             this ResourceConfig<ResourceGroup> resourceGroup,
@@ -39,9 +39,9 @@ public static ResourceConfig<NetworkInterface> CreateNetworkInterfaceConfig(
             ResourceConfig<PublicIPAddress> publicIPAddress,
             ResourceConfig<NetworkSecurityGroup> networkSecurityGroup = null)
             => Strategy.CreateResourceConfig(
-                resourceGroup,
-                name,
-                subscription => new NetworkInterface
+                resourceGroup: resourceGroup,
+                name: name,
+                createModel: subscription => new NetworkInterface
                 {
                     IpConfigurations = new []
                     {
@@ -62,6 +62,11 @@ public static ResourceConfig<NetworkInterface> CreateNetworkInterfaceConfig(
                             Id = networkSecurityGroup.GetId(subscription).IdToString()
                         }
                 },
-                new IEntityConfig[] { subnet, publicIPAddress, networkSecurityGroup });
+                dependencies: new IEntityConfig[] 
+                {
+                    subnet,
+                    publicIPAddress,
+                    networkSecurityGroup
+                });
     }
 }
diff --git a/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/NetworkSecurityGroupPolicy.cs b/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/NetworkSecurityGroupPolicy.cs
@@ -24,21 +24,21 @@ static class NetworkSecurityGroupStrategy
     {
         public static ResourceStrategy<NetworkSecurityGroup> Strategy { get; }
             = NetworkStrategy.Create(
-                "network security group",
-                "networkSecurityGroups",
-                client => client.NetworkSecurityGroups,
-                (o, p) => o.GetAsync(
+                type: "network security group",
+                header: "networkSecurityGroups",
+                getOperations: client => client.NetworkSecurityGroups,
+                getAsync: (o, p) => o.GetAsync(
                     p.ResourceGroupName, p.Name, null, p.CancellationToken),
-                (o, p) => o.CreateOrUpdateAsync(
+                createOrUpdateAsync: (o, p) => o.CreateOrUpdateAsync(
                     p.ResourceGroupName, p.Name, p.Model, p.CancellationToken),
-                _ => 15);
+                createTime: _ => 15);
 
         public static ResourceConfig<NetworkSecurityGroup> CreateNetworkSecurityGroupConfig(
             this ResourceConfig<ResourceGroup> resourceGroup, string name, int[] openPorts)
             => Strategy.CreateResourceConfig(
-                resourceGroup,
-                name,
-                _ => new NetworkSecurityGroup
+                resourceGroup: resourceGroup,
+                name: name,
+                createModel: _ => new NetworkSecurityGroup
                 {
                     SecurityRules = openPorts
                         .Select((port, index) => new SecurityRule
diff --git a/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/PublicIPAddressStrategy.cs b/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/PublicIPAddressStrategy.cs
@@ -23,24 +23,24 @@ static class PublicIPAddressStrategy
     {
         public static ResourceStrategy<PublicIPAddress> Strategy { get; }
             = NetworkStrategy.Create(
-                "public IP address",
-                "publicIPAddresses",
-                client => client.PublicIPAddresses,
-                (o, p) => o.GetAsync(
+                type: "public IP address",
+                header: "publicIPAddresses",
+                getOperations: client => client.PublicIPAddresses,
+                getAsync: (o, p) => o.GetAsync(
                     p.ResourceGroupName, p.Name, null, p.CancellationToken),
-                (o, p) => o.CreateOrUpdateAsync(
+                createOrUpdateAsync: (o, p) => o.CreateOrUpdateAsync(
                     p.ResourceGroupName, p.Name, p.Model, p.CancellationToken),
-                _ => 15);
+                createTime: _ => 15);
 
         public static ResourceConfig<PublicIPAddress> CreatePublicIPAddressConfig(
             this ResourceConfig<ResourceGroup> resourceGroup,
             string name,
             string domainNameLabel,
             string allocationMethod)
             => Strategy.CreateResourceConfig(
-                resourceGroup,
-                name,
-                _ => new PublicIPAddress
+                resourceGroup: resourceGroup,
+                name: name,
+                createModel: _ => new PublicIPAddress
                 {
                     PublicIPAllocationMethod = allocationMethod,
                     DnsSettings = new PublicIPAddressDnsSettings
diff --git a/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/SubnetStrategy.cs b/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/SubnetStrategy.cs
@@ -22,9 +22,9 @@ static class SubnetPolicy
     {
         public static NestedResourceStrategy<Subnet, VirtualNetwork> Strategy { get; }
             = NestedResourceStrategy.Create<Subnet, VirtualNetwork>(
-                "subnets",
-                (vn, name) => vn.Subnets?.FirstOrDefault(s => s?.Name == name),
-                (vn, name, subnet) =>
+                header: "subnets",
+                get: (vn, name) => vn.Subnets?.FirstOrDefault(s => s?.Name == name),
+                createOrUpdate: (vn, name, subnet) =>
                 {
                     subnet.Name = name;
                     if (vn.Subnets == null)
@@ -47,8 +47,8 @@ static class SubnetPolicy
         public static NestedResourceConfig<Subnet, VirtualNetwork> CreateSubnet(
             this ResourceConfig<VirtualNetwork> virtualNetwork, string name, string addressPrefix)
             => Strategy.CreateConfig(
-                virtualNetwork,
-                name,
-                () => new Subnet { Name = name, AddressPrefix = addressPrefix });
+                parent: virtualNetwork,
+                name: name,
+                createModel: () => new Subnet { Name = name, AddressPrefix = addressPrefix });
     }
 }
diff --git a/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/VirtualNetworkStrategy.cs b/src/ResourceManager/Compute/Commands.Compute/Strategies/Network/VirtualNetworkStrategy.cs
@@ -23,23 +23,23 @@ static class VirtualNetworkStrategy
     {
         public static ResourceStrategy<VirtualNetwork> Strategy { get; }
             = NetworkStrategy.Create(
-                "virtual network",
-                "virtualNetworks",
-                client => client.VirtualNetworks,
-                (o, p) => o.GetAsync(
+                type: "virtual network",
+                header: "virtualNetworks",
+                getOperations: client => client.VirtualNetworks,
+                getAsync: (o, p) => o.GetAsync(
                     p.ResourceGroupName, p.Name, null, p.CancellationToken),
-                (o, p) => o.CreateOrUpdateAsync(
+                createOrUpdateAsync: (o, p) => o.CreateOrUpdateAsync(
                     p.ResourceGroupName, p.Name, p.Model, p.CancellationToken),
-                _ => 15);
+                createTime: _ => 15);
 
         public static ResourceConfig<VirtualNetwork> CreateVirtualNetworkConfig(
             this ResourceConfig<ResourceGroup> resourceGroup,
             string name,
             string addressPrefix)
             => Strategy.CreateResourceConfig(
-                resourceGroup,
-                name,
-                _ => new VirtualNetwork
+                resourceGroup: resourceGroup,
+                name: name,
+                createModel: _ => new VirtualNetwork
                 {
                     AddressSpace = new AddressSpace
                     {
diff --git a/src/ResourceManager/Compute/Commands.Compute/Strategies/ResourceManager/ResourceGroupStrategy.cs b/src/ResourceManager/Compute/Commands.Compute/Strategies/ResourceManager/ResourceGroupStrategy.cs
@@ -22,15 +22,16 @@ static class ResourceGroupStrategy
     {
         public static ResourceStrategy<ResourceGroup> Strategy { get; }
             = ResourceStrategy.Create(
-                "resource group",
-                _ => Enumerable.Empty<string>(),
-                (ResourceManagementClient client) => client.ResourceGroups,
-                (o, p) => o.GetAsync(p.Name, p.CancellationToken),
-                (o, p) => o.CreateOrUpdateAsync(p.Name, p.Model, p.CancellationToken),
-                model => model.Location,
-                (model, location) => model.Location = location,
-                _ => 3,
-                false);
+                type: "resource group",
+                headers: Enumerable.Empty<string>(),
+                getOperations: (ResourceManagementClient client) => client.ResourceGroups,
+                getAsync: (o, p) => o.GetAsync(p.Name, p.CancellationToken),
+                createOrUpdateAsync: (o, p) 
+                    => o.CreateOrUpdateAsync(p.Name, p.Model, p.CancellationToken),
+                getLocation: model => model.Location,
+                setLocation: (model, location) => model.Location = location,
+                createTime: _ => 3,
+                compulsoryLocation: false);
 
         public static ResourceConfig<ResourceGroup> CreateResourceGroupConfig(string name)
             => Strategy.CreateConfig(name, name);

Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,12 @@ namespace Microsoft.Azure.Commands.Common.Strategies`
`21`	`21`	`{`
`22`	`22`	`public static class Extensions`
`23`	`23`	`{`
	`24`	`+ /// <summary>`
	`25`	`+ /// Returns an empty sequence if the given parameter is null.`
	`26`	`+ /// </summary>`
	`27`	`+ /// <typeparam name="T"></typeparam>`
	`28`	`+ /// <param name="value"></param>`
	`29`	`+ /// <returns></returns>`
`24`	`30`	`public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> value)`
`25`	`31`	`=> value ?? Enumerable.Empty<T>();`
`26`	`32`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,8 @@ public static async Task<IState> GetStateAsync<TModel>(`
`39`	`39`	`return context.Result;`
`40`	`40`	`}`
`41`	`41`
`42`		`- static Task GetStateAsyncDispatch(this StateOperationContext context, IResourceConfig config)`
	`42`	`+ static Task GetStateAsyncDispatch(`
	`43`	`+ this StateOperationContext context, IResourceConfig config)`
`43`	`44`	`=> config.Accept(new GetStateAsyncVisitor(), context);`
`44`	`45`
`45`	`46`	`static async Task GetStateAsync<TModel>(`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@`
`17`	`17`	`namespace Microsoft.Azure.Commands.Common.Strategies`
`18`	`18`	`{`
`19`	`19`	`/// <summary>`
`20`		`- /// Base interface for ResourceConfig and NestedResourceConfig.`
	`20`	`+ /// Base interface for ResourceConfig[TModel] and NestedResourceConfig[TModel, TParentModel].`
`21`	`21`	`/// </summary>`
`22`	`22`	`public interface IEntityConfig`
`23`	`23`	`{`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,8 @@ public interface IEntityConfigVisitor<TModel, TContext, TResult>`
`30`	`30`	`{`
`31`	`31`	`TResult Visit(ResourceConfig<TModel> config, TContext context);`
`32`	`32`
`33`		`- TResult Visit<TParentModel>(NestedResourceConfig<TModel, TParentModel> config, TContext context)`
	`33`	`+ TResult Visit<TParentModel>(`
	`34`	`+ NestedResourceConfig<TModel, TParentModel> config, TContext context)`
`34`	`35`	`where TParentModel : class;`
`35`	`36`	`}`
`36`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,9 @@ static class SubnetPolicy`
`22`	`22`	`{`
`23`	`23`	`public static NestedResourceStrategy<Subnet, VirtualNetwork> Strategy { get; }`
`24`	`24`	`= NestedResourceStrategy.Create<Subnet, VirtualNetwork>(`
`25`		`- "subnets",`
`26`		`- (vn, name) => vn.Subnets?.FirstOrDefault(s => s?.Name == name),`
`27`		`- (vn, name, subnet) =>`
	`25`	`+ header: "subnets",`
	`26`	`+ get: (vn, name) => vn.Subnets?.FirstOrDefault(s => s?.Name == name),`
	`27`	`+ createOrUpdate: (vn, name, subnet) =>`
`28`	`28`	`{`
`29`	`29`	`subnet.Name = name;`
`30`	`30`	`if (vn.Subnets == null)`
`@@ -47,8 +47,8 @@ static class SubnetPolicy`
`47`	`47`	`public static NestedResourceConfig<Subnet, VirtualNetwork> CreateSubnet(`
`48`	`48`	`this ResourceConfig<VirtualNetwork> virtualNetwork, string name, string addressPrefix)`
`49`	`49`	`=> Strategy.CreateConfig(`
`50`		`- virtualNetwork,`
`51`		`- name,`
`52`		`- () => new Subnet { Name = name, AddressPrefix = addressPrefix });`
	`50`	`+ parent: virtualNetwork,`
	`51`	`+ name: name,`
	`52`	`+ createModel: () => new Subnet { Name = name, AddressPrefix = addressPrefix });`
`53`	`53`	`}`
`54`	`54`	`}`