internal EntitySetInfo(IEdmModel edmModel, IEdmEntitySet edmEntitySet, ITypeResolver typeResolver)
{
Contract.Assert(edmModel != null);
Contract.Assert(edmEntitySet != null);
Contract.Assert(typeResolver != null);
Name = edmEntitySet.Name;
ElementType = new EntityTypeInfo(edmModel, edmEntitySet.ElementType, typeResolver);
var entityTypes = new List<EntityTypeInfo>(3) { ElementType };
// Create an EntityTypeInfo for any derived types in the model
foreach (var edmDerivedType in edmModel.FindAllDerivedTypes(edmEntitySet.ElementType).OfType<IEdmEntityType>())
{
entityTypes.Add(new EntityTypeInfo(edmModel, edmDerivedType, typeResolver));
}
// Connect any derived types with their base class
for (int i = 1; i < entityTypes.Count; ++i)
{
var baseEdmEntityType = entityTypes[i].EdmEntityType.BaseEntityType();
if (baseEdmEntityType != null)
{
var baseEntityTypeInfo = entityTypes.First(entityTypeInfo => entityTypeInfo.EdmEntityType == baseEdmEntityType);
if (baseEntityTypeInfo != null)
{
entityTypes[i].BaseTypeInfo = baseEntityTypeInfo;
}
}
}
EntityTypes = entityTypes;
}
public DebugPortableItem(ITypeResolver resolver, Vector2 pos)
: base(resolver, pos)
{
portable = new PortableProperty(this, 10, 10);
AddProperty(portable);
}
public DebugAttackableItem(ITypeResolver resolver, Vector2 pos)
: base(resolver, pos, Angle.Right)
{
attackable = new AttackableProperty(this, 5, 100, 100);
AddProperty(attackable);
}
public void Setup()
{
logger = new NullLogger();
typeResolver = MockRepository.GenerateMock<ITypeResolver>();
treeService = MockRepository.GenerateMock<ITreeCreationService>();
visitor = new ControllerVisitor(logger, typeResolver, treeService);
}
public void Setup()
{
ccu = new CodeCompileUnit();
mocks = new MockRepository();
engine = Engine.GlobalEngine;
engine.BinPath = @"C:\Program Files (x86)\MSBuild";
project = new Project();
buildEngine = mocks.DynamicMock<MockBuildEngine>(project);
logger = new NullLogger();
parserService = mocks.DynamicMock<ISiteTreeGeneratorService>();
naming = mocks.DynamicMock<INamingService>();
sourceStorage = mocks.DynamicMock<IParsedSourceStorageService>();
source = mocks.DynamicMock<ISourceGenerator>();
typeResolver = mocks.DynamicMock<ITypeResolver>();
treeService = mocks.DynamicMock<ITreeCreationService>();
viewSourceMapper = mocks.DynamicMock<IViewSourceMapper>();
generator = mocks.DynamicMock<IGenerator>();
task = new GenerateMonoRailSiteTreeTask(logger, parserService, naming, source, sourceStorage, typeResolver,
treeService, viewSourceMapper, generator);
item = mocks.DynamicMock<ITaskItem>();
parsedSource = mocks.DynamicMock<IParser>();
}
/// <summary>
/// </summary>
/// <param name="type">
/// </param>
/// <param name="typeResolver">
/// </param>
public SynthesizedSingleDimArrayIListSetItemMethod(IType arrayType, ITypeResolver typeResolver)
: base("set_Item", arrayType, typeResolver.System.System_Void)
{
var codeList = new IlCodeBuilder();
codeList.LoadArgument(0);
codeList.LoadArgument(1);
codeList.LoadArgument(2);
codeList.Add(Code.Stelem, 1);
codeList.Add(Code.Ret);
var locals = new List<IType>();
this._methodBody =
new SynthesizedMethodBodyDecorator(
null,
locals,
codeList.GetCode());
this._parameters = new List<IParameter>();
this._parameters.Add(typeResolver.System.System_Int32.ToParameter());
this._parameters.Add(arrayType.GetElementType().ToParameter());
this._tokenResolutions = new List<object>();
this._tokenResolutions.Add(arrayType.GetElementType());
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="XmlContentSerializer"/> class.
/// </summary>
/// <param name="resolver">
/// An <see cref="ITypeResolver" /> used to resolve XML names to
/// <see cref="Type" /> instances, used when deserializing XML to
/// objects.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="resolver" /> is <see langword="null" />.
/// </exception>
public XmlContentSerializer(ITypeResolver resolver)
{
if (resolver == null)
throw new ArgumentNullException("resolver");
this.resolver = resolver;
}
public DebugCarrierItem(ITypeResolver resolver, Vector2 pos)
: base(resolver, pos)
{
carrier = new CarrierProperty(this, 10f);
AddProperty(carrier);
}
/// <summary>
/// </summary>
/// <param name="type">
/// </param>
/// <param name="typeResolver">
/// </param>
public SynthesizedSingleDimArrayIListGetEnumeratorMethod(IType arrayType, ITypeResolver typeResolver)
: base("GetEnumerator", arrayType, typeResolver.System.System_Collections_Generic_IEnumerator_T.Construct(arrayType.GetElementType()))
{
var codeList = new IlCodeBuilder();
codeList.LoadArgument(0);
codeList.Add(Code.Newobj, 1);
codeList.Add(Code.Newobj, 2);
codeList.Add(Code.Ret);
var locals = new List<IType>();
this._methodBody =
new SynthesizedMethodBodyDecorator(
null,
locals,
codeList.GetCode());
this._parameters = new List<IParameter>();
this._tokenResolutions = new List<object>();
var arraySegmentType = typeResolver.System.System_ArraySegment_T1.Construct(arrayType.GetElementType());
this._tokenResolutions.Add(
IlReader.Constructors(arraySegmentType, typeResolver).First(c => c.GetParameters().Count() == 1));
this._tokenResolutions.Add(
IlReader.Constructors(arraySegmentType.GetNestedTypes().First(), typeResolver).First(c => c.GetParameters().Count() == 1));
}
private EnumerableTypeSpec(ITypeResolver typeResolver, Type type, Lazy<TypeSpec> itemType)
: base(typeResolver, type)
{
if (itemType == null)
throw new ArgumentNullException(nameof(itemType));
this.itemType = itemType;
}
public FieldAccessService(IFieldAccessRightsExecutor accessRightsExecutor, IEnumerable<IFieldAccessRule> rules, ITypeResolver types, IServiceLocator services)
{
_accessRightsExecutor = accessRightsExecutor;
_types = types;
_services = services;
_rules.AddRange(rules);
}
public static void GetEnumGetHashCodeMethod(
IType enumType,
ITypeResolver typeResolver,
out object[] code,
out IList<object> tokenResolutions,
out IList<IType> locals,
out IList<IParameter> parameters)
{
Debug.Assert(enumType.ToNormal().IsEnum, "This is for enum only");
var codeList = new List<object>();
codeList.Add(Code.Ldarg_0);
codeList.AppendInt(Code.Ldfld, 1);
codeList.Add(Code.Conv_I4);
// return
codeList.Add(Code.Ret);
// End of Code
// tokens
tokenResolutions = new List<object>();
// data
tokenResolutions.Add(enumType.GetFieldByName("Value", typeResolver));
// locals
locals = new List<IType>();
// code
code = codeList.ToArray();
// parameters
parameters = new List<IParameter>();
}
public Validator(ITypeResolver typeResolver, IEnumerable<IValidationSource> sources)
{
_typeResolver = typeResolver;
_sources = new List<IValidationSource>(sources){
new SelfValidatingClassRuleSource()
};
}
public static void Register(ITypeResolver typeResolver)
{
var codeList = new List<object>();
codeList.AddRange(
new object[]
{
Code.Ldarg_0,
});
codeList.AppendInt(Code.Castclass, 1);
codeList.AppendInt(Code.Ldfld, 2);
codeList.Add(Code.Ret);
var arrayType = typeResolver.System.System_Byte.ToArrayType(1);
var tokenResolutions = new List<object>();
tokenResolutions.Add(arrayType);
tokenResolutions.Add(arrayType.GetFieldByName("rank", typeResolver));
var locals = new List<IType>();
var parameters = new List<IParameter>();
MethodBodyBank.Register(Name, codeList.ToArray(), tokenResolutions, locals, parameters);
}
public SiteTreeGeneratorService(ILogger logger, ITypeResolver typeResolver, IParsedSourceStorageService cache, IParserFactory parserFactory)
{
_logger = logger;
_typeResolver = typeResolver;
_cache = cache;
_parserFactory = parserFactory;
}
public FullObjectGraphTraversalStrategy(Serializer serializer, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention)
{
if (maxRecursion <= 0)
{
throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
}
this.serializer = serializer;
if (typeDescriptor == null)
{
throw new ArgumentNullException("typeDescriptor");
}
this.typeDescriptor = typeDescriptor;
if (typeResolver == null)
{
throw new ArgumentNullException("typeResolver");
}
this.typeResolver = typeResolver;
this.maxRecursion = maxRecursion;
this.namingConvention = namingConvention;
}
public DebugSmellableItem(ITypeResolver resolver, Vector2 pos)
: base(resolver, pos, Angle.Right)
{
smellable = new SmellableProperty(this, 10);
AddProperty(smellable);
}
public static void Register(ITypeResolver typeResolver)
{
var codeBuilder = new IlCodeBuilder();
codeBuilder.LoadArgument(0);
codeBuilder.Add(Code.Call, 1);
codeBuilder.Add(Code.Dup);
codeBuilder.LoadArgument(0);
codeBuilder.Add(Code.Stfld, 2);
codeBuilder.Add(Code.Ret);
var parameters = new List<IParameter>();
parameters.Add(typeResolver.System.System_Int32.ToParameter());
var tokenResolutions = new List<object>();
tokenResolutions.Add(
new SynthesizedStaticMethod(
string.Empty,
typeResolver.System.System_String,
typeResolver.System.System_String,
parameters,
(llvmWriter, opCode) => llvmWriter.WriteNewMethodBody(opCode, typeResolver.System.System_String, enableStringFastAllocation: true)));
tokenResolutions.Add(typeResolver.System.System_String.GetFieldByName("m_stringLength", typeResolver));
var locals = new List<IType>();
MethodBodyBank.Register(Name, codeBuilder.GetCode(), tokenResolutions, locals, parameters);
}
public DebugAttackerItem(ITypeResolver resolver, Vector2 pos)
: base(resolver, pos, Angle.Right)
{
attacker = new AttackerProperty(this, 5, 10, 1);
AddProperty(attacker);
}
/// <summary>
/// Creates a new instance of this class using the specified settings
/// </summary>
/// <param name="defaultContainer">Default container name</param>
/// <param name="containers">Collection of containers</param>
/// <param name="typeResolver">Type resolver to use</param>
public ServiceRegistrySettings(string defaultContainer,
IEnumerable<ServiceContainerSettings> containers = null, ITypeResolver typeResolver = null)
{
Resolver = typeResolver;
DefaultContainer = defaultContainer;
if (containers != null) _containers = new List<ServiceContainerSettings>(containers);
}
/// <summary>
/// Creates a new instance of the <see cref="CachedTypeResolver"/> class.
/// </summary>
/// <param name="typeResolver">
/// The <see cref="ITypeResolver"/> that this instance will delegate
/// actual <see cref="System.Type"/> resolution to if a <see cref="System.Type"/>
/// cannot be found in this instance's <see cref="System.Type"/> cache.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// If the supplied <paramref name="typeResolver"/> is <see langword="null"/>.
/// </exception>
public CachedTypeResolver(ITypeResolver typeResolver)
{
if (typeResolver == null)
throw new ArgumentNullException("typeResolver");
_typeResolver = typeResolver;
}
public void Setup()
{
mocks = new MockRepository();
typeResolver = new TypeResolver();
typeResolver = mocks.DynamicMock<ITypeResolver>();
treeService = new DefaultTreeCreationService();
visitor = new ControllerVisitor(new NullLogger(), typeResolver, treeService);
}
internal override IEnumerable<Violation> Validate(MethodDefinition method, ITypeResolver typeResolver)
{
if (_excludedNamespaces.Any(ns => (method.DeclaringType.Namespace ?? string.Empty).StartsWith(ns))) yield break;
if (method.Body == null) yield break;
if (method.Body.Instructions.Count < 1000) yield break;
yield return new GodObjectViolationResult(method);
}
/// <summary>
/// Initialize a new instance of the AzureTopicEventBusReader
/// </summary>
/// <param name="sbsConnectionString">Service Bus Connection String</param>
/// <param name="topicName">Topic Name</param>
/// <param name="subscriptionName">Subscription Name</param>
/// <param name="context">Bounded context</param>
/// <param name="typeResolver">Type resolver for mapping JSON back to contract objects</param>
/// <param name="dispatcher">Event Dispatcher for finding handlers for events after processing</param>
public AzureTopicEventBusReader(string sbsConnectionString, string topicName, string subscriptionName,
IBoundedContext context, ITypeResolver typeResolver, IDispatcher<IEvent> dispatcher)
: base(context, typeResolver, dispatcher)
{
// Build instance
CurrentSubscription = SubscriptionClient.CreateFromConnectionString(sbsConnectionString, topicName,
subscriptionName);
}
public static object ResolveWithDependencies(this IEnumerable<ParameterInfo> parameterInfos, ConstructorInfo constructorInfo, ITypeResolver typeResolver)
{
var objects = new List<object>();
objects.AddRange(parameterInfos.GetDependencies(typeResolver));
return constructorInfo.Invoke(objects.ToArray());
}
public void Setup()
{
mocks = new MockRepository();
logger = new NullLogger();
typeResolver = mocks.DynamicMock<ITypeResolver>();
treeService = mocks.DynamicMock<ITreeCreationService>();
visitor = new WizardStepPageVisitor(logger, typeResolver, treeService);
}
public void Setup()
{
_mocks = new MockRepository();
_logger = new NullLogger();
_typeResolver = _mocks.DynamicMock<ITypeResolver>();
_treeService = _mocks.DynamicMock<ITreeCreationService>();
_visitor = new ControllerVisitor(_logger, _typeResolver, _treeService);
}
protected TypeSpec(ITypeResolver typeResolver, Type type)
: base(typeResolver, type)
{
if (type == null)
throw new ArgumentNullException(nameof(type));
this.@namespace = CreateLazy(() => typeResolver.LoadNamespace(this));
this.baseType = CreateLazy(() => typeResolver.LoadBaseType(this));
}
public PomonaHttpQueryTransformer(ITypeResolver typeMapper, QueryExpressionParser parser)
{
if (typeMapper == null)
throw new ArgumentNullException(nameof(typeMapper));
if (parser == null)
throw new ArgumentNullException(nameof(parser));
this.typeMapper = typeMapper;
this.parser = parser;
}
public DebugSnifferItem(ITypeResolver resolver, Vector2 pos)
: base(resolver, pos, Angle.Right)
{
sniffer = new SnifferProperty(this)
{
};
AddProperty(sniffer);
}
/// <summary>
/// Gets the type of this variable.
/// </summary>
TTypeRef IVariable.GetType <TTypeRef>(ITypeResolver <TTypeRef> typeResolver)
{
return(GetType(typeResolver));
}
public QueryProcessor(ITypeResolver typeResolver)
{
_typeResolver = typeResolver;
}
public PropertyObjectTypeResolver(Expression <Func <T, object> > exp, Func <object, object> sourceValueSelector = null, ITypeResolver resolver = null) :
base(GetPropertyType(exp), GetPropertyName(exp), sourceValueSelector, resolver)
{
}
public RoundtripObjectGraphTraversalStrategy(Serializer serializer, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion)
: base(serializer, typeDescriptor, typeResolver, maxRecursion)
{
}
public ClrNamespaceUriParseCache(ITypeResolver typeResolver)
{
this.typeResolver = typeResolver;
this.dictionary = new Dictionary <IXmlNamespace, ClrNamespaceUriParseCache.ClrNamespaceDeclaration>();
}
/// <summary>
/// Creates a new instance of this class using the specified settings
/// </summary>
/// <param name="defaultContainer">Default container name</param>
/// <param name="containers">Collection of containers</param>
/// <param name="typeResolver">Type resolver to use</param>
public ServiceRegistrySettings(string defaultContainer,
IEnumerable <ServiceContainerSettings> containers = null, ITypeResolver typeResolver = null)
{
Resolver = typeResolver;
DefaultContainer = defaultContainer;
if (containers != null)
{
_containers = new List <ServiceContainerSettings>(containers);
}
}
/// <summary>Initializes a new instance of the <see cref="OperationModelBase{TParameterModel, TResponseModel}"/> class.</summary>
/// <param name="exceptionSchema">The exception schema.</param>
/// <param name="operation">The operation.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="generator">The generator.</param>
/// <param name="settings">The settings.</param>
protected OperationModelBase(JsonSchema4 exceptionSchema, SwaggerOperation operation, ITypeResolver resolver, IClientGenerator generator, ClientGeneratorBaseSettings settings)
{
_operation = operation;
_resolver = resolver;
_generator = generator;
_settings = settings;
var responses = _operation.Responses
.Select(response => CreateResponseModel(response.Key, response.Value, exceptionSchema, generator, settings))
.ToList();
var defaultResponse = responses.SingleOrDefault(r => r.StatusCode == "default");
if (defaultResponse != null)
{
responses.Remove(defaultResponse);
}
Responses = responses;
DefaultResponse = defaultResponse;
}
public static IndexedClrPropertyReferenceStep GetReferenceStep(ITypeResolver typeResolver, Type declaringType, int index)
{
return(IndexedClrPropertyReferenceStep.GetReferenceStep(typeResolver, declaringType, index, true));
}
public static CommandValueLookup GetParameterValues(CommandTree?tree, ITypeResolver resolver)
{
var lookup = new CommandValueLookup();
var binder = new CommandValueBinder(lookup);
CommandValidator.ValidateRequiredParameters(tree);
while (tree != null)
{
// Process unmapped parameters.
foreach (var parameter in tree.Unmapped)
{
if (parameter.IsFlagValue())
{
// Set the flag value to an empty, not set instance.
var instance = Activator.CreateInstance(parameter.ParameterType);
lookup.SetValue(parameter, instance);
}
else
{
// Is this an option with a default value?
if (parameter.DefaultValue != null)
{
var value = parameter.DefaultValue?.Value;
// Need to convert the default value?
if (value != null && value.GetType() != parameter.ParameterType)
{
var converter = GetConverter(lookup, binder, resolver, parameter);
if (converter != null)
{
value = converter.ConvertFrom(value);
}
}
binder.Bind(parameter, resolver, value);
CommandValidator.ValidateParameter(parameter, lookup);
}
}
}
// Process mapped parameters.
foreach (var mapped in tree.Mapped)
{
if (mapped.Parameter.WantRawValue)
{
// Just try to assign the raw value.
binder.Bind(mapped.Parameter, resolver, mapped.Value);
}
else
{
var converter = GetConverter(lookup, binder, resolver, mapped.Parameter);
if (converter == null)
{
throw RuntimeException.NoConverterFound(mapped.Parameter);
}
if (mapped.Parameter.IsFlagValue() && mapped.Value == null)
{
if (mapped.Parameter is CommandOption option && option.DefaultValue != null)
{
// Set the default value.
binder.Bind(mapped.Parameter, resolver, option.DefaultValue?.Value);
}
else
{
// Set the flag but not the value.
binder.Bind(mapped.Parameter, resolver, null);
}
}
public static IndexedClrPropertyReferenceStep GetReferenceStep(ITypeResolver typeResolver, ITypeId declaringTypeId, int index)
{
IType type = typeResolver.ResolveType(declaringTypeId);
return(IndexedClrPropertyReferenceStep.GetReferenceStep(typeResolver, type.RuntimeType, index, true));
}
/// <summary>Initializes a new instance of the <see cref="DefaultValueGenerator" /> class.</summary>
/// <param name="typeResolver">The type typeResolver.</param>
protected DefaultValueGenerator(ITypeResolver typeResolver)
{
_typeResolver = typeResolver;
}
/// <summary> /// Resolves a type /// </summary> /// <param name="self">this</param> /// <param name="typeRef">The type</param> /// <returns>A <see cref="TypeDef"/> instance</returns> /// <exception cref="TypeResolveException">If the type couldn't be resolved</exception> public static TypeDef ResolveThrow(this ITypeResolver self, TypeRef typeRef) => self.ResolveThrow(typeRef, null);
protected virtual JsonSerializerSettings ReturnSerializerSettings(ITypeResolver typeResolver, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
return(OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(typeResolver, providerRuntime.GrainFactory), config));
}
public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
{
_propertyInfo = propertyInfo;
_typeResolver = typeResolver;
}
public FullObjectGraphTraversalStrategy(Serializer serializer, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention)
{
if (maxRecursion <= 0)
{
throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
}
this.serializer = serializer;
if (typeDescriptor == null)
{
throw new ArgumentNullException("typeDescriptor");
}
this.typeDescriptor = typeDescriptor;
if (typeResolver == null)
{
throw new ArgumentNullException("typeResolver");
}
this.typeResolver = typeResolver;
this.maxRecursion = maxRecursion;
this.namingConvention = namingConvention;
}
/// <summary>
/// Initializes a new silo server.
/// </summary>
/// <param name="args">The command line arguments given to the Main() method</param>
/// <param name="customTypeResolver">The type resolver, if any, responsible for resolving Type objects by their assembly qualified name</param>
/// <param name="codeGenerator">The code generator to create proxy and servant types</param>
/// <param name="postMortemSettings">
/// Settings to control how and if minidumps are collected - when set to null, default values are used (
/// <see
/// cref="PostMortemSettings" />
/// )
/// </param>
/// <param name="heartbeatSettings">The settings for heartbeat mechanism, if none are specified, then default settings are used</param>
/// <param name="latencySettings">The settings for latency measurements, if none are specified, then default settings are used</param>
/// <param name="endPointSettings">The settings for the endpoint itself (max. number of concurrent calls, etc...)</param>
/// <param name="endPointName">The name of this silo, used for debugging (and logging)</param>
public OutOfProcessSiloServer(string[] args,
ITypeResolver customTypeResolver = null,
ICodeGenerator codeGenerator = null,
PostMortemSettings postMortemSettings = null,
HeartbeatSettings heartbeatSettings = null,
LatencySettings latencySettings = null,
EndPointSettings endPointSettings = null,
string endPointName = null)
{
if (postMortemSettings != null && !postMortemSettings.IsValid)
{
throw new ArgumentException("postMortemSettings");
}
Log.InfoFormat("Silo Server starting, args ({0}): \"{1}\", {2} custom type resolver",
args.Length,
string.Join(" ", args),
customTypeResolver != null ? "with" : "without"
);
int pid;
if (args.Length >= 1 && int.TryParse(args[0], out pid))
{
_parentProcessId = pid;
_parentProcess = Process.GetProcessById(pid);
_parentProcess.EnableRaisingEvents = true;
_parentProcess.Exited += ParentProcessOnExited;
}
if (Log.IsDebugEnabled)
{
Log.DebugFormat("Args.Length: {0}", args.Length);
}
if (args.Length >= 10)
{
if (postMortemSettings != null)
{
Log.Info("Ignoring post-mortem settings specified from the command-line");
}
else
{
var settings = new PostMortemSettings();
bool.TryParse(args[1], out settings.CollectMinidumps);
bool.TryParse(args[2], out settings.SuppressErrorWindows);
bool.TryParse(args[3], out settings.HandleAccessViolations);
bool.TryParse(args[4], out settings.HandleCrtAsserts);
bool.TryParse(args[5], out settings.HandleCrtPureVirtualFunctionCalls);
int tmp;
int.TryParse(args[6], out tmp);
settings.RuntimeVersions = (CRuntimeVersions)tmp;
int.TryParse(args[7], out settings.NumMinidumpsRetained);
settings.MinidumpFolder = args[8];
settings.MinidumpName = args[9];
if (!settings.IsValid)
{
Log.ErrorFormat("Received invalid post-mortem debugger settings: {0}", settings);
}
else
{
postMortemSettings = settings;
}
}
}
_registry = new DefaultImplementationRegistry();
_waitHandle = new ManualResetEvent(false);
_customTypeResolver = customTypeResolver;
_postMortemSettings = postMortemSettings;
if (_postMortemSettings != null)
{
Log.InfoFormat("Using post-mortem debugger: {0}", _postMortemSettings);
if (!NativeMethods.LoadPostmortemDebugger())
{
int err = Marshal.GetLastWin32Error();
Log.ErrorFormat("Unable to load the post-mortem debugger dll: {0}",
err);
}
if (_postMortemSettings.CollectMinidumps)
{
if (NativeMethods.InitDumpCollection(_postMortemSettings.NumMinidumpsRetained,
_postMortemSettings.MinidumpFolder,
_postMortemSettings.MinidumpName))
{
Log.InfoFormat("Installed post-mortem debugger; up to {0} mini dumps will automatically be saved to: {1}",
_postMortemSettings.NumMinidumpsRetained,
_postMortemSettings.MinidumpFolder
);
}
}
NativeMethods.InstallPostmortemDebugger(_postMortemSettings.HandleAccessViolations,
_postMortemSettings.SuppressErrorWindows,
_postMortemSettings.HandleCrtAsserts,
_postMortemSettings.HandleCrtPureVirtualFunctionCalls,
_postMortemSettings.RuntimeVersions);
}
_endPoint = new SocketEndPoint(EndPointType.Server,
endPointName,
codeGenerator: codeGenerator,
heartbeatSettings: heartbeatSettings,
latencySettings: latencySettings,
endPointSettings: endPointSettings
);
_endPoint.OnConnected += EndPointOnOnConnected;
_endPoint.OnDisconnected += EndPointOnOnDisconnected;
_endPoint.OnFailure += EndPointOnOnFailure;
}
public MinioGrainStorage(string name, string container, IMinioStorage storage, ILogger <MinioGrainStorage> logger, IGrainFactory grainFactory, ITypeResolver typeResolver)
{
_name = name;
_container = container;
_logger = logger;
_storage = storage;
_grainFactory = grainFactory;
_typeResolver = typeResolver;
}
public OrderSerializerBuilderCase(ITypeResolver resolver, IBinaryCodec codec, IBinarySerializerBuilder builder) : base(codec, builder)
{
Resolver = resolver;
}
public TypeDeclaration(ITypeResolver resolver, string name, string namespaceName, short assemblyId)
: this(null, resolver, name, namespaceName, assemblyId, true)
{
}
public TypeDeclaration(XmlBamlReader reader, ITypeResolver resolver, string name, string namespaceName, short assemblyId)
: this(reader, resolver, name, namespaceName, assemblyId, true)
{
}
public MessageParser(ITypeResolver typeResolver, ISerializer serializer)
{
_typeResolver = typeResolver ?? throw new ArgumentNullException(nameof(typeResolver));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
/// <summary> /// Gets the type of this variable. /// </summary> protected abstract TTypeRef GetType <TTypeRef>(ITypeResolver <TTypeRef> typeResolver);
/// <summary>
/// Maps a source object, into a destination object
/// </summary>
/// <typeparam name="TDestination">The type of the destination object</typeparam>
/// <param name="source">The source object</param>
/// <param name="resolver">A custom resolver</param>
/// <param name="resolverExpressions">Any custom resolver, optional</param>
/// <param name="recursive">Defines whether to apply the mapping recursively, optional and by default false</param>
/// <returns>The mapped destination object</returns>
public static Object MapObjects <TDestination>(Object source, ITypeResolver resolver, Dictionary <Expression <Func <TDestination, Object> >, IResolver> resolverExpressions = null, Boolean recursive = false)
{
Dictionary <string, IResolver> resolvers = ConvertExpressionsToResolvers(resolverExpressions);
return(MapObjects(source, resolver, resolvers, recursive));
}
/// <summary>
/// Creates a new instance of this class and initializes it from the specified XML element.
/// </summary>
/// <param name="element">XML element to initialize this instance from.</param>
/// <param name="typeResolver">Optional type resolver</param>
public ConstructorParameterSettings(XElement element, ITypeResolver typeResolver = null)
: base(element)
{
_typeResolver = typeResolver;
}
internal AsyncRemoteQueryProvider(Func <Expressions.Expression, Task <TSource> > dataProvider, ITypeResolver typeResolver, IAsyncQueryResultMapper <TSource> resutMapper, Func <Expression, bool> canBeEvaluatedLocally)
{
if (ReferenceEquals(null, dataProvider))
{
throw new ArgumentNullException(nameof(dataProvider));
}
_dataProvider = dataProvider;
_resultMapper = resutMapper;
_typeResolver = typeResolver;
_canBeEvaluatedLocally = canBeEvaluatedLocally;
}
/// <summary>
/// Creates a new nullable resolver case.
/// </summary>
/// <param name="resolver">
/// The resolver instance to use to resolve underlying types.
/// </param>
/// <exception cref="ArgumentNullException">
/// Thrown when the resolver is null.
/// </exception>
public NullableResolverCase(ITypeResolver resolver)
{
Resolver = resolver ?? throw new ArgumentNullException(nameof(resolver), "Resolver cannot be null.");
}
public GraphTypeInfo(ITypeResolver typeResolver, TypeInfo type)
: base(typeResolver, type)
{
TypeRepresentation = type ?? (TypeInfo)AttributeProvider;
DeriveMetaData();
}
public TypeDeclaration(ITypeResolver resolver, string name, string namespaceName, short assemblyId, bool isExtension)
: this(null, resolver, name, namespaceName, assemblyId, true)
{
_isExtension = isExtension;
}
public GraphEnumMemberInfo(ITypeResolver typeResolver, MemberInfo enumValue = null)
: base(typeResolver, enumValue)
{
}
public ChainResolver(ITypeResolver typeResolver, BehaviorGraph behaviorGraph)
{
_typeResolver = typeResolver;
_behaviorGraph = behaviorGraph;
}
