/// <summary> /// 创建一个程序集编译类 /// </summary> /// <param name="name">程序集名字</param> /// <returns></returns> public static NAssembly CreateAssembly(this DomainBase domain, string name = default) { NAssembly result = new NAssembly(name); result.AssemblyBuilder.Compiler.Domain = domain; return(result); }
public static TDomain RegisterDefault <TDomain>() where TDomain : DomainBase <TDomain>, new() { if (Default != null) { if (typeof(TDomain) != Default.GetType()) { Default = (new TDomain()).GetInstance("Default"); } } else { Default = (new TDomain()).GetInstance("Default"); } foreach (var asm in DependencyContext .Default .CompileLibraries .SelectMany(cl => cl.ResolveReferencePaths())) { Default.AddReferencesFromDllFile(asm); } return((TDomain)Default); }
public static TDomain RegisterDefault <TDomain>(bool initializeReference = true) where TDomain : DomainBase { DynamicMethod method = new DynamicMethod("Domain" + Guid.NewGuid().ToString(), typeof(DomainBase), new Type[] { typeof(string) }); ILGenerator il = method.GetILGenerator(); ConstructorInfo ctor = typeof(TDomain).GetConstructor(BindingFlags.Instance | BindingFlags.Public, null, new Type[] { typeof(string) }, null); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Newobj, ctor); il.Emit(OpCodes.Ret); CreateDomain = (Func <string, DomainBase>)(method.CreateDelegate(typeof(Func <string, DomainBase>))); Default = Create("Default"); if (initializeReference) { foreach (var asm in DependencyContext .Default .CompileLibraries .SelectMany(cl => cl.ResolveReferencePaths())) { Default.AddReferencesFromDllFile(asm); } } return((TDomain)Default); }
public static T Use(DomainBase domain, Action <AssemblyCSharpBuilder> option = default) { T instance = new T(); instance.AssemblyBuilder.Compiler.Domain = domain; instance.OptionAction = option; option?.Invoke(instance.AssemblyBuilder); return(instance); }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { DomainBase domainBase = value as DomainBase; if (domainBase != null) { return(!domainBase.IsDirty); } return(true); }
public static Guid GetIDFromObject(DomainBase<Guid> domain) { if (domain != null) { return domain.ID; } else { return new Guid(); } }
public static T Delegate(string content, DomainBase domain = default, Action<AssemblyCSharpBuilder> option = default, params NamespaceConverter[] usings) { var method = typeof(T).GetMethod("Invoke"); return FakeMethodOperator.Use(domain, option) .UseMethod(method) .Using(usings) .StaticMethodBody(content) .Compile<T>(); }
public static T Delegate(string content, DomainBase domain = default, Action <AssemblyCSharpBuilder> option = default, Func <FakeMethodOperator, FakeMethodOperator> methodAction = null, params NamespaceConverter[] usings) { var method = typeof(T).GetMethod("Invoke"); var @operator = FakeMethodOperator.UseDomain(domain, option); @operator .UseMethod(method) .Using(usings) .StaticMethodBody(content); methodAction?.Invoke(@operator); return(@operator.Compile <T>()); }
internal static void RegisterDefault(Type type) { DomainBase domain = (DomainBase)type.Assembly.CreateInstance(type.FullName); if (Default == null || (Default != null && Default.GetType() != type)) { if (domain != null) { Default = domain.GetInstance("Default"); } } }
private bool isValidProduct(List <ProductDomain> ListProducts) { string AvailableProducts = DomainBase.GetAvailableProduct(); foreach (ProductDomain product in ListProducts) { if (!AvailableProducts.ToUpper().Contains(product.Name.ToUpper())) { return(false); } } return(true); }
public static void Add(string key, DomainBase domain) { if (Cache.ContainsKey(key)) { if (!Cache[key].IsAlive) { Cache[key] = new WeakReference(domain); } } else { Cache[key] = new WeakReference(domain, trackResurrection: true); } }
public static T RegisterDefault <T>() where T : DomainBase, new() { if (Default != null) { if (typeof(T) != Default.GetType()) { Default = (new T()).GetInstance("Default"); } } else { Default = (new T()).GetInstance("Default"); } return((T)Default); }
private void SetToolbaritems() { ToolbarItems.Clear(); var infoItem = new ToolbarItem("Info", "info.png", () => ShowInfo()); var scoreItem = TabView.SelectedIndex > 1 ? new ToolbarItem("Score", "todo.png", () => ShowToDo()) : new ToolbarItem("Score", "score.png", () => ShowScore()); var finishItem = new ToolbarItem("Finish", "finish.png", async() => await _vm.Finish()); ToolbarItems.Add(infoItem); ToolbarItems.Add(scoreItem); if (DomainBase.IsEmpty(_vm.Game.Game.FinishedAt)) { ToolbarItems.Add(finishItem); } }
public async Task LoadAsync(string gameId) { var gameDto = await DataService.GetPlayGame(gameId); Tees = new ObservableCollection <TeeDto>(gameDto.Tees.OrderBy(x => x.Number)); foreach (var teeDto in Tees) { teeDto.Scores = new ObservableCollection <ScoreDto>(gameDto.Scores.Where(x => x.TeeId == teeDto.Id).OrderBy(x => x.PlayerAbbreviation)); } var scores = gameDto.Scores.OrderBy(x => x.PlayerId).ToList(); foreach (var scoreDto in scores) { scoreDto.Player = gameDto.Players.First(x => x.Id == scoreDto.PlayerId); scoreDto.TeeNumber = gameDto.Tees.First(x => x.Id == scoreDto.TeeId).Number; } TotalScores = new ObservableCollection <TotalScoreDto>(); foreach (var player in gameDto.Players.OrderBy(x => x.Abbreviation)) { TotalScores.Add(new TotalScoreDto { PlayerId = player.Id, TotalPutts = scores.Where(x => x.PlayerId == player.Id).Sum(x => x.Putts), }); } Scores = new ObservableCollection <ScoreDto>(scores.OrderBy(x => x.TeeNumber).ThenBy(x => x.PlayerAbbreviation)); Game = gameDto; CurrentScore = Scores[Game.Game.CurrentTee]; CurrentScore.ScoreChanged += CurrentScore_ScoreChanged; CurrentTee = Tees.First(x => x.Id == CurrentScore.TeeId); IsBackEnabled = false; IsNextEnabled = true; ScoringIsEnabled = DomainBase.IsEmpty(Game.Game.FinishedAt); Title = $"{Game.Game.GameType} @ {Game.Venue.Name}"; RaisePropertyChanged(nameof(GameStartTime)); RaisePropertyChanged(nameof(GameFinishedTime)); }
private async Task <T> SaveAsync <T>(DomainBase entity, bool synchronize = false) where T : DomainBase { #if OFFLINE_SYNC_ENABLED var table = App.MobileService.GetSyncTable <T>(); #else var table = App.MobileService.GetTable <T>(); #endif var action = "init"; try { if (entity.IsNew) { entity.Id = NewId(); action = "insert"; await table.InsertAsync((T)entity).ConfigureAwait(false); } else { action = "update"; await table.UpdateAsync((T)entity).ConfigureAwait(false); } action = "sync"; if (synchronize) { await SyncAsync().ConfigureAwait(false); } action = "lookup"; return((T)entity); } catch (Exception e) { var msg = $"Error executing {action} operation. Item: {typeof(T).Name} ({entity.Id}). Operation discarded. "; ErrorReportingService.ReportError(this, e, msg); //Debug.WriteLine($"{msg}. Error: {e.Message}"); throw; } }
public static ContextualReflectionScope Lock(DomainBase domain) { return(domain.EnterContextualReflection()); }
/// <summary> /// Initializes a new instance of the <see cref="ValueNode{T}" /> class. /// </summary> /// <param name="identifier">The parameter's identifier. Must be unique.</param> /// <param name="domain">The parameter's domain.</param> public ValueNode(string identifier, DomainBase <T> domain) : base(identifier) { this._domain = domain; }
public DomainObjectMustContainIDRule(DomainBase domainBase) { _domainBase = domainBase; }
private bool ExecuteValidation(List <ProductDomain> ListProducts) { if (MachineDomain.InsertedCoins == null || MachineDomain.InsertedCoins.Count == 0) { throw new ValidationException("Please Insert some Coins.."); } else if (!isValidProduct(ListProducts)) { throw new ValidationException(String.Format("NO_PRODUCT. Please request only {0}", DomainBase.GetAvailableProduct())); } else if (!isAvailableQttProduct(ListProducts)) { throw new ValidationException("Unavailable Product. Insufficient Quantity. Sorry!"); } else if (!isEnoughMoney(ListProducts)) { throw new ValidationException("Insufficiente Coins to order the amount of product. Please Insert more Coins."); } return(true); }
public static void Send(IDomainMapper domainMapper, Socket publisher, RuntimeTypeModel typeModel, MemoryStream stream, DomainBase instance) { var status = publisher.SendMore(domainMapper.Type2Bytes(instance.GetType())); if (status != SendStatus.Sent) { throw new InvalidOperationException("Key not sent!"); } stream.SetLength(0); typeModel.Serialize(stream, instance); status = publisher.Send(stream.ToArray()); if (status != SendStatus.Sent) { throw new InvalidOperationException("Instance not sent!"); } }
/// <summary> /// 获取编译所需的引用库 /// </summary> /// <returns></returns> public static HashSet <PortableExecutableReference> GetCompileReferences(DomainBase main, DomainBase follow) { var defaultNode = (NatashaAssemblyDomain)main; //如果主从域不一样 if (follow.Name != "default") { //去除剩余的部分 var sets = new HashSet <PortableExecutableReference>(defaultNode.ReferencesFromStream.Values); //遍历主域的流引用集合 foreach (var item in defaultNode.ReferencesFromStream.Keys) { //遍历从域的流引用集合 foreach (var current in follow.ReferencesFromStream.Keys) { //如果程序集名相同 if (item.GetName().Name == current.GetName().Name) { //是否选用最新程序集 if (follow.UseNewVersionAssmebly) { //如果主域版本小,移除主域的引用 if (item.GetName().Version < current.GetName().Version) { //使用现有域的程序集版本 sets.Remove(defaultNode.ReferencesFromStream[item]); break; } } else { sets.Remove(defaultNode.ReferencesFromStream[item]); break; } } } } //添加从域的流编译的引用 sets.UnionWith(follow.ReferencesFromStream.Values); //添加主域的文件编译引用 sets.UnionWith(defaultNode.ReferencesFromFile.Values); //对比主从域的文件编译引用 foreach (var item in defaultNode.ReferencesFromFile.Keys) { foreach (var current in follow.ReferencesFromFile.Keys) { //如果从域指定了文件编译引用 if (item == current) { //移除主域的引用 sets.Remove(defaultNode.ReferencesFromFile[item]); } } } //添加从域的引用 sets.UnionWith(follow.ReferencesFromFile.Values); return(sets); } else { //如果是系统域则直接拼接自己的引用库 var sets = new HashSet <PortableExecutableReference>(defaultNode.ReferencesFromStream.Values); sets.UnionWith(defaultNode.ReferencesFromFile.Values); return(sets); } }