internal void Load() { var configType = config.GetType(); var holderAttribute = configType.GetCustomAttribute <ConfigurationHolderAttribute>(); foreach (PropertyInfo item in configType.GetProperties()) { if (item.PropertyType == typeof(ConfigurationElement)) { ConfigurationElement element = ConfigurationIO.Read(item.Name, name + "." + config.GetType().Name /*,item.GetValue(config).ToString()*/); if (!string.IsNullOrWhiteSpace(element)) { if (CheckValueVaild(item, element, holderAttribute)) { item.SetValue(config, element); } } else { //if not exist,write to config.ini immediately ConfigurationIO.Write(item.Name, (ConfigurationElement)item.GetValue(config), name + "." + config.GetType().Name); } } } }
public static string[] GetConfiguration(IConfigurable configurable) { List <string> output = new List <string>(); PropertyInfo[] properties = configurable.GetType().GetProperties(); for (int i = 0; i < properties.Length; i++) { PropertyInfo property = properties[i]; MakeConfigrable makeConfigurable = Attribute.GetCustomAttribute(property, typeof(MakeConfigrable)) as MakeConfigrable; if (makeConfigurable != null) { if (property.PropertyType.IsArray) { string outputEntry = property.Name + ": "; Array array = (Array)property.GetValue(configurable, null); for (int i2 = 0; i2 < array.Length; i2++) { outputEntry += ((object)array.GetValue(i2)).ToString() + VALUE_SEPERATOR; } output.Add(outputEntry); } else { output.Add(property.Name + ": " + property.GetValue(configurable, null).ToString()); } } } FieldInfo[] fields = configurable.GetType().GetFields(); for (int i = 0; i < fields.Length; i++) { FieldInfo field = fields[i]; MakeConfigrable makeConfigurable = Attribute.GetCustomAttribute(field, typeof(MakeConfigrable)) as MakeConfigrable; if (makeConfigurable != null) { if (field.FieldType.IsArray) { string outputEntry = field.Name + ": "; Array array = (Array)field.GetValue(configurable); for (int i2 = 0; i2 < array.Length; i2++) { outputEntry += ((object)array.GetValue(i2)).ToString() + VALUE_SEPERATOR; } output.Add(outputEntry); } else { output.Add(field.Name + ": " + field.GetValue(configurable).ToString()); } } } return(output.ToArray()); }
// Token: 0x0600606F RID: 24687 RVA: 0x00147B24 File Offset: 0x00145D24 public virtual void Provision(ADProvisioningPolicy templatePolicy, IConfigurable writablePresentationObject) { if (templatePolicy == null) { throw new ArgumentNullException("templatePolicy"); } if (writablePresentationObject == null) { throw new ArgumentNullException("writablePresentationObject"); } if (!base.TargetObjectTypes.Contains(writablePresentationObject.GetType())) { throw new ArgumentOutOfRangeException("writablePresentationObject"); } if (!(writablePresentationObject is ADObject)) { throw new ArgumentOutOfRangeException("writablePresentationObject"); } object obj = templatePolicy[base.PolicyProperty]; if (!this.IsNullOrUnlimited(obj) && !this.IsNullOrEmptyMvp(obj)) { if (base.ValueConverter != null) { obj = base.ValueConverter(obj); } ((ADObject)writablePresentationObject)[base.ObjectProperty] = obj; return; } }
public void Delete(IConfigurable instance) { if (instance == null) { throw new ArgumentNullException("instance"); } if (this.configurationSession.ReadOnly) { throw new InvalidOperationException("read only"); } if (this.serviceInstanceName == null) { throw new InvalidOperationException("Delete can be performed only for specific service instance."); } FullSyncObjectRequest fullSyncObjectRequest = instance as FullSyncObjectRequest; if (fullSyncObjectRequest == null) { throw new NotSupportedException(instance.GetType().FullName); } this.RefreshRidMasterInformation(); MsoMainStreamCookieContainer msoMainStreamCookieContainer = this.configurationSession.GetMsoMainStreamCookieContainer(this.serviceInstanceName); MultiValuedProperty <FullSyncObjectRequest> msoForwardSyncObjectFullSyncRequests = msoMainStreamCookieContainer.MsoForwardSyncObjectFullSyncRequests; if (msoForwardSyncObjectFullSyncRequests.Contains(fullSyncObjectRequest)) { msoForwardSyncObjectFullSyncRequests.Remove(fullSyncObjectRequest); this.configurationSession.Save(msoMainStreamCookieContainer); return; } throw new ADNoSuchObjectException(DirectoryStrings.ExceptionADOperationFailedNoSuchObject(this.configurationSession.DomainController, fullSyncObjectRequest.ToString())); }
public static void Configure(this IConfigurable leftHand) { if (leftHand == null) { return; } if (leftHand.Properties == null) { return; } foreach (var property in leftHand.Properties) { System.Reflection.PropertyInfo prop = null; try { prop = leftHand.GetType().GetProperty(property); //can be null if property not exists, can throw exceptions var value = leftHand.Config.GetValue(leftHand.Section, prop.Name); //can throw exceptions prop.SetValue(leftHand, value); } catch { if (prop != null) { leftHand.Config.SetValue(leftHand.Section, prop.Name, (string)prop.GetValue(leftHand)); } } } }
public void Initialize(String workingDirPath, string[] arguments) { if (arguments.Length != 1) { throw new Exception(GetType() + " expects one argument: \"<className>;<configFile>"); } string[] splitArguments = arguments[0].Split(new[] { ';' }); string dotNetFactoryClassName = splitArguments[0]; string[] dotNetFactoryArguments = new string[splitArguments.Length - 1]; for (int i = 0; i < dotNetFactoryArguments.Length; i++) { dotNetFactoryArguments[i] = splitArguments[i + 1]; } if (_insertedModelFactory != null) { // Model factory already set. Check class name if (!_insertedModelFactory.GetType().ToString().Equals(dotNetFactoryClassName)) { throw new Exception("Inserted ModelFactory is not of the type specified in the OpenDA config file"); } _actualModelFactory = _insertedModelFactory; } else { // Note: this dynamic object creation IConfigurable modelFactoryObject = Utils.CreateConfigurableInstance(dotNetFactoryClassName, typeof(IModelFactory)); if (!(modelFactoryObject is IModelFactory)) { throw new Exception("Unexpected object type " + modelFactoryObject.GetType()); } _actualModelFactory = (IModelFactory)modelFactoryObject; } _actualModelFactory.Initialize(workingDirPath, dotNetFactoryArguments); }
public void ForceLoad() { foreach (PropertyInfo item in config.GetType().GetProperties()) { if (item.PropertyType == typeof(ConfigurationElement)) { ConfigurationElement element = ConfigurationIO.Read(item.Name, instance.Name + "." + config.GetType().Name /*,item.GetValue(config).ToString()*/); if (!string.IsNullOrWhiteSpace(element)) { item.SetValue(config, element); } } } config.onConfigurationLoad(); }
public PluginConfiuration GetInstance(IConfigurable obj) { foreach (var item in items) { if (item.GetType() == obj.GetType()) { return(item); } } return(null); }
// Token: 0x06006075 RID: 24693 RVA: 0x00147CC4 File Offset: 0x00145EC4 public virtual bool IsApplicable(IConfigurable readOnlyPresentationObject) { if (readOnlyPresentationObject == null) { throw new ArgumentNullException("readOnlyPresentationObject"); } if (!base.TargetObjectTypes.Contains(readOnlyPresentationObject.GetType())) { throw new ArgumentOutOfRangeException("readOnlyPresentationObject"); } return(ObjectState.New == readOnlyPresentationObject.ObjectState); }
private void PopulateObject(IConfigurable obj) { string key; string typeName = obj.GetType().Name; PropertyInfo[] properties = obj.GetType().GetProperties(); foreach (PropertyInfo p in properties) { //if (p.PropertyType.Name == "String" // || p.PropertyType.Name == "Int32") if (p.GetCustomAttributes(typeof(ConfigItem), true).Length > 0) { key = typeName + "." + p.Name; if (!ConfigData.ContainsKey(key)) { continue; } switch (p.PropertyType.Name) { case "String": p.SetValue(obj, Get <String>(key), null); break; case "Int32": p.SetValue(obj, Get <int>(key), null); break; case "Boolean": p.SetValue(obj, Get <bool>(key), null); break; } //if (p.PropertyType.Name == "System.String") // p.SetValue(obj, Get<string>(key), null); //Set(typeName + "." + p.Name, p.GetValue(obj, null)?.ToString()); } } }
public void Save(IConfigurable instance) { if (instance == null) { throw new ArgumentNullException("instance"); } if (this.configurationSession.ReadOnly) { throw new InvalidOperationException("read only"); } if (this.serviceInstanceName == null) { throw new InvalidOperationException("Save can be performed only for specific service instance."); } FullSyncObjectRequest request = instance as FullSyncObjectRequest; if (request == null) { throw new NotSupportedException(instance.GetType().FullName); } this.RefreshRidMasterInformation(); MsoMainStreamCookieContainer msoMainStreamCookieContainer = this.configurationSession.GetMsoMainStreamCookieContainer(this.serviceInstanceName); MultiValuedProperty <FullSyncObjectRequest> msoForwardSyncObjectFullSyncRequests = msoMainStreamCookieContainer.MsoForwardSyncObjectFullSyncRequests; FullSyncObjectRequest fullSyncObjectRequest = msoForwardSyncObjectFullSyncRequests.Find((FullSyncObjectRequest r) => request.Identity.Equals(r.Identity) && request.ServiceInstanceId == r.ServiceInstanceId); if (fullSyncObjectRequest != null) { if (request.ObjectState == ObjectState.New) { throw new ADObjectAlreadyExistsException(DirectoryStrings.ExceptionADOperationFailedAlreadyExist(this.configurationSession.DomainController, request.ToString())); } if (request.ObjectState == ObjectState.Changed) { msoForwardSyncObjectFullSyncRequests.Remove(fullSyncObjectRequest); } } else { IEnumerable <FullSyncObjectRequest> source = from r in msoForwardSyncObjectFullSyncRequests where request.ServiceInstanceId == r.ServiceInstanceId select r; int maxObjectFullSyncRequestsPerServiceInstance = ProvisioningTasksConfigImpl.MaxObjectFullSyncRequestsPerServiceInstance; if (source.Count <FullSyncObjectRequest>() >= maxObjectFullSyncRequestsPerServiceInstance) { throw new DataSourceOperationException(Strings.OperationExceedsPerServiceInstanceFullSyncObjectRequestLimit(maxObjectFullSyncRequestsPerServiceInstance, request.ServiceInstanceId)); } } msoForwardSyncObjectFullSyncRequests.Add(request); this.configurationSession.Save(msoMainStreamCookieContainer); }
private static string CheckInputType(IConfigurable obj) { if (obj == null) { throw new ArgumentNullException("AsyncQueueSession input"); } string name = obj.GetType().Name; if (!(obj is AsyncQueueRequest) && !(obj is AsyncQueueRequestStatusUpdate) && !(obj is AsyncQueueLog) && !(obj is AsyncQueueLogBatch)) { throw new InvalidObjectTypeForSessionException(HygieneDataStrings.ErrorInvalidObjectTypeForSession("AsyncQueueSession", name)); } return(name); }
// Token: 0x06001085 RID: 4229 RVA: 0x000327DC File Offset: 0x000309DC private void GenerateSchema(PSObject template) { ExTraceGlobals.IntegrationTracer.Information <PSObject>((long)this.GetHashCode(), "-->MonadDataReader.GenerateSchema({0})", template); this.properties = new COPropertyInfoCollection(); IConfigurable configurable = this.UnWrappPSObject(template) as IConfigurable; if (configurable != null) { ExTraceGlobals.IntegrationTracer.Information((long)this.GetHashCode(), "\tTemplate is a IConfigurable"); if (template.Properties["Identity"] != null) { Type typeFromHandle = typeof(string); this.properties.Add(new COPropertyInfo("Identity", typeFromHandle)); ExTraceGlobals.IntegrationTracer.Information <string, Type>((long)this.GetHashCode(), "\tProperty added to schema: {0}, {1}", "Identity", typeFromHandle); } foreach (PSPropertyInfo pspropertyInfo in template.Properties) { if (!("Fields" == pspropertyInfo.Name) && !("Identity" == pspropertyInfo.Name)) { Type type = Type.GetType(pspropertyInfo.TypeNameOfValue); if (null == type) { PropertyInfo property = configurable.GetType().GetProperty(pspropertyInfo.Name); if (!(null != property)) { ExTraceGlobals.IntegrationTracer.Information <string>((long)this.GetHashCode(), "\tProperty skipped: {0}", pspropertyInfo.Name); continue; } type = property.PropertyType; } this.properties.Add(new COPropertyInfo(pspropertyInfo.Name, type)); ExTraceGlobals.IntegrationTracer.Information <string>((long)this.GetHashCode(), "\tProperty added to schema: {0}", pspropertyInfo.Name); } } if (!string.IsNullOrEmpty(this.preservedObjectProperty)) { this.properties.Add(new COPropertyInfo(this.preservedObjectProperty, configurable.GetType())); ExTraceGlobals.IntegrationTracer.Information <string>((long)this.GetHashCode(), "\tProperty added to schema: {0}", this.preservedObjectProperty); } } else { ExTraceGlobals.IntegrationTracer.Information((long)this.GetHashCode(), "\tTemplate is NOT a IConfigurable."); this.properties.Add(new COPropertyInfo("Value", this.UnWrappPSObject(template).GetType())); this.useBaseObject = true; } ExTraceGlobals.IntegrationTracer.Information((long)this.GetHashCode(), "<--MonadDataReader.GenerateSchema()"); }
// Token: 0x06006076 RID: 24694 RVA: 0x00147CFB File Offset: 0x00145EFB public virtual ProvisioningValidationError[] Validate(ADProvisioningPolicy enforcementPolicy, IConfigurable readOnlyPresentationObject) { if (enforcementPolicy == null) { throw new ArgumentNullException("enforcementPolicy"); } if (readOnlyPresentationObject == null) { throw new ArgumentNullException("readOnlyPresentationObject"); } if (!base.TargetObjectTypes.Contains(readOnlyPresentationObject.GetType())) { throw new ArgumentOutOfRangeException("readOnlyPresentationObject"); } return(null); }
public void AddConfigurable(IConfigurable configurable, String name) { if (_symbolTable.ContainsKey(name)) { throw new ArgumentException("tried to override existing component name"); } var dummyRPD = new RawPropertyData(name, configurable.GetType().Name); var ps = new PropertySheet(configurable, name, dummyRPD, this); _symbolTable.Put(name, ps); _rawPropertyMap.Put(name, dummyRPD); foreach (IConfigurationChangeListener changeListener in _changeListeners) { changeListener.ComponentAdded(this, ps); } }
public virtual void Save(IConfigurable instance) { if (instance == null) { throw new ArgumentNullException("instance"); } ConfigurableObject configurableObject = instance as ConfigurableObject; if (configurableObject == null) { throw new NotSupportedException("Save: " + instance.GetType().FullName); } ValidationError[] array = configurableObject.Validate(); if (array.Length > 0) { throw new DataValidationException(array[0]); } this.InternalSave(configurableObject); configurableObject.ResetChangeTracking(true); }
public void Delete(IConfigurable instance) { if (instance == null) { throw new ArgumentNullException("instance"); } ConfigurableObject configurableObject = instance as ConfigurableObject; if (configurableObject == null) { throw new NotSupportedException("Delete: " + instance.GetType().FullName); } if (configurableObject.ObjectState == ObjectState.Deleted) { throw new InvalidOperationException(ServerStrings.ExceptionObjectHasBeenDeleted); } this.InternalDelete(configurableObject); configurableObject.ResetChangeTracking(); configurableObject.MarkAsDeleted(); }
public void Save(IConfigurable obj) { if (obj == null) { throw new ArgumentNullException(obj.GetType().Name); } if (obj is OnDemandQueryRequest) { OnDemandQueryRequest reportRequest = obj as OnDemandQueryRequest; this.Save(reportRequest); } else { if (!(obj is ReportSchedule)) { throw new NotSupportedException("This object type cannot be saved through this session object"); } ReportSchedule reportSchedule = obj as ReportSchedule; this.Save(reportSchedule); } this.dataProviderDirectory.Save(obj); }
// Token: 0x0600607A RID: 24698 RVA: 0x00147E54 File Offset: 0x00146054 public override ProvisioningValidationError[] Validate(ADProvisioningPolicy enforcementPolicy, IConfigurable readOnlyPresentationObject) { base.Validate(enforcementPolicy, readOnlyPresentationObject); ADObject adobject; if (readOnlyPresentationObject is ADPublicFolder) { adobject = (ADPublicFolder)readOnlyPresentationObject; } else { adobject = (MailEnabledRecipient)readOnlyPresentationObject; } Unlimited <int> fromValue = (Unlimited <int>)enforcementPolicy[base.CountQuotaProperty]; if (!fromValue.IsUnlimited && (T)fromValue >= 0) { int num = (T)fromValue; bool flag; if (num == 0) { flag = true; } else { string domainController = null; if (base.Context != null && base.Context.UserSpecifiedParameters != null && base.Context.UserSpecifiedParameters.Contains("DomainController")) { object obj = base.Context.UserSpecifiedParameters["DomainController"]; if (obj != null) { domainController = obj.ToString(); } } ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopes(ADSystemConfigurationSession.GetRootOrgContainerIdForLocalForest(), adobject.OrganizationId, null, false); IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(domainController, true, ConsistencyMode.FullyConsistent, sessionSettings, 178, "Validate", "f:\\15.00.1497\\sources\\dev\\data\\src\\directory\\Provisioning\\RecipientResourceCountQuota.cs"); flag = SystemAddressListMemberCount.IsQuotaExceded(tenantOrTopologyConfigurationSession, adobject.OrganizationId, base.SystemAddressListName, num); } if (flag) { string policyId = string.Format("{0}: {1}", enforcementPolicy.Identity.ToString(), base.CountQuotaProperty.Name); LocalizedString description; if (adobject.OrganizationalUnitRoot == null) { description = DirectoryStrings.ErrorExceededHosterResourceCountQuota(policyId, (readOnlyPresentationObject.GetType() == typeof(ADPublicFolder)) ? "MailPublicFolder" : ProvisioningHelper.GetProvisioningObjectTag(readOnlyPresentationObject.GetType()), num); } else { description = DirectoryStrings.ErrorExceededMultiTenantResourceCountQuota(policyId, (readOnlyPresentationObject.GetType() == typeof(ADPublicFolder)) ? "MailPublicFolder" : ProvisioningHelper.GetProvisioningObjectTag(readOnlyPresentationObject.GetType()), adobject.OrganizationalUnitRoot.Name, num); } return(new ProvisioningValidationError[] { new ProvisioningValidationError(description, ExchangeErrorCategory.ServerOperation, null) }); } } return(null); }
void IConfigurable.CopyChangesFrom(IConfigurable source) { DatabaseEventWatermark databaseEventWatermark = source as DatabaseEventWatermark; if (databaseEventWatermark == null) { throw new NotImplementedException(string.Format("Cannot copy changes from type {0}.", source.GetType())); } this.watermark = databaseEventWatermark.watermark; this.consumerGuid = databaseEventWatermark.consumerGuid; this.databaseId = databaseEventWatermark.databaseId; this.server = databaseEventWatermark.server; this.isDatabaseCopyActive = databaseEventWatermark.isDatabaseCopyActive; }
internal void Delete(IConfigurable configurable) { if (!(configurable is ProbeOrganizationInfo) && !(configurable is TenantConfigurationCacheEntry)) { throw new ArgumentException(string.Format("The type {0} is not supported for the global session; please use a scoped DAL session instead.", configurable.GetType().ToString())); } this.WebStoreDataProvider.Delete(configurable); }
void IConfigurable.CopyChangesFrom(IConfigurable source) { DatabaseEvent databaseEvent = source as DatabaseEvent; if (databaseEvent == null) { throw new NotImplementedException(string.Format("Cannot copy changes from type {0}.", source.GetType())); } this.mapiEvent = databaseEvent.mapiEvent; this.databaseId = databaseEvent.databaseId; this.server = databaseEvent.server; this.isDatabaseCopyActive = databaseEvent.isDatabaseCopyActive; }
public PropertySheet(IConfigurable configurable, string name, RawPropertyData rpd, ConfigurationManager configurationManager) : this(configurable.GetType(), name, configurationManager, rpd) { _owner = configurable; }
public static void SetConfiguration(IConfigurable configurable) { PropertyInfo[] properties = configurable.GetType().GetProperties(); for (int i = 0; i < properties.Length; i++) { PropertyInfo property = properties[i]; MakeConfigrable makeConfigurable = Attribute.GetCustomAttribute(property, typeof(MakeConfigrable)) as MakeConfigrable; if (makeConfigurable != null) { if (property.PropertyType.IsArray) { string value = fileReader.ReadLine(); value = value.Replace(property.Name + ": ", ""); Array array = (Array)property.GetValue(configurable, null); for (int i2 = 0; i2 < array.Length; i2++) { if (array.GetValue(i2) is float) { property.SetValue(configurable, float.Parse(value.Substring(0, value.IndexOf(", "))), new object[] { i2 }); } else if (array.GetValue(i2) is int) { property.SetValue(configurable, int.Parse(value), new object[] { i2 }); } else if (array.GetValue(i2) is bool) { property.SetValue(configurable, bool.Parse(value), new object[] { i2 }); } value = value.Remove(0, value.IndexOf(", ")); } } else { string value = fileReader.ReadLine(); value = value.Replace(property.Name + ": ", ""); if (property.PropertyType == typeof(float)) { property.SetValue(configurable, float.Parse(value), null); } else if (property.PropertyType == typeof(int)) { property.SetValue(configurable, int.Parse(value), null); } else if (property.PropertyType == typeof(bool)) { property.SetValue(configurable, bool.Parse(value), null); } } } } FieldInfo[] fields = configurable.GetType().GetFields(); for (int i = 0; i < fields.Length; i++) { FieldInfo field = fields[i]; MakeConfigrable makeConfigurable = Attribute.GetCustomAttribute(field, typeof(MakeConfigrable)) as MakeConfigrable; if (makeConfigurable != null) { if (field.FieldType.IsArray) { string value = fileReader.ReadLine(); value = value.Replace(field.Name + ": ", ""); if (field.GetValue(configurable) is float[]) { List <float> values = new List <float>(); while (value.Contains(VALUE_SEPERATOR)) { values.Add(float.Parse(value.Substring(0, value.IndexOf(VALUE_SEPERATOR)))); value = value.Remove(0, value.IndexOf(VALUE_SEPERATOR) + VALUE_SEPERATOR.Length); } field.SetValue(configurable, values.ToArray()); } else if (field.GetValue(configurable) is int[]) { List <int> values = new List <int>(); while (value.Contains(VALUE_SEPERATOR)) { values.Add(int.Parse(value.Substring(0, value.IndexOf(VALUE_SEPERATOR)))); value = value.Remove(0, value.IndexOf(VALUE_SEPERATOR) + VALUE_SEPERATOR.Length); } field.SetValue(configurable, values.ToArray()); } else if (field.GetValue(configurable) is bool[]) { List <bool> values = new List <bool>(); while (value.Contains(VALUE_SEPERATOR)) { values.Add(bool.Parse(value.Substring(0, value.IndexOf(VALUE_SEPERATOR)))); value = value.Remove(0, value.IndexOf(VALUE_SEPERATOR) + VALUE_SEPERATOR.Length); } field.SetValue(configurable, values.ToArray()); } } else { string value = fileReader.ReadLine(); value = value.Replace(field.Name + ": ", ""); if (field.FieldType == typeof(float)) { field.SetValue(configurable, float.Parse(value)); } else if (field.FieldType == typeof(int)) { field.SetValue(configurable, int.Parse(value)); } else if (field.FieldType == typeof(bool)) { field.SetValue(configurable, bool.Parse(value)); } } } } }
/// <summary> /// /// </summary> /// <param name="content">Raw configuration file content.</param> /// <param name="configuration">The configuration object, implementing IConfigurable.</param> /// <param name="customParsers">Optional array of parser allowing to parse any type the way you want.</param> public static void AssignConfiguration(string content, IConfigurable configuration, params ICustomParser[] customParsers) { Dictionary <string, string> rawConfiguration = ParseConfiguration(content); var configurableProperties = (from p in configuration.GetType().GetProperties() let attr = p.GetCustomAttributes(typeof(MatchingKeyAttribute), true) where attr.Length == 1 select new { Property = p, Attribute = attr.First() as MatchingKeyAttribute }) .ToList(); foreach (var item in rawConfiguration) { string key = item.Key.ToLowerInvariant(); var matchingProps = configurableProperties.Where(x => x.Attribute.Key == key); PropertyInfo matchingProp = null; MatchingKeyAttribute matchingAttribute = null; if (matchingProps.Any()) { try { // try to find a matching property for this key var single = matchingProps.Single(); matchingProp = single.Property; matchingAttribute = single.Attribute; configurableProperties.Remove(single); } catch (Exception ex) { throw new Exception(string.Format("The key \"{0}\" was found multiple times!", key), ex); } // parse value var appropriateParser = customParsers.FirstOrDefault(x => x.ReturnType == matchingProp.PropertyType); if (appropriateParser != null) { object parsed = appropriateParser.Parse(item.Value, matchingAttribute.CustomParameter); matchingProp.SetValue(configuration, parsed, null); } // default parsers else if (matchingProp.PropertyType == typeof(string)) { // todo: handle default values for strings matchingProp.SetValue(configuration, item.Value, null); } else if (matchingProp.PropertyType == typeof(bool)) { if (matchingAttribute.CustomParameter is bool) { matchingProp.SetValue(configuration, ParseBool(item.Value, (bool)matchingAttribute.CustomParameter), null); } else { matchingProp.SetValue(configuration, ParseBool(item.Value), null); } } else if (matchingProp.PropertyType == typeof(int)) { if (matchingAttribute.CustomParameter is int) { matchingProp.SetValue(configuration, ParseInt(item.Value, (int)matchingAttribute.CustomParameter), null); } else { matchingProp.SetValue(configuration, ParseInt(item.Value), null); } } // TODO: default parser for other simple types (int, float...) else { throw new Exception(string.Format("Could not find a parser for type \"{0}\"!", matchingProp.PropertyType)); } } else { // no matching assignable property configuration.HandleDynamicKey(item.Key, item.Value); } } // assign default value if present for remaining properties not found in configuration foreach (var remainingPropery in configurableProperties) { // todo : throw exception if no default parameter to avoid impredictable errors? // >> need to differentiate default null from provided null if (remainingPropery.Attribute.CustomParameter != null) { remainingPropery.Property.SetValue(configuration, remainingPropery.Attribute.CustomParameter, null); } } }
private void CacheDeleteInternal(IConfigurable instance) { string error = null; Stopwatch stopwatch = Stopwatch.StartNew(); CachePerformanceTracker.StartLogging(); bool isNewProxyObject = false; int retryCount = 0; string callerInfo = null; Guid activityId = Guid.Empty; try { TSession tsession = this.GetCacheSession(); tsession.Delete(instance); CacheDirectorySession cacheDirectorySession = this.GetCacheSession() as CacheDirectorySession; if (cacheDirectorySession != null) { isNewProxyObject = cacheDirectorySession.IsNewProxyObject; retryCount = cacheDirectorySession.RetryCount; } TSession session = this.GetSession(); if (session.ActivityScope != null) { TSession session2 = this.GetSession(); if (session2.ActivityScope.Status == ActivityContextStatus.ActivityStarted) { TSession session3 = this.GetSession(); activityId = session3.ActivityScope.ActivityId; } } TSession session4 = this.GetSession(); callerInfo = session4.CallerInfo; } catch (Exception ex) { error = ex.ToString(); throw; } finally { stopwatch.Stop(); string cachePerformanceTracker = CachePerformanceTracker.StopLogging(); ADRawEntry adrawEntry = instance as ADRawEntry; CacheProtocolLog.BeginAppend("Remove", (adrawEntry != null) ? adrawEntry.GetDistinguishedNameOrName() : "<NULL>", DateTime.MinValue, stopwatch.ElapsedMilliseconds, -1L, stopwatch.ElapsedMilliseconds, -1L, -1L, isNewProxyObject, retryCount, instance.GetType().Name, cachePerformanceTracker, activityId, callerInfo, error); } }
internal virtual void ProvisionCustomDefaultProperties(IConfigurable provisionedDefault) { if (provisionedDefault == null) { throw new ArgumentNullException("provisionedDefault"); } if (this.SupportedPresentationObjectTypes == null || !this.SupportedPresentationObjectTypes.Contains(provisionedDefault.GetType())) { throw new InvalidOperationException(DirectoryStrings.ErrorPolicyDontSupportedPresentationObject(provisionedDefault.GetType(), base.GetType())); } }
void IConfigurable.CopyChangesFrom(IConfigurable source) { if (!(source is RestrictionRow)) { throw new NotImplementedException(string.Format("Cannot copy changes from type {0}.", source.GetType())); } }
internal virtual ProvisioningValidationError[] ProvisioningCustomValidate(IConfigurable roPresentationObject) { if (roPresentationObject == null) { throw new ArgumentNullException("roPresentationObject"); } if (this.SupportedPresentationObjectTypes == null || !this.SupportedPresentationObjectTypes.Contains(roPresentationObject.GetType())) { throw new InvalidOperationException(DirectoryStrings.ErrorPolicyDontSupportedPresentationObject(roPresentationObject.GetType(), base.GetType())); } return(null); }
public void CopyChangesFrom(IConfigurable source) { if (source == null) { throw new ArgumentNullException("source"); } IPListEntry iplistEntry = source as IPListEntry; if (iplistEntry == null) { throw new ArgumentException(DirectoryStrings.ExceptionCopyChangesForIncompatibleTypes(source.GetType(), base.GetType()), "source"); } if (iplistEntry.identity != null) { this.identity = new IPListEntryIdentity(iplistEntry.identity.Index); } if (iplistEntry.range != null) { this.range = new IPRange(new IPvxAddress(iplistEntry.range.LowerBound), new IPvxAddress(iplistEntry.range.UpperBound), iplistEntry.range.RangeFormat); } this.expirationTimeUtc = iplistEntry.expirationTimeUtc; this.isMachineGenerated = iplistEntry.IsMachineGenerated; this.listType = iplistEntry.ListType; this.isValid = iplistEntry.IsValid; this.comment = iplistEntry.Comment; }