C# Entity.Set方法代码示例

 public static Entity AsignarPeriodoContable(int pIdPeriodoContable)
 {
     Entity parametros = new Entity();
     parametros.Set("pIdPeriodoContable", pIdPeriodoContable);
     parametros.Set("pIdEmpresa", Configuracion.IdEmpresa);
     Entity resultado = ManejadorBaseDatos.Instancia.EjecutarSP("asignar_periodo_contable", parametros);
     return resultado;
 }

 public static Entity IngresarTipoCambio(int pIdMonedaBase, int pIdMonedaCambio, decimal pValor)
 {
     Entity parametros = new Entity();
     parametros.Set("pidmonedabase", pIdMonedaBase);
     parametros.Set("pidmonedacambio", pIdMonedaCambio);
     parametros.Set("pvalor", pValor);
     Entity resultado = ManejadorBaseDatos.Instancia.EjecutarSP("ingresar_tipo_cambio", parametros);
     return resultado;
 }

 public static Entity ObtenerTipoCambio(int pIdMonedaBase, int pIdMonedaCambio, DateTime pFecha)
 {
     Entity parametros = new Entity();
     parametros.Set("pmonedabase", pIdMonedaBase);
     parametros.Set("pmonedacambio", pIdMonedaCambio);
     parametros.Set("pfecha", pFecha);
     Entity resultado = ManejadorBaseDatos.Instancia.EjecutarSP("obtener_tipo_cambio", parametros);
     return resultado;
 }

        public void Update(Entity e, GameTime t)
        {
            // We burn through just enough time for emission to occur.  We
            // update the state, then perform an emission.  Then we pick up
            // where we left off (when the loop loops).
            uint dt = (uint) t.ElapsedGameTime.TotalMilliseconds;
            while (dt > 0) {
                uint emitTime = e.Get(EmitTime);

                uint timeToEmission = e.Get(TimeToEmission);
                if (timeToEmission == 0) {
                    timeToEmission = emitTime;
                }

                uint burntTime = Math.Min(timeToEmission, dt);
                timeToEmission -= burntTime;
                dt -= burntTime;

                e.Set(TimeToEmission, timeToEmission);

                if (timeToEmission == 0 && e.Get(IsEmitting)) {
                    this.onEmit(e);
                }
            }
        }

        public static float Damage(Entity e, float damageAmount, Entity damager = null)
        {
            float originalHealth = e.Get(Health);
            float finalHealth = Math.Max(0, originalHealth - damageAmount);
            e.Set(Health, finalHealth);

            float damageDealt = originalHealth - finalHealth;

            if (damager != null) {
                damager.ForEach<IDamager>((c) => {
                    c.Damaged(damager, e, damageDealt);
                });
            }

            if (finalHealth == 0) {
                e.ForEach<IKillable>((c) => {
                    c.Kill(e, damager);
                });

                if (damager != null) {
                    damager.ForEach<IKiller>((c) => {
                        c.Killed(damager, e);
                    });
                }
            }

            return damageDealt;
        }

 public static Entities ObtenerEmpresaGrupo()
 {
     Entity parametros = new Entity();
     parametros.Set("pIdEmpresa", Configuracion.IdEmpresa);
     Entity resultado = ManejadorBaseDatos.Instancia.EjecutarSP("obtener_empresa_grupo", parametros);
     Entities resultado_table = (Entities)resultado.Get("table");
     return resultado_table;
 }

 public override Entity CreateEntityOfSchema()
 {
     Entity entity = new Entity(GetOrCreateSchema());
      IList<String> stringSet = new List<string>() as IList<string>;
      stringSet.Add("abc");
      stringSet.Add("123");
      stringSet.Add("def");
      entity.Set("someStringArray", stringSet);
      return entity;
 }

 /// <summary>
 /// Create a new component instance and assign it to an entity.
 /// </summary>
 public Component Make(Entity entity)
 {
     Component component = BuildComponent(entity);
       if (component.Family != Family)
       {
     throw new ApplicationException(
       "Component template for family '"+Family+
       "' produced a component of family '"+
       Component.GetFamily()+"'.");
       }
       entity.Set(component);
       return component;
 }

 public static Entity CrearEmpresaGrupo(String pNombre, String pEsquema, int pCedula, byte[] pLogotipo, String pMonedaLocal, String pMonedaSistema)
 {
     Entity parametros = new Entity();
     parametros.Set("pNombre", pNombre);
     parametros.Set("pEsquema", pEsquema);
     parametros.Set("pCedulaJuridica", pCedula);
     parametros.Set("pLogotipo", pLogotipo);
     parametros.Set("pMonedaLocal", pMonedaLocal);
     parametros.Set("pMonedaSistema", pMonedaSistema);
     Entity resultado = ManejadorBaseDatos.Instancia.EjecutarSP("crear_empresa", parametros, pEsquema);
     return resultado;
 }

 public static Entity AgregarPeriodoContable(DateTime pFechaInicioC, DateTime pFechaFinalC, DateTime pFechaInicioD,
     DateTime pFechaFinalD, DateTime pFechaInicioV, DateTime pFechaFinalV)
 {
     Entity parametros = new Entity();
     parametros.Set("pFechaInicioC", pFechaInicioC);
     parametros.Set("pFechaFinC", pFechaFinalC);
     parametros.Set("pFechaInicioD", pFechaInicioD);
     parametros.Set("pFechaFinD", pFechaFinalD);
     parametros.Set("pFechaInicioV", pFechaInicioV);
     parametros.Set("pFechaFinV", pFechaFinalV);
     Entity resultado = ManejadorBaseDatos.Instancia.EjecutarSP("crear_periodo_contable", parametros);
     return resultado;
 }

        public Entity GenerateRotationGizmo()
        {
            var entity = new Entity("RotationGizmo");
            entity.Set(TransformationComponent.Key, new TransformationComponent());

            // TODO: Factorize some of this code with GenerateTranslationGizmo?
            var gizmoActions = new[] { GizmoAction.RotationX, GizmoAction.RotationY, GizmoAction.RotationZ };
            var orientationMatrices = new[] { Matrix.Identity, Matrix.RotationZ((float)Math.PI * 0.5f), Matrix.RotationY(-(float)Math.PI * 0.5f) };
            var colors = new[] { Color.Green, Color.Blue, Color.Red };

            var albedoMaterial = new ShaderMixinSource()
                {
                    "AlbedoDiffuseBase",
                    "AlbedoSpecularBase",
                    new ShaderComposition("albedoDiffuse", new ShaderClassSource("ComputeColorFixed", MaterialKeys.DiffuseColor)),
                    new ShaderComposition("albedoSpecular", new ShaderClassSource("ComputeColor")), // TODO: Default values!
                };

            for (int axis = 0; axis < 3; ++axis)
            {
                // Rendering
                var circleEffectMeshData = new EffectMeshData();
                circleEffectMeshData.Parameters = new ParameterCollection();
                circleEffectMeshData.MeshData = MeshDataHelper.CreateCircle(20.0f, 32, colors[axis]);
                circleEffectMeshData.EffectData = new EffectData("Gizmo") { AlbedoMaterial = albedoMaterial };

                var circleEntity = new Entity("ArrowCone");
                circleEntity.GetOrCreate(ModelComponent.Key).SubMeshes.Add(circleEffectMeshData);
                circleEntity.Set(TransformationComponent.Key, TransformationMatrix.CreateComponent(orientationMatrices[axis]));

                circleEntity.Set(GizmoColorKey, colors[axis]);
                circleEntity.Set(GizmoActionKey, gizmoActions[axis]);

                entity.GetOrCreate(TransformationComponent.Key).Children.Add(circleEntity.GetOrCreate(TransformationComponent.Key));
            }

            return entity;
        }

//.........这里部分代码省略.........
                    new Vector3(4732.579f, 955.4061f,   -400.0f),						// 21
                    new Vector3(1630.28f, 1551.338f,    -400.0f),						// 22
                    new Vector3(931.7393f, 1274.533f,   -400.0f),						// 23
                    new Vector3(1586.493f, 1505.558f,   -400.0f),						// 24
                    new Vector3(906.572f, 1268.478f,    -400.0f),						// 25
                    new Vector3(390.1973f, 1314.976f,   -400.0f),						// 26
                    new Vector3(-30.39231f, 1553.894f,  -400.0f),						// 27
                    new Vector3(-356.4023f, 1605.162f,  -400.0f),						// 28
                    new Vector3(-1055.699f, 971.7286f,  -400.0f),						// 29
                    new Vector3(-1218.041f, 727.1427f,  -400.0f),						// 30
                    new Vector3(-1377.148f, 606.9602f,  -400.0f),						// 31
                    new Vector3(-1676.512f, 640.7913f,  -400.0f),						// 32
                    new Vector3(-2089.593f, 833.8343f,  -400.0f),						// 33
                    new Vector3(-2290.1f, 992.6068f,    -400.0f),						// 34
                    new Vector3(-2196.059f, 764.4152f,  -400.0f),						// 35
                    new Vector3(-1448.233f, 391.5037f,  -400.0f),						// 36
                    new Vector3(-1337.535f, 223.827f,   -400.0f),						// 37
                    new Vector3(-1287.335f, -125.6966f, -400.0f),						// 38
                    new Vector3(-4226.484f, -1213.027f, -400.0f),						// 39 - Magma Left
                    new Vector3(-4593.09f, -1091.131f,  -400.0f),						// 40
                    new Vector3(-4803.661f, -958.4816f, -400.0f),						// 41
                    new Vector3(-5262.959f, -1025.99f,  -400.0f),						// 42
                    new Vector3(-5519.119f, -881.3628f, -400.0f),						// 43
                    new Vector3(-5543.972f, -547.7667f, -400.0f),						// 44
                    new Vector3(-5775.069f, -294.6195f, -400.0f),						// 45
                    new Vector3(-6333.859f, -423.4442f, -400.0f),						// 46
                    new Vector3(-6977.528f, 840.5598f,  -400.0f),						// 47
                    new Vector3(-6847.938f, 1640.414f,  -400.0f),						// 48
                    new Vector3(-7259.18f, 1724.889f,   -400.0f),						// 49
                    new Vector3(-7693.181f, 1660.773f,  -400.0f),						// 50
                    new Vector3(-8300.401f, 1609.711f,  -400.0f),						// 51
                    new Vector3(-8704.221f, 1241.705f,  -400.0f),						// 52
                    new Vector3(-9049.8f, 905.2922f,    -400.0f),						// 53
                    new Vector3(-8739.72f, 105.7951f,   -400.0f),						// 54
                    new Vector3(-8515.267f, -371.7517f, -400.0f),						// 55
                    new Vector3(-8110.098f, -316.8557f, -400.0f),						// 56
                    new Vector3(-7915.391f, -304.8632f, -400.0f),						// 57
                    new Vector3(-7191.82f, -353.2674f,  -400.0f),						// 58
                    new Vector3(-6270.604f, -2246.958f, -400.0f),						// 59 - Magma right
                    new Vector3(-6655.961f, -2615.954f, -400.0f),						// 60
                    new Vector3(-7056.6f, -2839.48f,    -400.0f),						// 61
                    new Vector3(-7632.455f, -3047.234f, -400.0f),						// 62
                    new Vector3(-8325.431f, -2937.415f, -400.0f),						// 63
                    new Vector3(-8273.172f, -3403.743f, -400.0f),						// 64
                    new Vector3(-8179.38f, -3616.764f,  -400.0f),						// 65
                    new Vector3(-7814.024f, -4484.587f, -400.0f),						// 66
                    new Vector3(-6525.229f, -4816.507f, -400.0f),						// 67
                    new Vector3(-5648.252f, -4344.051f, -400.0f),						// 68
                    new Vector3(-6140.713f, -3957.125f, -400.0f),						// 69
                    new Vector3(-7001.114f, -3650.077f, -400.0f),						// 70
                };


            var random = new Random(1);

            var emitters = new SmokeParticleEmitterComponent[emitterPositions.Length];
            for (int i = 0; i < emitters.Length; i++)
            {

                var verticalScatter = (float)(2.0 + 3.0 * random.NextDouble());
                var horizontalScatter = (float)(3.0 + 6.0 * random.NextDouble());

                var emitter = new SmokeParticleEmitterComponent()
                    {
                        Count = 256,
                        Description = new SmokeEmitterDescription()
                        {
                            Position = emitterPositions[i],
                            Scatter = new Vector3(horizontalScatter, horizontalScatter, verticalScatter),
                            Velocity = new Vector3(0, 0.0f, 0.5f + 4.0f * (float)random.NextDouble()),
                            MaxTime = 1000.0f + 4000.0f * (float)random.NextDouble(),
                            InitialSize = 50.0f + 30.0f * (float)random.NextDouble(),
                            DeltaSize = 30.0f + 20.0f * (float)random.NextDouble(),
                            Opacity = 0.7f,
                        }
                    };
                emitter.OnUpdateData();

                emitters[i] = emitter;
            }

            var smokeVolTexture = (Texture2D)engineContext.AssetManager.Load<Texture>("/global_data/gdc_demo/fx/smokevol.dds");
            var smokeGradTexture = (Texture2D)engineContext.AssetManager.Load<Texture>("/global_data/gdc_demo/fx/smokegrad.dds");
            particlePlugin.Parameters.Set(SmokeTexture, smokeVolTexture);
            particlePlugin.Parameters.Set(SmokeColor, smokeGradTexture);

            var particleEmitterRootEntity = new Entity("ParticleEmitters");
            particleEmitterRootEntity.Set(TransformationComponent.Key, new TransformationComponent());
            engineContext.EntityManager.AddEntity(particleEmitterRootEntity);

            for (int index = 0; index < emitters.Length; index++)
            {
                var emitter = emitters[index];
                var entity = new Entity(string.Format("ParticleEmitter-{0}", index));
                entity.Set(TransformationComponent.Key, new TransformationComponent(new TransformationTRS { Translation = emitter.Description.Position }));
                entity.Set(ParticleEmitterComponent.Key, emitter);

                particleEmitterRootEntity.Transformation.Children.Add(entity.Transformation);
            }
        }

        // Setup routine: updates parameters of the window to the appropriate values on load
        internal void UpdateInitialParameters(Document doc)
        {
            Transaction t = new Transaction(doc, "Update parameters");
               t.Start();

               SchemaBuilder builder = new SchemaBuilder(m_schemaId); //(new Guid("{4DE4BE80-0857-4785-A7DF-8A8918851CB2}"));
               builder.AddSimpleField("Position", typeof(XYZ)).SetUnitType(UnitType.UT_Length);
               builder.AddSimpleField("Orientation", typeof(XYZ)).SetUnitType(UnitType.UT_Length);
               builder.SetSchemaName("WallPositionData");
               builder.SetDocumentation("Two points in a Window element that assist in placing a section view.");
               builder.SetVendorId("adsk");
               builder.SetApplicationGUID(doc.Application.ActiveAddInId.GetGUID());

               m_schema = builder.Finish();

               t.Commit();

               t.Start();
               Field fieldPosition = m_schema.GetField("Position");
               Field fieldOrientation = m_schema.GetField("Orientation");

               FamilyInstance window = doc.get_Element(m_windowId) as FamilyInstance;

               Entity storageEntity = new Entity(m_schema);

               LocationPoint lp = window.Location as LocationPoint;
               XYZ location = lp.Point;

               storageEntity.Set<XYZ>(fieldPosition, location, DisplayUnitType.DUT_FEET_FRACTIONAL_INCHES);

               XYZ orientation = window.FacingOrientation;
               storageEntity.Set<XYZ>(fieldOrientation, orientation, DisplayUnitType.DUT_FEET_FRACTIONAL_INCHES);
               window.SetEntity(storageEntity);

               t.Commit();
        }

        /// <summary>
        /// Update the address saved into the extensible storage using values from the UI 
        /// </summary>
        /// <param name="document">The document storing the saved address.</param>
        /// <param name="addressItem">address information from the UI to be saved into extensible storage</param>
        public void UpdateAddress(Document document, IFCAddressItem addressItem)
        {
            if (m_schema == null)
            {
                m_schema = Schema.Lookup(s_schemaId);
            }
            if (m_schema != null)
            {
                IList<DataStorage> oldSavedAddress = GetAddressInStorage(document, m_schema);
                if (oldSavedAddress.Count > 0)
                {
                    Transaction deleteTransaction = new Transaction(document, "Delete old IFC address");
                    deleteTransaction.Start();
                    List<ElementId> dataStorageToDelete = new List<ElementId>();
                    foreach (DataStorage dataStorage in oldSavedAddress)
                    {
                        dataStorageToDelete.Add(dataStorage.Id);
                    }
                    document.Delete(dataStorageToDelete);
                    deleteTransaction.Commit();
                }
            }

            // Update the address using the new information
            if (m_schema == null)
            {
                m_schema = Schema.Lookup(s_schemaId);
            }
            if (m_schema != null)
            {
                Transaction transaction = new Transaction(document, "Update saved IFC Address");
                transaction.Start();

                DataStorage addressStorage = DataStorage.Create(document);

                Entity mapEntity = new Entity(m_schema);
                IDictionary<string, string> mapData = new Dictionary<string, string>();
                if (addressItem.Purpose != null) mapData.Add(s_addressPurpose, addressItem.Purpose.ToString());
                if (addressItem.Description != null) mapData.Add(s_addressDescription, addressItem.Description.ToString());
                if (addressItem.UserDefinedPurpose != null) mapData.Add(s_addressUserDefinedPurpose, addressItem.UserDefinedPurpose.ToString());
                if (addressItem.InternalLocation != null) mapData.Add(s_addressInternalLocation, addressItem.InternalLocation.ToString());
                if (addressItem.AddressLine1 != null) mapData.Add(s_addressAddressLine1, addressItem.AddressLine1.ToString());
                if (addressItem.AddressLine2 != null) mapData.Add(s_addressAddressLine2, addressItem.AddressLine2.ToString());
                if (addressItem.POBox != null) mapData.Add(s_addressPOBox, addressItem.POBox.ToString());
                if (addressItem.TownOrCity != null) mapData.Add(s_addressTownOrCity, addressItem.TownOrCity.ToString());
                if (addressItem.RegionOrState != null) mapData.Add(s_addressRegionOrState, addressItem.RegionOrState.ToString());
                if (addressItem.PostalCode != null) mapData.Add(s_addressPostalCode, addressItem.PostalCode.ToString());
                if (addressItem.Country != null) mapData.Add(s_addressCountry, addressItem.Country.ToString());

                mapEntity.Set<IDictionary<string, String>>(s_addressMapField, mapData);
                addressStorage.SetEntity(mapEntity);

                transaction.Commit();
            }
        }

        /// <summary>
        /// Updates the setups to save into the document.
        /// </summary>
        /// <param name="document">The document storing the saved configuration.</param>
        public void UpdateSavedConfigurations(Document document)
        {
            if (m_schema == null)
            {
                m_schema = Schema.Lookup(s_schemaId);
            }

            // Are there any setups to save or resave?
            List<IFCExportConfiguration> setupsToSave = new List<IFCExportConfiguration>();
            foreach (IFCExportConfiguration configuration in m_configurations.Values)
            {
                if (configuration.IsBuiltIn)
                    continue;

                // Store in-session settings in the cached in-session configuration
                if (configuration.IsInSession)
                {
                    IFCExportConfiguration.SetInSession(configuration);
                    continue;
                }

                setupsToSave.Add(configuration);
           }

           // If there are no setups to save, and if the schema is not present (which means there are no
           // previously existing setups which might have been deleted) we can skip the rest of this method.
           if (setupsToSave.Count <= 0 && m_schema == null)
               return;

           if (m_schema == null)
           {
                SchemaBuilder builder = new SchemaBuilder(s_schemaId);
                builder.SetSchemaName("IFCExportConfiguration");
                builder.AddSimpleField(s_setupName, typeof(String));
                builder.AddSimpleField(s_setupDescription, typeof(String));
                builder.AddSimpleField(s_setupVersion, typeof(int));
                builder.AddSimpleField(s_setupFileFormat, typeof(int));
                builder.AddSimpleField(s_setupSpaceBoundaries, typeof(int));
                builder.AddSimpleField(s_setupQTO, typeof(bool));
                builder.AddSimpleField(s_splitWallsAndColumns, typeof(bool));
                builder.AddSimpleField(s_setupCurrentView, typeof(bool));
                builder.AddSimpleField(s_setupExport2D, typeof(bool));
                builder.AddSimpleField(s_setupExportRevitProps, typeof(bool));
                builder.AddSimpleField(s_setupUse2DForRoomVolume, typeof(bool));
                builder.AddSimpleField(s_setupUseFamilyAndTypeName, typeof(bool));
                builder.AddSimpleField(s_setupExportPartsAsBuildingElements, typeof(bool));

                m_schema = builder.Finish();
           }

           // Overwrite all saved configs with the new list
           Transaction transaction = new Transaction(document, "Update IFC export setups");
           transaction.Start();
           IList<DataStorage> savedConfigurations = GetSavedConfigurations(document);
           int savedConfigurationCount = savedConfigurations.Count<DataStorage>();
           int savedConfigurationIndex = 0;
           foreach (IFCExportConfiguration configuration in setupsToSave)
           {
                DataStorage configStorage;
                if (savedConfigurationIndex >= savedConfigurationCount)
                {
                    configStorage = DataStorage.Create(document);
                }
                else
                {
                    configStorage = savedConfigurations[savedConfigurationIndex];
                    savedConfigurationIndex ++;
                }
                Entity entity = new Entity(m_schema);
                entity.Set(s_setupName, configuration.Name);
                entity.Set(s_setupDescription, configuration.Description);
                entity.Set(s_setupVersion, (int)configuration.IFCVersion);
                entity.Set(s_setupFileFormat, (int)configuration.IFCFileType);
                entity.Set(s_setupSpaceBoundaries, configuration.SpaceBoundaries);
                entity.Set(s_setupQTO, configuration.ExportBaseQuantities);
                entity.Set(s_setupCurrentView, configuration.VisibleElementsOfCurrentView);
                entity.Set(s_splitWallsAndColumns, configuration.SplitWallsAndColumns);
                entity.Set(s_setupExport2D, configuration.Export2DElements);
                entity.Set(s_setupExportRevitProps, configuration.ExportInternalRevitPropertySets);
                entity.Set(s_setupUse2DForRoomVolume, configuration.Use2DRoomBoundaryForVolume);
                entity.Set(s_setupUseFamilyAndTypeName, configuration.UseFamilyAndTypeNameForReference);
                entity.Set(s_setupExportPartsAsBuildingElements, configuration.ExportPartsAsBuildingElements);

                configStorage.SetEntity(entity);
            }

            List<ElementId> elementsToDelete = new List<ElementId>();
            for (; savedConfigurationIndex < savedConfigurationCount; savedConfigurationIndex++)
            {
                DataStorage configStorage = savedConfigurations[savedConfigurationIndex];
                elementsToDelete.Add(configStorage.Id);
            }
            if (elementsToDelete.Count > 0)
                document.Delete(elementsToDelete);

            transaction.Commit();
//.........这里部分代码省略.........