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