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