public static void Main(string[] args) { try { var resolveUrOptions = ConsoleArgsResolveUR.Resolve(args); resolveUrOptions.MsBuilderPath = MsBuildResolveUR.FindMsBuildPath(resolveUrOptions.Platform); _resolveur = ResolveURFactory.GetResolver( resolveUrOptions, resolveur_HasBuildErrorsEvent, resolveur_ProjectResolveCompleteEvent); _resolveur.Resolve(); } catch (ArgumentException ae) { Console.WriteLine(ae.Message); } catch (FileNotFoundException fnfe) { Console.WriteLine(fnfe.Message); } catch (InvalidDataException ide) { Console.WriteLine(ide.Message); } catch (NotSupportedException nse) { Console.WriteLine(nse.Message); } }
public object CreateInstance(IResolve resolvingContext) { ConstructorInfo[] ctors = _targetType.GetConstructors(); if (ctors.Length > 1) { throw new Exception($"type {_targetType} has more than 1 constructor"); } object instance; if (ctors.Length == 0) { instance = Activator.CreateInstance(_targetType); } else { ParameterInfo[] parameters = ctors[0].GetParameters(); object[] instances = new object[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { instances[i] = resolvingContext.Resolve(parameters[i].ParameterType); } ; instance = Activator.CreateInstance(_targetType, instances); } return(instance); }
/////////////////////////////////////////////////////////////////////// public override ReturnCode GetCurrentNamespace( ICallFrame frame, ref INamespace @namespace, ref Result error ) { INamespace localNamespace = NamespaceOps.GetCurrent( base.Interpreter, frame); if (localNamespace != null) { IResolve resolve = localNamespace.Resolve; if (resolve != null) { return(resolve.GetCurrentNamespace( frame, ref @namespace, ref error)); } else { @namespace = localNamespace; return(ReturnCode.Ok); } } error = "no current namespace for call frame"; return(ReturnCode.Error); }
public UserActor(ILogFactory logFactory, ICommandToEventAdapter commandToEventAdapter, IResolve resolver) { _user = resolver.Resolve <IUser>(); _commandToEventAdapter = commandToEventAdapter; _resolver = resolver; _logger = logFactory.CreateLog(); Receive <IUpdateUserActorStateCommand>(cmd => { _user = cmd.UpdatedUser; Sender.Tell(_commandToEventAdapter.Adapt <IUpdateUserActorStateCommand, IUserUpdatedEvent>(cmd)); }); Receive <IRequestTrackUserCommand>(trackuserCommand => { if (string.IsNullOrEmpty(_user.Id)) { _user.Id = trackuserCommand.UserId; } var response = _commandToEventAdapter.Adapt <IRequestTrackUserCommand, IRespondActorStateEvent>(trackuserCommand); response.User = _user; Sender.Tell(response); //Sender.Tell(_commandToEventAdapter.Adapt<IRequestTrackUserCommand, IUserTrackingEvent>(trackuserCommand)); }); }
/////////////////////////////////////////////////////////////////////// #region IResolve Members public override ReturnCode GetVariableFrame( ref ICallFrame frame, ref string varName, ref VariableFlags flags, ref Result error ) { INamespace @namespace = NamespaceOps.GetCurrent( base.Interpreter, frame); if (@namespace != null) { IResolve resolve = @namespace.Resolve; if (resolve != null) { return(resolve.GetVariableFrame( ref frame, ref varName, ref flags, ref error)); } } return(NamespaceOps.GetVariableFrame( base.Interpreter, ref frame, ref varName, ref flags, ref error)); }
public void IResolveTest(IResolve resolver) { // Act var value = resolver.Resolve(ref Context); // Validate Assert.IsNotNull(value); Assert.AreSame(StringConst, value); }
public FtpServerViewModel( IResolve dependencyService, IFtpServer ftpServer) { DependencyService = dependencyService; FtpServer = ftpServer; ConnectToServerCommand = new RelayCommand(InitialConnectToServer); MessengerInstance.Register <ChangeWorkingDirectoryMessage>(this, SetWorkingDirectory); }
/////////////////////////////////////////////////////////////////////// public override ReturnCode GetIExecute( ICallFrame frame, EngineFlags engineFlags, string name, ArgumentList arguments, LookupFlags lookupFlags, ref bool ambiguous, ref long token, ref IExecute execute, ref Result error ) { if (!Engine.HasGlobalOnly(engineFlags)) { IResolve resolve = null; string tail = null; INamespace @namespace = GetNamespaceForIExecute( frame, name, ref resolve, ref tail, ref error); if (@namespace != null) { if (resolve != null) { return(resolve.GetIExecute( frame, engineFlags, tail, arguments, lookupFlags, ref ambiguous, ref token, ref execute, ref error)); } else { Interpreter interpreter = base.Interpreter; if (!NamespaceOps.IsGlobal(interpreter, @namespace)) { string qualifiedName = NamespaceOps.MakeQualifiedName( interpreter, @namespace, name); if (base.GetIExecute(frame, engineFlags | EngineFlags.ExactMatch, qualifiedName, arguments, lookupFlags, ref ambiguous, ref token, ref execute, ref error) == ReturnCode.Ok) { return(ReturnCode.Ok); } } } } } return(base.GetIExecute( frame, engineFlags, name, arguments, lookupFlags, ref ambiguous, ref token, ref execute, ref error)); }
/////////////////////////////////////////////////////////////////////// protected virtual INamespace GetNamespaceForVariable( ICallFrame frame, /* in */ string varName, /* in */ ref IResolve resolve, /* out */ ref string tail, /* out */ ref Result error /* out */ ) { return(NamespaceOps.GetForVariable( base.Interpreter, frame, varName, ref resolve, ref tail, ref error)); }
public MainViewModel( IResolve dependencyService, IFtpServerViewModel ftpServerViewModel, ILocalSystemViewModel localSystem) { DependencyService = dependencyService; FtpServer = ftpServerViewModel; LocalSystem = localSystem; MessengerInstance.Register <UploadDirectoryItemsMessage>(this, message => UploadDirectoryItems(message)); MessengerInstance.Register <DeleteDirectoryItemsMessage>(this, message => DeleteDirectoryItems(message)); MessengerInstance.Register <ResolveUploadConflictsMessage>(this, message => ResolveUploadConflicts(message)); MessengerInstance.Register <ResolveDownloadConflictsMessage>(this, message => ResolveDownloadConflicts(message)); MessengerInstance.Register <ApplicationStatusMessage>(this, message => ApplicationStatus(message)); }
static void Main(string[] args) { ConcreteClass abstractFactory = new Factory(); IResolve mapA = abstractFactory.Get("Hi"); MyObject resolverA = mapA.Resolve(); Console.WriteLine(resolverA.ToString()); IResolve mapB = abstractFactory.Get("Bye"); MyObject resolverB = mapB.Resolve(); Console.WriteLine(resolverB); Console.ReadLine(); }
public AtomicJobQueue( IProcessingEngine processingEngine, ShellSettings shellSettings, IShellDescriptorManager shellDescriptorManager, IResolve <IJobManager> jobManagerResolve, IWorkContextAccessor wca) { _processingEngine = processingEngine; _shellSettings = shellSettings; _shellDescriptorManager = shellDescriptorManager; _jobManagerResolve = jobManagerResolve; _wca = wca; Logger = NullLogger.Instance; }
public BitbucketChangesetUpdater( IBitbucketService bitbucketService, IResolve<IDistributedLock> lockResolve, IScheduledTaskManager scheduledTaskManager, IClock clock, ISiteService siteService) { _bitbucketService = bitbucketService; _lockResolve = lockResolve; _scheduledTaskManager = scheduledTaskManager; _clock = clock; _siteService = siteService; Logger = NullLogger.Instance; }
public override IResolve Get(string value) { IResolve mapper = null; switch (value) { case "Hi": mapper = new Resolvers.ResolverA(); break; case "Bye": mapper = new Resolvers.ResolverB(); break; } return(mapper); }
/////////////////////////////////////////////////////////////////////// public override ReturnCode GetVariable( ICallFrame frame, string varName, string varIndex, ref VariableFlags flags, ref IVariable variable, ref Result error ) { IResolve resolve = null; string tail = null; INamespace @namespace = GetNamespaceForVariable( frame, varName, ref resolve, ref tail, ref error); if (@namespace != null) { if (resolve != null) { return(resolve.GetVariable( frame, tail, varIndex, ref flags, ref variable, ref error)); } else { Interpreter interpreter = base.Interpreter; if (!NamespaceOps.IsGlobal(interpreter, @namespace)) { frame = @namespace.VariableFrame; return(base.GetVariable( frame, tail, varIndex, ref flags, ref variable, ref error)); } } } return(base.GetVariable( frame, varName, varIndex, ref flags, ref variable, ref error)); }
public BroadcastLogger(IEnumerable <ILog> logs, IResolve resolver) { _loggers = (from l in logs where l.GetType() != typeof(BroadcastLogger) select l).ToImmutableArray(); _enabled = _loggers.Any(); if (resolver.IsRegistered <IConfiguration>()) { var config = resolver.Resolve <IConfiguration>(); if (config.IsReady) { var levels = config.GetValueOrDefault("Logging:Levels", "NONE"); if (levels.IndexOf("DEBUG", StringComparison.InvariantCultureIgnoreCase) >= 0) { debugEnabled = true; } if (levels.IndexOf("INFO", StringComparison.InvariantCultureIgnoreCase) >= 0) { informationEnabled = true; } if (levels.IndexOf("EVENT", StringComparison.InvariantCultureIgnoreCase) >= 0) { eventEnabled = true; } if (levels.IndexOf("ERROR", StringComparison.InvariantCultureIgnoreCase) >= 0) { errorEnabled = true; } if (levels.IndexOf("FATAL", StringComparison.InvariantCultureIgnoreCase) >= 0) { fatalEnabled = true; } if (levels.IndexOf("ALL", StringComparison.InvariantCultureIgnoreCase) >= 0) { debugEnabled = true; informationEnabled = true; eventEnabled = true; errorEnabled = true; fatalEnabled = true; } } } }
public NamespaceData( string name, IClientData clientData, Interpreter interpreter, INamespace parent, IResolve resolve, ICallFrame variableFrame, string unknown ) { this.kind = IdentifierKind.NamespaceData; this.id = AttributeOps.GetObjectId(this); this.name = NamespaceOps.TrimAll(name); this.clientData = clientData; this.interpreter = interpreter; this.parent = parent; this.resolve = resolve; this.variableFrame = variableFrame; this.unknown = unknown; }
public TcpClientFactory(IResolve resolver) { _resolver = resolver; }
public LockFileManager(IResolve <ILockFile> lockFileResolve) { _lockFileResolve = lockFileResolve; }
/// <summary> /// 向工作队列添加对象,对象添加以后,如果已经绑定工作的事件会触发事件处理程序,对item对象进行处理 /// </summary> /// <param name="resolveItem">添加到队列的对象</param> public static void EnqueueItem(IResolve resolveItem) { m_WorkQueue.EnqueueItem(resolveItem); }
public FtpServer(IResolve dependencyService) { DependencyService = dependencyService; }
public LockFileManager(IResolve<ILockFile> lockFileResolve) { _lockFileResolve = lockFileResolve; }
public JobManager(IRepository<JobRecord> repository, IResolve<ILockFile> lockFileResolve) { _repository = repository; _lockFileResolve = lockFileResolve; }
public SerilogLogger(IResolve resolver) { var loggerConfiguration = new LoggerConfiguration(); if (resolver.IsRegistered <IConfiguration>()) { _configuration = resolver.Resolve <IConfiguration>(); if (_configuration.DebugMode) { loggerConfiguration.WriteTo.Debug(); WriteToDebug = true; } //if (resolver.IsRegistered<IAzureServicesConfiguration>()) //{ // var azureConfig = resolver.Resolve<IAzureServicesConfiguration>(); // if (azureConfig != null && azureConfig.ApplicationInsights != null && // azureConfig.ApplicationInsights.Enabled && // !string.IsNullOrEmpty(azureConfig.ApplicationInsights.Key)) // { // loggerConfiguration.WriteTo.ApplicationInsights(azureConfig.ApplicationInsights.Key, // LogEventToTelemetryConverter); // TelemetryDebugWriter.IsTracingDisabled = true; // WriteToAppInsights = true; // } //} if (System.Diagnostics.Debugger.IsAttached) { try { loggerConfiguration.WriteTo.ColoredConsole(); WriteToColoredConsole = true; } catch (Exception) { //optional, swallow if failes } } var levelMap = new Dictionary <string, LogEventLevel>(StringComparer.InvariantCultureIgnoreCase) { { "DEBUG", LogEventLevel.Debug }, { "INFO", LogEventLevel.Information }, { "EVENT", LogEventLevel.Information }, { "ERROR", LogEventLevel.Error }, { "FATAL", LogEventLevel.Fatal }, { "ALL", LogEventLevel.Verbose } }; var levels = _configuration.GetValueOrDefault("Logging:Levels", "NONE"); if (levelMap.TryGetValue(levels, out var logEventLevel)) { loggerConfiguration.MinimumLevel.Is(logEventLevel); } } _logger = loggerConfiguration.CreateLogger(); _contextProperties = new ConcurrentDictionary <string, string>(); }
public SetUpResult(IResolve <TCodeElement> populateBoxes, IOrType <TSetUpSideNode, IError> setUpSideNode) { Resolve = populateBoxes ?? throw new ArgumentNullException(nameof(populateBoxes)); SetUpSideNode = setUpSideNode; }
public object CreateInstance(IResolve resolvingContext) { return(_func(resolvingContext)); }
private readonly Dictionary<IJob, JobReference> _jobReferences = new Dictionary<IJob, JobReference>(); // No need to dispose undisposed jobs' lock files, as the Dispose() on the lock files will be called by Autofac public JobManager(IRepository<JobRecord> repository, IResolve<IDistributedLock> lockResolve) { _repository = repository; _lockResolve = lockResolve; }
/////////////////////////////////////////////////////////////////////// private /* protected virtual */ void Dispose( bool disposing ) { if (!disposed) { if (disposing) { //////////////////////////////////// // dispose managed resources here... //////////////////////////////////// if (children != null) { foreach (INamespace child in children.Values) { if (child == null) { continue; } IDisposable disposable = child as IDisposable; if (disposable != null) { disposable.Dispose(); disposable = null; } } children.Clear(); children = null; } /////////////////////////////////////////////////////////// if (exportNames != null) { exportNames.Clear(); exportNames = null; } /////////////////////////////////////////////////////////// if (imports != null) { ReturnCode removeCode; Result removeError = null; removeCode = RemoveImports( null, false, ref removeError); if (removeCode != ReturnCode.Ok) { DebugOps.Complain( interpreter, removeCode, removeError); } imports.Clear(); imports = null; } /////////////////////////////////////////////////////////// if (interpreter != null) { interpreter = null; /* NOT OWNED */ } /////////////////////////////////////////////////////////// parent = null; /* NOT OWNED */ resolve = null; /* NOT OWNED */ /////////////////////////////////////////////////////////// if (variableFrame != null) { variableFrame.Free(true); variableFrame = null; } /////////////////////////////////////////////////////////// unknown = null; /////////////////////////////////////////////////////////// qualifiedName = null; referenceCount = 0; deleted = false; /////////////////////////////////////////////////////////// kind = IdentifierKind.None; id = Guid.Empty; name = null; group = null; description = null; clientData = null; } ////////////////////////////////////// // release unmanaged resources here... ////////////////////////////////////// disposed = true; } }
public IResolve <T> Resolve <T>(IResolve <T> value) => Bind(value);
public static IResolveBuilder <T, ClientObjectResolveContext> ValidateIsClientObjectResolveBuilder <T>(this IResolve <T> resolve) { if (resolve == null) { throw Logger.Fatal.ArgumentNull(nameof(resolve)); } var result = (resolve as IResolveBuilder <T, ClientObjectResolveContext>); if (result == null) { throw Logger.Fatal.ArgumentNotAssignableTo( nameof(resolve), resolve, typeof(IResolveBuilder <T, ClientObjectResolveContext>) ); } return(result); }
public DistributedLockManager(IResolve<IDistributedLock> lockResolve) { _lockResolve = lockResolve; }
public AkkaUserManager(IResolve resolver) { _resolver = resolver; _userManagerActorRef = _resolver.Resolve <IActorRef>("UserManagerActor"); }
public StatusProvider(IResolve resolver, IConfiguration configuration) { _resolver = resolver; _configuration = configuration; }
public JobManager(IRepository <JobRecord> repository, IResolve <ILockFile> lockFileResolve) { _repository = repository; _lockFileResolve = lockFileResolve; }
public ResolvingContext(IResolve resolver) { Resolver = resolver; }
public ApplicationController() { DependencyService = new DependencyService(); Messenger.Default.Register <ChangePageMessage>(this, ChangePage); }