public async Task BindModelAsync(ModelBindingContext bindingContext) { var messageTypeModelName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, "messageType"); var messageTypeResult = bindingContext.ValueProvider.GetValue(messageTypeModelName); if (messageTypeResult == ValueProviderResult.None) { bindingContext.Result = ModelBindingResult.Failed(); return; } IModelBinder binder; if (!_binders.TryGetValue(messageTypeResult.FirstValue, out binder)) { bindingContext.Result = ModelBindingResult.Failed(); return; } // Now know the type exists in the assembly. var type = Type.GetType(messageTypeResult.FirstValue); var metadata = _metadataProvider.GetMetadataForType(type); ModelBindingResult result; using (bindingContext.EnterNestedScope(metadata, bindingContext.FieldName, bindingContext.ModelName, model: null)) { await binder.BindModelAsync(bindingContext); result = bindingContext.Result; } bindingContext.Result = result; }
public void Validate_ReturnsExpectedResults_Collection() { // Arrange var validator = new DataSetValidator(); var model = DataSet <SampleModel> .Create(); model.AddRow(); var metadata = _metadataProvider.GetMetadataForProperty( typeof(SampleModelContainer), nameof(SampleModelContainer.SampleModel)); var validationContext = new ModelValidationContext( new ActionContext(), metadata, _metadataProvider, container: null, model: model); // Act var results = validator.Validate(validationContext); var resultsArray = results.ToArray(); // Assert Assert.NotNull(results); Assert.Single(resultsArray); Assert.Equal(ModelNames.CreatePropertyModelName("[0]", nameof(SampleModel.ID)), resultsArray[0].MemberName); }
public Task BindModelAsync(ModelBindingContext bindingContext) { if (bindingContext == null) { throw new ArgumentNullException(nameof(bindingContext)); } Debug.Assert(bindingContext.Result == null); if (bindingContext.ModelType != typeof(Address)) { return(TaskCache.CompletedTask); } var address = new Address() { Street = "SomeStreet" }; bindingContext.ModelState.SetModelValue( ModelNames.CreatePropertyModelName(bindingContext.ModelName, "Street"), new string[] { address.Street }, address.Street); bindingContext.Result = ModelBindingResult.Success(bindingContext.ModelName, address); return(TaskCache.CompletedTask); }
public bool MoveNext() { TValue value; while (true) { if (!_keyMappingEnumerator.MoveNext()) { return(false); } if (_model.TryGetValue(_keyMappingEnumerator.Current.Value, out value)) { // Skip over entries that we can't find in the dictionary, they will show up as unvalidated. break; } } var key = ModelNames.CreateIndexModelName(_key, _keyMappingEnumerator.Current.Key); var model = value; _entry = new ValidationEntry(_metadata, key, model); return(true); }
public async Task CollectionModelBinder_DoesNotCreateCollection_IfNotIsTopLevelObject( string prefix, bool allowValidatingTopLevelNodes, bool isBindingRequired) { // Arrange var binder = new CollectionModelBinder <string>( new StubModelBinder(result: ModelBindingResult.Failed()), NullLoggerFactory.Instance, allowValidatingTopLevelNodes); var bindingContext = CreateContext(); bindingContext.ModelName = ModelNames.CreatePropertyModelName(prefix, "ListProperty"); var metadataProvider = new TestModelMetadataProvider(); metadataProvider .ForProperty(typeof(ModelWithListProperty), nameof(ModelWithListProperty.ListProperty)) .BindingDetails(b => b.IsBindingRequired = isBindingRequired); bindingContext.ModelMetadata = metadataProvider.GetMetadataForProperty( typeof(ModelWithListProperty), nameof(ModelWithListProperty.ListProperty)); bindingContext.ValueProvider = new TestValueProvider(new Dictionary <string, object>()); // Act await binder.BindModelAsync(bindingContext); // Assert Assert.False(bindingContext.Result.IsModelSet); Assert.Equal(0, bindingContext.ModelState.ErrorCount); }
public async Task DictionaryModelBinder_DoesNotCreateCollection_IfNotIsTopLevelObject(string prefix) { // Arrange var binder = new DictionaryModelBinder <int, int>( new SimpleTypeModelBinder(typeof(int)), new SimpleTypeModelBinder(typeof(int))); var context = CreateContext(); context.ModelName = ModelNames.CreatePropertyModelName(prefix, "ListProperty"); var metadataProvider = new TestModelMetadataProvider(); context.ModelMetadata = metadataProvider.GetMetadataForProperty( typeof(ModelWithDictionaryProperties), nameof(ModelWithDictionaryProperties.DictionaryProperty)); context.ValueProvider = new TestValueProvider(new Dictionary <string, object>()); // Act var result = await binder.BindModelResultAsync(context); // Assert Assert.Equal(default(ModelBindingResult), result); }
private void BindCollection(ModelStateDictionary modelState, IValueProvider valueProvider, string modelName, DataSet dataSet) { var indexNames = GetIndexNames(valueProvider, modelName); bool indexNamesIsFinite; if (indexNames != null) { indexNamesIsFinite = true; } else { indexNamesIsFinite = false; indexNames = Enumerable.Range(0, int.MaxValue).Select(i => i.ToString(CultureInfo.InvariantCulture)); } var currentIndex = 0; foreach (var indexName in indexNames) { var dataRowModelName = ModelNames.CreateIndexModelName(modelName, indexName); if (!valueProvider.ContainsPrefix(dataRowModelName) && !indexNamesIsFinite) { break; } if (currentIndex >= dataSet.Count) { dataSet.AddRow(); } Bind(modelState, valueProvider, dataRowModelName, dataSet[currentIndex++]); } }
private void Bind(ModelStateDictionary modelState, IValueProvider valueProvider, string modelName, DataRow dataRow) { modelState.SetModelValue(modelName, dataRow, string.Empty); dataRow.SuspendValueChangedNotification(); var model = dataRow.Model; var columns = model.GetColumns(); foreach (var column in columns) { if (column.IsReadOnly(dataRow)) { continue; } Bind(modelState, valueProvider, modelName, column, dataRow); } IReadOnlyList <DataSet> childDataSets = dataRow.ChildDataSets; foreach (var childDataSet in childDataSets) { Bind(modelState, valueProvider, ModelNames.CreatePropertyModelName(modelName, childDataSet.Model.GetName()), childDataSet, isScalar: false); } dataRow.ResumeValueChangedNotification(); }
public List <ModelNames> GetAll() { List <ModelNames> models = new List <ModelNames>(); using (var cn = new SqlConnection(Settings.GetConnectionString())) { SqlCommand cmd = new SqlCommand("ModelsSelectAll", cn); cmd.CommandType = CommandType.StoredProcedure; cn.Open(); using (SqlDataReader dr = cmd.ExecuteReader()) { while (dr.Read()) { ModelNames currentRow = new ModelNames(); currentRow.MakeID = (int)dr["MakeID"]; currentRow.MakeName = dr["MakeName"].ToString(); currentRow.ModelID = (int)dr["ModelID"]; currentRow.ModelName = dr["ModelName"].ToString(); currentRow.AddDate = (DateTime)dr["AddDate"]; currentRow.UserID = dr["UserID"].ToString(); currentRow.Email = dr["Email"].ToString(); models.Add(currentRow); } } } return(models); }
public Task <ModelBindingResult> BindModelAsync(ModelBindingContext bindingContext) { if (bindingContext.ModelType != typeof(Address)) { return(null); } var address = new Address() { Street = "SomeStreet" }; bindingContext.ModelState.SetModelValue( ModelNames.CreatePropertyModelName(bindingContext.ModelName, "Street"), new ValueProviderResult( address.Street, address.Street, CultureInfo.CurrentCulture)); var validationNode = new ModelValidationNode( bindingContext.ModelName, bindingContext.ModelMetadata, address) { ValidateAllProperties = true }; return(Task.FromResult(new ModelBindingResult(address, bindingContext.ModelName, true, validationNode))); }
public async Task BindModelAsync(ModelBindingContext bindingContext) { if (bindingContext == null) { throw new ArgumentNullException(nameof(bindingContext)); } var fieldName = nameof(Model.Value); var modelName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, fieldName); ModelBindingResult valueResult; using (bindingContext.EnterNestedScope( bindingContext.ModelMetadata.Properties[fieldName], fieldName, modelName, model: null)) { await _binder.BindModelAsync(bindingContext); valueResult = bindingContext.Result; } if (!valueResult.IsModelSet) { return; } var model = new Model { FieldName = bindingContext.FieldName, Value = (string)valueResult.Model, }; bindingContext.Result = ModelBindingResult.Success(model); }
public async Task DictionaryModelBinder_DoesNotCreateCollection_IfNotIsTopLevelObject(string prefix) { // Arrange var binder = new DictionaryModelBinder <int, int>( new SimpleTypeModelBinder(typeof(int), NullLoggerFactory.Instance), new SimpleTypeModelBinder(typeof(int), NullLoggerFactory.Instance), NullLoggerFactory.Instance); var bindingContext = CreateContext(); bindingContext.ModelName = ModelNames.CreatePropertyModelName(prefix, "ListProperty"); var metadataProvider = new TestModelMetadataProvider(); bindingContext.ModelMetadata = metadataProvider.GetMetadataForProperty( typeof(ModelWithDictionaryProperties), nameof(ModelWithDictionaryProperties.DictionaryProperty)); bindingContext.ValueProvider = new TestValueProvider(new Dictionary <string, object>()); // Act await binder.BindModelAsync(bindingContext); // Assert Assert.False(bindingContext.Result.IsModelSet); }
public async Task KeyValuePairModelBinder_DoesNotCreateCollection_IfNotIsTopLevelObject(string prefix) { // Arrange var binder = new KeyValuePairModelBinder <string, string>( new SimpleTypeModelBinder(typeof(string)), new SimpleTypeModelBinder(typeof(string))); var bindingContext = CreateContext(); bindingContext.ModelName = ModelNames.CreatePropertyModelName(prefix, "KeyValuePairProperty"); var metadataProvider = new TestModelMetadataProvider(); bindingContext.ModelMetadata = metadataProvider.GetMetadataForProperty( typeof(ModelWithKeyValuePairProperty), nameof(ModelWithKeyValuePairProperty.KeyValuePairProperty)); bindingContext.ValueProvider = new TestValueProvider(new Dictionary <string, object>()); // Act await binder.BindModelAsync(bindingContext); // Assert Assert.False(bindingContext.Result.IsModelSet); }
public Task BindModelAsync(ModelBindingContext bindingContext) { var modelTypeValue = bindingContext.ValueProvider.GetValue(ModelNames.CreatePropertyModelName(bindingContext.ModelName, "ModelTypeName")); if (modelTypeValue != null && modelTypeValue.FirstValue != null) { Type modelType = Type.GetType(modelTypeValue.FirstValue); if (this.modelBuilderByType.TryGetValue(modelType, out var modelBinder)) { ModelBindingContext innerModelBindingContext = DefaultModelBindingContext.CreateBindingContext( bindingContext.ActionContext, bindingContext.ValueProvider, this.modelMetadataProvider.GetMetadataForType(modelType), null, bindingContext.ModelName); modelBinder.BindModelAsync(innerModelBindingContext); bindingContext.Result = innerModelBindingContext.Result; return(Task.CompletedTask); } } bindingContext.Result = ModelBindingResult.Failed(); return(Task.CompletedTask); }
public bool MoveNext() { _index++; if (_index >= _properties.Count) { return(false); } var property = _properties[_index]; var propertyName = property.BinderModelName ?? property.PropertyName; var key = ModelNames.CreatePropertyModelName(_key, propertyName); if (_model == null) { // Performance: Never create a delegate when container is null. _entry = new ValidationEntry(property, key, model: null); } else if (IsMono) { _entry = new ValidationEntry(property, key, () => GetModelOnMono(_model, property.PropertyName)); } else { _entry = new ValidationEntry(property, key, () => GetModel(_model, property)); } return(true); }
// Used when the ValueProvider contains the collection to be bound as multiple elements, e.g. foo[0], foo[1]. private Task <CollectionResult> BindComplexCollection(IndexModelBindingContext bindingContext) { var indexPropertyName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, "index"); var valueProviderResultIndex = bindingContext.ValueProvider.GetValue(indexPropertyName); var indexNames = GetIndexNamesFromValueProviderResult(valueProviderResultIndex); return(BindComplexCollectionFromIndexes(bindingContext, indexNames)); }
private async Task BindModelCoreAsync(ModelBindingContext bindingContext) { // Create model first (if necessary) to avoid reporting errors about properties when activation fails. if (bindingContext.Model == null) { bindingContext.Model = CreateModel(bindingContext); } for (var i = 0; i < bindingContext.ModelMetadata.Properties.Count; i++) { var property = bindingContext.ModelMetadata.Properties[i]; if (!CanBindProperty(bindingContext, property)) { continue; } // Pass complex (including collection) values down so that binding system does not unnecessarily // recreate instances or overwrite inner properties that are not bound. No need for this with simple // values because they will be overwritten if binding succeeds. Arrays are never reused because they // cannot be resized. object propertyModel = null; if (property.PropertyGetter != null && property.IsComplexType && !property.ModelType.IsArray) { propertyModel = property.PropertyGetter(bindingContext.Model); } var fieldName = property.BinderModelName ?? property.PropertyName; var modelName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, fieldName); ModelBindingResult result; using (bindingContext.EnterNestedScope( modelMetadata: property, fieldName: fieldName, modelName: modelName, model: propertyModel)) { await BindProperty(bindingContext); result = bindingContext.Result; } if (result.IsModelSet) { SetProperty(bindingContext, modelName, property, result); } else if (property.IsBindingRequired) { var message = property.ModelBindingMessageProvider.MissingBindRequiredValueAccessor(fieldName); bindingContext.ModelState.TryAddModelError(modelName, message); } } bindingContext.Result = ModelBindingResult.Success(bindingContext.Model); _logger.DoneAttemptingToBindModel(bindingContext); }
private static string GetName(string containerName, ApiParameterDescriptionContext metadata) { if (string.IsNullOrEmpty(metadata.BinderModelName)) { return(ModelNames.CreatePropertyModelName(containerName, metadata.PropertyName)); } return(metadata.BinderModelName); }
/// <summary> /// Validates a single node in a model object graph. /// </summary> /// <returns><c>true</c> if the node is valid, otherwise <c>false</c>.</returns> protected virtual bool ValidateNode() { var state = ModelState.GetValidationState(Key); // Rationale: we might see the same model state key used for two different objects. // We want to run validation unless it's already known that this key is invalid. if (state != ModelValidationState.Invalid) { var validators = Cache.GetValidators(Metadata, ValidatorProvider); var count = validators.Count; if (count > 0) { var context = new ModelValidationContext( Context, Metadata, MetadataProvider, Container, Model); var results = new List <ModelValidationResult>(); for (var i = 0; i < count; i++) { results.AddRange(validators[i].Validate(context)); } var resultsCount = results.Count; for (var i = 0; i < resultsCount; i++) { var result = results[i]; var key = ModelNames.CreatePropertyModelName(Key, result.MemberName); // It's OK for key to be the empty string here. This can happen when a top // level object implements IValidatableObject. ModelState.TryAddModelError(key, result.Message); } } } state = ModelState.GetFieldValidationState(Key); if (state == ModelValidationState.Invalid) { return(false); } else { // If the field has an entry in ModelState, then record it as valid. Don't create // extra entries if they don't exist already. var entry = ModelState[Key]; if (entry != null) { entry.ValidationState = ModelValidationState.Valid; } return(true); } }
public Task BindModelAsync(ModelBindingContext bindingContext) { var name = ModelNames.CreatePropertyModelName( bindingContext.ModelName, nameof(Device.Kind)); var deviceKind = bindingContext.ValueProvider.GetValue(name).FirstValue; if (string.IsNullOrEmpty(deviceKind)) { bindingContext.Result = ModelBindingResult.Failed(); return(Task.CompletedTask); } Device result; if (deviceKind == "Laptop") { var modelName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, nameof(Laptop.CPUIndex)); var cpuIndex = bindingContext.ValueProvider.GetValue(modelName).FirstValue; result = new Laptop { Kind = deviceKind, CPUIndex = cpuIndex, }; } else if (deviceKind == "SmartPhone") { var modelName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, nameof(SmartPhone.ScreenSize)); var screenSize = bindingContext.ValueProvider.GetValue(modelName).FirstValue; result = new SmartPhone { Kind = deviceKind, ScreenSize = screenSize, }; } else { bindingContext.ModelState.TryAddModelError(name, $"Unknown device kind '{deviceKind}'."); bindingContext.Result = ModelBindingResult.Failed(); return(Task.CompletedTask); } bindingContext.Result = ModelBindingResult.Success(result); // Add a ValidationStateEntry with the "correct" ModelMetadata so validation executes on the actual type, not the declared type. var modelMetadataProvider = bindingContext.HttpContext.RequestServices.GetRequiredService <IModelMetadataProvider>(); bindingContext.ValidationState.Add(result, new ValidationStateEntry { Metadata = modelMetadataProvider.GetMetadataForType(result.GetType()), }); return(Task.CompletedTask); }
private static string ResolveMemberName(DataSet dataSet, bool isScalar, Column column, DataRow dataRow) { if (column.GetParent() == dataSet.Model) { return(isScalar ? column.Name : ModelNames.CreatePropertyModelName(ModelNames.CreateIndexModelName(string.Empty, dataRow.Index), column.Name)); } Debug.Assert(dataRow != null); return(ResolveMemberName(dataSet, isScalar, dataRow, column.Name)); }
private static Expression <Func <ModelBindingContext, string, bool> > GetPredicateExpression <TModel> (string prefix, Expression <Func <TModel, object> > expression) { var propertyName = GetPropertyName(expression.Body); var property = ModelNames.CreatePropertyModelName(prefix, propertyName); return ((context, modelPropertyName) => property.Equals(ModelNames.CreatePropertyModelName(context.ModelName, modelPropertyName), StringComparison.OrdinalIgnoreCase)); }
private static string ResolveMemberName(DataSet dataSet, bool isScalar, DataRow dataRow, string memberName) { if (dataRow.Model == dataSet.Model) { return(isScalar ? memberName : ModelNames.CreatePropertyModelName(ModelNames.CreateIndexModelName(string.Empty, dataRow.Index), memberName)); } memberName = ModelNames.CreatePropertyModelName(ModelNames.CreateIndexModelName(dataRow.Model.GetName(), dataRow.Index), memberName); Debug.Assert(dataRow.ParentDataRow != null); return(ResolveMemberName(dataSet, isScalar, dataRow.ParentDataRow, memberName)); }
private static IEnumerable <ModelValidationResult> ValidateCollection(string prefix, DataSet dataSet) { for (int index = 0; index < dataSet.Count; index++) { var dataRowPrefix = ModelNames.CreateIndexModelName(prefix, index); foreach (var result in Validate(dataRowPrefix, dataSet[index])) { yield return(result); } } }
/// <inheritdoc /> public async Task BindModelAsync(ModelBindingContext bindingContext) { if (bindingContext == null) { throw new ArgumentNullException(nameof(bindingContext)); } _logger.AttemptingToBindModel(bindingContext); var keyModelName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, "Key"); var keyResult = await TryBindStrongModel <TKey>(bindingContext, _keyBinder, "Key", keyModelName); var valueModelName = ModelNames.CreatePropertyModelName(bindingContext.ModelName, "Value"); var valueResult = await TryBindStrongModel <TValue>(bindingContext, _valueBinder, "Value", valueModelName); if (keyResult.IsModelSet && valueResult.IsModelSet) { var model = new KeyValuePair <TKey, TValue>( ModelBindingHelper.CastOrDefault <TKey>(keyResult.Model), ModelBindingHelper.CastOrDefault <TValue>(valueResult.Model)); bindingContext.Result = ModelBindingResult.Success(model); _logger.DoneAttemptingToBindModel(bindingContext); return; } if (!keyResult.IsModelSet && valueResult.IsModelSet) { bindingContext.ModelState.TryAddModelError( keyModelName, bindingContext.ModelMetadata.ModelBindingMessageProvider.MissingKeyOrValueAccessor()); _logger.DoneAttemptingToBindModel(bindingContext); return; } if (keyResult.IsModelSet && !valueResult.IsModelSet) { bindingContext.ModelState.TryAddModelError( valueModelName, bindingContext.ModelMetadata.ModelBindingMessageProvider.MissingKeyOrValueAccessor()); _logger.DoneAttemptingToBindModel(bindingContext); return; } // If we failed to find data for a top-level model, then generate a // default 'empty' model and return it. if (bindingContext.IsTopLevelObject) { var model = new KeyValuePair <TKey, TValue>(); bindingContext.Result = ModelBindingResult.Success(model); } _logger.DoneAttemptingToBindModel(bindingContext); }
private static string GetName(string containerName, ApiParameterDescriptionContext metadata) { if (!string.IsNullOrEmpty(metadata.BinderModelName)) { // Name was explicitly provided return(metadata.BinderModelName); } else { return(ModelNames.CreatePropertyModelName(containerName, metadata.PropertyName)); } }
private IList <ModelValidationNode> GetChildNodes(ValidationContext context, ModelExplorer modelExplorer) { var validationNode = context.ValidationNode; // This is the trivial case where the node-tree that was built-up during binding already has // all of the nodes we need. if (validationNode.ChildNodes.Count != 0 || !validationNode.ValidateAllProperties || validationNode.Model == null) { return(validationNode.ChildNodes); } var childNodes = new List <ModelValidationNode>(validationNode.ChildNodes); var elementMetadata = modelExplorer.Metadata.ElementMetadata; if (elementMetadata == null) { foreach (var property in validationNode.ModelMetadata.Properties) { var propertyExplorer = modelExplorer.GetExplorerForProperty(property.PropertyName); var propertyBindingName = property.BinderModelName ?? property.PropertyName; var childKey = ModelNames.CreatePropertyModelName(validationNode.Key, propertyBindingName); var childNode = new ModelValidationNode(childKey, property, propertyExplorer.Model) { ValidateAllProperties = true }; childNodes.Add(childNode); } } else { var enumerableModel = (IEnumerable)modelExplorer.Model; // An integer index is incorrect in scenarios where there is a custom index provided by the user. // However those scenarios are supported by createing a ModelValidationNode with the right keys. var index = 0; foreach (var element in enumerableModel) { var elementExplorer = new ModelExplorer(_modelMetadataProvider, elementMetadata, element); var elementKey = ModelNames.CreateIndexModelName(validationNode.Key, index); var childNode = new ModelValidationNode(elementKey, elementMetadata, elementExplorer.Model) { ValidateAllProperties = true }; childNodes.Add(childNode); index++; } } return(childNodes); }
/// <summary> /// Validates a single node in a model object graph. /// </summary> /// <returns><c>true</c> if the node is valid, otherwise <c>false</c>.</returns> protected virtual bool ValidateNode() { var state = _modelState.GetValidationState(_key); if (state == ModelValidationState.Unvalidated) { var validators = GetValidators(_metadata); var count = validators.Count; if (count > 0) { var context = new ModelValidationContext() { Container = _container, Model = _model, Metadata = _metadata, }; var results = new List <ModelValidationResult>(); for (var i = 0; i < count; i++) { results.AddRange(validators[i].Validate(context)); } var resultsCount = results.Count; for (var i = 0; i < resultsCount; i++) { var result = results[i]; var key = ModelNames.CreatePropertyModelName(_key, result.MemberName); _modelState.TryAddModelError(key, result.Message); } } } state = _modelState.GetFieldValidationState(_key); if (state == ModelValidationState.Invalid) { return(false); } else { // If the field has an entry in ModelState, then record it as valid. Don't create // extra entries if they don't exist already. var entry = _modelState[_key]; if (entry != null) { entry.ValidationState = ModelValidationState.Valid; } return(true); } }
public ModelOutput GetParsedModel(ModelNames name) { if (this.parsedModels.ContainsKey(name)) { return(this.parsedModels[name]); } this.parsedModels[name] = this.HasModels() ? JsonConvert.DeserializeObject <ModelOutput>(Inference.Decision.Models[name]) : null; return(this.parsedModels[name]); } // GetParsedModel
public void CanAddModel() { ModelNames modelToAdd = new ModelNames(); var repo = new ModelsRepositoryADO(); modelToAdd.MakeID = 1; modelToAdd.MakeName = "Prius"; modelToAdd.UserID = "48207816-600d-4d87-a87a-96722dad81cc"; repo.Insert(modelToAdd); Assert.AreEqual("Prius", modelToAdd.MakeName); }