Apprenda.SaaSGrid.Addons.NetApp.DeveloperParameters.MapToOption C# (CSharp) Метод

        private static void MapToOption(DeveloperParameters requiredParams, string key, string value)
        {
            // Begin Required Parameters.
            // this is called only if the developer wishes to overwrite the platform operator's default aggregate
            if ("name".Equals(key))
            {
                requiredParams.VolumeToProvision.Name = value;
                return;
            }
            if ("aggregatename".Equals(key))
            {
                requiredParams.VolumeToProvision.AggregateName = value;
                return;
            }
            // with version 1.2, we've removed the need to specify a junction path, that's now taken care of based on policy.
            // this is advantageous since we've abstracted another level of complexity away from the dev.
            if ("size".Equals(key))
            {
                requiredParams.VolumeToProvision.Size = value;
                return;
            }

            // Begin Optional Parameters
            if ("comment".Equals(key))
            {
                requiredParams.VolumeToProvision.Comment = value;
                return;
            }

            if ("antivirusonaccesspolicy".Equals(key))
            {
                requiredParams.VolumeToProvision.AntiVirusOnAccessPolicy = value;
                return;
            }

            if ("exportpolicy".Equals(key))
            {
                requiredParams.VolumeToProvision.ExportPolicy = value;
                return;
            }

            if ("flexcachecachepolicy".Equals(key))
            {
                requiredParams.VolumeToProvision.FlexCacheCachePolicy = value;
                return;
            }

            if ("flexcachefillpolicy".Equals(key))
            {
                requiredParams.VolumeToProvision.FlexCacheFillPolicy = value;
                return;
            }

            if ("flexcacheoriginvolume".Equals(key))
            {
                requiredParams.VolumeToProvision.FlexCacheOriginVolume = value;
                return;
            }

            if ("groupid".Equals(key))
            {
                int tmp;
                if (!(int.TryParse(value, out tmp)))
                {
                    throw new ArgumentException("GroupId must be an integer value");
                }
                requiredParams.VolumeToProvision.GroupId = tmp;
                return;
            }

            if ("indexdirectoryformat".Equals(key))
            {
                requiredParams.VolumeToProvision.IndexDirectoryFormat = value;
                return;
            }

            if ("junctionactive".Equals(key))
            {
                bool tmp;
                if (!(bool.TryParse(value, out tmp)))
                {
                    throw new ArgumentException("JunctionActive must be a boolean type");
                }
                requiredParams.VolumeToProvision.JunctionActive = tmp;
                return;
            }

            if ("maxdirectorysize".Equals(key))
            {
                double tmp;
                if (!(double.TryParse(value, out tmp)))
                {
                    throw new ArgumentException("MaxDirectorySize must be a boolean type");
                }
                requiredParams.VolumeToProvision.MaxDirectorySize = tmp;
                return;
            }

            if ("nvfailenabled".Equals(key))
            {
                bool tmp;
                if (!(bool.TryParse(value, out tmp)))
                {
                    throw new ArgumentException("NvFailEnabled must be a boolean type");
                }
                requiredParams.VolumeToProvision.NvFailEnabled = tmp;
                return;
            }

            if ("securitystyle".Equals(key))
            {
                requiredParams.VolumeToProvision.SecurityStyle = value;
                return;
            }

            if ("snapshotpolicy".Equals(key))
            {
                requiredParams.VolumeToProvision.SnapshotPolicy = value;
                return;
            }

            if ("spacereserver".Equals(key))
            {
                requiredParams.VolumeToProvision.SpaceReserver = value;
                return;
            }

            if ("state".Equals(key))
            {
                requiredParams.VolumeToProvision.State = value;
                return;
            }

            if ("type".Equals(key))
            {
                requiredParams.VolumeToProvision.Type = value;
                return;
            }

            if ("unixpermissions".Equals(key))
            {
                requiredParams.VolumeToProvision.UnixPermissions = value;
                return;
            }

            if ("userid".Equals(key))
            {
                int tmp;
                if (!(int.TryParse(value, out tmp)))
                {
                    throw new ArgumentException("MaxDirectorySize must be a boolean type");
                }
                requiredParams.VolumeToProvision.UserId = tmp;
                return;
            }

            if ("vserverroot".Equals(key))
            {
                bool tmp;
                if (!(bool.TryParse(value, out tmp)))
                {
                    throw new ArgumentException("NvFailEnabled must be a boolean type");
                }
                requiredParams.VolumeToProvision.VserverRoot = tmp;
                return;
            }

            if ("snapshotreserver".Equals(key))
            {
                int tmp;
                if (!(int.TryParse(value, out tmp)))
                {
                    throw new ArgumentException("MaxDirectorySize must be a boolean type");
                }
                requiredParams.VolumeToProvision.SnapshotReserver = tmp;
                return;
            }

            if ("vmalignsector".Equals(key))
            {
                int tmp;
                if (!(int.TryParse(value, out tmp)))
                {
                    throw new ArgumentException("NvFailEnabled must be a boolean type");
                }
                requiredParams.VolumeToProvision.VmAlignSector = tmp;
                return;
            }

            if ("vmalignsuffic".Equals(key))
            {
                requiredParams.VolumeToProvision.VmAlignSuffic = value;
                return;
            }

            if ("qospolicygroup".Equals(key))
            {
                requiredParams.VolumeToProvision.QosPolicyGroup = value;
                return;
            }
            // for multi-national support
            if ("language".Equals(key))
            {
                requiredParams.VolumeToProvision.Language = value;
                return;
            }
            // only if there are both nfs and cifs shares should this ever be used.
            if ("protocol".Equals(key))
            {
                requiredParams.VolumeToProvision.Protocol = value;
            }

            throw new ArgumentException(
                string.Format("The developer option '{0}' was not expected and is not understood.", key));
        }