a lot

Author: sergey-shandar

experiments/Azure.Experiments/Azure.Experiments/ChildResourceConfig.cs

@@ -1,31 +1,23 @@
 using Microsoft.Azure.Management.Compute;
 using Microsoft.Azure.Management.Compute.Models;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace Microsoft.Azure.Experiments.Compute
 {
-    public abstract class ComputePolicy<Info, Operations>
-        : ResourcePolicy<Info, IComputeManagementClient, Operations>
-        where Info : Resource
-    {
-        public sealed override string GetLocation(Info info)
-            => info.Location;
-
-        public sealed override void SetLocation(Info info, string location)
-            => info.Location = location;
-    }
-
-    /*
     public static class ComputePolicy
     {
-        public static ResourcePolicy<Info> Create<Operations, Info>(
+        public static ResourcePolicy<ResourceName, Config> Create<Config, Operations>(
             Func<IComputeManagementClient, Operations> getOperations,
-            Func<Operations, ResourceName, Task<Info>> getAsync,
-            Func<Operations, ResourceName, Info, Task<Info>> createOrUpdateAsync)
-            where Info : Management.Compute.Models.Resource
-            => OperationsPolicy
-                .Create(getAsync, createOrUpdateAsync)
-                .Transform(getOperations)
-                .CreateResourcePolicy(i => i.Location, (i, location) => i.Location = location);
+            Func<Operations, ResourceName, CancellationToken, Task<Config>> getAsync,
+            Func<Operations, ResourceName, Config, CancellationToken, Task<Config>> createOrUpdateAsync)
+            where Config : Resource
+            => ResourcePolicy.Create(
+                getOperations,
+                getAsync,
+                createOrUpdateAsync,
+                config => config.Location,
+                (config, location) => config.Location = location);
     }
-    */
 }

experiments/Azure.Experiments/Azure.Experiments/ChildResourcePolicy.cs

@@ -1,53 +1,23 @@
-using System.Threading.Tasks;
-using Microsoft.Azure.Management.Compute;
+using Microsoft.Azure.Management.Compute;
 using Microsoft.Azure.Management.Compute.Models;
+using Microsoft.Azure.Management.ResourceManager.Models;
 
 namespace Microsoft.Azure.Experiments.Compute
 {
-    public sealed class VirtualMachinePolicy
-        : ComputePolicy<VirtualMachine, IVirtualMachinesOperations>
-    {
-        public override Task<VirtualMachine> CreateOrUpdateAsync(CreateParams p)
-            => p.Operations.CreateOrUpdateAsync(
-                p.ResourceGroupName, p.Name, p.Info, p.CancellationToken);
-
-        public override Task<VirtualMachine> GetAsync(GetParams p)
-            => p.Operations.GetAsync(
-                p.ResourceGroupName, p.Name, cancellationToken: p.CancellationToken);
-
-        public override IVirtualMachinesOperations GetOperations(IComputeManagementClient client)
-            => client.VirtualMachines;
-    }
-
-    /*
     public static class VirtualMachinePolicy
     {
-        public static ResourcePolicy<VirtualMachine> Policy { get; }
+        public static ResourcePolicy<ResourceName, VirtualMachine> Policy { get; }
             = ComputePolicy.Create(
                 client => client.VirtualMachines,
-                (operations, name) => operations.GetAsync(name.ResourceGroupName, name.Name),
-                (operations, name, info)
-                    => operations.CreateOrUpdateAsync(name.ResourceGroupName, name.Name, info));
+                (operations, name, cancellationTokent)
+                    => operations.GetAsync(
+                        name.ResourceGroupName, name.Name, cancellationToken: cancellationTokent),
+                (operations, name, config, cancellationTokent)
+                    => operations.CreateOrUpdateAsync(
+                        name.ResourceGroupName, name.Name, config, cancellationTokent));
 
-        public static ResourceConfig<VirtualMachine> CreateVirtualMachineConfig(
-            this ResourceName name,
-            ResourceConfig<NetworkInterface> networkInterface)
-            => Policy.CreateConfig(
-                name,
-                state => new VirtualMachine
-                {
-                    NetworkProfile = new NetworkProfile
-                    {
-                        NetworkInterfaces = new []
-                        {
-                            new NetworkInterfaceReference
-                            {
-                                Id = state.Get(networkInterface).Id
-                            }
-                        }
-                    }
-                },
-                new[] { networkInterface });
+        public static ResourceConfig<ResourceName, VirtualMachine> CreateVirtualMachineConfig(
+            this ResourceConfig<string, ResourceGroup> resourceGroup, string name)
+            => Policy.CreateConfig(resourceGroup, name);
     }
-    */
 }

experiments/Azure.Experiments/Azure.Experiments/Compute/ComputePolicy.cs

@@ -0,0 +1,30 @@
+using System.Threading;
+
+namespace Microsoft.Azure.Experiments
+{
+    public sealed class CreateOrUpdateAsyncParams<TOperations, TConfig>
+    {
+        public TOperations Operations { get; }
+
+        public string ResourceGroupName { get; }
+
+        public string Name { get; }
+
+        public CancellationToken CancellationToken { get; }
+
+        public TConfig Config { get; }
+
+        public CreateOrUpdateAsyncParams(
+            TOperations operations,
+            ResourceName name,
+            TConfig config,
+            CancellationToken cancellationToken)
+        {
+            Operations = operations;
+            ResourceGroupName = name.ResourceGroupName;
+            Name = name.Name;
+            Config = config;
+            CancellationToken = cancellationToken;
+        }
+    }
+}

experiments/Azure.Experiments/Azure.Experiments/Compute/VirtualMachinePolicy.cs

@@ -6,6 +6,6 @@ namespace Microsoft.Azure.Experiments
     public static class EnumerableEx
     {
         public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> value)
-            => value == null ? Enumerable.Empty<T>() : value;
+            => value ?? Enumerable.Empty<T>();
     }
 }

experiments/Azure.Experiments/Azure.Experiments/CreateOrUpdateAsyncParams.cs

@@ -0,0 +1,24 @@
+using System.Threading;
+
+namespace Microsoft.Azure.Experiments
+{
+    public sealed class GetAsyncParams<TOperations>
+    {
+        public TOperations Operations { get; }
+
+        public string ResourceGroupName { get; }
+
+        public string Name { get; }
+
+        public CancellationToken CancellationToken { get; }
+
+        public GetAsyncParams(
+            TOperations operations, ResourceName name, CancellationToken cancellationToken)
+        {
+            Operations = operations;
+            ResourceGroupName = name.ResourceGroupName;
+            Name = name.Name;
+            CancellationToken = cancellationToken;
+        }
+    }
+}

experiments/Azure.Experiments/Azure.Experiments/CreateTask.cs

@@ -0,0 +1,6 @@
+namespace Microsoft.Azure.Experiments
+{
+    public interface IResourceConfig
+    {            
+    }
+}

experiments/Azure.Experiments/Azure.Experiments/EnumerableEx.cs

@@ -0,0 +1,6 @@
+namespace Microsoft.Azure.Experiments
+{
+    public interface IResourcePolicy
+    {
+    }
+}