public static double SoftwareQualityIndex(this IParameterProvider parameters) { var cachedParameters = new CachedParameters(parameters); var metrics = cachedParameters.CalculateAllSqiMetrics().ToList(); return(metrics.Sum()); }
/// <summary> /// Creates shared memory object. /// </summary> public void LowLevel_CreateSharedMemory() { if (WindowsAPI.FailureReason != null) { throw OperationException.WrapException(WindowsAPI.FailureReason); } IParameterProvider parameters = this.ITransportContext.IParameterProvider; string fileMappingName = GenuineSharedMemoryChannel.ConstructSharedObjectName( this.ShareName, parameters); this._mapHandle = WindowsAPI.CreateFileMapping((IntPtr)(int)-1, WindowsAPI.AttributesWithNullDACL, WindowsAPI.PAGE_READWRITE, 0, (uint)this._shareSize, fileMappingName); if (this._mapHandle == IntPtr.Zero) { throw GenuineExceptions.Get_Windows_CanNotCreateOrOpenSharedMemory(Marshal.GetLastWin32Error()); } this._pointer = WindowsAPI.MapViewOfFile(this._mapHandle, WindowsAPI.SECTION_MAP_READ | WindowsAPI.SECTION_MAP_WRITE, 0, 0, 0); if (this._pointer == IntPtr.Zero) { int lastWinError = Marshal.GetLastWin32Error(); WindowsAPI.CloseHandle(this._mapHandle); throw GenuineExceptions.Get_Windows_SharedMemoryError(lastWinError); } }
/// <summary> /// Creates a new <see cref="IntegraParameterProvider{TIndexer}"/> instance. /// </summary> /// <param name="provider">The model providing the parameter indexer property.</param> protected IntegraParameterProvider(IParameterProvider <TIndexer> provider) : base() { Debug.Assert(provider.GetType().GetInterfaces().Contains(typeof(IParameterProvider <TIndexer>))); Provider = provider; Provider.PropertyChanged += ProviderPropertyChanged; }
/// <summary> /// Initializes a new instance of the <see cref="ActionBase"/> class. /// </summary> /// <param name="other">The other.</param> protected ActionBase(ActionBase other) { NameId = other.NameId; _collection = other._collection; Cooldown = other.Cooldown; Parameters = other.Parameters?.Clone(); }
public override bool IsAvailable(IUserDataHolder cache) { var testProjectProvider = ComponentResolver.GetComponent <ITestProjectProvider>(_dataProvider); _parameterProvider = ComponentResolver.GetComponent <IParameterProvider>(_dataProvider); _selectedElement = _dataProvider.GetSelectedElement <IObjectCreationExpression>(false, false); _block = _dataProvider.GetSelectedElement <IBlock>(); _classBody = _dataProvider.GetSelectedElement <IClassBody>(); _classDeclaration = _classBody?.GetContainingTypeDeclaration() as IClassLikeDeclaration; if (_classDeclaration == null || _block == null || _selectedElement == null) { return(false); } if (!(_selectedElement.TypeReference?.Resolve().DeclaredElement is IClass c)) { return(false); } _parameterNumber = _selectedElement.ArgumentList.Arguments.Count(x => x.Kind != ParameterKind.UNKNOWN); _constructor = c.Constructors.ToArray().FirstOrDefault(x => !x.IsParameterless && x.Parameters.Count > _parameterNumber); if (_constructor == null) { return(false); } return(testProjectProvider.IsTestProject(_dataProvider.PsiModule)); }
public override void Restore(IParameterProvider data) { if (data.ParameterNames.Contains(Id)) { _value = data.GetParameter(Id); } }
public IApiRequest AuthorizedRequest(string accessToken, Method method, string endpoint, IDictionary<string, string> urlSubstitutions = null, IParameterProvider additionalParameters = null) { // Verify the provided parameters at least have a chance of succeeding, otherwise, exit early via exception... VerifyAccessToken(accessToken); VerifyParameters(additionalParameters); // Generate a basic request... ApiRequest request = new ApiRequest(accessToken); request.Method = method; request.Path = endpoint; // Add url parameters if they are present... if (urlSubstitutions != null) { foreach (var item in urlSubstitutions) { request.UrlSegments.Add(item); } } // Add query or body parameters if present... if (additionalParameters != null) { foreach (var parameter in additionalParameters.GetParameterValues()) { request.Query.Add(parameter); } } return request; }
/// <overloads> /// + 1 Overloads. /// </overloads> /// <summary> /// Parse the configuration file and build the EmailMessage object /// </summary> /// <param name="configFilePath">Config file fullpath</param> /// <param name="key">Emailconfig section key</param> /// <param name="parameterProvider">Parameter value provider</param> /// <returns>EmailMessage that contains the email information</returns> public static EmailMessage BuildMessage( string configFilePath, string key, IParameterProvider parameterProvider) { return BuildMessage(configFilePath,key,string.Empty,parameterProvider); }
protected virtual object ResolveParameterValue(string name, Type type, Form form, IParameterProvider parameterProvider) { if (type == typeof(object) || type == typeof(EventArgs)) { return(ExtractEventArgs(form, parameterProvider)); } if (name.StartsWith("event")) { var parameterName = name.Substring("event".Length); parameterName = parameterName.Substring(0, 1).ToLower() + parameterName.Substring(1); var eventArgs = ExtractEventArgs(form, parameterProvider); var val = eventArgs[parameterName]; if (typeof(ComponentProxy).IsAssignableFrom(type)) { return(form.Get(type, val)); } return(ParseValue(type, val)); } if (typeof(ComponentProxy).IsAssignableFrom(type)) { return(form.Get(type, name)); } if (type == typeof(IUploadedFile)) { return(parameterProvider.GetFile(form.GlobalizeId(name))); } var value = parameterProvider.GetParameter(form.GlobalizeId(name)); if (value == null) { return(null); } return(ParseValue(type, value)); }
internal IReadOnlyList <ParameterExpression> VisitAndConvertParameters(IParameterProvider nodes) { ParameterExpression[] newNodes = null; var count = nodes.ParameterCount; for (var i = 0; i < count; ++i) { var node = nodes.GetParameter(i); var newNode = VisitAndConvert(node); if (newNodes != null) { newNodes[i] = newNode; } else if (!Equals(newNode, node)) { newNodes = new ParameterExpression[count]; for (var j = 0; j < i; ++j) { newNodes[j] = nodes.GetParameter(j); } newNodes[i] = newNode; } } return(newNodes); }
public FormEngine(IParameterProvider parameterProvider, IViewRenderer viewRenderer, IFormPersister formPersister, IMethodInvoker methodInvoker) { _parameterProvider = parameterProvider; _viewRenderer = viewRenderer; _formPersister = formPersister; _methodInvoker = methodInvoker; }
/// <summary> /// Initializes a new instance of the <see cref="ActionBase"/> class. /// </summary> /// <param name="other">The other.</param> protected ActionBase(ActionBase other) { NameId = other.NameId; _collection = other._collection; Cooldown = other.Cooldown; _cooldownTimer = new Stopwatch(); Parameters = other.Parameters?.Clone(); }
public ParameterController(IParameterProvider <ACM.AzureChallengeResult, ACMP.GlobalChallengeParameters> parametersProvider, IMapper mapper, IConfiguration configuration) { this.parametersProvider = parametersProvider; this.mapper = mapper; this.configuration = configuration; }
/// <summary> /// Initializes a new instance of the <see cref="T:Crystal.ConsiderationBase"/> class. /// </summary> /// <param name="other">The other.</param> protected ConsiderationBase(ConsiderationBase other) { _collection = other._collection; NameId = other.NameId; DefaultUtility = other.DefaultUtility; Utility = other.Utility; Weight = other.Weight; Parameters = other.Parameters?.Clone(); }
public override bool IsAvailable(IUserDataHolder cache) { var testProjectProvider = ComponentResolver.GetComponent <ITestProjectProvider>(_dataProvider); _selectedElement = _dataProvider.GetSelectedElement <IObjectCreationExpression>(false, false); _parameterProvider = ComponentResolver.GetComponent <IParameterProvider>(_dataProvider); return(testProjectProvider.IsTestProject(_dataProvider.PsiModule) && _selectedElement != null && _selectedElement.Arguments.Count == 0); }
public QuestionController(IQuestionProvider <ACM.AzureChallengeResult, ACMQ.Question> questionProvider, IParameterProvider <ACM.AzureChallengeResult, ACMP.GlobalParameters> globalParameterProvider, IMapper mapper, IConfiguration configuration) { this.questionProvider = questionProvider; this.globalParameterProvider = globalParameterProvider; this.mapper = mapper; this.configuration = configuration; }
public DefaultServiceEntryGenerator(IServiceIdGenerator serviceIdGenerator, IParameterProvider parameterProvider, IHttpMethodProvider httpMethodProvider, IOptions <GovernanceOptions> governanceOptions) { _serviceIdGenerator = serviceIdGenerator; _parameterProvider = parameterProvider; _httpMethodProvider = httpMethodProvider; _governanceOptions = governanceOptions.Value; }
/// <summary> /// Initializes a new instance of the <see cref="AntColonyHarmonySearcher{T}"/> class. /// </summary> /// <param name="harmonyGenerator">The harmony generator.</param> /// <param name="parameterProvider">The parameter provider.</param> /// <param name="antColonyOptimizer">The ant colony optimizer.</param> /// <param name="harmonyMemorySize">Size of the harmony memory.</param> /// <param name="maxImprovisationCount">The maximum improvisation count.</param> /// <exception cref="ArgumentNullException">antColonyOptimizer</exception> public AntColonyHarmonySearcher(IHarmonyGenerator <T> harmonyGenerator, IParameterProvider parameterProvider, IAntColonyOptimizer <T> antColonyOptimizer, int harmonyMemorySize = HarmonySearchConstants.DefaultHarmonyMemorySize, long maxImprovisationCount = HarmonySearchConstants.DefaultMaxImprovisationCount) : base(harmonyGenerator, parameterProvider, harmonyMemorySize, maxImprovisationCount) { _antColonyOptimizer = antColonyOptimizer ?? throw new ArgumentNullException(nameof(antColonyOptimizer)); MaxImprovisationCountWithTheSameBestValue = (int)(maxImprovisationCount / 20); }
/// <summary> /// Constructs an instance of the ConnectionEstablishingClosure class. /// </summary> /// <param name="__hostName">The host name.</param> /// <param name="portNumber">The port.</param> /// <param name="parameterProvider">The current Transport Context parameter collection.</param> public ConnectionEstablishingClosure(string __hostName, int portNumber, IParameterProvider parameterProvider) { this.hostName = __hostName; this._portNumber = portNumber; this._parameterProvider = parameterProvider; this.Completed = new ManualResetEvent(false); this._continue = true; this._syncRoot = new object(); this.socket = null; this._exception = null; }
public AssignedQuestionProvider(IDataProvider <AzureChallengeResult, AssignedQuestion> dataProvider, IAzureAuthProvider authProvider, IRESTProvider restProvider, IParameterProvider <ACM.AzureChallengeResult, ACMP.GlobalChallengeParameters> parametersProvider, ILogger <AssignedQuestionProvider> logger) { this.dataProvider = dataProvider; this.authProvider = authProvider; this.restProvider = restProvider; this.parametersProvider = parametersProvider; this._logger = logger; }
static Parameters() { if (AppDomain.CurrentDomain.IsDefaultAppDomain()) { _provider = new ParameterProviderProxy(AppDomain.CreateDomain(Guid.NewGuid().ToString())); } else { // Breakpoint here to see the non-default AppDomain pick an implementation. _provider = new NonDefaultParameterProvider(); } }
public static int IndexOf(this IParameterProvider provider, ParameterExpression parameter) { for (int i = 0, n = provider.ParameterCount; i < n; i++) { if (provider.GetParameter(i) == parameter) { return(i); } } return(-1); }
/// <summary> /// Validates an IParameterProvider and throws an exception if an error is present. /// </summary> /// <param name="parameters">IParameterProvider being validated.</param> private static void VerifyParameters(IParameterProvider parameters) { // if there are no parameters, there are no errors // otherwise check provider for an error message var errorMessage = parameters?.ValidationError(); if (string.IsNullOrEmpty(errorMessage)) { return; } throw new InvalidOperationException($"API Argument Error: {errorMessage}"); }
public SqlDataLayerGenerator(IMapper mapperService,ITableProvider tableProvider, IKeyProvider keyProvider, IViewProvider viewProvider, IStoredProcedureProvider storedProcedureProvider, IParameterProvider parameterProvider, IEntityGenerator entityGenerator, IProviderGenerator providerGenerator,INinjectModuleGenerator ninjectModuleGenerator,[Named("settings")]IParameterReaderService parameterReaderService) { _mapper = mapperService; _tableProvider = tableProvider; _keyProvider = keyProvider; _viewProvider = viewProvider; _storedProcedureProvider = storedProcedureProvider; _parameterProvider = parameterProvider; _entityGenerator = entityGenerator; _providerGenerator = providerGenerator; _ninjectModuleGenerator = ninjectModuleGenerator; _parameterReaderService = parameterReaderService; }
/// <summary> /// The constructor /// </summary> /// <param name="harmonyGenerator">Harmony generator</param> /// <param name="parameterProvider"></param> /// <param name="harmonyMemorySize">Harmony memory size</param> /// <param name="maxImprovisationCount">Maximal improvisation count</param> public HarmonySearcher(IHarmonyGenerator <T> harmonyGenerator, IParameterProvider parameterProvider, int harmonyMemorySize = DefaultHarmonyMemorySize, long maxImprovisationCount = DefaultMaxImprovisationCount) { MaxImprovisationCount = maxImprovisationCount; HarmonyGenerator = harmonyGenerator ?? throw new ArgumentNullException(nameof(harmonyGenerator)); ParameterProvider = parameterProvider ?? throw new ArgumentNullException(nameof(parameterProvider)); HarmonyMemory = new HarmonyMemory <T>(harmonyMemorySize); HarmonyGenerator.HarmonyMemory = HarmonyMemory; BestHarmonyObjectiveValue = double.PositiveInfinity; MaxImprovisationCountWithTheSameBestValue = (int)(maxImprovisationCount / 10); }
public CachedParameters(IParameterProvider parameters) { TestCoverageCached = new Lazy <double>(() => parameters.TestCoverage); NamespaceCyclesCached = new Lazy <int>(() => parameters.NamespaceCycles); ComplicatedMethodsCached = new Lazy <int>(() => parameters.ComplicatedMethods); AverageComponentDependencyCached = new Lazy <double>(() => parameters.AverageComponentDependency); BigClassesCached = new Lazy <int>(() => parameters.BigClasses); BigMethodsCached = new Lazy <int>(() => parameters.BigMethods); CompilerWarningsCached = new Lazy <int>(() => parameters.CompilerWarnings); NamespacesCached = new Lazy <int>(() => parameters.Namespaces); ClassesCached = new Lazy <int>(() => parameters.Classes); MethodsCached = new Lazy <int>(() => parameters.Methods); RlocCached = new Lazy <int>(() => parameters.Rloc); }
static Parameters() { if (AppDomain.CurrentDomain.IsDefaultAppDomain()) { _provider = new ParameterProviderProxy(AppDomain.CreateDomain(Guid.NewGuid().ToString())); } else { // This code is currently uncalled, but if you // happen to run other code inside the non-default // AppDomain, this will get called. _provider = new NonDefaultParameterProvider(); } }
/// <summary> /// See overload with <see cref="IArgumentProvider"/> for more information. /// </summary> public static ReadOnlyCollection <ParameterExpression> ReturnReadOnly(IParameterProvider provider, ref object collection) { if (collection is ParameterExpression tObj) { // otherwise make sure only one read-only collection ever gets exposed Interlocked.CompareExchange( ref collection !, new ReadOnlyCollection <ParameterExpression>(new ListParameterProvider(provider, tObj)), tObj ); } // and return what is not guaranteed to be a read-only collection return((ReadOnlyCollection <ParameterExpression>)collection); }
public void Invoke(Form form, IParameterProvider parameterProvider) { try { _methodInvoker.Invoke(form, parameterProvider); } catch (TargetInvocationException e) { Handle(e.InnerException); } catch (Exception t) { Handle(t); } }
/// <summary> /// Validates an IParameterProvider and throws an exception if an error is present. /// </summary> /// <param name="parameters">IParameterProvider being validated.</param> private void VerifyParameters(IParameterProvider parameters) { // if there are no parameters, there are no errors if (parameters == null) { return; } // otherwise check provider for an error message string errorMessage = parameters.ValidationError(); if (String.IsNullOrEmpty(errorMessage)) { return; } else { throw new InvalidOperationException(String.Format("API Argument Error: {0}", errorMessage)); } }
public Expression ToExpression <T>(IParameterProvider <T> parameterProvider, Expression formatProviderExpression) { Expression parameter = parameterProvider.GetParameter(Param); if (parameter.Type != typeof(IFormattable) && !parameter.Type.GetInterfaces().Contains(typeof(IFormattable))) { throw new FormatStringSyntaxException($"Property '{Param}' does not return a type implementing IFormattable hence a format string cannot be applied to it."); } Expression formatExpression = Expression.Constant(format); MethodInfo toStringMethod = parameter.Type.GetMethod("ToString", new Type[] { typeof(string), typeof(IFormatProvider) }); Expression stringified = Expression.Call(parameter, toStringMethod, formatExpression, formatProviderExpression); return(parameterProvider.WrapWithNullCheck(parameter, stringified)); }
/// <summary> /// See overload with <see cref="IArgumentProvider"/> for more information. /// </summary> public static ReadOnlyCollection<ParameterExpression> ReturnReadOnly(IParameterProvider provider, ref object collection) { ParameterExpression tObj = collection as ParameterExpression; if (tObj != null) { // otherwise make sure only one read-only collection ever gets exposed Interlocked.CompareExchange( ref collection, new ReadOnlyCollection<ParameterExpression>(new ListParameterProvider(provider, tObj)), tObj ); } // and return what is not guaranteed to be a read-only collection return (ReadOnlyCollection<ParameterExpression>)collection; }
private static IEnumerable <double> CalculateAllSqiMetrics(this IParameterProvider parameters) { yield return(0.1 * 2.28 * CalculateTestCoverage(parameters)); yield return(0.1 * 1.93 * CalculateNamespacesInCycles(parameters)); yield return(0.1 * 1.75 * CalculateCompilcatedMethods(parameters)); yield return(0.1 * 1.58 * CalculateAcd(parameters)); yield return(0.1 * 1.05 * CalculateBigClasses(parameters)); yield return(0.1 * 1.05 * CalculateBigMethods(parameters)); yield return(0.1 * 0.36 * CalculateCompilerWarnings(parameters)); }
public void Invoke(Form form, IParameterProvider parameterProvider) { var eventHandler = parameterProvider.GetParameter("eventHandler"); var method = form.GetType().GetMethods().FirstOrDefault(x => x.Name == eventHandler); if (method == null) { throw new MissingMethodException(GetType().FullName, eventHandler); } var p = new List <object>(); foreach (var parameter in method.GetParameters()) { p.Add(ResolveParameterValue(parameter.Name, parameter.ParameterType, form, parameterProvider)); } method.Invoke(form, p.ToArray()); }
public MigrationSegmentRunner( IOperationExecutive operationExecutive, IServiceProvider <TEntity> serviceProvider, ISafeMetadataProvider <TEntity> safeMetadataProvider, IParameterProvider parameterProvider, IMappingRepository <TEntity> mappingRepository, IProcessor <TEntity> processor, IEventDispatcher <TEntity> eventDispatcher) { this.operationExecutive = operationExecutive; this.serviceProvider = serviceProvider; this.safeMetadataProvider = safeMetadataProvider; this.parameterProvider = parameterProvider; this.mappingRepository = mappingRepository; this.processor = processor; this.eventDispatcher = eventDispatcher; }
public static ParameterExpression[] VisitParameters(ExpressionVisitor visitor, IParameterProvider nodes, string callerName) { ParameterExpression[] newNodes = null; for (int i = 0, n = nodes.ParameterCount; i < n; i++) { ParameterExpression curNode = nodes.GetParameter(i); ParameterExpression node = visitor.VisitAndConvert(curNode, callerName); if (newNodes != null) { newNodes[i] = node; } else if (!object.ReferenceEquals(node, curNode)) { newNodes = new ParameterExpression[n]; for (int j = 0; j < i; j++) { newNodes[j] = nodes.GetParameter(j); } newNodes[i] = node; } } return newNodes; }
/// <overloads> /// + 1 Overloads. /// </overloads> /// <summary> /// Parse the configuration file and build the EmailMessage object /// </summary> /// <param name="configFilePath">Configuration file fullpath</param> /// <param name="key">Emailconfig section key</param> /// <param name="message">Message text</param> /// <param name="parameterProvider">Parameter value provider</param> /// <returns>EmailMessage that contains the email information</returns> public static EmailMessage BuildMessage( string configFilePath, string key, string message, IParameterProvider parameterProvider) { IEmailerConfig emailerConfig=EmailerConfigManager.GetConfig(configFilePath); EmailerSection emailerSection=emailerConfig[key]; string server,from,to,subject,cc,bcc,priority,attachments, isBodyHtml,enableSsl,timeout; bool bIsBodyHtml = false,bEnableSSL=false; int maxNumberOfRecipientsPerEmail=int.MaxValue,iTimeout=100000,iOut; string sMaxNumberOfRecipientsPerEmail=TokenMapper.ParseParameterizedString(emailerSection.MaxNumberOfRecipientsPerEmail,parameterProvider); if (!string.IsNullOrEmpty(sMaxNumberOfRecipientsPerEmail)) { if (Int32.TryParse(sMaxNumberOfRecipientsPerEmail, out iOut)) if(iOut>0) maxNumberOfRecipientsPerEmail = iOut; } timeout = TokenMapper.ParseParameterizedString(emailerSection.Timeout, parameterProvider); if (!string.IsNullOrEmpty(timeout)) { if (Int32.TryParse(timeout, out iOut)) if (iOut > 0) iTimeout = iOut; } isBodyHtml = TokenMapper.ParseParameterizedString(emailerSection.IsBodyHtml, parameterProvider); if (!string.IsNullOrEmpty(isBodyHtml) && isBodyHtml.Trim().ToLower()=="true") { bIsBodyHtml = true; } enableSsl = TokenMapper.ParseParameterizedString(emailerSection.EnableSSL, parameterProvider); if (!string.IsNullOrEmpty(enableSsl) && enableSsl.Trim().ToLower() == "true") { bEnableSSL = true; } server = emailerSection.SmtpServer; from=emailerSection.From; to=emailerSection.To; cc=emailerSection.CC; bcc=emailerSection.Bcc; subject=emailerSection.Subject; priority=emailerSection.Priority; attachments=emailerSection.Attachments; if(string.IsNullOrEmpty(message)) message=emailerSection.Body; return new EmailMessage(TokenMapper.ParseParameterizedString(message,parameterProvider), TokenMapper.ParseParameterizedString(server,parameterProvider), TokenMapper.ParseParameterizedString(to,parameterProvider), TokenMapper.ParseParameterizedString(from,parameterProvider), TokenMapper.ParseParameterizedString(subject,parameterProvider), TokenMapper.ParseParameterizedString(cc,parameterProvider), TokenMapper.ParseParameterizedString(bcc,parameterProvider), (MailPriority) Enum.Parse(typeof(MailPriority),TokenMapper.ParseParameterizedString(priority,parameterProvider), true), maxNumberOfRecipientsPerEmail, attachments, bIsBodyHtml, bEnableSSL, iTimeout); }
public ParameterProviderContainsKeyFailedException(IParameterProvider parameterProvider, string parameterName, System.Exception exception) : base(ExceptionMessage.Build("ParameterProvider contains key failed").Add("ParameterProviderName", parameterProvider.Name).Add("ParameterName", parameterName), exception) { }
/// <summary> /// Substitue paramerters in source string with values provided by the <see cref="IParameterProvider"/>. /// The followings are predefined parameters: /// {=DateTime}: Current datetime value. Default format is "MMMM d, yyyy \"at\" HH:mm ET". /// <see cref="IParameterProvider"/> can provide a custom format using the key "DateTimeFormat"; /// {=Newline}: New line character. /// {=Tab}: Tab. /// {=WhiteSpace}: White space. /// {=DoubleQuote}: Double quote. /// {SingleQuote}: Single quote. /// </summary> /// <param name="sSource">Source string with parameters defined in the format of {=paramertername}</param> /// <param name="oParameterProvider">Paramerters value provider</param> /// <returns>String with matched parameters replaced</returns> public static string ParseParameterizedString(string source, IParameterProvider parameterProvider) { string dateTimeFormat; string pre, post = String.Empty; int begin = 0, end = 0; StringBuilder strBuilder = new StringBuilder(); MatchCollection matches = Regex.Matches(source, TokenMapper.CodeBlock); if (matches.Count <= 0) { return source; } foreach (Match match in matches) { end = match.Index; if (begin < source.Length) { pre = source.Substring(begin, end - begin); begin = end + match.Length; post = source.Substring(begin); strBuilder.Append(pre); } try { switch (match.Result("$1").Trim()) { case TokenMapper.DateTime: dateTimeFormat = parameterProvider.GetProperty(DateTimeFormat); if (dateTimeFormat != null && dateTimeFormat.Trim() != String.Empty) try { strBuilder.Append(System.DateTime.Now.ToString(dateTimeFormat)); } catch { throw new System.ArgumentException("DateTimeFormat is not valid."); } else strBuilder.Append(System.DateTime.Now.ToString("MMMM d, yyyy \"at\" HH:mm ET")); break; case TokenMapper.Newline: strBuilder.AppendLine(); break; case TokenMapper.Tab: strBuilder.Append("\t"); break; case TokenMapper.WhiteSpace: strBuilder.Append(" "); break; case TokenMapper.DoubleQuote: strBuilder.Append("\""); break; case TokenMapper.SingleQuote: strBuilder.Append("'"); break; default: strBuilder.Append(parameterProvider.GetProperty(match.Result("$1").Trim())); break; } } catch (Exception exception) { throw new Exception(string.Format("Failed to retrieve value for key {0}.", match.Result("$1").Trim()), exception); } } strBuilder.Append(post); return strBuilder.ToString(); }
/// <summary> /// Initializes parameters from the provided dictionary. /// </summary> /// <param name="parameters">A dictionary containing parameters to be read.</param> /// <param name="underlyingProvider">Underlying parameter provider.</param> public ReadingCascadeParameterProvider(IDictionary parameters, IParameterProvider underlyingProvider) { this._readParameters = new object[(int) GenuineParameter.LastParameter + 1]; this.UnderlyingProvider = underlyingProvider; // read parameters from the dictionary foreach (DictionaryEntry entry in (IDictionary) parameters) { string parameterName = entry.Key.ToString().ToUpper(); switch(parameterName) { // Queue parameters -------------------------------------------------------- case "MAXCONTENTSIZE": this._readParameters[(int) GenuineParameter.MaxContentSize] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "MAXQUEUEDITEMS": this._readParameters[(int) GenuineParameter.MaxQueuedItems] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "MAXTOTALSIZE": this._readParameters[(int) GenuineParameter.MaxTotalSize] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "NOSIZECHECKING": this._readParameters[(int) GenuineParameter.NoSizeChecking] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "COMPRESSION": case "COMPRESS": this._readParameters[(int) GenuineParameter.Compression] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "INVOCATIONTIMEOUT": this._readParameters[(int) GenuineParameter.InvocationTimeout] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "SYNCRESPONSES": this._readParameters[(int) GenuineParameter.SyncResponses] = GenuineUtility.SafeConvertToBool(entry.Value); break; // Common parameters ------------------------------------------------------- case "CONNECTTIMEOUT": this._readParameters[(int) GenuineParameter.ConnectTimeout] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "SECURITYSESSIONFORPERSISTENTCONNECTIONS": this._readParameters[(int) GenuineParameter.SecuritySessionForPersistentConnections] = entry.Value.ToString(); break; case "SECURITYSESSIONFORNAMEDCONNECTIONS": this._readParameters[(int) GenuineParameter.SecuritySessionForNamedConnections] = entry.Value.ToString(); break; case "SECURITYSESSIONFORINVOCATIONCONNECTIONS": this._readParameters[(int) GenuineParameter.SecuritySessionForInvocationConnections] = entry.Value.ToString(); break; case "CLOSEPERSISTENTCONNECTIONAFTERINACTIVITY": this._readParameters[(int) GenuineParameter.ClosePersistentConnectionAfterInactivity] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "CLOSENAMEDCONNECTIONAFTERINACTIVITY": this._readParameters[(int) GenuineParameter.CloseNamedConnectionAfterInactivity] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "CLOSEINVOCATIONCONNECTIONAFTERINACTIVITY": this._readParameters[(int) GenuineParameter.CloseInvocationConnectionAfterInactivity] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "CLOSEONEWAYCONNECTIONAFTERINACTIVITY": this._readParameters[(int) GenuineParameter.CloseOneWayConnectionAfterInactivity] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "PERSISTENTCONNECTIONSENDPINGAFTERINACTIVITY": this._readParameters[(int) GenuineParameter.PersistentConnectionSendPingAfterInactivity] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "MAXTIMESPANTORECONNECT": this._readParameters[(int) GenuineParameter.MaxTimeSpanToReconnect] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "RECONNECTIONTRIES": this._readParameters[(int) GenuineParameter.ReconnectionTries] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "SLEEPBETWEENRECONNECTIONS": this._readParameters[(int) GenuineParameter.SleepBetweenReconnections] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; // case "IGNOREREMOTEHOSTURICHANGES": // this._readParameters[(int) GenuineParameter.IgnoreRemoteHostUriChanges] = GenuineUtility.SafeConvertToBool(entry.Value); // break; // TCP parameters ---------------------------------------------------------- case "TCPMAXSENDSIZE": this._readParameters[(int) GenuineParameter.TcpMaxSendSize] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "TCPREADREQUESTBEFOREPROCESSING": this._readParameters[(int) GenuineParameter.TcpReadRequestBeforeProcessing] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "TCPDONOTRESENDMESSAGES": this._readParameters[(int) GenuineParameter.TcpDoNotResendMessages] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "TCPDISABLENAGGLING": this._readParameters[(int) GenuineParameter.TcpDisableNagling] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "TCPPREVENTDELAYEDACK": this._readParameters[(int) GenuineParameter.TcpPreventDelayedAck] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "TCPRECEIVEBUFFERSIZE": this._readParameters[(int) GenuineParameter.TcpReceiveBufferSize] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "TCPSENDBUFFERSIZE": this._readParameters[(int) GenuineParameter.TcpSendBufferSize] = GenuineUtility.SafeConvertToInt32(entry.Value); break; // Shared memory ----------------------------------------------------------- case "SMSHARESIZE": this._readParameters[(int) GenuineParameter.SMShareSize] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "SMSENDTIMEOUT": this._readParameters[(int) GenuineParameter.SMSendTimeout] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "SMSESSIONLOCAL": this._readParameters[(int) GenuineParameter.SMSessionLocal] = GenuineUtility.SafeConvertToBool(entry.Value); break; // UDP transport ----------------------------------------------------------- case "UDPJOINTO": this._readParameters[(int) GenuineParameter.UdpJoinTo] = entry.Value.ToString(); break; case "UDPTTL": this._readParameters[(int) GenuineParameter.UdpTtl] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "UDPRECEIVEBUFFER": this._readParameters[(int) GenuineParameter.UdpReceiveBuffer] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "UDPPACKETSIZE": this._readParameters[(int) GenuineParameter.UdpPacketSize] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "UDPMTU": this._readParameters[(int) GenuineParameter.UdpMtu] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "UDPMULTICASTTO": this._readParameters[(int) GenuineParameter.UdpMulticastTo] = entry.Value.ToString(); break; case "UDPASSEMBLETIMESPAN": this._readParameters[(int) GenuineParameter.UdpAssembleTimeSpan] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; // HTTP transport ---------------------------------------------------------- case "HTTPPROXYURI": this._readParameters[(int) GenuineParameter.HttpProxyUri] = entry.Value.ToString(); break; case "HTTPWEBUSERAGENT": this._readParameters[(int) GenuineParameter.HttpWebUserAgent] = entry.Value.ToString(); break; case "HTTPAUTHUSERNAME": this._readParameters[(int) GenuineParameter.HttpAuthUserName] = entry.Value.ToString(); break; case "HTTPAUTHPASSWORD": this._readParameters[(int) GenuineParameter.HttpAuthPassword] = entry.Value.ToString(); break; case "HTTPAUTHDOMAIN": this._readParameters[(int) GenuineParameter.HttpAuthDomain] = entry.Value.ToString(); break; case "HTTPAUTHCREDENTIAL": this._readParameters[(int) GenuineParameter.HttpAuthCredential] = entry.Value as NetworkCredential; break; case "HTTPUSEGLOBALPROXY": this._readParameters[(int) GenuineParameter.HttpUseGlobalProxy] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "HTTPBYPASSONLOCAL": this._readParameters[(int) GenuineParameter.HttpBypassOnLocal] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "HTTPUSEDEFAULTCREDENTIALS": this._readParameters[(int) GenuineParameter.HttpUseDefaultCredentials] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "HTTPALLOWWRITESTREAMBUFFERING": this._readParameters[(int) GenuineParameter.HttpAllowWriteStreamBuffering] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "HTTPUNSAFECONNECTIONSHARING": this._readParameters[(int) GenuineParameter.HttpUnsafeConnectionSharing] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "HTTPRECOMMENDEDPACKETSIZE": this._readParameters[(int) GenuineParameter.HttpRecommendedPacketSize] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "HTTPKEEPALIVE": this._readParameters[(int) GenuineParameter.HttpKeepAlive] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "HTTPAUTHENTICATION": this._readParameters[(int) GenuineParameter.HttpAuthentication] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "HTTPSTOREANDPROVIDEHTTPCONTEXT": this._readParameters[(int) GenuineParameter.HttpStoreAndProvideHttpContext] = GenuineUtility.SafeConvertToBool(entry.Value); break; case "HTTPWEBREQUESTINITIATIONTIMEOUT": this._readParameters[(int) GenuineParameter.HttpWebRequestInitiationTimeout] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "HTTPASYNCHRONOUSREQUESTTIMEOUT": this._readParameters[(int) GenuineParameter.HttpAsynchronousRequestTimeout] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; case "HTTPMIMEMEDIATYPE": this._readParameters[(int) GenuineParameter.HttpMimeMediaType] = entry.Value.ToString(); break; // XHTTP transport --------------------------------------------------------- case "XHTTPREADHEADERTIMEOUT": this._readParameters[(int) GenuineParameter.XHttpReadHttpMessageTimeout] = GenuineUtility.SafeConvertToTimeSpan(entry.Value); break; // Security Session--------------------------------------------------------- case "HOLDTHREADDURINGSECURITYSESSIONESTABLISHING": this._readParameters[(int) GenuineParameter.HoldThreadDuringSecuritySessionEstablishing] = GenuineUtility.SafeConvertToBool(entry.Value); break; // Logging ----------------------------------------------------------------- case "ENABLEGLOBALLOGGINGTOMEMORY": this._readParameters[(int) GenuineParameter.EnableGlobalLoggingToMemory] = GenuineUtility.SafeConvertToInt32(entry.Value); break; case "ENABLEGLOBALLOGGINGTOFILE": this._readParameters[(int) GenuineParameter.EnableGlobalLoggingToFile] = entry.Value.ToString(); break; case "LOGGINGPARAMETERS": this._readParameters[(int) GenuineParameter.LoggingParameters] = entry.Value.ToString(); break; // Versioning -------------------------------------------------------------- case "COMPATIBILITYLEVEL": this._readParameters[(int) GenuineParameter.CompatibilityLevel] = GenuineUtility.SafeConvertToInt32(entry.Value); break; default: // GenuineLoggingServices.BinaryLogWriter.Log(LogMessageCategory.Notification, null, "ReadingCascadeParameterProvider.ReadingCascadeParameterProvider", // null, "An unknown parameter was found. Parameter name: {0}. Parameter value: {1}. If this parameter is not processed on the channel level, it will be ignored.", entry.Key.ToString(), entry.Value.ToString()); break; } } }
public DatabaseLoggerConfiguration(IParameterProvider parameterProvider) : base("Logger.Database", parameterProvider) { }
/// <summary> /// Puts down a record containing Connection Parameters. /// </summary> /// <param name="logCategory">The category of the event.</param> /// <param name="author">The author.</param> /// <param name="type">The type of the event(Subcategory).</param> /// <param name="exception">The exception associated with the event.</param> /// <param name="remote">The remote host participating in the event.</param> /// <param name="iParameterProvider">The connection parameters.</param> /// <param name="sourceThreadId">The id of the thread where the invocation was made.</param> /// <param name="sourceThreadName">The name of the thread.</param> /// <param name="connectionId">The identifier of the connection.</param> /// <param name="description">The description of the event.</param> /// <param name="parameters">Parameters to the description.</param> public void WriteConnectionParameterEvent(LogCategory logCategory, string author, LogMessageType type, Exception exception, HostInformation remote, IParameterProvider iParameterProvider, int sourceThreadId, string sourceThreadName, int connectionId, string description, params object[] parameters) { lock (this._streamLock) { this.WriteRecordHeader(BinaryRecordVersion.ConnectionParametersRecord, logCategory, type, author); this.WriteException( exception ); this.WriteHostInformationId( remote ); this.BinaryWriter.Write( (int) connectionId ); this.WriteConnectionParameters(iParameterProvider); this.BinaryWriter.Write( (int) sourceThreadId); this.WriteString( sourceThreadName ); this.WriteStringWithParameters( description, parameters); this.BinaryWriter.Flush(); } }
/// <summary> /// Puts down all parameters from the specified parameter provider. /// </summary> /// <param name="iParameterProvider">The parameter provider.</param> public void WriteConnectionParameters(IParameterProvider iParameterProvider) { Type enumType = typeof(GenuineParameter); foreach (FieldInfo fieldInfo in enumType.GetFields()) if (fieldInfo.FieldType == enumType) { GenuineParameter theCurrentParameter = (GenuineParameter) fieldInfo.GetValue(null); this.BinaryWriter.Write(true); this.WriteString( Enum.Format(enumType, theCurrentParameter, "g") ); this.WriteString( iParameterProvider[theCurrentParameter] == null ? "<<null>>" : iParameterProvider[theCurrentParameter].ToString() ); } this.BinaryWriter.Write(false); }
public ParameterProviderGetValueFailedException(IParameterProvider parameterProvider, string parameterName, System.Exception exception) :base(ExceptionMessage.Build("ParameterProvider GetValue failed").Add("ParameterProviderName", parameterProvider.Name).Add("ParameterName", parameterName), exception) { }
public ParameterNotExistsException(IParameterProvider parameterProvider, string parameterName) : base(ExceptionMessage.Build("Parameter not exists exception").Add("ParameterProviderName", parameterProvider.Name).Add("ParameterName", parameterName)) { }
/// <summary> /// Initiates reading incoming content from the socket and dispatching it to the message handler manager. /// Should be called only once for persistent and named connections. /// </summary> /// <param name="tcpSocketInfo">The connection.</param> /// <param name="iParameterProvider">Parameter provider or a null reference.</param> private void Pool_InitiateReceiving(TcpSocketInfo tcpSocketInfo, IParameterProvider iParameterProvider) { this.LowLevel_HalfSync_StartReceiving(tcpSocketInfo); }