C# IFrameworkItem.GetType方法代码示例

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstRootNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstRootNode)targetItem;
            foreach (var item in _connections)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._connections.Add((VulcanEngine.IR.Ast.Connection.AstConnectionNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _tables)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._tables.Add((VulcanEngine.IR.Ast.Table.AstTableBaseNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _dimensions)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._dimensions.Add((VulcanEngine.IR.Ast.Dimension.AstDimensionNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _facts)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._facts.Add((VulcanEngine.IR.Ast.Fact.AstFactNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _packages)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._packages.Add((VulcanEngine.IR.Ast.Task.AstPackageBaseNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _schemas)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._schemas.Add((VulcanEngine.IR.Ast.Table.AstSchemaNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _principals)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._principals.Add((VulcanEngine.IR.Ast.Table.AstPrincipalNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _persistentVariables)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._persistentVariables.Add((VulcanEngine.IR.Ast.PersistentVariables.AstPersistentVariableNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _templates)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._templates.Add((VulcanEngine.IR.Ast.AstTemplateNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstPersistentVariableNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstPersistentVariableNode)targetItem;
            castedTargetItem.TypeCode_BackingField = TypeCode_BackingField;

        }

 public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
 {
     base.CloneInto(targetItem, cloneMapping);
     if (targetItem == null || !typeof(AstFactTableColumnNode).IsAssignableFrom(targetItem.GetType()))
     {
         throw new ArgumentException("Provided target node is not of the correct type.");
     }
 }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstSortNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstSortNode)targetItem;
            castedTargetItem.AutoPassthrough_BackingField = AutoPassthrough_BackingField;

            castedTargetItem.EliminateDuplicates_BackingField = EliminateDuplicates_BackingField;

            castedTargetItem.MaximumThreads_BackingField = MaximumThreads_BackingField;

            foreach (var item in _inputColumns)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._inputColumns.Add((VulcanEngine.IR.Ast.Transformation.AstSortColumnNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstTableNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstTableNode)targetItem;
            if (_connection == null)
            {
                castedTargetItem._connection = null;
            }
            else if (cloneMapping.ContainsKey(_connection))
            {
                castedTargetItem._connection = (VulcanEngine.IR.Ast.Connection.AstConnectionNode)cloneMapping[_connection];
            }
            else
            {
                castedTargetItem._connection = _connection;
            }

            foreach (var item in _columns)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._columns.Add((VulcanEngine.IR.Ast.Table.AstTableColumnBaseNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _keys)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._keys.Add((VulcanEngine.IR.Ast.Table.AstTableKeyBaseNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _sources)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._sources.Add((VulcanEngine.IR.Ast.Table.AstTableSourceBaseNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _lookups)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._lookups.Add((VulcanEngine.IR.Ast.Transformation.AstEtlFragmentNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _indexes)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._indexes.Add((VulcanEngine.IR.Ast.Table.AstTableIndexNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            if (_customExtensions == null)
            {
                castedTargetItem._customExtensions = null;
            }
            else if (cloneMapping.ContainsKey(_customExtensions))
            {
                castedTargetItem._customExtensions = (VulcanEngine.IR.Ast.Task.AstContainerTaskNode)cloneMapping[_customExtensions];
                _customExtensions.CloneInto(cloneMapping[_customExtensions], cloneMapping);
            }
            else
            {
                castedTargetItem._customExtensions = _customExtensions;
            }

            castedTargetItem.LateArriving_BackingField = LateArriving_BackingField;

            if (_schema == null)
            {
                castedTargetItem._schema = null;
            }
            else if (cloneMapping.ContainsKey(_schema))
            {
                castedTargetItem._schema = (VulcanEngine.IR.Ast.Table.AstSchemaNode)cloneMapping[_schema];
            }
            else
            {
                castedTargetItem._schema = _schema;
            }

            castedTargetItem.CompressionType_BackingField = CompressionType_BackingField;

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstTableStaticSourceNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstTableStaticSourceNode)targetItem;
            foreach (var item in _rows)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._rows.Add((VulcanEngine.IR.Ast.Table.AstStaticSourceRowNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            castedTargetItem.EmitMergePackage_BackingField = EmitMergePackage_BackingField;

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstExecuteSqlQueryNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstExecuteSqlQueryNode)targetItem;
            foreach (var item in _parameters)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._parameters.Add((VulcanEngine.IR.Ast.Task.AstExecuteSqlParameterMappingTypeNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstAttributeRelationshipNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstAttributeRelationshipNode)targetItem;
            castedTargetItem.Visible_BackingField = Visible_BackingField;

            if (_parentAttribute == null)
            {
                castedTargetItem._parentAttribute = null;
            }
            else if (cloneMapping.ContainsKey(_parentAttribute))
            {
                castedTargetItem._parentAttribute = (VulcanEngine.IR.Ast.Dimension.AstAttributeNode)cloneMapping[_parentAttribute];
            }
            else
            {
                castedTargetItem._parentAttribute = _parentAttribute;
            }

            if (_childAttribute == null)
            {
                castedTargetItem._childAttribute = null;
            }
            else if (cloneMapping.ContainsKey(_childAttribute))
            {
                castedTargetItem._childAttribute = (VulcanEngine.IR.Ast.Dimension.AstAttributeNode)cloneMapping[_childAttribute];
            }
            else
            {
                castedTargetItem._childAttribute = _childAttribute;
            }

            castedTargetItem.RelationshipType_BackingField = RelationshipType_BackingField;

            castedTargetItem.Cardinality_BackingField = Cardinality_BackingField;

            castedTargetItem.Optionality_BackingField = Optionality_BackingField;

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstReadPersistentVariableNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstReadPersistentVariableNode)targetItem;
            if (_connection == null)
            {
                castedTargetItem._connection = null;
            }
            else if (cloneMapping.ContainsKey(_connection))
            {
                castedTargetItem._connection = (VulcanEngine.IR.Ast.Connection.AstConnectionNode)cloneMapping[_connection];
            }
            else
            {
                castedTargetItem._connection = _connection;
            }

            if (_persistentVariable == null)
            {
                castedTargetItem._persistentVariable = null;
            }
            else if (cloneMapping.ContainsKey(_persistentVariable))
            {
                castedTargetItem._persistentVariable = (VulcanEngine.IR.Ast.PersistentVariables.AstPersistentVariableNode)cloneMapping[_persistentVariable];
            }
            else
            {
                castedTargetItem._persistentVariable = _persistentVariable;
            }

            if (_targetVariable == null)
            {
                castedTargetItem._targetVariable = null;
            }
            else if (cloneMapping.ContainsKey(_targetVariable))
            {
                castedTargetItem._targetVariable = (VulcanEngine.IR.Ast.Task.AstVariableNode)cloneMapping[_targetVariable];
            }
            else
            {
                castedTargetItem._targetVariable = _targetVariable;
            }

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstExecuteSqlTaskNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstExecuteSqlTaskNode)targetItem;
            castedTargetItem.ExecuteDuringDesignTime_BackingField = ExecuteDuringDesignTime_BackingField;

            if (_connection == null)
            {
                castedTargetItem._connection = null;
            }
            else if (cloneMapping.ContainsKey(_connection))
            {
                castedTargetItem._connection = (VulcanEngine.IR.Ast.Connection.AstConnectionNode)cloneMapping[_connection];
            }
            else
            {
                castedTargetItem._connection = _connection;
            }

            castedTargetItem.ResultSet_BackingField = ResultSet_BackingField;

            if (_query == null)
            {
                castedTargetItem._query = null;
            }
            else if (cloneMapping.ContainsKey(_query))
            {
                castedTargetItem._query = (VulcanEngine.IR.Ast.Task.AstExecuteSqlQueryNode)cloneMapping[_query];
                _query.CloneInto(cloneMapping[_query], cloneMapping);
            }
            else
            {
                castedTargetItem._query = _query;
            }

            foreach (var item in _results)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._results.Add((VulcanEngine.IR.Ast.Task.AstExecuteSqlParameterMappingTypeNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstForLoopContainerTaskNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstForLoopContainerTaskNode)targetItem;
            castedTargetItem.InitializerExpression_BackingField = InitializerExpression_BackingField;

            castedTargetItem.LoopTestExpression_BackingField = LoopTestExpression_BackingField;

            castedTargetItem.CountingExpression_BackingField = CountingExpression_BackingField;

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstConditionalSplitNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstConditionalSplitNode)targetItem;
            foreach (var item in _outputPaths)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._outputPaths.Add((VulcanEngine.IR.Ast.Transformation.AstConditionalSplitOutputPathNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            if (_defaultOutputPath == null)
            {
                castedTargetItem._defaultOutputPath = null;
            }
            else if (cloneMapping.ContainsKey(_defaultOutputPath))
            {
                castedTargetItem._defaultOutputPath = (VulcanEngine.IR.Ast.Transformation.AstDataflowOutputPathNode)cloneMapping[_defaultOutputPath];
                _defaultOutputPath.CloneInto(cloneMapping[_defaultOutputPath], cloneMapping);
            }
            else
            {
                castedTargetItem._defaultOutputPath = _defaultOutputPath;
            }

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstTableIndexNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstTableIndexNode)targetItem;
            castedTargetItem.PadIndex_BackingField = PadIndex_BackingField;

            castedTargetItem.SortInTempDB_BackingField = SortInTempDB_BackingField;

            castedTargetItem.DropExisting_BackingField = DropExisting_BackingField;

            castedTargetItem.IgnoreDupKey_BackingField = IgnoreDupKey_BackingField;

            castedTargetItem.Online_BackingField = Online_BackingField;

            castedTargetItem.Clustered_BackingField = Clustered_BackingField;

            castedTargetItem.Unique_BackingField = Unique_BackingField;

            foreach (var item in _columns)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._columns.Add((VulcanEngine.IR.Ast.Table.AstTableIndexColumnNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            foreach (var item in _leafs)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._leafs.Add((VulcanEngine.IR.Ast.Table.AstTableIndexLeafNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstFactNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstFactNode)targetItem;
            castedTargetItem.MeasureGroupName_BackingField = MeasureGroupName_BackingField;

            castedTargetItem.AggregationPrefix_BackingField = AggregationPrefix_BackingField;

            castedTargetItem.DataAggregation_BackingField = DataAggregation_BackingField;

            castedTargetItem.Description_BackingField = Description_BackingField;

            castedTargetItem.ErrorConfiguration_BackingField = ErrorConfiguration_BackingField;

            castedTargetItem.EstimatedRows_BackingField = EstimatedRows_BackingField;

            castedTargetItem.EstimatedSize_BackingField = EstimatedSize_BackingField;

            castedTargetItem.IgnoreUnrelatedDimensions_BackingField = IgnoreUnrelatedDimensions_BackingField;

            castedTargetItem.ProactiveCaching_BackingField = ProactiveCaching_BackingField;

            castedTargetItem.ProcessingMode_BackingField = ProcessingMode_BackingField;

            castedTargetItem.ProcessingPriority_BackingField = ProcessingPriority_BackingField;

            castedTargetItem.StorageMode_BackingField = StorageMode_BackingField;

            castedTargetItem.MeasureGroupType_BackingField = MeasureGroupType_BackingField;

            castedTargetItem.Visible_BackingField = Visible_BackingField;

            if (_defaultMeasure == null)
            {
                castedTargetItem._defaultMeasure = null;
            }
            else if (cloneMapping.ContainsKey(_defaultMeasure))
            {
                castedTargetItem._defaultMeasure = (VulcanEngine.IR.Ast.Fact.AstMeasureNode)cloneMapping[_defaultMeasure];
            }
            else
            {
                castedTargetItem._defaultMeasure = _defaultMeasure;
            }

            castedTargetItem.StorageLocation_BackingField = StorageLocation_BackingField;

            foreach (var item in _measures)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._measures.Add((VulcanEngine.IR.Ast.Fact.AstMeasureNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

        }

        public override void CloneInto(IFrameworkItem targetItem, Dictionary<IFrameworkItem, IFrameworkItem> cloneMapping)
        {
            base.CloneInto(targetItem, cloneMapping);
            if (targetItem == null || !typeof(AstTaskNode).IsAssignableFrom(targetItem.GetType()))
            {
                throw new ArgumentException("Provided target node is not of the correct type.");
            }
            var castedTargetItem = (AstTaskNode)targetItem;
            if (_precedenceConstraints == null)
            {
                castedTargetItem._precedenceConstraints = null;
            }
            else if (cloneMapping.ContainsKey(_precedenceConstraints))
            {
                castedTargetItem._precedenceConstraints = (VulcanEngine.IR.Ast.Task.AstTaskflowPrecedenceConstraintsNode)cloneMapping[_precedenceConstraints];
                _precedenceConstraints.CloneInto(cloneMapping[_precedenceConstraints], cloneMapping);
            }
            else
            {
                castedTargetItem._precedenceConstraints = _precedenceConstraints;
            }

            foreach (var item in _events)
            {
                IFrameworkItem candidate = cloneMapping[item];
                castedTargetItem._events.Add((VulcanEngine.IR.Ast.Task.AstTaskEventHandlerNode)candidate);
                item.CloneInto(candidate, cloneMapping);
            }

            castedTargetItem.DelayValidation_BackingField = DelayValidation_BackingField;

            castedTargetItem.IsolationLevel_BackingField = IsolationLevel_BackingField;

        }