public static PropertyInstance GetCacheModificationPI(IClassVisitor cv) { Object bean = State.BeanContext.GetService <ICacheModification>(); PropertyInstance pi = State.GetProperty(cacheModificationName, NewType.GetType(bean.GetType())); if (pi != null) { return(pi); } return(cv.ImplementAssignedReadonlyProperty(cacheModificationName, bean)); }
public static PropertyInstance GetEmbeddedMemberTemplatePI(IClassVisitor cv) { Object bean = State.BeanContext.GetService(templateType); PropertyInstance pi = State.GetProperty(templatePropertyName, NewType.GetType(bean.GetType())); if (pi != null) { return(pi); } return(cv.ImplementAssignedReadonlyProperty(templatePropertyName, bean)); }
public override void Generate(IndentedStringBuilder stringBuilder) { var argBuilders = Arguments.Select(t => { var b = new IndentedStringBuilder(); t.Generate(b); return(b.Builder.ToString()); }); var arguments = string.Join(", ", argBuilders); stringBuilder.Append($"new {NewType.GetRightFullName()}({arguments})"); }
public static PropertyInstance GetConversionHelperPI(IClassVisitor cv) { Object bean = State.BeanContext.GetService <IConversionHelper>(); PropertyInstance pi = State.GetProperty("ConversionHelper", NewType.GetType(bean.GetType())); if (pi != null) { return(pi); } return(cv.ImplementAssignedReadonlyProperty("ConversionHelper", bean)); }
/// <summary> /// 添加 /// </summary> /// <param name="item">NewType</param> /// <returns></returns> public static int AddNewType(NewType item) { string spName = "cudo_createnewtype"; SqlParameter[] paramvalues = new SqlParameter[] { new SqlParameter("@classname", item.ClassName), new SqlParameter("@parentid", item.ParentId), new SqlParameter("@sortid", item.SortId) }; return(SqlHelper.ExecuteNonQuery(SqlHelper.ConnectionString, CommandType.StoredProcedure, spName, paramvalues)); }
static void Main(string[] args) { int TestNum = OnePlus(100); Console.WriteLine(TestNum); NewType aNewType = new NewType(OnePlus); TestNum = aNewType(1000); Console.WriteLine(TestNum); aNewType = new NewType(TenPlus); TestNum = aNewType(1000); Console.WriteLine(TestNum); }
public static PropertyInstance FindByTemplate(String propertyName, NewType propertyType, bool tryOnly) { IBytecodeBehaviorState state = BytecodeBehaviorState.State; PropertyInstance pi = state.GetProperty(propertyName, propertyType); if (pi != null) { return(pi); } if (tryOnly) { return(null); } throw new ArgumentException("No property found on class hierarchy: " + propertyName + ". Start type: " + state.NewType); }
protected void ImplementValueHolderCode(PropertyInstance p_valueHolderContainerTemplate, PropertyInstance p_targetCache, PropertyInstance p_relationMembers) { RelationMember[] relationMembers = metaData.RelationMembers; NewType owner = State.NewType; for (int relationIndex = relationMembers.Length; relationIndex-- > 0;) { RelationMember relationMember = relationMembers[relationIndex]; relationMember = (RelationMember)GetApplicableMember(relationMember); if (relationMember == null) { // member is handled in another type continue; } String propertyName = relationMember.Name; IPropertyInfo propertyInfo = propertyInfoProvider.GetProperty(relationMember.DeclaringType, propertyName); PropertyInstance prop = PropertyInstance.FindByTemplate(propertyInfo, true); MethodInstance m_get = prop != null ? prop.Getter : new MethodInstance(((MethodPropertyInfo)propertyInfo).Getter); MethodInstance m_set = prop != null ? prop.Setter : new MethodInstance(((MethodPropertyInfo)propertyInfo).Setter); FieldInstance f_objRefs = GetObjRefsFieldByPropertyName(propertyName); FieldInstance f_objRefs_existing = State.GetAlreadyImplementedField(f_objRefs.Name); FieldInstance f_initialized = GetInitializedFieldByPropertyName(propertyName); FieldInstance f_initialized_existing = State.GetAlreadyImplementedField(f_initialized.Name); if (f_objRefs_existing == null) { f_objRefs_existing = ImplementField(f_objRefs); ImplementGetter(new MethodInstance(null, MethodAttributes.Public, f_objRefs_existing.Type, "get_" + f_objRefs_existing.Name), f_objRefs_existing); ImplementSetter( new MethodInstance(null, MethodAttributes.Public, NewType.VOID_TYPE, "set_" + f_objRefs_existing.Name, f_objRefs_existing.Type), f_objRefs_existing); } if (f_initialized_existing == null) { f_initialized_existing = ImplementField(f_initialized); ImplementGetter(new MethodInstance(null, MethodAttributes.Public, f_initialized_existing.Type, "get_" + f_initialized_existing.Name), f_initialized_existing); ImplementSetter(new MethodInstance(null, MethodAttributes.Public, NewType.VOID_TYPE, "set_" + f_initialized_existing.Name, f_initialized_existing.Type), f_initialized_existing); } ImplementRelationGetter(propertyName, m_get, m_set, relationIndex, p_valueHolderContainerTemplate, p_targetCache, p_relationMembers, f_initialized_existing, f_objRefs_existing); ImplementRelationSetter(propertyName, m_set, f_initialized_existing, f_objRefs_existing); } }
public int Compare(NewType <NEWTYPE, A> mx, NewType <NEWTYPE, A> my) { if (ReferenceEquals(mx, my)) { return(0); } if (ReferenceEquals(mx, null)) { return(-1); } if (ReferenceEquals(my, null)) { return(1); } return(default(ORD).Compare((A)mx, (A)my)); }
public async Task <ActionResult <JobType> > CreateType(NewType newType) { var tenant = (await _tenantService.GetTenantFromHostAsync()); if (tenant != null) { Console.WriteLine($"creating type for {tenant.Id} : {tenant.Name}"); using (var context = _tenantService.CreateContext(tenant)) { var jobExtrasService = new JobExtrasService(context); return(Ok(await jobExtrasService.CreateJobType(newType))); } } return(BadRequest("Tenant doesn't exist")); }
protected void ImplementHashCodeMethod(PropertyInstance p_entityEqualsTemplate) { MethodInstance methodTemplate = new MethodInstance(null, typeof(Object), typeof(int), "GetHashCode"); MethodInstance method = MethodInstance.FindByTemplate(methodTemplate, true); if (NewType.GetType(typeof(Object)).Equals(method.Owner) || method.Access.HasFlag(MethodAttributes.Abstract)) { IMethodVisitor mg = VisitMethod(methodTemplate); mg.CallThisGetter(p_entityEqualsTemplate); mg.LoadThis(); mg.LoadArgs(); mg.InvokeVirtual(entityEquals_HashCode); mg.ReturnValue(); mg.EndMethod(); } }
/// <summary> /// Equality test /// </summary> /// <param name="x">The left hand side of the equality operation</param> /// <param name="y">The right hand side of the equality operation</param> /// <returns>True if x and y are equal</returns> public bool Equals(NewType <NEWTYPE, A> x, NewType <NEWTYPE, A> y) { if (ReferenceEquals(x, y)) { return(true); } if (ReferenceEquals(x, null)) { return(false); } if (ReferenceEquals(y, null)) { return(false); } return(default(EQ).Equals((A)x, (A)y)); }
private void PageInit() { if (action == "edit") { ltltitle.Text = "修改类别"; ddl_type.Text = "0"; NewType ClassItem = bll.GetNewTypeItem(classId); txt_ClassName.Text = ClassItem.ClassName; ddl_type.SelectedValue = ClassItem.ParentId.ToString(); txt_SortId.Value = ClassItem.SortId.ToString(); } else { ddl_type.SelectedValue = classId.ToString(); } }
private void CompareInterfaces() { IEnumerable <string> referenceInterfaces = ReferenceType.GetInterfaces().Select(@interface => @interface.GetCompareableName()).ToList(); IEnumerable <string> newInterfaces = NewType.GetInterfaces().Select(@interface => @interface.GetCompareableName()).ToList(); // missing interfaces foreach (string @interface in referenceInterfaces.Except(newInterfaces)) { ComparerResult.AddRemovedItem(ResultContext.Interface, @interface, Severity.Error); } // new interfaces foreach (string @interface in newInterfaces.Except(referenceInterfaces)) { ComparerResult.AddAddedItem(ResultContext.Interface, @interface, Severity.Warning); } }
static void Main(string[] args) { int TestNum = OnePlus(100); Console.WriteLine(TestNum); // NewType() 에 메서드 이름을 넣은것이 포인트! NewType aNewType = new NewType(OnePlus); // aNewType과 onePlus는 같아지는 거임 TestNum = aNewType(1000); // aNewType이 OnePlus에 값을 받음 Console.WriteLine(TestNum); aNewType = new NewType(TenPlus); TestNum = aNewType(1000); Console.WriteLine(TestNum); }
static void Main(string[] args) { using (var db = new NewContext()) { Console.WriteLine("请输入Name:"); var name = Console.ReadLine(); var newType = new NewType { Name = name }; db.NewTypes.Add(newType); db.SaveChanges(); Console.WriteLine("Save successfully"); Console.Read(); } }
public virtual void InvokeInterface(MethodInstance method) { if (method.Access.HasFlag(MethodAttributes.Static)) { throw new ArgumentException("Given method is not virtual: " + method); } NewType owner = method.Owner; if (owner == null) { InvokeVirtual(method.DeriveOwner()); } else { InvokeVirtual(method); } }
public virtual IMethodVisitor StartOverrideWithSuperCall(MethodInstance superMethod) { IBytecodeBehaviorState state = State; NewType superType = NewType.GetType(state.CurrentType); if (!superType.Equals(superMethod.Owner)) { throw new ArgumentException("Not a method of " + state.CurrentType + ": " + superMethod); } IMethodVisitor mg = VisitMethod(superMethod); mg.LoadThis(); mg.LoadArgs(); mg.InvokeSuper(superMethod); return(mg); }
protected override void InternalProcessRecord() { bool test = false; ShouldProcessReason reason; if (!base.ShouldProcess(null, null, null, out reason)) { if (reason == ShouldProcessReason.WhatIf) { test = true; } } string fileUrl = File.FileUrl; SetWebPart(fileUrl, OldType.Read(), NewType.Read(), Title, Properties, Publish, test); base.InternalProcessRecord(); }
public ProductType AddType(NewType newType) { using (var db = new SqlConnection(_connectionString)) { string selectQuery = @"INSERT Into ProductType (Name) OUTPUT inserted.* VALUES (@name)"; var parameters = new { name = newType.Name }; var productType = db.QueryFirstOrDefault <ProductType>(selectQuery, parameters); if (productType != null) { return(productType); } } throw new Exception("error getting product types"); }
public PropertyInstance(NewType owner, PropertyAttributes access, String propertyName, MethodInstance getter, MethodInstance setter) { this.owner = owner; this.access = access; this.name = propertyName; this.getter = getter; this.setter = setter; if (getter != null) { propertyType = getter.ReturnType; } else if (setter != null) { propertyType = setter.Parameters[0]; } else { throw new ArgumentException("Either a getter or a setter must be specified"); } }
protected void ImplementSelfGetter(PropertyInstance p_valueHolderContainerTemplate) { NewType owner = State.NewType; MethodInstance m_getSelf = new MethodInstance(owner, typeof(IValueHolderContainer), typeof(IObjRelation), "Get__Self", typeof(int)); { // public IObjRelation getSelf(String memberName) // { // return ValueHolderContainerTemplate.GetSelf(this, relationIndex); // } IMethodVisitor mv = VisitMethod(m_getSelf); mv.CallThisGetter(p_valueHolderContainerTemplate); // this mv.LoadThis(); // relationIndex mv.LoadArgs(); mv.InvokeVirtual(m_template_getSelf); mv.ReturnValue(); mv.EndMethod(); } }
protected override IList ExecuteCrawl(bool crawlAll) { IList list = new ArrayList(); //GetCorpStaffDui(crawlAll, list); //GetCorpStaffShuili(crawlAll, list); //GetCorpStaffXiao(crawlAll, list); NewType newType1 = new NewType(GetCorpStaffDui); IAsyncResult irr1 = newType1.BeginInvoke(crawlAll, list, null, null); NewType newTypw2 = new NewType(GetCorpStaffShuili); IAsyncResult irr2 = newTypw2.BeginInvoke(crawlAll, list, null, null); NewType newType3 = new NewType(GetCorpStaffXiao); IAsyncResult irr3 = newType3.BeginInvoke(crawlAll, list, null, null); NewMethod newMeth1 = new NewMethod(GetCorpStaffJzao); IAsyncResult ir1 = newMeth1.BeginInvoke(2, crawlAll, list, null, null); NewMethod newMeth2 = new NewMethod(GetCorpStaffJLi); IAsyncResult ir2 = newMeth2.BeginInvoke(3, crawlAll, list, null, null); NewMethod newMeth3 = new NewMethod(GetCorpStaffZJia); IAsyncResult ir3 = newMeth3.BeginInvoke(4, crawlAll, list, null, null); NewMethod newMeth4 = new NewMethod(GetCorpStaffZLZR); IAsyncResult ir4 = newMeth4.BeginInvoke(7, crawlAll, list, null, null); NewMethod newMeth5 = new NewMethod(GetCorpStaffAQZR); IAsyncResult ir5 = newMeth5.BeginInvoke(8, crawlAll, list, null, null); NewMethod newMeth6 = new NewMethod(GetCorpStaffXXXM); IAsyncResult ir6 = newMeth6.BeginInvoke(1, crawlAll, list, null, null); NewMethod newMeth7 = new NewMethod(GetCorpStaffJZGCS); IAsyncResult ir7 = newMeth7.BeginInvoke(5, crawlAll, list, null, null); NewMethod newMeth8 = new NewMethod(GetCorpStaffJGGCS); IAsyncResult ir8 = newMeth8.BeginInvoke(6, crawlAll, list, null, null); //GetCorpStaffJzao(2, crawlAll, list);//采集建造工程师 //GetCorpStaffJLi(3, crawlAll, list);//采集监理工程师 //GetCorpStaffZJia(4, crawlAll, list); //采集造价工程师 //GetCorpStaffZLZR(7, crawlAll, list);//采集质量主任 //GetCorpStaffAQZR(8, crawlAll, list);//采集安全主任 //GetCorpStaffXXXM(1, crawlAll, list);// 采集小型工程项目负责人 //GetCorpStaffJZGCS(5, crawlAll, list);// 采集建筑工程师 //GetCorpStaffJGGCS(6, crawlAll, list);//采集结构工程师 return(list); }
public virtual void InvokeVirtual(MethodInstance method) { if (method.Access.HasFlag(MethodAttributes.Static)) { throw new ArgumentException("Given method is not virtual: " + method); } NewType owner = method.Owner; if (owner == null) { owner = BytecodeBehaviorState.State.NewType; } if (method is ConstructorInstance) { gen.Emit(OpCodes.Callvirt, (ConstructorInfo)method.Method); } else { gen.Emit(OpCodes.Callvirt, (MethodInfo)method.Method); } }
protected void ImplementEmbeddedConstructor(FieldInstance f_parentObject, ConstructorInstance superConstructor) { if (superConstructor.Parameters.Length > 0 && superConstructor.Parameters[0].Equals(f_parentObject.Type)) { // super constructor already enhanced return; } bool baseIsEnhanced = false;//EntityEnhancer.IsEnhancedType(vs.CurrentType); NewType[] parameters = superConstructor.Parameters; NewType[] types; if (baseIsEnhanced) { // Only Pass-through constructors necessary. So signature remains the same types = null;//TypeUtil.GetClassesToTypes(..GetTypes(parameters); } else { types = new NewType[parameters.Length + 1]; for (int a = parameters.Length + 1; a-- > 1;) { types[a] = parameters[a - 1]; } types[0] = f_parentObject.Type; } IMethodVisitor mv = VisitMethod(new ConstructorInstance(MethodAttributes.Public, types)); mv.LoadThis(); for (int a = 1, size = types.Length; a < size; a++) { mv.LoadArg(a); // Load constructor argument one by one, starting with the 2nd constructor argument } mv.InvokeConstructor(superConstructor); mv.PutThisField(f_parentObject, delegate(IMethodVisitor mv2) { mv2.LoadArg(0); }); mv.ReturnValue(); mv.EndMethod(); }
public dlgNewLayer(NewType Type) { InitializeComponent(); this._type = Type; if (_type == NewType.Map) //Anpassen des Dialogs auf MAP - Standard ist LAYER! { this.Text = "New Map"; this.label_LayerHeight.Text = "Map Height"; this.label_LayerWidth.Text = "Map Width"; this.label_ParallaxHeaderString.Text = "The base parallax scrolling value is:"; this.groupBox_LayerDimensions.Text = "Map Dimensions"; this.groupBox_Scrolling.Text = "Base scrolling value"; this.button_AddLayer.Text = "Generate"; this.groupBox_LayerInformation.Text = "General map information"; } if (_type == NewType.EditLayer) //Anpassen des Dialogs auf MAP - Standard ist LAYER! { this.Text = "Edit Layer"; this.button_AddLayer.Text = "Save"; } }
public static T SetState <T>(Type originalType, Type currentType, NewType newType, IServiceContext beanContext, IEnhancementHint context, IResultingBackgroundWorkerDelegate <T> runnable) { IBytecodeBehaviorState oldState = stateTL.Value; stateTL.Value = new BytecodeBehaviorState(currentType, newType, originalType, beanContext, context); try { return(runnable.Invoke()); } finally { if (oldState != null) { stateTL.Value = oldState; } else { stateTL.Value = null; } } }
private void CompareTypes() { IEnumerable <string> referenceTypes = GetTypeNames(() => ReferenceType.DefinedTypes).ToList(); IEnumerable <string> newTypes = GetTypeNames(() => NewType.DefinedTypes).ToList(); // Missing types foreach (string type in referenceTypes.Except(newTypes)) { ComparerResult.AddRemovedItem(GetItemType(ReferenceType.GetType(type)), type, Severities.TypeRemoved); } // New types foreach (string type in newTypes.Except(referenceTypes)) { ComparerResult.AddAddedItem(GetItemType(NewType.GetType(type)), type, Severities.TypeAdded); } // Equal types foreach (string type in referenceTypes.Intersect(newTypes)) { ComparerResult.AddComparerResult(ComparerContext.CreateComparer(ReferenceType.GetType(type), NewType.GetType(type)).Compare()); } }
public override IComparerResult Compare() { ComparerContext.LogDetail(string.Format("Comparing field '{0}'", ReferenceType)); if (ReferenceType.FieldType.GetCompareableName() != NewType.FieldType.GetCompareableName()) { ComparerResult.AddChangedProperty("Type", ReferenceType.FieldType.GetCompareableName(), NewType.FieldType.GetCompareableName(), Severity.Error); } if (ReferenceType.IsStatic != NewType.IsStatic) { ComparerResult.AddChangedFlag("Static", ReferenceType.IsStatic, Severity.Error); } if (ReferenceType.IsStatic && NewType.IsStatic && ReferenceType.FieldType.IsEnum) { // compare numeric enum values object referenceValue = ReferenceType.GetRawConstantValue(); object newValue = NewType.GetRawConstantValue(); if (Convert.ToInt32(referenceValue) != Convert.ToInt32(newValue)) { ComparerResult.AddChangedProperty("Value", referenceValue.ToString(), newValue.ToString(), Severity.Error); } } return(ComparerResult); }
protected void ImplementToString() { PropertyInstance p_objRefTemplate = GetObjRefTemplatePI(this); MethodInstance methodSb; { methodSb = MethodInstance.FindByTemplate(template_m_toStringSb, true); if (methodSb == null || methodSb.Access.HasFlag(MethodAttributes.Abstract)) { IMethodVisitor mg = VisitMethod(template_m_toStringSb); mg.CallThisGetter(p_objRefTemplate); mg.LoadThis(); mg.LoadArgs(); mg.InvokeVirtual(m_objRef_toStringSb); mg.ReturnValue(); mg.EndMethod(); methodSb = mg.Method; } } { MethodInstance method = MethodInstance.FindByTemplate(template_m_toString, true); if (method == null || NewType.GetType(typeof(Object)).Equals(method.Owner) || methodSb.Access.HasFlag(MethodAttributes.Abstract)) { IMethodVisitor mg = VisitMethod(template_m_toString); LocalVariableInfo loc_sb = mg.NewLocal(typeof(StringBuilder)); mg.LoadThis(); mg.NewInstance(c_stringBuilder, null); mg.StoreLocal(loc_sb); mg.LoadLocal(loc_sb); mg.InvokeVirtual(methodSb); mg.LoadLocal(loc_sb); mg.InvokeVirtual(new MethodInstance(null, typeof(StringBuilder), typeof(String), "ToString")); mg.ReturnValue(); mg.EndMethod(); } } }
public ActionResult NewMetricType(NewType newType) { string JsonQuery = "{" + "\"MetricClassId\":\"" + newType.MetricClassId + "\"," + "\"MetricType\":\"" + newType.MetricType + "\"," + "\"MetricUnitId\":\"" + newType.MetricUnitId + "\"," + "}"; JObject jObj = QueryMicroService(CreateNewMetricTypeEndpoint, "POST", JsonQuery); string message = ""; if (jObj["status"].ToString() == "OK") { message = "New type created successfully!"; } else { message = $"Failed to create new type.\n{jObj["result"].ToString()}"; } return(Json(new { message }, JsonRequestBehavior.AllowGet)); }