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)); }
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 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 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 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); } }
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); } }
// 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 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]); } })); }
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); } }
// 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 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);