コード例 #1
0
ファイル: Selection.cs プロジェクト: dotnet/ef6tools
        /// <summary>
        ///     Selection helper method.  This takes the existing selection in the
        ///     context and creates a new selection that contains the toggled
        ///     state of the item.  If the item is to be
        ///     added to the selection, it is added as the primary selection.
        /// </summary>
        /// <param name="context">The editing context to apply this selection change to.</param>
        /// <param name="itemToToggle">The item to toggle selection for.</param>
        /// <returns>A Selection object that contains the new selection.</returns>
        /// <exception cref="ArgumentNullException">If context or itemToToggle is null.</exception>
        internal static T Toggle <T>(EditingContext context, EFObject itemToToggle) where T : Selection
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (itemToToggle == null)
            {
                throw new ArgumentNullException("itemToToggle");
            }

            var existing = context.Items.GetValue <T>();

            // Is the item already in the selection?  If so, remove it.
            // If not, add it to the beginning.

            var list = new List <EFObject>(existing.SelectedObjects);

            if (list.Contains(itemToToggle))
            {
                list.Remove(itemToToggle);
            }
            else
            {
                list.Insert(0, itemToToggle);
            }

            var selection = Activator.CreateInstance <T>();

            selection.SetSelectedObjects(list);
            context.Items.SetValue(selection);
            return(selection);
        }
コード例 #2
0
        internal ModelElement GetExisting(EFObject obj)
        {
            ModelElement result;

            _modelToViewModel.TryGetValue(obj, out result);
            return(result);
        }
コード例 #3
0
        /// <summary>
        ///     Retrieve the root "Schema" node for current node.  If there is no root mapping node, this will return null.
        /// </summary>
        /// <returns></returns>
        internal static XNamespace GetRootNamespace(EFObject node)
        {
            var currNode = node;
            EFRuntimeModelRoot runtimeModel = null;
            EFDesignerInfoRoot designerInfo = null;
            XNamespace ns = null;

            while (currNode != null)
            {
                runtimeModel = currNode as EFRuntimeModelRoot;
                designerInfo = currNode as EFDesignerInfoRoot;
                if (runtimeModel != null)
                {
                    ns = runtimeModel.XNamespace;
                    break;
                }
                else if (designerInfo != null)
                {
                    ns = designerInfo.XNamespace;
                    break;
                }
                else
                {
                    currNode = currNode.Parent;
                }
            }

            return ns;
        }
コード例 #4
0
 internal void RecordModelChange(
     EfiChange.EfiChangeType changeType, EFObject changed,
     string property, object oldValue, object newValue)
 {
     switch (changeType)
     {
         case EfiChange.EfiChangeType.Create:
             _creates.Add(new EfiChange(changeType, changed));
             break;
         case EfiChange.EfiChangeType.Delete:
             _deletes.Add(new EfiChange(changeType, changed));
             break;
         case EfiChange.EfiChangeType.Update:
             EfiChange change = null;
             if (_updates.ContainsKey(changed))
             {
                 change = _updates[changed];
             }
             else
             {
                 change = new EfiChange(changeType, changed);
                 _updates[changed] = change;
             }
             change.RecordModelChange(property, oldValue, newValue);
             break;
     }
 }
コード例 #5
0
ファイル: Selection.cs プロジェクト: dotnet/ef6tools
        /// <summary>
        ///     Selection helper method.  This takes the existing selection in the
        ///     context and creates a new selection that contains the original
        ///     selection and the itemToAdd.  If itemToAdd is already in the
        ///     original selection it is promoted to the primary selection.
        /// </summary>
        /// <param name="context">The editing context to apply this selection change to.</param>
        /// <param name="itemToAdd">The item to add to the selection.</param>
        /// <returns>A Selection object that contains the new selection.</returns>
        /// <exception cref="ArgumentNullException">If context or itemToAdd is null.</exception>
        internal static T Union <T>(EditingContext context, EFObject itemToAdd) where T : Selection
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (itemToAdd == null)
            {
                throw new ArgumentNullException("itemToAdd");
            }

            var existing = context.Items.GetValue <T>();

            // short cut if we're already in the right state.
            if (existing.PrimarySelection == itemToAdd)
            {
                return(existing);
            }

            // Is the item already in the selection?  If not, add it.
            var list = new List <EFObject>(existing.SelectedObjects);

            if (list.Contains(itemToAdd))
            {
                list.Remove(itemToAdd);
            }

            list.Insert(0, itemToAdd);
            var selection = Activator.CreateInstance <T>();

            selection.SetSelectedObjects(list);
            context.Items.SetValue(selection);
            return(selection);
        }
コード例 #6
0
ファイル: Selection.cs プロジェクト: dotnet/ef6tools
        /// <summary>
        ///     Selection helper method.  This sets itemToSelect into the selection.
        ///     Any existing items are deselected.
        /// </summary>
        /// <param name="context">The editing context to apply this selection change to.</param>
        /// <param name="itemToSelect">The item to select.</param>
        /// <returns>A Selection object that contains the new selection.</returns>
        /// <exception cref="ArgumentNullException">If context or itemToSelect is null.</exception>
        internal static T SelectOnly <T>(EditingContext context, EFObject itemToSelect) where T : Selection
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (itemToSelect == null)
            {
                throw new ArgumentNullException("itemToSelect");
            }

            // Check to see if only this object is selected.  If so, bail.
            var existing = context.Items.GetValue <T>();

            if (existing.PrimarySelection == itemToSelect)
            {
                var en = existing.SelectedObjects.GetEnumerator();
                en.MoveNext();
                if (!en.MoveNext())
                {
                    return(existing);
                }
            }

            var selection = Activator.CreateInstance <T>();

            selection.SetSelectedObjects(itemToSelect);
            context.Items.SetValue(selection);
            return(selection);
        }
コード例 #7
0
 internal static void ScheduleChildAntiDependenciesForRebinding(CommandProcessorContext cpc, EFObject efObject)
 {
     // identify any binding that was referencing this symbol, and add it to the list of things to rebind.
     var visitor = new AntiDependencyCollectorVisitor();
     visitor.Traverse(efObject);
     ScheduleBindingsForRebind(cpc, visitor.AntiDependencyBindings);
 }
コード例 #8
0
        /// <summary>
        ///     This method makes sure that:
        ///     1. Any given item is not duplicated in the list
        ///     2. If the newDeleted item's parent is already in the list, don't add it
        ///     3. If any children of newDeleted are already in the list, remove the child item
        ///     This greatly optimizes the actually CleanUp() process.
        /// </summary>
        /// <param name="newDeleted"></param>
        private void AddToDeleteList(EFObject newDeleted)
        {
            // if newDeleted is already there, just return
            if (_itemsToDelete.Contains(newDeleted))
            {
                return;
            }

            // don't add newDeleted if any of its parents are already being deleted
            var container = newDeleted.Parent;

            while (container != null)
            {
                if (_itemsToDelete.Contains(container))
                {
                    return;
                }
                container = container.Parent;
            }

            // if the newDeleted item is the parent of an existing item
            // remove the child item and just add the parent below
            RemoveChildrenOfNewDeleted(newDeleted as EFContainer);

            // add the item
            _itemsToDelete.Add(newDeleted);
        }
コード例 #9
0
        internal void RecordModelChange(
            EfiChange.EfiChangeType changeType, EFObject changed,
            string property, object oldValue, object newValue)
        {
            switch (changeType)
            {
            case EfiChange.EfiChangeType.Create:
                _creates.Add(new EfiChange(changeType, changed));
                break;

            case EfiChange.EfiChangeType.Delete:
                _deletes.Add(new EfiChange(changeType, changed));
                break;

            case EfiChange.EfiChangeType.Update:
                EfiChange change = null;
                if (_updates.ContainsKey(changed))
                {
                    change = _updates[changed];
                }
                else
                {
                    change            = new EfiChange(changeType, changed);
                    _updates[changed] = change;
                }
                change.RecordModelChange(property, oldValue, newValue);
                break;
            }
        }
コード例 #10
0
 private void CheckAll(EFObject obj)
 {
     CheckEntityType(obj);
     CheckAssociation(obj);
     CheckEntityModel(obj);
     CheckComplexType(obj);
 }
コード例 #11
0
        /// <summary>
        ///     This method will make an AttributePath for a given an EFObject.
        /// </summary>
        private static AttributePath MakeAttributePathFromEFObject(EFObject efobject)
        {
            var attributePath = new AttributePath();
            var curr          = efobject.XObject;

            while (curr != null)
            {
                if (curr.NodeType == XmlNodeType.Document)
                {
                    var doc = (XDocument)curr;
                    attributePath.PushFront(doc.Root.Name.LocalName, doc.Root.Name.Namespace.NamespaceName, true);
                }
                else if (curr.NodeType == XmlNodeType.Attribute)
                {
                    var attr = (XAttribute)curr;
                    attributePath.PushFront(attr.Name.LocalName, attr.Name.Namespace.NamespaceName, false);
                }
                else if (curr.NodeType == XmlNodeType.Element)
                {
                    var el = (XElement)curr;
                    attributePath.PushFront(el.Name.LocalName, el.Name.Namespace.NamespaceName, true);
                }
                else
                {
                    Debug.Fail("Unexpected XObject type is neither an attribute nor an element");
                    return(null);
                }

                curr = curr.Parent;
            }
            return(attributePath);
        }
コード例 #12
0
        internal static MappingViewModel CreateViewModel(EditingContext ctx, EFObject selection)
        {
            // clear out the xref so its clean for this new view model
            var xref = ModelToMappingModelXRef.GetModelToMappingModelXRef(ctx);
            xref.Clear();

            // we might be creating a view model for an entity or an association or a FunctionImport
            var entityType = selection as EntityType;
            var association = selection as Association;
            var fim = selection as FunctionImportMapping;

            // create the view model root
            MappingEFElement root = null;
            if (entityType != null)
            {
                root = ModelToMappingModelXRef.GetNewOrExisting(ctx, entityType, null);
            }
            else if (association != null)
            {
                root = ModelToMappingModelXRef.GetNewOrExisting(ctx, association, null);
            }
            else if (fim != null)
            {
                root = ModelToMappingModelXRef.GetNewOrExisting(ctx, fim, null);
            }
            else
            {
                throw new ArgumentException("selection");
            }

            return new MappingViewModel(ctx, root);
        }
コード例 #13
0
        internal static void RefactorRenameElement(EFObject objectToRefactor, string newName = null, bool showPreview = true)
        {
            if (objectToRefactor != null &&
                objectToRefactor.Artifact != null)
            {
                var namedObject = objectToRefactor as EFNormalizableItem;
                if (namedObject != null)
                {
                    // If the API call did not supply a new name for the object, bring up the dialog for the user to input a name
                    if (newName == null)
                    {
                        var dialog = new RefactorRenameDialog(namedObject);
                        if (dialog.ShowModal() == true)
                        {
                            newName = dialog.NewName;

                            if (dialog.ShowPreview.HasValue)
                            {
                                showPreview = dialog.ShowPreview.Value;
                            }
                        }
                    }

                    if (newName != null)
                    {
                        RefactorRenameElementInDesignerOnly(namedObject, newName, showPreview);
                    }
                }
            }
        }
コード例 #14
0
        private bool CheckForMissingAnnotations(EFObject efObject)
        {
            if (_checkAnnotations)
            {
                var miaEFobject = ModelItemAnnotation.GetModelItem(efObject.XObject);
                var isArtifact  = efObject is EFArtifact;
                if (miaEFobject == null &&
                    !isArtifact)
                {
                    if (!_noMIAList.Contains(efObject.XObject))
                    {
                        _noMIAList.Add(efObject.XObject);
                    }
                    return(true);
                }

                // Check for incorrect/stale annotations
                if (miaEFobject != efObject &&
                    !isArtifact &&
                    !IsValidGhostNode(efObject))
                {
                    if (!_incorrectMIAList.ContainsKey(efObject.XObject))
                    {
                        _incorrectMIAList.Add(efObject.XObject, miaEFobject);
                    }
                    return(true);
                }
            }

            return(false);
        }
コード例 #15
0
        internal static MappingViewModel CreateViewModel(EditingContext ctx, EFObject selection)
        {
            // clear out the xref so its clean for this new view model
            var xref = ModelToMappingModelXRef.GetModelToMappingModelXRef(ctx);

            xref.Clear();

            // we might be creating a view model for an entity or an association or a FunctionImport
            var entityType  = selection as EntityType;
            var association = selection as Association;
            var fim         = selection as FunctionImportMapping;

            // create the view model root
            MappingEFElement root = null;

            if (entityType != null)
            {
                root = ModelToMappingModelXRef.GetNewOrExisting(ctx, entityType, null);
            }
            else if (association != null)
            {
                root = ModelToMappingModelXRef.GetNewOrExisting(ctx, association, null);
            }
            else if (fim != null)
            {
                root = ModelToMappingModelXRef.GetNewOrExisting(ctx, fim, null);
            }
            else
            {
                throw new ArgumentException("selection");
            }

            return(new MappingViewModel(ctx, root));
        }
コード例 #16
0
        private bool CheckForNoXObject(EFObject efObject)
        {
            if (_checkXObject && efObject.XObject == null)
            {
                // some EFAttributes are not tied to XAttributes
                var efAttribute   = efObject as EFAttribute;
                var parentElement = efObject.Parent as EFElement;
                if (efAttribute != null &&
                    parentElement != null)
                {
                    var xattr = efAttribute.Namespace != null
                                    ? parentElement.GetAttribute(efObject.EFTypeName, efAttribute.Namespace.NamespaceName)
                                    : parentElement.GetAttribute(efObject.EFTypeName);

                    if (xattr == null)
                    {
                        return(true);
                    }
                }

                if (!_noXObjectList.Contains(efObject))
                {
                    _noXObjectList.Add(efObject);
                }
                return(true);
            }

            return(false);
        }
コード例 #17
0
        private static ModelElement CreateModelElementForEFObjectType(EFObject obj, Partition partition)
        {
            ModelElement modelElement = null;
            var t = obj.GetType();
            if (t == typeof(ConceptualEntityModel))
            {
                modelElement = new EntityDesignerViewModel(partition);
            }
            else if (t == typeof(ConceptualEntityType))
            {
                modelElement = new EntityType(partition);
            }
            else if (t == typeof(ConceptualProperty))
            {
                modelElement = new ScalarProperty(partition);
            }
            else if (t == typeof(ComplexConceptualProperty))
            {
                modelElement = new ComplexProperty(partition);
            }
            else if (t == typeof(Association))
            {
                modelElement = new ViewModel.Association(partition);
            }
            else if (t == typeof(EntityTypeBaseType))
            {
                modelElement = new Inheritance(partition);
            }
            else if (t == typeof(NavigationProperty))
            {
                modelElement = new ViewModel.NavigationProperty(partition);
            }

            return modelElement;
        }
コード例 #18
0
        internal static void RefactorRenameElement(EFObject objectToRefactor, string newName = null, bool showPreview = true)
        {
            if (objectToRefactor != null
                && objectToRefactor.Artifact != null)
            {
                var namedObject = objectToRefactor as EFNormalizableItem;
                if (namedObject != null)
                {
                    // If the API call did not supply a new name for the object, bring up the dialog for the user to input a name
                    if (newName == null)
                    {
                        var dialog = new RefactorRenameDialog(namedObject);
                        if (dialog.ShowModal() == true)
                        {
                            newName = dialog.NewName;

                            if (dialog.ShowPreview.HasValue)
                            {
                                showPreview = dialog.ShowPreview.Value;
                            }
                        }
                    }

                    if (newName != null)
                    {
                        RefactorRenameElementInDesignerOnly(namedObject, newName, showPreview);
                    }
                }
            }
        }
コード例 #19
0
        internal override DslModeling.ModelElement SynchronizeSingleDslModelElement(
            DslModeling.ModelElement parentViewModel, EFObject modelElement)
        {
            var t = modelElement.GetType();

            if (t == typeof(ConceptualEntityType))
            {
                return(TranslateEntityType(parentViewModel as EntityDesignerViewModel, modelElement as ConceptualEntityType));
            }
            else if (t == typeof(EntityTypeBaseType))
            {
                return(TranslateBaseType(parentViewModel as EntityDesignerViewModel, (modelElement).Parent as ConceptualEntityType));
            }
            else if (t == typeof(ModelNavigationProperty))
            {
                return(TranslateNavigationProperty(parentViewModel as ViewModelEntityType, modelElement as ModelNavigationProperty));
            }
            else if (t == typeof(ComplexConceptualProperty) ||
                     t == typeof(ConceptualProperty))
            {
                return(TranslateProperty(parentViewModel as ViewModelEntityType, modelElement as ModelProperty));
            }
            else if (t == typeof(ModelAssociation))
            {
                return(TranslateAssociation(parentViewModel as EntityDesignerViewModel, modelElement as ModelAssociation));
            }
            else if (t == typeof(DesignerModel.Diagram))
            {
                return(TranslateDiagramValues(parentViewModel as EntityDesignerViewModel, modelElement as DesignerModel.Diagram));
            }

            Debug.Assert(false, "modelElement with type= " + t.Name + " is not supported");

            return(null);
        }
コード例 #20
0
        internal static void NavigateTo(EFObject efobject)
        {
            if (efobject.RuntimeModelRoot() == null)
            {
                // nothing to navigate to, so just return;
                return;
            }

            if (efobject.RuntimeModelRoot() is StorageEntityModel)
            {
                // s-space object, so just return;
                return;
            }

            var selectionService = Services.DslMonitorSelectionService;
            Debug.Assert(selectionService != null, "Could not retrieve IMonitorSelectionService from Escher package.");
            var foundDSLElementMatchInDiagram = false;
            if (selectionService != null)
            {
                var singleDiagramDocView = selectionService.CurrentDocumentView as SingleDiagramDocView;

                if (singleDiagramDocView != null)
                {
                    foundDSLElementMatchInDiagram = NavigateToDSLNodeInDiagram(
                        singleDiagramDocView.Diagram as EntityDesignerDiagram, efobject);
                    if (foundDSLElementMatchInDiagram)
                    {
                        // The code below is added to ensure that the right doc-view is shown and activated.
                        singleDiagramDocView.Frame.Show();
                        return;
                    }
                }
            }

            // Retrieves the doc data for the efobject.
            var docdata = VSHelpers.GetDocData(Services.ServiceProvider, efobject.Uri.LocalPath) as ModelingDocData;
            Debug.Assert(docdata != null, "Could not find get doc data for artifact with URI:" + efobject.Uri.LocalPath);
            if (docdata != null)
            {
                foreach (var docView in docdata.DocViews)
                {
                    var singleDiagramDocView = docView as SingleDiagramDocView;
                    Debug.Assert(
                        singleDiagramDocView != null,
                        "Why the doc view is not type of SingleDiagramDocView? Actual type:" + docView.GetType().Name);
                    if (docView != null)
                    {
                        foundDSLElementMatchInDiagram = NavigateToDSLNodeInDiagram(
                            singleDiagramDocView.Diagram as EntityDesignerDiagram, efobject);
                        if (foundDSLElementMatchInDiagram)
                        {
                            // The code below is added to ensure that the right doc-view is shown and activated.
                            singleDiagramDocView.Frame.Show();
                            return;
                        }
                    }
                }
            }
        }
コード例 #21
0
 internal void Add(EFObject obj, ModelElement viewElement, EditingContext context)
 {
     if (_globalMapModelAndViewModel.ContainsKey(viewElement.Partition) == false)
     {
         _globalMapModelAndViewModel[viewElement.Partition] = new ModelToDesignerModelXRefItem();
     }
     _globalMapModelAndViewModel[viewElement.Partition].Add(obj, viewElement, context);
 }
コード例 #22
0
 internal ModelElement GetExisting(EFObject obj, Partition partition)
 {
     if (_globalMapModelAndViewModel.ContainsKey(partition))
     {
         return(_globalMapModelAndViewModel[partition].GetExisting(obj));
     }
     return(null);
 }
コード例 #23
0
 internal override void Initialize(EFObject obj, EditingContext editingContext, bool runningInVS)
 {
     base.Initialize(obj, editingContext, runningInVS);
     if (obj != null)
     {
         LoadDesignerInfoAndDescriptors(editingContext, obj.Artifact);
     }
 }
コード例 #24
0
 internal void Remove(EFObject obj, ModelElement viewElement)
 {
     Debug.Assert(
         _globalMapModelAndViewModel.ContainsKey(viewElement.Partition), "There is no modelToViewModel map for the partition");
     if (_globalMapModelAndViewModel.ContainsKey(viewElement.Partition))
     {
         _globalMapModelAndViewModel[viewElement.Partition].Remove(obj, viewElement);
     }
 }
コード例 #25
0
        internal void Remove(EFObject efObject)
        {
            ModelElement viewElement;

            if (_modelToViewModel.TryGetValue(efObject, out viewElement))
            {
                Remove(efObject, viewElement);
            }
        }
コード例 #26
0
        internal override void Initialize(EFObject obj, EditingContext editingContext, bool runningInVS)
        {
            _attribute      = obj as TEFAttribute;
            _editingContext = editingContext;
            _runningInVS    = runningInVS;

            // now perform any initialization on derived types
            OnTypeDescriptorInitialize();
        }
コード例 #27
0
        internal void Remove(EFObject efObject)
        {
            ModelElement viewElement;

            if (_modelToViewModel.TryGetValue(efObject, out viewElement))
            {
                Remove(efObject, viewElement);
            }
        }
コード例 #28
0
ファイル: ScalarProperty.cs プロジェクト: dotnet/ef6tools
        /// <summary>
        ///     Returns the top most ComplexProperty that this ScalarProperty lives in (null if the parent isn't a ComplexProperty)
        /// </summary>
        /// <returns></returns>
        internal ComplexProperty GetTopMostComplexProperty()
        {
            EFObject efObject = this;

            while (efObject.Parent is ComplexProperty)
            {
                efObject = efObject.Parent;
            }
            return(efObject as ComplexProperty);
        }
コード例 #29
0
 private static void Main(string[] args)
 {
     Mapper.CreateMap <EFObject, DTOObject>().
     ForMember(dtoo => dtoo.DS, opt => opt.MapFrom(efo => efo.D.ToString("g")));
     var fromDB = new EFObject()
     {
         D = DateTime.Now
     };
     var toDTO = Mapper.Map <EFObject, DTOObject>(fromDB);
 }
コード例 #30
0
        internal EFRenameContributorInput(EFObject objectToBeRenamed, string newName, string oldName)
        {
            ArgumentValidation.CheckForNullReference(objectToBeRenamed, "objectToBeRenamed");
            ArgumentValidation.CheckForNullReference(newName, "newName");
            ArgumentValidation.CheckForNullReference(oldName, "oldName");

            _objectToBeRenamed = objectToBeRenamed;
            _oldName = oldName;
            _newName = newName;
        }
コード例 #31
0
            private void CheckComplexType(EFObject obj)
            {
                var complexType = obj as ComplexType;

                if (complexType != null)
                {
                    CheckForCircularComplexTypeDefinition(complexType);
                    CheckForEnumPropertiesWithStoreGeneratedPattern(complexType);
                }
            }
コード例 #32
0
        internal EFRenameContributorInput(EFObject objectToBeRenamed, string newName, string oldName)
        {
            ArgumentValidation.CheckForNullReference(objectToBeRenamed, "objectToBeRenamed");
            ArgumentValidation.CheckForNullReference(newName, "newName");
            ArgumentValidation.CheckForNullReference(oldName, "oldName");

            _objectToBeRenamed = objectToBeRenamed;
            _oldName           = oldName;
            _newName           = newName;
        }
コード例 #33
0
            private void CheckAssociation(EFObject obj)
            {
                var a = obj as Association;

                if (a != null)
                {
                    CheckForAssociationWithoutAssociationSet(a);
                    CheckForUnmappedAssociation(a);
                    CheckAssociationForUnmappedEntityTypeKeys(a);
                }
            }
コード例 #34
0
            private void CheckEntityType(EFObject obj)
            {
                var et = obj as EntityType;

                if (et != null)
                {
                    CheckForEntityTypesWithoutEntitySets(et);
                    CheckForMultipleEntitySetsPerType(et);
                    CheckConceptualEntityType(et);
                }
            }
コード例 #35
0
        internal static IList <ModelElement> GetExisting(EditingContext context, EFObject obj)
        {
            IList <ModelElement> result;

            var xref = GetModelToDesignerModelXRef(context);

            result = xref.GetExisting(obj);

            Debug.Assert(result != null);
            return(result);
        }
コード例 #36
0
        internal ErrorInfo(Severity severity, string message, EFObject item, int errorCode, ErrorClass errorClass)
        {
            Debug.Assert(item != null, "item != null");
            _severity = severity;

            // prefix the error code in front of the error message.  This is here to help identify runtime errors that cause safe-mode
            _message    = String.Format(CultureInfo.CurrentCulture, Resources.Error_Message_With_Error_Code_Prefix, errorCode, message);
            _item       = item;
            _errorCode  = errorCode;
            _errorClass = errorClass;
        }
コード例 #37
0
 internal static void SetModelItem(XObject xobject, EFObject efobject)
 {
     if (xobject.Annotation <EFObject>() == null)
     {
         xobject.AddAnnotation(efobject);
     }
     else
     {
         xobject.RemoveAnnotations <EFObject>();
         xobject.AddAnnotation(efobject);
     }
 }
コード例 #38
0
 internal static void SetModelItem(XObject xobject, EFObject efobject)
 {
     if (xobject.Annotation<EFObject>() == null)
     {
         xobject.AddAnnotation(efobject);
     }
     else
     {
         xobject.RemoveAnnotations<EFObject>();
         xobject.AddAnnotation(efobject);
     }
 }
コード例 #39
0
        internal void UpdateSelection()
        {
            var newSelection = new HashSet <EFObject>();

            if (SelectedModelItem != null &&
                TreeControl.CurrentColumn < TreeControl.Columns.Length &&
                TreeControl.Columns[TreeControl.CurrentColumn] != null)
            {
                // use the current column index to find what type of column we have
                var currentColumnType = TreeControl.Columns[TreeControl.CurrentColumn].GetType();

                // we have to find the "descriptable" EFElements for the MappingEFElements here
                EFObject modelItemForDescriptor = null;
                if (SelectedModelItem is ScalarProperty)
                {
                    var scalarProperty = SelectedModelItem as ScalarProperty;
                    if (currentColumnType.IsAssignableFrom(typeof(ValueColumn)) ||
                        currentColumnType.IsAssignableFrom(typeof(PropertyColumn)))
                    {
                        modelItemForDescriptor = scalarProperty.Name.Target;
                    }
                    else if (currentColumnType.IsAssignableFrom(typeof(ColumnNameColumn)))
                    {
                        modelItemForDescriptor = scalarProperty.ColumnName.Target;
                    }
                }
                else if (SelectedModelItem is FunctionScalarProperty)
                {
                    var functionScalarProperty = SelectedModelItem as FunctionScalarProperty;
                    if (currentColumnType.IsAssignableFrom(typeof(PropertyColumn)))
                    {
                        modelItemForDescriptor = functionScalarProperty.Name.Target;
                    }
                    else if (currentColumnType.IsAssignableFrom(typeof(ParameterColumn)))
                    {
                        modelItemForDescriptor = functionScalarProperty.ParameterName.Target;
                    }
                }

                // if we were able to find a corresponding descriptable EFElement (if we allow the property window to
                // display the properties) then add the EFElement to a new MappingDetailsSelection and update the context
                if (modelItemForDescriptor != null)
                {
                    newSelection.Add(modelItemForDescriptor);
                }
            }
            if (_editingContext != null &&
                _editingContext.Items != null)
            {
                _editingContext.Items.SetValue(new MappingDetailsSelection(newSelection));
            }
        }
コード例 #40
0
            private static T GetFirstAntiDependencyOfType <T>(EFObject obj) where T : EFObject
            {
                var antiDeps = obj.GetAntiDependenciesOfType <T>();

                if (antiDeps != null)
                {
                    foreach (var t in antiDeps)
                    {
                        return(t);
                    }
                }
                return(null);
            }
コード例 #41
0
ファイル: ErrorInfo.cs プロジェクト: Cireson/EntityFramework6
        private ErrorInfo(Severity severity, string message, EFObject item, string itemPath, int errorCode, ErrorClass errorClass)
        {
            Debug.Assert(item == null ^ itemPath == null, "item and itemPath are mutually exclusive");

            _severity = severity;
            _item = item;
            _itemPath = itemPath;
            // prefix the error code in front of the error message.  This is here to help identify runtime errors that cause safe-mode
            _message = String.Format(CultureInfo.CurrentCulture, Resources.Error_Message_With_Error_Code_Prefix, errorCode, message);
            _item = item;
            _errorCode = errorCode;
            _errorClass = errorClass;
        }
コード例 #42
0
        internal void Add(EFObject obj, ModelElement viewElement, EditingContext context)
        {
            var viewModel = viewElement as EntityDesignerViewModel;
            if (viewModel != null)
            {
                viewModel.EditingContext = context;
            }

            Remove(obj);
            Remove(viewElement);

            _modelToViewModel.Add(obj, viewElement);
            _viewModelToModel.Add(viewElement, obj);
        }
コード例 #43
0
        internal override void Initialize(EFObject obj, EditingContext editingContext, bool runningInVS)
        {
            _entityTypeShape = obj as EntityTypeShape;

            Debug.Assert(_entityTypeShape != null, "EFObject is null or is not a type of EntityTypeShape.");

            if (_entityTypeShape != null)
            {
                var entityType = _entityTypeShape.EntityType.Target;
                Debug.Assert(entityType != null, "EntityTypeShape does not contain instance of an entity type.");
                if (entityType != null)
                {
                    base.Initialize(entityType, editingContext, runningInVS);
                }
            }
        }
コード例 #44
0
 private static ExplorerTreeViewItem GetTreeViewItemForEFObject(EFObject efobject, ExplorerFrame explorerFrame)
 {
     var treeViewItem = explorerFrame.ExplorerTreeRoot;
     if (null != efobject
         && !(efobject is EFArtifact))
     {
         var entityDesignArtifact = efobject.Artifact.ArtifactSet.GetEntityDesignArtifact();
         var editingContext =
             PackageManager.Package.DocumentFrameMgr.EditingContextManager.GetNewOrExistingContext(entityDesignArtifact.Uri);
         var element = explorerFrame.ExplorerViewModelHelper.GetExplorerEFElementForEFObject(editingContext, efobject);
         Debug.Assert(element != null, "Unable to find ExplorerEFElement for efobject of type " + efobject.GetType());
         if (element != null)
         {
             treeViewItem = explorerFrame.GetTreeViewItem(element, true);
         }
     }
     return treeViewItem;
 }
コード例 #45
0
        internal static ModelElement CreateConnectorModelElementForEFObjectType(EFObject obj, ModelElement end1, ModelElement end2)
        {
            ModelElement modelElement = null;
            var t = obj.GetType();
            var et1 = end1 as EntityType;
            var et2 = end2 as EntityType;
            if (t == typeof(Association))
            {
                Debug.Assert(et1 != null && et2 != null, "Unexpected end type for Association model element");
                modelElement = new ViewModel.Association(et1, et2);
            }
            else if (t == typeof(EntityTypeBaseType))
            {
                Debug.Assert(et1 != null && et2 != null, "Unexpected end type for Inheritance model element");
                modelElement = new Inheritance(et1, et2);
            }

            return modelElement;
        }
コード例 #46
0
        internal static XNamespace GetRootNamespace(EFObject node)
        {
            var currNode = node;
            EFDesignerInfoRoot model = null;
            XNamespace ns = null;

            while (currNode != null)
            {
                model = currNode as EFDesignerInfoRoot;
                if (model != null)
                {
                    ns = model.XNamespace;
                    break;
                }
                else
                {
                    currNode = currNode.Parent;
                }
            }

            return ns;
        }
コード例 #47
0
ファイル: EfiChange.cs プロジェクト: Cireson/EntityFramework6
 internal EfiChange(EfiChangeType changeType, EFObject changed)
 {
     _changeType = changeType;
     _changed = changed;
     _properties = new Dictionary<string, OldNewPair>();
 }
コード例 #48
0
        private bool CheckForMissingAnnotations(EFObject efObject)
        {
            if (_checkAnnotations)
            {
                var miaEFobject = ModelItemAnnotation.GetModelItem(efObject.XObject);
                var isArtifact = efObject is EFArtifact;
                if (miaEFobject == null
                    && !isArtifact)
                {
                    if (!_noMIAList.Contains(efObject.XObject))
                    {
                        _noMIAList.Add(efObject.XObject);
                    }
                    return true;
                }

                // Check for incorrect/stale annotations
                if (miaEFobject != efObject
                    && !isArtifact
                    && !IsValidGhostNode(efObject))
                {
                    if (!_incorrectMIAList.ContainsKey(efObject.XObject))
                    {
                        _incorrectMIAList.Add(efObject.XObject, miaEFobject);
                    }
                    return true;
                }
            }

            return false;
        }
コード例 #49
0
        private bool CheckForNoXObject(EFObject efObject)
        {
            if (_checkXObject && efObject.XObject == null)
            {
                // some EFAttributes are not tied to XAttributes
                var efAttribute = efObject as EFAttribute;
                var parentElement = efObject.Parent as EFElement;
                if (efAttribute != null
                    && parentElement != null)
                {
                    var xattr = efAttribute.Namespace != null
                                    ? parentElement.GetAttribute(efObject.EFTypeName, efAttribute.Namespace.NamespaceName)
                                    : parentElement.GetAttribute(efObject.EFTypeName);
                    if (xattr == null)
                    {
                        return true;
                    }
                }

                if (!_noXObjectList.Contains(efObject))
                {
                    _noXObjectList.Add(efObject);
                }
                return true;
            }

            return false;
        }
コード例 #50
0
        private bool CheckForUnresolved(EFObject efObject)
        {
            var efElement = efObject as EFElement;
            var itemBinding = efObject as ItemBinding;
            var parentElement = efObject.Parent as EFElement;
            if (_checkUnresolved)
            {
                if (efElement != null)
                {
                    if (!(efElement.State == EFElementState.Resolved || efElement.State == EFElementState.ResolveAttempted))
                    {
                        if (!_unresolvedList.Contains(efObject))
                        {
                            _unresolvedList.Add(efObject);
                        }
                        return true;
                    }
                }
                else if (itemBinding != null)
                {
                    if (itemBinding.Parent.State == EFElementState.Resolved
                        && (itemBinding.Resolved == false || itemBinding.IsStatusUnknown))
                    {
                        var xattr = parentElement.GetAttribute(efObject.EFTypeName);
                        if (xattr == null)
                        {
                            return true;
                        }

                        if (!_unresolvedList.Contains(efObject))
                        {
                            _unresolvedList.Add(efObject);
                        }
                        return true;
                    }
                }
            }

            return false;
        }
コード例 #51
0
        private bool CheckForDisposed(EFObject efObject)
        {
            if (_checkDisposed && efObject.IsDisposed)
            {
                if (!_disposedList.Contains(efObject))
                {
                    _disposedList.Add(efObject);
                }
                return true;
            }

            return false;
        }
コード例 #52
0
        // <summary>
        //     Returns a wrapper for the specified EFObject. The wrapper is the type descriptor
        //     that describes the properties that should be displayed for the EFObject.
        //     The returned wrapper should be handed to a property window control
        // </summary>
        public static ObjectDescriptor GetObjectDescriptor(EFObject obj, EditingContext editingContext, bool runningInVS)
        {
            if (obj != null)
            {
                Type objectDescriptorType;

                if (ObjectDescriptorTypes.TryGetValue(obj.GetType(), out objectDescriptorType))
                {
                    // create the descriptor wrapper for the EFObject object
                    var descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, objectDescriptorType, null, null);
                    descriptor.Initialize(obj, editingContext, runningInVS);
                    return descriptor;
                }
                else
                {
                    // special case for Property
                    var property = obj as Property;
                    if (property != null)
                    {
                        ObjectDescriptor descriptor = null;
                        if (property is ComplexConceptualProperty)
                        {
                            descriptor =
                                (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFComplexPropertyDescriptor), null, null);
                        }
                        else if (property.EntityModel.IsCSDL)
                        {
                            descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFPropertyDescriptor), null, null);
                        }
                        else
                        {
                            descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFSPropertyDescriptor), null, null);
                        }
                        descriptor.Initialize(obj, editingContext, runningInVS);
                        return descriptor;
                    }

                    // special case for Parameter
                    var parameter = obj as Parameter;
                    if (parameter != null)
                    {
                        ObjectDescriptor descriptor = null;
                        if (parameter.Parent is FunctionImport)
                        {
                            descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFParameterDescriptor), null, null);
                            descriptor.Initialize(obj, editingContext, runningInVS);
                            return descriptor;
                        }
                        else if (parameter.Parent is Function)
                        {
                            //Stored procedure parameter descriptor (EFSParameterDescriptor)
                            descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFSParameterDescriptor), null, null);
                            descriptor.Initialize(obj, editingContext, runningInVS);
                            return descriptor;
                        }
                    }
                }
            }

            return null;
        }
コード例 #53
0
 /// <summary>
 /// </summary>
 /// <param name="efObject"></param>
 /// <returns></returns>
 protected abstract EFElement GetNavigationTarget(EFObject efObject);
コード例 #54
0
        internal ExplorerEFElement GetExplorerEFElementForEFObject(EditingContext editingContext, EFObject targetEFObject)
        {
            if (targetEFObject == null)
            {
                return null;
            }

            // 
            //  Find the EFObject we want to navigate to for the given EFObject
            //
            var targetEFElement = GetNavigationTarget(targetEFObject);

            //
            // get all EFElement nodes on the path from our target node to the root.
            //
            var elementStack = new LinkedList<EFElement>();
            var e = targetEFElement;
            while (e != null)
            {
                elementStack.AddLast(e);
                e = e.Parent as EFElement;
            }

            //
            // unwind the stack, making sure that each element's explorer model node exists. 
            //
            var explorerElement = ViewModel.RootNode;
            while (elementStack.Count > 0)
            {
                var e2 = elementStack.Last.Value;
                elementStack.RemoveLast();
                var viewModelType = ModelToExplorerModelXRef.GetViewModelTypeForEFlement(editingContext, e2);
                // if viewModelType is null then that kind of EFElement is not displayed
                // in the Explorer (e.g. S-side StorageEntityContainer and children)
                if (null != viewModelType)
                {
                    var nextElement = ModelToExplorerModelXRef.GetNewOrExisting(editingContext, e2, explorerElement, viewModelType);

                    // There are "dummy-nodes" in the view-model that don't correspond to a node in the model.  
                    // We need to skip over them here. 
                    if (nextElement != null
                        && elementStack.Count > 0)
                    {
                        nextElement = nextElement.GetParentNodeForElement(elementStack.Last.Value);
                        Debug.Assert(nextElement != null, "GetParentNodeForElement returned null");
                    }

                    if (nextElement != null)
                    {
                        explorerElement = nextElement;
                    }
                }
            }
            Debug.Assert(explorerElement != null, "no explorer element found for targetEFObject");

            if (explorerElement != null)
            {
                //
                // now make sure that our target node in the explorer tree is visible.
                //
                explorerElement.ExpandTreeViewToMe();
            }

            return explorerElement;
        }
コード例 #55
0
 internal ICollection<EFObject> GetAntiDependenciesClosure(EFObject item)
 {
     return _dependencyGraph.GetAntiDependenciesClosure(item);
 }
コード例 #56
0
        internal void RemoveErrorsForEFObject(EFObject efobject, ErrorClass errorClass, int errorCodeToRemove)
        {
            Dictionary<ErrorClass, ICollection<ErrorInfo>> errorClass2ErrorInfo = null;
            _artifacts2Errors.TryGetValue(efobject.Artifact, out errorClass2ErrorInfo);
            if (errorClass2ErrorInfo != null)
            {
                foreach (var errors in GetErrorInfosUsingMask(errorClass2ErrorInfo, errorClass))
                {
                    var errorsToRemove = new List<ErrorInfo>();
                    foreach (var errorInfo in errors)
                    {
                        if (errorInfo.ErrorCode == errorCodeToRemove)
                        {
                            errorsToRemove.Add(errorInfo);
                        }
                    }

                    foreach (var errorInfo in errorsToRemove)
                    {
                        errors.Remove(errorInfo);
                    }
                }
            }
        }
コード例 #57
0
 /// <summary>
 ///     Gets a value indicating whether the EFObject should be visited.
 /// </summary>
 protected virtual bool ShouldVisit(EFObject efObject)
 {
     return true;
 }
コード例 #58
0
 /// <summary>
 ///     Gets a value indicating whether the EFObject is a valid ghost node.
 /// </summary>
 /// <remarks>
 ///     A valid ghost node will not cause an error if it has an incorrect or stale xlinq annotation.
 /// </remarks>
 protected virtual bool IsValidGhostNode(EFObject efObject)
 {
     return false;
 }
コード例 #59
0
        /// <summary>
        ///     This method makes sure that:
        ///     1. Any given item is not duplicated in the list
        ///     2. If the newDeleted item's parent is already in the list, don't add it
        ///     3. If any children of newDeleted are already in the list, remove the child item
        ///     This greatly optimizes the actually CleanUp() process.
        /// </summary>
        /// <param name="newDeleted"></param>
        private void AddToDeleteList(EFObject newDeleted)
        {
            // if newDeleted is already there, just return
            if (_itemsToDelete.Contains(newDeleted))
            {
                return;
            }

            // don't add newDeleted if any of its parents are already being deleted
            var container = newDeleted.Parent;
            while (container != null)
            {
                if (_itemsToDelete.Contains(container))
                {
                    return;
                }
                container = container.Parent;
            }

            // if the newDeleted item is the parent of an existing item
            // remove the child item and just add the parent below
            RemoveChildrenOfNewDeleted(newDeleted as EFContainer);

            // add the item
            _itemsToDelete.Add(newDeleted);
        }
コード例 #60
0
 internal abstract XNamespace GetRootNamespace(EFObject node);