protected virtual void OnValidateFormatMediaTypeName(ArgumentUtilitiesHandle <string> name) { name .EnsureNotNull() .EnsureNotEmptyOrWhiteSpace(); // }
// TODO: Improve exception message. // public static Stats Calculate(ArgumentUtilitiesHandle <IEnumerable <double> > values, Stats entire = default) { values.EnsureNotNull(); var valuesArray = values .Value .Select( (locValue, locIndex) => { if (double.IsNaN(locValue)) { throw new ArgumentOutOfRangeException( paramName: $"{values.Name}[{locIndex:d}]", message: FormatXResource(locator: typeof(ArgumentOutOfRangeException), subpath: "CanNotNaN")); } return(locValue); }) .ToArray(); if (valuesArray.Length == 0) { return(entire is null ? Empty : new Stats(entire: entire)); } else if (!(entire is null) && (entire.IsEmpty || entire.Count < valuesArray.Length)) { throw new ArgumentOutOfRangeException(paramName: nameof(entire)); }
// TODO: Put strings into the resources. // public static void EnsureValid(ArgumentUtilitiesHandle <string> name) { if (!IsValid(name.Value, out var validationMessage)) { var exceptionMessage = (name.IsProp ? $"Указано недопустимое значение свойства '{name.Name}'.{Environment.NewLine}" : string.Empty) + validationMessage; throw name.ExceptionFactory?.Invoke(message: exceptionMessage) ?? new ArgumentException(message: exceptionMessage, paramName: name.Name); } }
public ServiceProviderHandler(ArgumentUtilitiesHandle <IServiceProvider> serviceProvider) { serviceProvider.EnsureNotNull(); // _serviceProvider = serviceProvider.Value; _serviceScope = null; _hasServiceScope = false; }
public ServiceProviderHandler(ArgumentUtilitiesHandle <IServiceScope> serviceScope, bool ownsServiceScope = default) { var locServiceScope = serviceScope.EnsureNotNull().Value; var locServiceProvider = locServiceScope.ServiceProvider.ArgProp($"{nameof(serviceScope)}.{nameof(serviceScope.Value.ServiceProvider)}").EnsureNotNull().Value; // _serviceProvider = locServiceProvider; _serviceScope = locServiceScope.ToValueHolder(ownsValue: ownsServiceScope); _hasServiceScope = true; }
public static void EnsureValid(ArgumentUtilitiesHandle <string> id) { string validationMessage; if (!IsValid(id.Value, out validationMessage)) { throw new ArgumentException(message: validationMessage, paramName: id.Name); } }
public DependencyScope(ArgumentUtilitiesHandle <IServiceProviderHandler> outerServiceProvider, bool ownsOuterServiceProvider = default) { outerServiceProvider.EnsureNotNull(); // _outerScopeGetter = new DefaultOuterDependencyScopeGetter(outerScope: null).ToValueHolder(ownsValue: true); _prohibitNewInstanceRequest = false; P_CtorInitializer( exporter: new DefaultDependencyExporter(handler: outerServiceProvider.Value, ownsHandler: ownsOuterServiceProvider), ownsDependencyExporter: true, outerServiceProvider: outerServiceProvider.Value.ServiceProvider, owner: null); }
public MetadataPathName(ArgumentUtilitiesHandle <string> metadataPathName) { string validationMessage; if (P_TryParse(metadataPathName, out validationMessage, out _value, out _components)) { P_PutInCache(this); } else { throw new ArgumentException(message: $"{FormatXResource(typeof(ArgumentException), "ValueIsInvalid")}{Environment.NewLine}{validationMessage}", paramName: metadataPathName.Name); } }
public static void ParseSerializationString(ArgumentUtilitiesHandle <string> value, out string assembly, out string type) { value.EnsureNotNull().EnsureNotEmpty().EnsureHasMaxLength(maxLength: SerializationStringMaxLength).EnsureMatchRegex(regex: SerializationStringRegex); // var valueString = value.Value; var index1 = valueString.IndexOf(value: '='); var index2 = valueString.IndexOf(value: ';', startIndex: index1 + 1); var index3 = valueString.IndexOf(value: '=', startIndex: index2); var locAssembly = valueString.Substring(startIndex: index1 + 1, index2 - index1 - 1); var locType = valueString.Substring(startIndex: index3 + 1, valueString.Length - (index3 + 1) - (valueString[valueString.Length - 1] == ';' ? 1 : 0)); assembly = locAssembly; type = locType; }
public static UriBasedIdentifier AsChanged(this UriBasedIdentifier original, ArgumentUtilitiesHandle <string> newUriString) { if (newUriString.Value == null) { return(null); } else if (ReferenceEquals(original, null) || !original.StringValue.EqualsOrdinalCS(newUriString.Value)) { return(new UriBasedIdentifier(uriString: newUriString)); } else { return(original); } }
public static bool IsNonStaticRead(this ArgumentUtilitiesHandle <PropertyInfo> hnd, out MethodInfo getAccessor) { MethodInfo getter, setter; hnd.EnsureNotNull().EnsureNonStatic(out getter, out setter); // if (getter is null) { getAccessor = null; return(false); } else { getAccessor = getter; return(true); } }
public static bool IsWrite(this ArgumentUtilitiesHandle <PropertyInfo> hnd, out MethodInfo setAccessor) { hnd.EnsureNotNull(); // var locSetAccessor = hnd.Value.GetSetMethod(true); if (locSetAccessor is null) { setAccessor = null; return(false); } else { setAccessor = locSetAccessor; return(true); } }
// TODO: Put strings into the resources. // static bool P_TryDeconstructManifestResourceUri(ArgumentUtilitiesHandle <Uri> uri, bool partial, out AssemblyName assemblyName, out string name, out Exception exception) { uri.EnsureNotNull(); // try { uri .EnsureAbsolute() .EnsureScheme(scheme: UriUtilities.UriSchemeAsemblyManifestResource) .EnsureComponentsOnly(components: UriComponents.Scheme | UriComponents.Path) .EnsureFixedSegmentCount(count: partial ? 2 : 3); try { var locAssemblyNameString = Uri.UnescapeDataString(stringToUnescape: uri.Value.Segments[1].TrimEndSingle('/')); var locAssemblyName = new AssemblyName(assemblyName: locAssemblyNameString); string locName; if (partial) { locName = null; } else { locName = Uri.UnescapeDataString(uri.Value.Segments[2]); if (string.IsNullOrEmpty(locName)) { throw new EonException(message: "В указанном URI отсутствует имя ресурса."); } } assemblyName = locAssemblyName; name = locName; exception = null; return(true); } catch (Exception locException) { throw new ArgumentException(paramName: uri.Name, message: "Ошибка обработки компонентов URI.", innerException: locException); } } catch (Exception locException) { exception = locException; assemblyName = default; name = default; return(false); } }
public static bool IsNonStatic(this ArgumentUtilitiesHandle <PropertyInfo> hnd, out MethodInfo getAccessor, out MethodInfo setAccessor) { hnd.EnsureNotNull(); // var locGetAccessor = hnd.Value.GetGetMethod(true); var locSetAccessor = hnd.Value.GetSetMethod(true); var isStatic = locGetAccessor?.IsStatic ?? locSetAccessor.IsStatic; if (isStatic) { getAccessor = null; setAccessor = null; return(false); } else { getAccessor = locGetAccessor; setAccessor = locSetAccessor; return(true); } }
/// <summary> /// Выполняет парсинг строки <paramref name="metadataPathName"/> и возвращает объект пути метаданных — <seealso cref="MetadataPathName"/>. /// </summary> /// <param name="metadataPathName"> /// Входная строка, представляющая путь метаданных. /// <para>Может быть null. В этом случае метод возвращает null.</para> /// </param> /// <returns>Объект <seealso cref="MetadataPathName"/>.</returns> public static MetadataPathName Parse(ArgumentUtilitiesHandle <string> metadataPathName) { if (metadataPathName.Value == null) { return(null); } else { MetadataPathName result; if (P_TryGetFromCache(metadataPathName.Value, out result)) { return(result); } else { return (new MetadataPathName( metadataPathName: metadataPathName)); } } }
public static MetadataPropertyHandle <TMetadata, string> EnsureNotEquals <TMetadata>( this MetadataPropertyHandle <TMetadata, string> hnd, ArgumentUtilitiesHandle <string> operand, StringComparison comparison) where TMetadata : class, IMetadata { // hnd.EnsureHandleValid(); // try { hnd .PropertyValue .ArgProp(nameof(hnd.PropertyValue)) .EnsureNotEquals(operand, comparison); } catch (ArgumentException firstException) { throw hnd.P_CreateMetadataValidationException(firstException); } // return(hnd); }
// TODO: Put strings into the resources. // public static string RequireSingleValue(this ArgumentUtilitiesHandle <NameValueCollection> collection, string name) { collection.EnsureNotNull(); name.EnsureNotNull(nameof(name)); // var values = collection.Value.GetValues(name: name); if (values is null) { var message = $"The required named value is missing.{Environment.NewLine}\tName:{name.FmtStr().GNLI2()}"; throw collection.ExceptionFactory?.Invoke(message: message) ?? new ArgumentException(message: message, paramName: collection.Name); } else if (values.Length == 1) { return(values[0]); } else { var message = $"The specified name maps to more than one values.{Environment.NewLine}\tName:{name.FmtStr().GNLI2()}"; throw collection.ExceptionFactory?.Invoke(message: message) ?? new ArgumentException(message: message, paramName: collection.Name); } }
public static T RequireSingleParameter <T>(this ArgumentUtilitiesHandle <NameValueCollection> collection, string name, Func <string, T> converter) { collection.EnsureNotNull(); converter.EnsureNotNull(nameof(converter)); // string valueString; try { valueString = collection.RequireSingleValue(name: name); } catch (Exception exception) { throw new OperationIllegalParameterException(message: $"Parameter reading error.{Environment.NewLine}Parameter name:{name.FmtStr().GNLI2()}", innerException: exception); } T value; try { value = converter(arg: valueString); } catch (Exception exception) { throw new OperationIllegalParameterException(message: $"An exception occurred while converting the string value of the specified parameter to the value of type '{typeof(T)}'.{Environment.NewLine}Parameter name:{name.FmtStr().GNLI2()}", innerException: exception); } return(value); }
public DependencyServiceScope(ArgumentUtilitiesHandle <IServiceScope> serviceScope, bool ownsServiceScope = default) : base(outerServiceScope: serviceScope, ownsOuterServiceScope: ownsServiceScope) { }
public static TContext Set <TContext, T>(this TContext ctx, ContextProperty <T> prop, ArgumentUtilitiesHandle <T> value) where TContext : class, IContext { // if (ctx is null) { throw new ArgumentNullException(paramName: nameof(ctx)); } else if (prop is null) { throw new ArgumentNullException(paramName: nameof(prop)); } // prop.SetLocalValue(ctx: ctx, value: value); return(ctx); }
public static Task <IList <ITriggerXInstance> > CreateInitializeAsync(ArgumentUtilitiesHandle <IEnumerable <ITriggerDescription> > descriptions, IXAppScopeInstance scope, IContext ctx = default) => XInstanceFactoryUtilities.CreateInitializeAppScopeInstanceAsync <ITriggerXInstance>(scope: scope, ctx: ctx, descriptions: descriptions.AsBase <IEnumerable <ITriggerDescription>, IEnumerable <IDescription> >());
public static bool TryDeconstructManifestResourceUri(ArgumentUtilitiesHandle <Uri> uri, out AssemblyName assemblyName, out Exception exception) => P_TryDeconstructManifestResourceUri(uri: uri, partial: true, assemblyName: out assemblyName, name: out var name, exception: out exception);
public static PersistenceEntityReferenceKeyTypeDescriptor GetReferenceKeyTypeDescriptor(ArgumentUtilitiesHandle <Type> entityType) { entityType.EnsureNotNull(); // return (__ReferenceKeyTypeDescriptorCache .GetOrAdd( spinLock: __ReferenceKeyTypeDescriptorCacheSpinLock, key: entityType.Value, factory: (locEntityType) => { locEntityType.Arg(name: entityType.Name).EnsureClass().EnsureNotContainsGenericParameters(); // var locEntityTypeInfo = locEntityType.GetTypeInfo(); var locFoundInterfaces = locEntityTypeInfo .FindInterfaces( filter: (locT, locCriteria) => { var locTInfo = locT.GetTypeInfo(); return locTInfo.IsGenericType && locTInfo.GetGenericTypeDefinition() == __IPersistenceEntityType2GenericDefinition; }, filterCriteria: null); if (locFoundInterfaces.Length == 0) { throw new ArgumentException( paramName: entityType.Name, message: FormatXResource(locator: typeof(Type), subpath: "NoImplementationOfT", args: new object[] { locEntityType, __IPersistenceEntityType2GenericDefinition })); } else if (locFoundInterfaces.Length > 1) { throw new ArgumentException( paramName: entityType.Name, message: FormatXResource(locator: typeof(Type), subpath: "AmbiguousImplementationOfT", args: new object[] { locEntityType, __IPersistenceEntityType2GenericDefinition })); } else { return new PersistenceEntityReferenceKeyTypeDescriptor(entityType: locEntityType, referenceKeyType: locFoundInterfaces[0].GetTypeInfo().GetGenericArguments()[0]); } })); }
/// <summary> /// Создает дескриптор доступа к утилитам одиночного узла к.л. дерева. /// </summary> /// <typeparam name="T">Тип узла дерева.</typeparam> /// <param name="hnd">Дескриптор доступа к утилитам аргумента, представляющий узел дерева (см. <see cref="ArgumentUtilitiesHandle{T}.Value"/>).</param> /// <returns>Значение <seealso cref="SingleTreeNodeUtilitiesHandle{T}"/>.</returns> public static SingleTreeNodeUtilitiesHandle <T> TreeNode <T>(this ArgumentUtilitiesHandle <T> hnd) => new SingleTreeNodeUtilitiesHandle <T>(source: hnd.Value);
public static bool IsNonStaticRead(this ArgumentUtilitiesHandle <PropertyInfo> hnd) => IsNonStaticRead(hnd, out _);
public static bool HasIndexParameters(this ArgumentUtilitiesHandle <PropertyInfo> hnd) => hnd.EnsureNotNull().Value.GetIndexParameters().Length > 0;
public static Stats Calculate(ArgumentUtilitiesHandle <IEnumerable <int> > values, Stats entire = default) => Calculate(values: values.EnsureNotNull().Select(locValue => (double)locValue), entire: entire);
public static DurationStats Calculate(ArgumentUtilitiesHandle <IEnumerable <TimeSpan> > values, DurationStats entire = default) => new DurationStats(stats: Stats.Calculate(values: values.Select(selector: locValue => locValue.TotalMilliseconds), entire: entire?._stats), entire: entire);