public NetConstructor(Db4objects.Db4o.Reflect.IReflector reflector, System.Reflection.ConstructorInfo constructor) { this.reflector = reflector; this.constructor = constructor; Db4objects.Db4o.Internal.Platform4.SetAccessible(constructor); }
/// <summary> /// Create an <see cref="IEnumerable"/> wrapper over an <see cref="IDataReader"/>. /// </summary> /// <param name="reader">The <see cref="IDataReader"/> to enumerate over.</param> /// <param name="cmd">The <see cref="IDbCommand"/> used to create the <see cref="IDataReader"/>.</param> /// <param name="sess">The <see cref="ISession"/> to use to load objects.</param> /// <param name="types">The <see cref="IType"/>s contained in the <see cref="IDataReader"/>.</param> /// <param name="columnNames">The names of the columns in the <see cref="IDataReader"/>.</param> /// <param name="selection">The <see cref="RowSelection"/> that should be applied to the <see cref="IDataReader"/>.</param> /// <param name="holderType">Optional type of the result holder (used for "select new SomeClass(...)" queries).</param> /// <remarks> /// The <see cref="IDataReader"/> should already be positioned on the first record in <see cref="RowSelection"/>. /// </remarks> public EnumerableImpl( IDataReader reader, IDbCommand cmd, ISessionImplementor sess, IType[ ] types, string[ ][ ] columnNames, RowSelection selection, System.Type holderType ) { _reader = reader; _cmd = cmd; _sess = sess; _types = types; _names = columnNames; _selection = selection; if( holderType != null ) { _holderConstructor = NHibernate.Util.ReflectHelper.GetConstructor( holderType, types ); } _single = _types.Length == 1; }
public void DisplayConstructorProperties(System.Reflection.ConstructorInfo constructorInfo) { ThisConstructor = constructorInfo;//store the constructor information Label2.Text = ThisConstructor.Name;//display constructor name //calling convention output to textbox Label4.Text = "0x" + ThisConstructor.CallingConvention.ToString("x") + " = " + ThisConstructor.CallingConvention.ToString(); //standard attributes to textbox Label6.Text = "0x" + ThisConstructor.Attributes.ToString("x") + " = " + ThisConstructor.Attributes.ToString(); //constructor parameters foreach (System.Reflection.ParameterInfo parm in ThisConstructor.GetParameters()) { ListBox1.Items.Add(parm); } //display custom attributes foreach (object attr in ThisConstructor.GetCustomAttributes(true)) { ListBox2.Items.Add(attr); } }
public void SetCustomAttribute(System.Reflection.ConstructorInfo con, byte[] binaryAttribute) { throw new PlatformNotSupportedException(); }
public CustomAttributeBuilder(System.Reflection.ConstructorInfo con, object?[] constructorArgs, System.Reflection.PropertyInfo[] namedProperties, object?[] propertyValues, System.Reflection.FieldInfo[] namedFields, object?[] fieldValues) { }
public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Reflection.ConstructorInfo con) { }
public NewExpression(System.Reflection.ConstructorInfo constructor, IEnumerable <Expression> arguments = null, IEnumerable <System.Reflection.MemberInfo> members = null) : this(new ConstructorInfo(constructor), arguments, ReferenceEquals(null, members) ? null : members.Select(x => MemberInfo.Create(x))) { }
/// <summary> /// 加载程序集信息 /// </summary> /// <returns></returns> public bool EnsureLoadAssembly() { if (constInfo != null) return true; System.Type tp = null; State = ServiceState.NotInstalled; if (string.IsNullOrEmpty(Assembly)) { try { tp = System.Type.GetType(TypeName); } catch (Exception) { return false; } } else { string file = LocateAssemblyPath(Assembly); if (file == null) return false; try { tp = System.Reflection.Assembly.LoadFile(file).GetType(TypeName); } catch (Exception) { return false; } } State = ServiceState.LoadingError; if (tp == null) return false; //获得插件的信息 object[] infos = tp.GetCustomAttributes(typeof(ServiceAttribute), true); if (infos != null && infos.Length > 0) { this.ServiceDescription = (infos[0] as ServiceAttribute).Description; } else { this.ServiceDescription = new ServiceDescription("未知", "未知", tp.Name, "未知", tp.FullName); } if ((constInfo = tp.GetConstructor(System.Type.EmptyTypes)) == null) return false; State = ServiceState.TypeLoaded; return true; }
internal NewArrayExpression(Type type, ReadOnlyCollection<Expression> expressions) : base(AstNodeType.NewArrayExpression) { _type = type; _expressions = expressions; _constructor = _type.GetConstructor(new Type[] { typeof(int) }); }
/// <summary> /// Creates a new object or a new instance of a value type, pushing an object reference (type O) /// onto the evaluation stack. /// </summary> /// <param name="il">The instance of <see cref="ILGenerator"/>.</param> /// <param name="constructorInfo">The constructor of the type.</param> /// <returns>The instance of <see cref="ILGenerator"/>.</returns> public static System.Reflection.Emit.ILGenerator Newobj(this System.Reflection.Emit.ILGenerator il, System.Reflection.ConstructorInfo constructorInfo) { il.Emit(System.Reflection.Emit.OpCodes.Newobj, constructorInfo); return(il); }
private dynamic ParseCollection(Type t, STEPParser.CollectionContext value) { // Ex: #25 = IFCDIRECTION((1., 0., 0.)); // IfcDirection takes a List<double> as its input parameters, so we get the type argument - double - and // do the coercion for all the items. // Ex: #31 = IFCSITE('3BoQ8L5UXBEOT1kW0PLzej', #2, 'Default Site', 'Description of Default Site', $, #32, $, $, .ELEMENT., (24, 28, 0), (54, 25, 0), 10., $, $); // IfcSite takes two IfcCompoundPlaneMeasure objects. It seems that some IFC exporters will not specify a type's constructor, they'll just // specify the arguments as a collection. Type collectionType; System.Reflection.ConstructorInfo ctor = null; var ctorChain = new List <System.Reflection.ConstructorInfo>(); if (t.IsGenericType) { collectionType = t.GetGenericArguments()[0]; } else { ctor = GetConstructorForType(t, ref ctorChain); collectionType = ctor.GetParameters()[0].ParameterType.GetGenericArguments()[0]; } var result = new List <object>(); foreach (var cv in value.collectionValue()) { if (cv.Id() != null) { result.Add(ParseId(cv.Id().GetText())); } else if (cv.AnyString() != null) { result.Add(ParseString(collectionType, cv.AnyString().GetText())); } else if (cv.StringLiteral() != null) { result.Add(ParseString(collectionType, cv.StringLiteral().GetText())); } else if (cv.IntegerLiteral() != null) { result.Add(ParseInt(collectionType, cv.IntegerLiteral().GetText())); } else if (cv.RealLiteral() != null) { result.Add(ParseReal(collectionType, cv.RealLiteral().GetText())); } else if (cv.constructor() != null) { result.Add(ParseConstructor(currId, cv.constructor())); } } if (ctor != null) { return(new InstanceData(-1, t, new List <object>() { result }, ctor, ctorChain)); } return(result); }
public static System.Reflection.ConstructorInfo GetConstructor(System.Type type, System.Reflection.ConstructorInfo constructor) { return(default(System.Reflection.ConstructorInfo)); }
/// <summary> /// Calls a method on this variable /// </summary> /// <param name="Method">Method</param> /// <param name="Parameters">Parameters sent in</param> /// <returns>Variable returned by the function (if one exists, null otherwise)</returns> public virtual void Call(System.Reflection.ConstructorInfo Method, object[] Parameters = null) { Contract.Requires<ArgumentNullException>(Method!=null,"Method"); MethodBase.CurrentMethod.Call(this, Method, Parameters); }
public static Microsoft.Extensions.DiagnosticAdapter.Internal.ProxyTypeCacheResult FromType(System.Tuple <System.Type, System.Type> key, System.Type type, System.Reflection.ConstructorInfo constructor) { throw null; }
static public void Emit(this MethodBody body, OpCode instruction, ConstructorInfo constructor) { body.Add(Instruction.Create(instruction, body.Method.DeclaringType.Module.Import(constructor))); }
public bool Is <T>() where T : class { System.Reflection.ConstructorInfo ctor = typeof(T).GetConstructors()[0]; System.Type paramType = ctor.GetParameters()[0].ParameterType; return(paramType.IsInstanceOfType(this.WrappedObject)); }
SqlMapper.IMemberMap SqlMapper.ITypeMap.GetConstructorParameter(System.Reflection.ConstructorInfo constructor, string columnName) { return(null); }
static SqlExceptionInstantiator() { constructor = typeof(System.Data.SqlClient.SqlException).GetConstructor ( System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, new System.Type[] { typeof(string), typeof(System.Data.SqlClient.SqlErrorCollection) }, null ); return; }
private void startService(string service, string entryPoint, string[] args) { lock (this) { // // Extract the assembly name and the class name. // string err = "ServiceManager: unable to load service '" + entryPoint + "': "; int sepPos = entryPoint.IndexOf(':'); if (sepPos != -1) { const string driveLetters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; if (entryPoint.Length > 3 && sepPos == 1 && driveLetters.IndexOf(entryPoint[0]) != -1 && (entryPoint[2] == '\\' || entryPoint[2] == '/')) { sepPos = entryPoint.IndexOf(':', 3); } } if (sepPos == -1) { FailureException e = new FailureException(); e.reason = err + "invalid entry point format"; throw e; } System.Reflection.Assembly serviceAssembly = null; string assemblyName = entryPoint.Substring(0, sepPos); string className = entryPoint.Substring(sepPos + 1); try { // // First try to load the assembly using Assembly.Load, which will succeed // if a fully-qualified name is provided or if a partial name has been qualified // in configuration. If that fails, try Assembly.LoadFrom(), which will succeed // if a file name is configured or a partial name is configured and DEVPATH is used. // try { serviceAssembly = System.Reflection.Assembly.Load(assemblyName); } catch (Exception ex) { try { serviceAssembly = System.Reflection.Assembly.LoadFrom(assemblyName); } catch (Exception) { throw ex; } } } catch (Exception ex) { FailureException e = new FailureException(ex); e.reason = err + "unable to load assembly: " + assemblyName; throw e; } // // Instantiate the class. // Type c = null; try { c = serviceAssembly.GetType(className, true); } catch (Exception ex) { FailureException e = new FailureException(ex); e.reason = err + "GetType failed for '" + className + "'"; throw e; } ServiceInfo info = new ServiceInfo(); info.name = service; info.status = ServiceStatus.Stopped; info.args = args; // // If IceBox.UseSharedCommunicator.<name> is defined, create a // communicator for the service. The communicator inherits // from the shared communicator properties. If it's not // defined, add the service properties to the shared // commnunicator property set. // Ice.Communicator communicator; if (_communicator.getProperties().getPropertyAsInt("IceBox.UseSharedCommunicator." + service) > 0) { Debug.Assert(_sharedCommunicator != null); communicator = _sharedCommunicator; } else { // // Create the service properties. We use the communicator properties as the default // properties if IceBox.InheritProperties is set. // Ice.InitializationData initData = new Ice.InitializationData(); initData.properties = createServiceProperties(service); if (info.args.Length > 0) { // // Create the service properties with the given service arguments. This should // read the service config file if it's specified with --Ice.Config. // initData.properties = Ice.Util.createProperties(ref info.args, initData.properties); // // Next, parse the service "<service>.*" command line options (the Ice command // line options were parsed by the createProperties above) // info.args = initData.properties.parseCommandLineOptions(service, info.args); } // // Clone the logger to assign a new prefix. If one of the built-in loggers is configured // don't set any logger. // if (initData.properties.getProperty("Ice.LogFile").Length == 0) { initData.logger = _logger.cloneWithPrefix(initData.properties.getProperty("Ice.ProgramName")); } // // If Admin is enabled on the IceBox communicator, for each service that does not set // Ice.Admin.Enabled, we set Ice.Admin.Enabled=1 to have this service create facets; then // we add these facets to the IceBox Admin object as IceBox.Service.<service>.<facet>. // string serviceFacetNamePrefix = "IceBox.Service." + service + "."; bool addFacets = configureAdmin(initData.properties, serviceFacetNamePrefix); // // Remaining command line options are passed to the communicator. This is // necessary for Ice plug-in properties (e.g.: IceSSL). // info.communicator = Ice.Util.initialize(ref info.args, initData); communicator = info.communicator; if (addFacets) { // Add all facets created on the service communicator to the IceBox communicator // but renamed IceBox.Service.<service>.<facet-name>, except for the Process facet // which is never added foreach (KeyValuePair <string, Ice.Object> p in communicator.findAllAdminFacets()) { if (!p.Key.Equals("Process")) { _communicator.addAdminFacet(p.Value, serviceFacetNamePrefix + p.Key); } } } } try { // // Instantiate the service. // try { // // If the service class provides a constructor that accepts an Ice.Communicator argument, // use that in preference to the default constructor. // Type[] parameterTypes = new Type[1]; parameterTypes[0] = typeof(Ice.Communicator); System.Reflection.ConstructorInfo ci = c.GetConstructor(parameterTypes); if (ci != null) { try { object[] parameters = new object[1]; parameters[0] = _communicator; info.service = (Service)ci.Invoke(parameters); } catch (MethodAccessException ex) { FailureException e = new FailureException(ex); e.reason = err + "unable to access service constructor " + className + "(Ice.Communicator)"; throw e; } } else { // // Fall back to the default constructor. // try { info.service = (Service)IceInternal.AssemblyUtil.createInstance(c); if (info.service == null) { FailureException e = new FailureException(); e.reason = err + "no default constructor for '" + className + "'"; throw e; } } catch (UnauthorizedAccessException ex) { FailureException e = new FailureException(ex); e.reason = err + "unauthorized access to default service constructor for " + className; throw e; } } } catch (FailureException) { throw; } catch (InvalidCastException ex) { FailureException e = new FailureException(ex); e.reason = err + "service does not implement IceBox.Service"; throw e; } catch (System.Reflection.TargetInvocationException ex) { if (ex.InnerException is FailureException) { throw ex.InnerException; } else { FailureException e = new FailureException(ex.InnerException); e.reason = err + "exception in service constructor for " + className; throw e; } } catch (Exception ex) { FailureException e = new FailureException(ex); e.reason = err + "exception in service constructor " + className; throw e; } try { info.service.start(service, communicator, info.args); } catch (FailureException) { throw; } catch (Exception ex) { FailureException e = new FailureException(ex); e.reason = "exception while starting service " + service; throw e; } info.status = ServiceStatus.Started; _services.Add(info); } catch (Exception) { if (info.communicator != null) { destroyServiceCommunicator(service, info.communicator); } throw; } } }
public System.Reflection.Emit.MethodToken GetConstructorToken(System.Reflection.ConstructorInfo constructor, System.Collections.Generic.IEnumerable <System.Type> optionalParameterTypes) { throw new PlatformNotSupportedException(); }
/*=========================*/ #endregion #region Private Methods /*=========================*/ /// <summary> /// Fills DB with data that retrieved by EasyForex BackOffice /// </summary> /// <param name="dataFromBO">Data from BackOffice to write to DB.</param> private void ProcessData(string xmlPath, DateTime _requiredDay) { SqlCommand insertCommand = InitalizeInsertCommand(); using (ConnectionKey key = DataManager.Current.OpenConnection()) { // Init insertCommand with the data manger connection DataManager.ApplyConnection(insertCommand); // Yaniv: add Exception ///////////////////// Type t = Type.GetType(Instance.Configuration.Options["BackOfficeXmlReader"]); System.Reflection.ConstructorInfo constructor = t.GetConstructor(new Type[] { typeof(string) }); //if (constructor == null) // throw new blahl //BackOfficeXmlReader reader = (BackOfficeXmlReader) constructor.Invoke(new object[] { xmlPath }); //////////////////// //EasyForexReader reader = new EasyForexReader(xmlPath); // Initalize const parmaters. insertCommand.Parameters["@Downloaded_Date"].Value = DateTime.Now; insertCommand.Parameters["@day_Code"].Value = DayCode(_requiredDay); insertCommand.Parameters["@hour_Code"].Value = DayCode(_requiredDay) == DayCode(DateTime.Today) ? DateTime.Now.Hour : 0; insertCommand.Parameters["@account_ID"].Value = Instance.AccountID; //insertCommand.Parameters["@channel_ID"].Value = ChannelID; using (EasyForexReader reader = (EasyForexReader)constructor.Invoke(new object[] { xmlPath })) { // Read all rows in the BackOffice XML and insert them to the DB. while (reader.Read()) { if (reader.CurrentRow.GatewayID == 0) { Log.Write("Error parsing BackOffice row, Can't insert row to DB.", LogMessageType.Error); continue; } InitalizeParametersWithNull(insertCommand); // Initalize command parmaters. insertCommand.Parameters["@gateway_id"].Value = reader.CurrentRow.GatewayID; insertCommand.Parameters["@total_Hits"].Value = reader.CurrentRow.TotalHits; insertCommand.Parameters["@new_Leads"].Value = reader.CurrentRow.NewLeads; insertCommand.Parameters["@new_Users"].Value = reader.CurrentRow.NewUsers; insertCommand.Parameters["@new_Active_Users"].Value = reader.CurrentRow.NewActiveUsers; insertCommand.Parameters["@new_Net_Deposits_in_dollars"].Value = reader.CurrentRow.NewNetDepostit; insertCommand.Parameters["@active_Users"].Value = reader.CurrentRow.ActiveUsers; insertCommand.Parameters["@total_Net_Deposits_in_dollars"].Value = reader.CurrentRow.TotalNetDeposit; insertCommand.Parameters["@Gateway_GK"].Value = GkManager.GetGatewayGK(Instance.AccountID, reader.CurrentRow.GatewayID); try { // Execute command. insertCommand.ExecuteNonQuery(); } catch (Exception ex) { Log.Write(string.Format("Error in Inserting data to BackOffice_Client_Gateway table in easynet_Oltp DB."), ex); } } } } }
// OBJECTS, METHODS, TYPES AND FIELDS //_________________________________________________________________________________________ /// <summary> /// Pops the constructor arguments off the stack and creates a new instance of the object. /// </summary> /// <param name="constructor"> The constructor that is used to initialize the object. </param> public override void NewObject(System.Reflection.ConstructorInfo constructor) { this.m_generator.Emit(OpCodes.Newobj, constructor); }
/// <summary> /// Returns a friendly strign representation of this instruction /// </summary> /// <returns></returns> public string GetCode() { string result = ""; result += GetExpandedOffset(offset) + " : " + code; if (operand != null) { switch (code.OperandType) { case OperandType.InlineField: System.Reflection.FieldInfo fOperand = ((System.Reflection.FieldInfo)operand); result += " " + Globals.ProcessSpecialTypes(fOperand.FieldType.ToString()) + " " + Globals.ProcessSpecialTypes(fOperand.ReflectedType.ToString()) + "::" + fOperand.Name + ""; break; case OperandType.InlineMethod: try { System.Reflection.MethodInfo mOperand = (System.Reflection.MethodInfo)operand; result += " "; if (!mOperand.IsStatic) { result += "instance "; } result += Globals.ProcessSpecialTypes(mOperand.ReturnType.ToString()) + " " + Globals.ProcessSpecialTypes(mOperand.ReflectedType.ToString()) + "::" + mOperand.Name + "()"; } catch { try { System.Reflection.ConstructorInfo mOperand = (System.Reflection.ConstructorInfo)operand; result += " "; if (!mOperand.IsStatic) { result += "instance "; } result += "void " + Globals.ProcessSpecialTypes(mOperand.ReflectedType.ToString()) + "::" + mOperand.Name + "()"; } catch { } } break; case OperandType.ShortInlineBrTarget: case OperandType.InlineBrTarget: result += " " + GetExpandedOffset((int)operand); break; case OperandType.InlineType: result += " " + Globals.ProcessSpecialTypes(operand.ToString()); break; case OperandType.InlineString: if (operand.ToString() == "\r\n") { result += " \"\\r\\n\""; } else { result += " \"" + operand.ToString() + "\""; } break; case OperandType.ShortInlineVar: result += operand.ToString(); break; case OperandType.InlineI: case OperandType.InlineI8: case OperandType.InlineR: case OperandType.ShortInlineI: case OperandType.ShortInlineR: result += operand.ToString(); break; case OperandType.InlineTok: if (operand is Type) { result += ((Type)operand).FullName; } else { result += "not supported"; } break; default: result += "not supported"; break; } } return(result); }
/// <summary>Puts the specified instruction and metadata token for the specified constructor onto the Microsoft intermediate language (MSIL) stream of instructions.</summary> /// <param name="opcode">The MSIL instruction to be emitted onto the stream. </param> /// <param name="con">A ConstructorInfo representing a constructor. </param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="con" /> is null. This exception is new in the .NET Framework 4.</exception> /// <param name="generator">The <see cref="T:System.Reflection.Emit.XsILGenerator" /> to emit instructions from</param> public static XsILGenerator FluentEmit(this XsILGenerator generator, System.Reflection.Emit.OpCode opcode, System.Reflection.ConstructorInfo con) { generator.Emit(opcode, con); return(generator); }
/// <summary> /// Outputs an instruction and a constructor to the log. /// </summary> /// <param name="instruction"> The instruction to output. </param> /// <param name="constructor"> The constructor to output. </param> private void Log(string instruction, System.Reflection.ConstructorInfo constructor) { LogInstruction(instruction, string.Format("{0}/{1}", constructor, constructor.DeclaringType)); }
public CustomAttributeBuilder(System.Reflection.ConstructorInfo con, object?[] constructorArgs) { }
// OBJECTS, METHODS, TYPES AND FIELDS //_________________________________________________________________________________________ /// <summary> /// Pops the constructor arguments off the stack and creates a new instance of the object. /// </summary> /// <param name="constructor"> The constructor that is used to initialize the object. </param> public override void NewObject(System.Reflection.ConstructorInfo constructor) { Log("newobj", constructor); this.m_generator.NewObject(constructor); }
public void SetCustomAttribute(System.Reflection.ConstructorInfo con, byte[] binaryAttribute) { }
public void SetCustomAttribute(System.Reflection.ConstructorInfo !con, Byte[] !binaryAttribute) { CodeContract.Requires(con != null); CodeContract.Requires(binaryAttribute != null); }
public static WorldEditBlock Create(Block block, Vector3i originalPosition, Vector3i offsetPosition) { Vector3i relativePosition = originalPosition - offsetPosition; WorldEditBlock worldEditBlock = new WorldEditBlock(); worldEditBlock.Position = relativePosition; worldEditBlock.OffsetPosition = offsetPosition; worldEditBlock.OriginalPosition = originalPosition; worldEditBlock.BlockType = block.GetType(); switch (block) { case PlantBlock plantBlock: case TreeBlock treeBlock: //Log.Debug($"{worldEditBlock.BlockType.ToString()} at {originalPosition} is a PlantBlock or TreeBlock"); Plant plant = EcoSim.PlantSim.GetPlant(originalPosition); if (plant != null) { worldEditBlock.Position = plant.Position.XYZi - offsetPosition; worldEditBlock.BlockData = WorldEditPlantBlockData.From(plant); } else { worldEditBlock.BlockType = typeof(EmptyBlock); } break; case WorldObjectBlock objectBlock: //Log.Debug($"{worldEditBlock.BlockType.ToString()} at {originalPosition} is a WorldObjectBlock"); WorldObject worldObject = objectBlock.WorldObjectHandle.Object; worldEditBlock.BlockData = WorldEditWorldObjectBlockData.From(worldObject); relativePosition = worldObject.Position3i - offsetPosition; worldEditBlock.Position = relativePosition; break; case EmptyBlock emptyBlock: //Log.Debug($"{worldEditBlock.BlockType.ToString()} at {originalPosition} is a EmptyBlock"); break; default: //Log.Debug($"{worldEditBlock.BlockType.ToString()} at {originalPosition} is a Block"); System.Reflection.ConstructorInfo constuctor = worldEditBlock.BlockType.GetConstructor(Type.EmptyTypes); if (constuctor == null) { throw new ArgumentOutOfRangeException(message: "Block type is not supported", paramName: worldEditBlock.BlockType.FullName); } if (BlockContainerManager.Obj.IsBlockContained(originalPosition)) { worldEditBlock.BlockType = typeof(EmptyBlock); WorldObject obj = ServiceHolder <IWorldObjectManager> .Obj.All.Where(x => x.Position3i.Equals(originalPosition)).FirstOrDefault(); if (obj != null) { worldEditBlock.BlockType = typeof(WorldObjectBlock); worldEditBlock.BlockData = WorldEditWorldObjectBlockData.From(obj); relativePosition = obj.Position3i - offsetPosition; worldEditBlock.Position = relativePosition; } } break; } return(worldEditBlock); }
public void SetCustomAttribute(System.Reflection.ConstructorInfo con, System.Byte[] binaryAttribute) => throw null;
public ConstructorMetadata(System.Reflection.ConstructorInfo constructor) { // TODO: Complete member initialization this.constructor = constructor; }
public static ImageResource CreateResource(Type type) { System.Reflection.ConstructorInfo ci = type.GetConstructor(new Type[] { }); return (ImageResource)ci.Invoke(new object[] { }); }
public virtual System.Reflection.ConstructorInfo GetConstructorInfo() { if(this.constructorInfo == null) { if(this.DeclaringType == null) return null; Type t = this.DeclaringType.GetRuntimeType(); if(t == null) return null; ParameterList pars = this.Parameters; int n = pars == null ? 0 : pars.Count; Type[] types = new Type[n]; for(int i = 0; i < n; i++) { Parameter p = pars[i]; if(p == null || p.Type == null) return null; Type pt = types[i] = p.Type.GetRuntimeType(); if(pt == null) return null; } System.Reflection.MemberInfo[] members = t.GetMember(this.Name.ToString(), System.Reflection.MemberTypes.Constructor, BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); foreach(System.Reflection.ConstructorInfo cons in members) { if(cons == null) continue; System.Reflection.ParameterInfo[] parameters = cons.GetParameters(); int numPars = parameters == null ? 0 : parameters.Length; if(numPars != n) continue; if(parameters != null) for(int i = 0; i < n; i++) { System.Reflection.ParameterInfo par = parameters[i]; if(par == null || par.ParameterType != types[i]) goto tryNext; } return this.constructorInfo = cons; tryNext: ; } } return this.constructorInfo; }
private void AddFilter(IDeviceFilter filter, bool isReadonly) { this.RowCount++; this.RowStyles.Add(new RowStyle()); Type typControl = this.m_Application.GetControlType(filter.GetType(), typeof(System.Windows.Forms.Control)); if (typControl == null) { Label lab = new Label(); lab.Text = "未发现 " + filter.GetType().FullName + " 的筛选器控件"; lab.AutoEllipsis = true; lab.Padding = new System.Windows.Forms.Padding(3); lab.Dock = DockStyle.Bottom; this.Controls.Add(lab); if (this.EnabledRemove) { System.Windows.Forms.Button btnFilterRemove = new Button(); btnFilterRemove.Image = Properties.Resources.DeleteBlack; btnFilterRemove.Width = 24; btnFilterRemove.FlatStyle = FlatStyle.Flat; btnFilterRemove.FlatAppearance.BorderSize = 0; btnFilterRemove.Dock = DockStyle.Right; btnFilterRemove.Click += new EventHandler(btnFilterRemove_Click); this.Controls.Add(btnFilterRemove); } } else { System.Reflection.ConstructorInfo ciFilter = typControl.GetConstructor(new System.Type[] { }); object objFilterInstance = ciFilter.Invoke(new object[] { }); IDeviceFilterControl _FilterControl = objFilterInstance as IDeviceFilterControl; _FilterControl.SetApplication(this.m_Application); if (objFilterInstance is IUseAccount) { IUseAccount useAccount = objFilterInstance as IUseAccount; useAccount.SetAccount(this.m_Account); } _FilterControl.SetFilter(filter); Control ctl = objFilterInstance as Control; ctl.Dock = DockStyle.Bottom; if (isReadonly) { ctl.Enabled = false; } this.Controls.Add(ctl); if (this.EnabledRemove) { if (isReadonly) { Control ctlButton = new Control(); this.Controls.Add(ctlButton); } else { System.Windows.Forms.Button btnFilterRemove = new Button(); btnFilterRemove.Image = Properties.Resources.DeleteBlack; btnFilterRemove.Width = 24; btnFilterRemove.FlatStyle = FlatStyle.Flat; btnFilterRemove.FlatAppearance.BorderSize = 0; btnFilterRemove.Dock = DockStyle.Right; btnFilterRemove.Click += new EventHandler(btnFilterRemove_Click); this.Controls.Add(btnFilterRemove); } } } }
static SqlErrorCollectionInstantiator() { constructor = typeof(System.Data.SqlClient.SqlErrorCollection).GetConstructor ( System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, new System.Type[] { }, null ); add = typeof(System.Data.SqlClient.SqlErrorCollection).GetMethod ( "Add", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance ); return; }
/// <summary> Instantiates an LdapControl. We search through our list of /// registered controls. If we find a matchiing OID we instantiate /// that control by calling its contructor. Otherwise we default to /// returning a regular LdapControl object /// /// </summary> private LdapControl controlFactory(System.String oid, bool critical, sbyte[] value_Renamed) { // throw new NotImplementedException(); RespControlVector regControls = LdapControl.RegisteredControls; try { /* * search through the registered extension list to find the * response control class */ System.Type respCtlClass = regControls.findResponseControl(oid); // Did not find a match so return default LDAPControl if (respCtlClass == null) { return(new LdapControl(oid, critical, value_Renamed)); } /* If found, get LDAPControl constructor */ System.Type[] argsClass = new System.Type[] { typeof(System.String), typeof(bool), typeof(sbyte[]) }; System.Object[] args = new System.Object[] { oid, critical, value_Renamed }; System.Exception ex = null; try { System.Reflection.ConstructorInfo ctlConstructor = respCtlClass.GetConstructor(argsClass); try { /* Call the control constructor for a registered Class*/ System.Object ctl = null; // ctl = ctlConstructor.newInstance(args); ctl = ctlConstructor.Invoke(args); return((LdapControl)ctl); } catch (System.UnauthorizedAccessException e) { ex = e; } catch (System.Reflection.TargetInvocationException e) { ex = e; } catch (System.Exception e) { // Could not create the ResponseControl object // All possible exceptions are ignored. We fall through // and create a default LDAPControl object ex = e; } } catch (System.MethodAccessException e) { // bad class was specified, fall through and return a // default LDAPControl object ex = e; } } catch (System.FieldAccessException e) { // No match with the OID // Do nothing. Fall through and construct a default LDAPControl object. } // If we get here we did not have a registered response control // for this oid. Return a default LDAPControl object. return(new LdapControl(oid, critical, value_Renamed)); }
internal ConstructorInfoImpl(System.Reflection.ConstructorInfo constructor) { Debug.Assert(constructor != null); this.Constructor = constructor; }
public EmbeddedType(Type type, System.Reflection.ConstructorInfo ctor, PropertyAttributes attrs) { Type = type; Ctor = ctor; Attributes = attrs; }
//TODO: Возможно объеденить с compiled_function_node private compiled_constructor_node(System.Reflection.ConstructorInfo con_info) { _con_info=con_info; compiled_constructors[con_info] = this; //type_node ret_val=null; System.Reflection.ParameterInfo[] pinf=_con_info.GetParameters(); parameter_list pal=new parameter_list(); foreach(System.Reflection.ParameterInfo pi in pinf) { Type t=null; type_node par_type=null; SemanticTree.parameter_type pt=SemanticTree.parameter_type.value; if (pi.ParameterType.IsByRef) { t=pi.ParameterType.GetElementType(); par_type=compiled_type_node.get_type_node(t); pt=SemanticTree.parameter_type.var; } else { par_type=compiled_type_node.get_type_node(pi.ParameterType); } string name=pi.Name; compiled_parameter crpar=new compiled_parameter(pi); crpar.SetParameterType(pt); pal.AddElement(crpar); if (pi.IsOptional && pi.DefaultValue != null) _num_of_default_parameters++; } this.return_value_type=compiled_type_node.get_type_node(_con_info.DeclaringType); this.parameters.AddRange(pal); }
private System.ComponentModel.Design.Serialization.InstanceDescriptor ConvertToInstanceDescriptor(OleDbParameter p) { int flags = 0; if (p.ShouldSerializeOleDbType()) { flags |= 1; } if (p.ShouldSerializeSize()) { flags |= 2; } if (!ADP.IsEmpty(p.SourceColumn)) { flags |= 4; } if (null != p.Value) { flags |= 8; } if ((ParameterDirection.Input != p.Direction) || p.IsNullable || p.ShouldSerializePrecision() || p.ShouldSerializeScale() || (DataRowVersion.Current != p.SourceVersion)) { flags |= 16; // V1.0 everything } if (p.SourceColumnNullMapping) { flags |= 32; // v2.0 everything } Type[] ctorParams; object[] ctorValues; switch (flags) { case 0: // ParameterName case 1: // OleDbType ctorParams = new Type[] { typeof(string), typeof(OleDbType) }; ctorValues = new object[] { p.ParameterName, p.OleDbType }; break; case 2: // Size case 3: // Size, OleDbType ctorParams = new Type[] { typeof(string), typeof(OleDbType), typeof(int) }; ctorValues = new object[] { p.ParameterName, p.OleDbType, p.Size }; break; case 4: // SourceColumn case 5: // SourceColumn, OleDbType case 6: // SourceColumn, Size case 7: // SourceColumn, Size, OleDbType ctorParams = new Type[] { typeof(string), typeof(OleDbType), typeof(int), typeof(string) }; ctorValues = new object[] { p.ParameterName, p.OleDbType, p.Size, p.SourceColumn }; break; case 8: // Value ctorParams = new Type[] { typeof(string), typeof(object) }; ctorValues = new object[] { p.ParameterName, p.Value }; break; default: // everything else if (0 == (32 & flags)) { // V1.0 everything ctorParams = new Type[] { typeof(string), typeof(OleDbType), typeof(int), typeof(ParameterDirection), typeof(bool), typeof(byte), typeof(byte), typeof(string), typeof(DataRowVersion), typeof(object) }; ctorValues = new object[] { p.ParameterName, p.OleDbType, p.Size, p.Direction, p.IsNullable, p.PrecisionInternal, p.ScaleInternal, p.SourceColumn, p.SourceVersion, p.Value }; } else { // v2.0 everything - round trip all browsable properties + precision/scale ctorParams = new Type[] { typeof(string), typeof(OleDbType), typeof(int), typeof(ParameterDirection), typeof(byte), typeof(byte), typeof(string), typeof(DataRowVersion), typeof(bool), typeof(object) }; ctorValues = new object[] { p.ParameterName, p.OleDbType, p.Size, p.Direction, p.PrecisionInternal, p.ScaleInternal, p.SourceColumn, p.SourceVersion, p.SourceColumnNullMapping, p.Value }; } break; } System.Reflection.ConstructorInfo ctor = typeof(OleDbParameter).GetConstructor(ctorParams); return(new System.ComponentModel.Design.Serialization.InstanceDescriptor(ctor, ctorValues)); }