protected CsvMapping(ITypeConverterProvider typeConverterProvider)
{
this.typeConverterProvider = typeConverterProvider;
this.csvIndexPropertyMappings = new List <IndexToPropertyMapping>();
this.csvRangePropertyMappings = new List <RangeToPropertyMapping>();
this.csvRowMappings = new List <CsvRowMapping <TEntity> >();
}
public CsvPersonMappingWithTypeConverterProvider(ITypeConverterProvider typeConverterProvider)
: base(typeConverterProvider)
{
MapProperty(0, x => x.FirstName);
MapProperty(1, x => x.LastName);
MapProperty(2, x => x.BirthDate);
}
public async Task <IActionResult> GetCharacterActionBar([FromRoute(Name = "id")] int characterId, [FromServices] ICharacterActionBarRepository actionBarRepository,
[FromServices] ICharacterDefaultActionBarRepository characterDefaultActionBarRepository,
[FromServices] ITypeConverterProvider <ICharacterActionBarEntry, CharacterActionBarInstanceModel> converter)
{
ProjectVersionStage.AssertBeta();
//TODO: Check that they own the character.
if (await actionBarRepository.ContainsAsync(characterId))
{
CharacterActionBarEntry[] actionBarEntries = await actionBarRepository.RetrieveAllForCharacterAsync(characterId);
CharacterActionBarInstanceModel[] barInstanceModels = actionBarEntries.Select(converter.Convert)
.ToArrayTryAvoidCopy();
//Just send it as raw JSON.
return(Json(barInstanceModels));
}
else
{
//We need the default action bars
//Right now we only have 1 class so let's use mage.
CharacterDefaultActionBarEntry[] actionBarEntries = await characterDefaultActionBarRepository.RetrieveAllActionsAsync(EntityPlayerClassType.Mage);
CharacterActionBarInstanceModel[] barInstanceModels = actionBarEntries.Select(converter.Convert)
.ToArrayTryAvoidCopy();
//TODO: Return default bars.
return(Json(barInstanceModels));
}
}
public virtual async Task <IActionResult> CreateObjectInstance([FromRoute(Name = "world")] long worldId,
[FromServices][NotNull] TInstanceRepositoryType instanceObjectRepository,
[FromServices][NotNull] IFactoryCreatable <TInstanceEntryModelType, WorldInstanceableEntryModelCreationContext> defaultInstanceEntryModelFactory,
[FromServices][NotNull] ITypeConverterProvider <TInstanceEntryModelType, TInstanceTransportModelType> tableToNetworkModelConverter)
{
if (instanceObjectRepository == null)
{
throw new ArgumentNullException(nameof(instanceObjectRepository));
}
if (defaultInstanceEntryModelFactory == null)
{
throw new ArgumentNullException(nameof(defaultInstanceEntryModelFactory));
}
if (tableToNetworkModelConverter == null)
{
throw new ArgumentNullException(nameof(tableToNetworkModelConverter));
}
TInstanceEntryModelType entry = defaultInstanceEntryModelFactory.Create(new WorldInstanceableEntryModelCreationContext(worldId));
bool result = await instanceObjectRepository.TryCreateAsync(entry);
//No known reason that this should fail.
if (!result)
{
return(BuildFailedResponseModel(SceneContentQueryResponseCode.GeneralServerError));
}
//Otherwise, it has been created so let's get it
return(await GetObjectInstance(entry.ObjectInstanceId, instanceObjectRepository, tableToNetworkModelConverter));
}
public override Task <IActionResult> CreateObjectInstance([FromRoute(Name = "id")] long worldId,
[FromServices] TInstanceRepositoryType instanceObjectRepository,
[FromServices] IFactoryCreatable <TInstanceEntryModelType, WorldInstanceableEntryModelCreationContext> defaultInstanceEntryModelFactory,
[FromServices] ITypeConverterProvider <TInstanceEntryModelType, TInstanceTransportModelType> tableToNetworkModelConverter)
{
return(Task.FromResult((IActionResult)BadRequest($"This request is not valid for {typeof(TInstanceTransportModelType).Name}.")));
}
/// <inheritdoc />
public VanillaToWotlkMovementBlockDataTypeConverter([NotNull] ITypeConverterProvider <ObjectUpdateFlags_Vanilla, ObjectUpdateFlags> objectUpdateFlagsConverter, [NotNull] ITypeConverterProvider <MovementInfo_Vanilla, MovementInfo> moveInfoConverter, [NotNull] ITypeConverterProvider <SplineInfo_Vanilla, SplineInfo> splineInfoConverter, [NotNull] ITypeConverterProvider <CorpseInfo_Vanilla, CorpseInfo> corpseInfoConverter)
{
ObjectUpdateFlagsConverter = objectUpdateFlagsConverter ?? throw new ArgumentNullException(nameof(objectUpdateFlagsConverter));
MoveInfoConverter = moveInfoConverter ?? throw new ArgumentNullException(nameof(moveInfoConverter));
SplineInfoConverter = splineInfoConverter ?? throw new ArgumentNullException(nameof(splineInfoConverter));
CorpseInfoConverter = corpseInfoConverter ?? throw new ArgumentNullException(nameof(corpseInfoConverter));
}
public virtual async Task <IActionResult> UpdateObjectInstance(
[FromBody][NotNull] TInstanceTransportModelType model,
[FromRoute(Name = "id")] int objectId,
[FromServices][NotNull] TInstanceRepositoryType instanceObjectRepository,
[FromServices][NotNull] ITypeConverterProvider <TInstanceTransportModelType, TInstanceEntryModelType> networkToTableConverter)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (instanceObjectRepository == null)
{
throw new ArgumentNullException(nameof(instanceObjectRepository));
}
if (networkToTableConverter == null)
{
throw new ArgumentNullException(nameof(networkToTableConverter));
}
//It's TRUE that they should be sending a valid GUID.
//But it doesn't matter, it's not this action's responsibility to deal with it.
//if(model.Guid.EntryId != creatureId)
// return BadRequest();
TInstanceEntryModelType entryModel = await instanceObjectRepository.RetrieveAsync(objectId);
//The idea here is we CONVERT the incoming data model to the table model type
//and then we tell the table model type it needs to update.
entryModel.Update(networkToTableConverter.Convert(model));
//Then we save it.
await instanceObjectRepository.UpdateAsync(objectId, entryModel);
return(Ok());
}
public async Task <IActionResult> GetObjectTemplate([FromRoute(Name = "id")] int objectTemplateId,
[FromServices][NotNull] TInstanceRepositoryType objectTemplateRepository,
[FromServices][NotNull] ITypeConverterProvider <TTemplateEntryType, TTemplateTransferType> tableToNetworkModelConverter)
{
if (objectTemplateRepository == null)
{
throw new ArgumentNullException(nameof(objectTemplateRepository));
}
if (tableToNetworkModelConverter == null)
{
throw new ArgumentNullException(nameof(tableToNetworkModelConverter));
}
//If unknown templateId, then just indicate such.
if (!await objectTemplateRepository.ContainsAsync(objectTemplateId))
{
return(BuildFailedResponseModel(SceneContentQueryResponseCode.TemplateUnknown));
}
//Load the model, convert and send back.
TTemplateEntryType entryModel = await objectTemplateRepository.RetrieveAsync(objectTemplateId);
TTemplateTransferType templateModel = tableToNetworkModelConverter.Convert(entryModel);
return(BuildSuccessfulResponseModel(templateModel));
}
//[ResponseCache(Duration = 5000)]
public async Task <IActionResult> GetLevelLearnedSpellsAsync([FromServices] ILevelLearnedSpellRepository levelLearnedSpellRepository,
[FromServices] ITypeConverterProvider <SpellLevelLearned, SpellLevelLearnedDefinition> converter)
{
SpellLevelLearned[] levelLearneds = await levelLearnedSpellRepository.RetrieveAllAsync();
return(Json(CreatedSpellLevelLearnedCollectionResponse(levelLearneds, converter)));
}
public TypeFeatureProviderBuilder FromAttributes(IEnumerable<Type> types)
{
var listOfTypes = types as IList<Type> ?? types.ToList();
contentPropertyProvider = ContentPropertyProvider.FromAttributes(listOfTypes);
converterProvider = TypeConverterProvider.FromAttributes(listOfTypes);
return this;
}
public static ITypeConverterProvider FillFromAttributes(this ITypeConverterProvider converterProvider, IEnumerable <Type> types)
{
var defs = Extensions.GatherAttributes <TypeConverterAttribute, TypeConverterRegistration>(
types,
(type, attribute) => new TypeConverterRegistration(type, CreateConverterInstance(attribute)));
converterProvider.AddAll(defs);
return(converterProvider);
}
/// <inheritdoc />
public VanillaToWotlkObjectUpdateBlock([NotNull] ITypeConverterProvider <ObjectUpdateValuesObjectBlock_Vanilla, ObjectUpdateValuesObjectBlock> updateBlockConverter,
[NotNull] ITypeConverterProvider <ObjectUpdateMovementBlock_Vanilla, ObjectUpdateMovementBlock> movementBlockConverter,
[NotNull] ITypeConverterProvider <ObjectUpdateCreateObject1Block_Vanilla, ObjectUpdateCreateObject1Block> object1BlockConverter,
[NotNull] ITypeConverterProvider <ObjectUpdateCreateObject2Block_Vanilla, ObjectUpdateCreateObject2Block> object2BlockConverter,
[NotNull] ITypeConverterProvider <ObjectUpdateDestroyObjectBlock_Vanilla, ObjectUpdateDestroyObjectBlock> destroyBlockConverter)
{
UpdateBlockConverter = updateBlockConverter ?? throw new ArgumentNullException(nameof(updateBlockConverter));
MovementBlockConverter = movementBlockConverter ?? throw new ArgumentNullException(nameof(movementBlockConverter));
CreateObject1BlockConverter = object1BlockConverter ?? throw new ArgumentNullException(nameof(object1BlockConverter));
CreateObject2BlockConverter = object2BlockConverter ?? throw new ArgumentNullException(nameof(object2BlockConverter));
DestroyBlockConverter = destroyBlockConverter ?? throw new ArgumentNullException(nameof(destroyBlockConverter));
}
public ObjectAssembler(WiringContext wiringContext, ObjectAssemblerSettings settings = null)
{
this.wiringContext = wiringContext;
typeConverterProvider = wiringContext.ConverterProvider;
xamlTypeRepository = wiringContext.TypeContext;
typeRepository = wiringContext.TypeContext;
typeOperations = new TypeOperations(typeRepository.TypeFactory);
startMemberWriter = new StartMemberWriter(this);
getObjectWriter = new GetObjectWriter(this);
startObjectWriter = new StartObjectWriter(this, settings?.RootInstance);
valueWriter = new ValueWriter(this);
}
//[ResponseCache(Duration = 5000)]
public async Task <IActionResult> GetLevelLearnedSpellsForClassAsync([FromRoute(Name = "class")] EntityPlayerClassType classType, [FromServices] ILevelLearnedSpellRepository levelLearnedSpellRepository,
[FromServices] ITypeConverterProvider <SpellLevelLearned, SpellLevelLearnedDefinition> converter)
{
if (!Enum.IsDefined(typeof(EntityPlayerClassType), classType))
{
throw new InvalidEnumArgumentException(nameof(classType), (int)classType, typeof(EntityPlayerClassType));
}
SpellLevelLearned[] levelLearneds = await levelLearnedSpellRepository.RetrieveAllAsync(classType);
return(Json(CreatedSpellLevelLearnedCollectionResponse(levelLearneds, converter)));
}
public DataContextChangeSynchronizer(BindingSource bindingSource, BindingTarget bindingTarget, ITypeConverterProvider typeConverterProvider)
{
_bindingTarget = bindingTarget;
Guard.ThrowIfNull(bindingTarget.Object, nameof(bindingTarget.Object));
Guard.ThrowIfNull(bindingTarget.Property, nameof(bindingTarget.Property));
Guard.ThrowIfNull(bindingSource.SourcePropertyPath, nameof(bindingSource.SourcePropertyPath));
Guard.ThrowIfNull(bindingSource.Source, nameof(bindingSource.Source));
Guard.ThrowIfNull(typeConverterProvider, nameof(typeConverterProvider));
_bindingEndpoint = new TargetBindingEndpoint(bindingTarget.Object, bindingTarget.Property);
_sourceEndpoint = new ObservablePropertyBranch(bindingSource.Source, bindingSource.SourcePropertyPath);
_targetPropertyTypeConverter = typeConverterProvider.GetTypeConverter(bindingTarget.Property.PropertyType);
}
public DataContextChangeSynchronizer(PerspexObject target, PerspexProperty targetProperty,
PropertyPath sourcePropertyPath, object source, ITypeConverterProvider typeConverterProvider)
{
Guard.ThrowIfNull(target, nameof(target));
Guard.ThrowIfNull(targetProperty, nameof(targetProperty));
Guard.ThrowIfNull(sourcePropertyPath, nameof(sourcePropertyPath));
Guard.ThrowIfNull(source, nameof(source));
Guard.ThrowIfNull(typeConverterProvider, nameof(typeConverterProvider));
this.bindingEndpoint = new TargetBindingEndpoint(target, targetProperty);
this.sourceEndpoint = new ObservablePropertyBranch(source, sourcePropertyPath);
this.targetPropertyTypeConverter = typeConverterProvider.GetTypeConverter(targetProperty.PropertyType);
}
public UpdateWorkOrderCommandHandler(ILogAs logAs,
IWorkOrderReadRepository workOrderReadRepository,
IWorkOrderWriteRepository workOrderWriteRepository,
IVersionProvider versionProvider,
IDateTimeProvider dateTimeProvider,
ITypeConverterProvider typeConverterProvider)
{
_logAs = logAs ?? throw Error.ArgumentNull(nameof(logAs));
_workOrderReadRepository = workOrderReadRepository ?? throw Error.ArgumentNull(nameof(workOrderReadRepository));
_workOrderWriteRepository = workOrderWriteRepository ?? throw Error.ArgumentNull(nameof(workOrderWriteRepository));
_versionProvider = versionProvider ?? throw Error.ArgumentNull(nameof(versionProvider));
_dateTimeProvider = dateTimeProvider ?? throw Error.ArgumentNull(nameof(dateTimeProvider));
_typeConverterProvider = typeConverterProvider ?? throw Error.ArgumentNull(nameof(typeConverterProvider));
}
public virtual WiringContext Build()
{
var typingCore = typingCoreBuilder.Build();
if (converterProvider == null)
{
converterProvider = new TypeConverterProvider();
foreach (var converterRegistration in converterRegistrations)
{
converterProvider.RegisterConverter(converterRegistration);
}
}
return new WiringContext(typingCore, contentPropertyProvider, converterProvider);
}
public async Task <IActionResult> GetClientStaticContent([FromServices][NotNull] TContentRepositoryType repository,
[FromServices][NotNull] ITypeConverterProvider <TContentEntryType, TContentTransferType> converter)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
if (converter == null)
{
throw new ArgumentNullException(nameof(converter));
}
TContentEntryType[] contentEntryTypes = await repository.RetrieveAllAsync();
return(Json(contentEntryTypes));
}
//[ResponseCache(Duration = 5000)]
public async Task <IActionResult> GetDefaultSpellDataAsync([FromServices] ITypeConverterProvider <SpellEntryModel, SpellDefinitionDataModel> spellEntryConverter,
[FromServices] ITypeConverterProvider <SpellEffectEntryModel, SpellEffectDefinitionDataModel> spellEffectConverter)
{
SpellEntryModel[] entryModels = await SpellEntryRepository.RetrieveAllDefaultAsync(true);
SpellEffectEntryModel[] effectModels = entryModels.Select(s => s.SpellEffectOne)
.Distinct(new ContentIdentifiableEqualityComparer <SpellEffectEntryModel>())
.ToArray();
SpellDefinitionDataModel[] transportableEntryModels = entryModels.Select(spellEntryConverter.Convert)
.ToArray();
SpellEffectDefinitionDataModel[] transportableEffectEntryModels = effectModels.Select(spellEffectConverter.Convert)
.ToArray();
return(Json(new SpellDefinitionCollectionResponseModel(transportableEntryModels, transportableEffectEntryModels)));
}
public async Task <IActionResult> GetObjectEntries([FromRoute(Name = "world")] long worldId,
[FromServices] TInstanceRepositoryType instanceObjectRepository,
[FromServices] ITypeConverterProvider <TInstanceEntryModelType, TInstanceTransportModelType> tableToNetworkModelConverter)
{
IReadOnlyCollection <TInstanceEntryModelType> models = await instanceObjectRepository.RetrieveAllWorldIdAsync((int)worldId);
if (models.Count == 0)
{
return(BuildFailedResponseModel(ContentEntryCollectionResponseCode.NoneFound));
}
TInstanceTransportModelType[] instanceModels = models
.Select(tableToNetworkModelConverter.Convert)
.ToArray();
return(BuildSuccessfulResponseModel(new ObjectEntryCollectionModel <TInstanceTransportModelType>(instanceModels)));
}
public async Task <IActionResult> GetObjectInstance([FromRoute(Name = "id")] int objectId,
[FromServices] TInstanceRepositoryType instanceObjectRepository,
[FromServices] ITypeConverterProvider <TInstanceEntryModelType, TInstanceTransportModelType> tableToNetworkModelConverter)
{
//If unknown templateId, then just indicate such.
if (!await instanceObjectRepository.ContainsAsync(objectId))
{
return(BuildFailedResponseModel(SceneContentQueryResponseCode.TemplateUnknown));
}
//Load the model, convert and send back.
TInstanceEntryModelType entryModel = await instanceObjectRepository.RetrieveAsync(objectId);
TInstanceTransportModelType instanceModel = tableToNetworkModelConverter.Convert(entryModel);
return(BuildSuccessfulResponseModel(instanceModel));
}
public async Task <IActionResult> GetObjectTemplatesForWorld([FromRoute(Name = "world")] int worldId,
[FromServices] TInstanceRepositoryType objectTemplateRepository,
[FromServices] ITypeConverterProvider <TTemplateEntryType, TTemplateTransferType> tableToNetworkModelConverter)
{
//We can actually get all the templates FROM the creature instances.
IReadOnlyCollection <TTemplateEntryType> models = await objectTemplateRepository.RetrieveTemplatesByWorldIdAsync((int)worldId);
if (models.Count == 0)
{
return(BuildFailedResponseModel(ContentEntryCollectionResponseCode.NoneFound));
}
TTemplateTransferType[] templateModels = models
.Distinct(DatabaseModelKeyableEquailityComparer <TTemplateEntryType> .Instance)
.Select(tableToNetworkModelConverter.Convert)
.ToArray();
return(BuildSuccessfulResponseModel(new ObjectEntryCollectionModel <TTemplateTransferType>(templateModels)));
}
public void ConstructorShouldFailWhenTypeConverterProviderIsNull()
{
// Arrange
var logAs = new Mock <ILogAs>().Object;
var workOrderWriteRepository = new Mock <IWorkOrderWriteRepository>().Object;
var workOrderReadRepository = new Mock <IWorkOrderReadRepository>().Object;
var versionProvider = new Mock <IVersionProvider>().Object;
var dateTimeProvider = new Mock <IDateTimeProvider>().Object;
ITypeConverterProvider typeConverterProvider = null;
// Act
Action ctor = () =>
{
new UpdateWorkOrderCommandHandler(logAs, workOrderReadRepository, workOrderWriteRepository, versionProvider, dateTimeProvider, typeConverterProvider);
};
// Assert
ctor.Should().Throw <ArgumentNullException>();
}
public override async Task <IActionResult> UpdateObjectInstance([FromBody][NotNull] TInstanceTransportModelType model,
[FromRoute(Name = "id")] int objectId,
[FromServices][NotNull] TInstanceRepositoryType instanceObjectRepository,
[FromServices][NotNull] ITypeConverterProvider <TInstanceTransportModelType, TInstanceEntryModelType> networkToTableConverter)
{
//So, this one is abit different since there is no created instance.
//The client needs to create it, we don't assign a default behavior.
//So it's possible it DOESN'T exist.
if (await instanceObjectRepository.ContainsAsync(objectId))
{
return(await base.UpdateObjectInstance(model, objectId, instanceObjectRepository, networkToTableConverter));
}
else
{
//it doesn't exist, we need to try to create it.
TInstanceEntryModelType entryModel = networkToTableConverter.Convert(model);
await instanceObjectRepository.TryCreateAsync(entryModel);
}
return(Ok());
}
public XamlBinding(ITypeConverterProvider typeConverterProvider)
{
_typeConverterProvider = typeConverterProvider;
}
/// <inheritdoc />
public ConvertRequiredDatabaseEntryInserterDecorator([NotNull] IDatabaseDbcInsertable <TDBCEntryType> decorateDbcInsertable, [NotNull] ITypeConverterProvider <TDBCFileType, TDBCEntryType> dbcTypeConverter, [NotNull] ILogger <ConvertRequiredDatabaseEntryInserterDecorator <TDBCFileType, TDBCEntryType> > logger)
{
DecorateDbcInsertable = decorateDbcInsertable ?? throw new ArgumentNullException(nameof(decorateDbcInsertable));
DbcTypeConverter = dbcTypeConverter ?? throw new ArgumentNullException(nameof(dbcTypeConverter));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
protected CsvMapping(ITypeConverterProvider typeConverterProvider)
{
this.typeConverterProvider = typeConverterProvider;
this.csvPropertyMappings = new List <IndexToPropertyMapping>();
}
/// <inheritdoc />
public LocalizedStringToStringDbcRefTypeConverter([NotNull] ITypeConverterProvider <string, StringDBCReference> stringToStringRefConverter)
{
StringToStringRefConverter = stringToStringRefConverter ?? throw new ArgumentNullException(nameof(stringToStringRefConverter));
}
public TypeFeatureProviderBuilder FromAttributes(IEnumerable<Type> types)
{
contentPropertyProvider = ContentPropertyProvider.FromAttributes(types);
converterProvider = TypeConverterProvider.FromAttributes(types);
return this;
}
public XamlBinding(ITypeConverterProvider typeConverterProvider)
{
_typeConverterProvider = typeConverterProvider;
}
public TypeFeatureProvider(IContentPropertyProvider contentPropertyProvider, ITypeConverterProvider converterProvider)
{
ContentPropertyProvider = contentPropertyProvider;
ConverterProvider = converterProvider;
}
public PerspexPropertyBinder(ITypeConverterProvider typeConverterProvider)
{
this.typeConverterProvider = typeConverterProvider;
this.bindings = new HashSet<XamlBinding>();
}
public WiringContext(ITypeContext typeContext, IContentPropertyProvider contentPropertyProvider, ITypeConverterProvider converterProvider)
{
TypeContext = typeContext;
ContentPropertyProvider = contentPropertyProvider;
ConverterProvider = converterProvider;
}
public DependencyPropertyService()
{
this.typeConverterProvider = new XamarinTypeConverterProvider();
}
public MultiBinding(ITypeConverterProvider typeConverterProvider)
{
_typeConverterProvider = typeConverterProvider;
}
/// <inheritdoc />
public WotlkToVanillaMonsterSplineInfoTypeConverter([NotNull] ITypeConverterProvider <SplineMoveFlags, SplineMoveFlags_Vanilla> splineFlagsConverter)
{
SplineFlagsConverter = splineFlagsConverter ?? throw new ArgumentNullException(nameof(splineFlagsConverter));
}
/// <inheritdoc />
public VanillaToWotlkCharacterScreenCharacterTypeConverter([NotNull] ITypeConverterProvider <CharacterScreenItem_Vanilla, CharacterScreenItem> characterScreenItemConverter)
{
CharacterScreenItemConverter = characterScreenItemConverter ?? throw new ArgumentNullException(nameof(characterScreenItemConverter));
}
public WpfTypeFeatureProvider(ITypeConverterProvider converterProvider)
{
inner = new TypeFeatureProvider(converterProvider);
}
public TypeFeatureProvider(ITypeConverterProvider converterProvider)
{
ConverterProvider = converterProvider;
}
public WiringContextBuilder WithConverterProvider(ITypeConverterProvider provider)
{
converterProvider = provider;
return this;
}
public WotlkToVanillaClientMovementPayloadHandler([NotNull] ILog logger, [NotNull] ITypeConverterProvider <MovementInfo, MovementInfo_Vanilla> moveInfoConverter)
{
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
MoveInfoConverter = moveInfoConverter ?? throw new ArgumentNullException(nameof(moveInfoConverter));
}
protected EntityMapping(ITypeConverterProvider typeConverterProvider)
{
_typeConverterProvider = typeConverterProvider;
_propertyMappings = new List <IndexToPropertyMapping>();
}
public TypeFeatureProvider(IContentPropertyProvider contentPropertyProvider, ITypeConverterProvider converterProvider)
{
ContentPropertyProvider = contentPropertyProvider;
ConverterProvider = converterProvider;
}
