// *** Constructors *** public ShareSourceManager(INavigationManager navigationManager) { if (navigationManager == null) throw new ArgumentNullException(nameof(navigationManager)); _navigationManager = navigationManager; navigationManager.NavigationStack.NavigatedTo += NavigationManager_NavigatedTo; }
// *** Methods *** public void NavigateTo(object page, INavigationBase navigationManager) { _navigationManager = navigationManager; if (!_eventHandlersRegistered) { RegisterEventHandlers(); _eventHandlersRegistered = true; } SetWindowContent(page); }
private static void IncludeCollection <TEntity, TIncludingEntity, TIncludedEntity>( QueryContext queryContext, IEnumerable <ValueBuffer> innerValueBuffers, Func <QueryContext, ValueBuffer, TIncludedEntity> innerShaper, TEntity entity, INavigationBase navigation, INavigationBase inverseNavigation, Action <TIncludingEntity, TIncludedEntity> fixup, bool trackingQuery) where TIncludingEntity : class, TEntity where TEntity : class where TIncludedEntity : class { if (entity is TIncludingEntity includingEntity) { var collectionAccessor = navigation.GetCollectionAccessor(); collectionAccessor.GetOrCreate(includingEntity, forMaterialization: true); if (trackingQuery) { queryContext.SetNavigationIsLoaded(entity, navigation); } else { navigation.SetIsLoadedWhenNoTracking(entity); } foreach (var valueBuffer in innerValueBuffers) { var relatedEntity = innerShaper(queryContext, valueBuffer); if (!trackingQuery) { fixup(includingEntity, relatedEntity); if (inverseNavigation != null) { inverseNavigation.SetIsLoadedWhenNoTracking(relatedEntity); } } } } }
public void GetRelationshipType_Customer_CustomerSetting_Should_Return_OneToOne() { // Arrange var context = _fixture.GetContext(); var customer = new MockNorthwind().Customers[0]; customer.CustomerSetting = new CustomerSetting { CustomerId = customer.CustomerId, Customer = customer, Setting = "Setting 1" }; INavigationBase nav = context.Entry(customer).Navigation(nameof(customer.CustomerSetting)).Metadata; // Act RelationshipType?relType = nav.GetRelationshipType(); // Assert Assert.Equal(RelationshipType.OneToOne, relType); }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public virtual async Task LoadAsync( INavigationBase navigation, InternalEntityEntry entry, CancellationToken cancellationToken = default) { if (entry.EntityState == EntityState.Detached) { throw new InvalidOperationException(CoreStrings.CannotLoadDetached(navigation.Name, entry.EntityType.DisplayName())); } // Short-circuit for any null key values for perf and because of #6129 var keyValues = GetLoadValues(navigation, entry); if (keyValues != null) { await Query(navigation, keyValues).LoadAsync(cancellationToken) .ConfigureAwait(false); } entry.SetIsLoaded(navigation); }
private static object[] GetLoadValues(INavigationBase navigation, InternalEntityEntry entry) { var properties = ((INavigation)navigation).IsOnDependent ? ((INavigation)navigation).ForeignKey.Properties : ((INavigation)navigation).ForeignKey.PrincipalKey.Properties; var values = new object[properties.Count]; for (var i = 0; i < values.Length; i++) { var value = entry[properties[i]]; if (value == null) { return(null); } values[i] = value; } return(values); }
protected NavigationEntry(InternalEntityEntry internalEntry, INavigationBase navigationBase, bool collection) : base(internalEntry, navigationBase) { if (collection && !navigationBase.IsCollection) { throw new InvalidOperationException( CoreStrings.CollectionIsReference( navigationBase.Name, internalEntry.EntityType.DisplayName(), nameof(ChangeTracking.EntityEntry.Collection), nameof(ChangeTracking.EntityEntry.Reference))); } if (!collection && navigationBase.IsCollection) { throw new InvalidOperationException( CoreStrings.ReferenceIsCollection( navigationBase.Name, internalEntry.EntityType.DisplayName(), nameof(ChangeTracking.EntityEntry.Reference), nameof(ChangeTracking.EntityEntry.Collection))); } }
private static void IncludeReference <TEntity, TIncludingEntity, TIncludedEntity>( QueryContext queryContext, TEntity entity, TIncludedEntity relatedEntity, INavigationBase navigation, INavigationBase inverseNavigation, Action <TIncludingEntity, TIncludedEntity> fixup, bool trackingQuery) where TIncludingEntity : class, TEntity where TEntity : class where TIncludedEntity : class { if (entity is TIncludingEntity includingEntity) { if (trackingQuery && navigation.DeclaringEntityType.FindPrimaryKey() != null) { // For non-null relatedEntity StateManager will set the flag if (relatedEntity == null) { queryContext.SetNavigationIsLoaded(includingEntity, navigation); } } else { navigation.SetIsLoadedWhenNoTracking(includingEntity); if (relatedEntity != null) { fixup(includingEntity, relatedEntity); if (inverseNavigation != null && !inverseNavigation.IsCollection) { inverseNavigation.SetIsLoadedWhenNoTracking(relatedEntity); } } } } }
static (Type itemType, bool isCollection) GetNavigationType(INavigationBase navigation) { var navigationType = navigation.ClrType; Type?collectionType; if (navigationType.IsGenericType && navigationType.GetGenericTypeDefinition() == typeof(ICollection <>)) { collectionType = navigationType; } else { collectionType = navigationType.GetInterfaces() .SingleOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(ICollection <>)); } if (collectionType == null) { return(navigationType, false); } return(collectionType.GetGenericArguments().Single(), true); }
/// <summary>Static getter for Keywords</summary> public static IEnumerable <string> GetKeywords(INavigationBase that) { return(that.GetPropertyValue <IEnumerable <string> >("keywords")); }
private static IClrCollectionAccessor CreateGeneric <TEntity, TCollection, TElement>(INavigationBase navigation) where TEntity : class where TCollection : class, IEnumerable <TElement> where TElement : class { var entityParameter = Expression.Parameter(typeof(TEntity), "entity"); var valueParameter = Expression.Parameter(typeof(TCollection), "collection"); var memberInfoForRead = navigation.GetMemberInfo(forMaterialization: false, forSet: false); navigation.TryGetMemberInfo(forConstruction: false, forSet: true, out var memberInfoForWrite, out _); navigation.TryGetMemberInfo(forConstruction: true, forSet: true, out var memberInfoForMaterialization, out _); var memberAccessForRead = (Expression)Expression.MakeMemberAccess(entityParameter, memberInfoForRead); if (memberAccessForRead.Type != typeof(TCollection)) { memberAccessForRead = Expression.Convert(memberAccessForRead, typeof(TCollection)); } var getterDelegate = Expression.Lambda <Func <TEntity, TCollection> >( memberAccessForRead, entityParameter).Compile(); Action <TEntity, TCollection>?setterDelegate = null; Action <TEntity, TCollection>?setterDelegateForMaterialization = null; Func <TEntity, Action <TEntity, TCollection>, TCollection>?createAndSetDelegate = null; Func <TCollection>?createDelegate = null; if (memberInfoForWrite != null) { setterDelegate = CreateSetterDelegate(entityParameter, memberInfoForWrite, valueParameter); } if (memberInfoForMaterialization != null) { setterDelegateForMaterialization = CreateSetterDelegate(entityParameter, memberInfoForMaterialization, valueParameter); } var concreteType = new CollectionTypeFactory().TryFindTypeToInstantiate( typeof(TEntity), typeof(TCollection), navigation.DeclaringEntityType.Model[CoreAnnotationNames.FullChangeTrackingNotificationsRequiredAnnotation] != null); if (concreteType != null) { var isHashSet = concreteType.IsGenericType && concreteType.GetGenericTypeDefinition() == typeof(HashSet <>); if (setterDelegate != null || setterDelegateForMaterialization != null) { if (isHashSet) { createAndSetDelegate = (Func <TEntity, Action <TEntity, TCollection>, TCollection>)_createAndSetHashSet .MakeGenericMethod(typeof(TEntity), typeof(TCollection), typeof(TElement)) .CreateDelegate(typeof(Func <TEntity, Action <TEntity, TCollection>, TCollection>)); } else if (IsObservableHashSet(concreteType)) { createAndSetDelegate = (Func <TEntity, Action <TEntity, TCollection>, TCollection>)_createAndSetObservableHashSet .MakeGenericMethod(typeof(TEntity), typeof(TCollection), typeof(TElement)) .CreateDelegate(typeof(Func <TEntity, Action <TEntity, TCollection>, TCollection>)); } else { createAndSetDelegate = (Func <TEntity, Action <TEntity, TCollection>, TCollection>)_createAndSet .MakeGenericMethod(typeof(TEntity), typeof(TCollection), concreteType) .CreateDelegate(typeof(Func <TEntity, Action <TEntity, TCollection>, TCollection>)); } } if (isHashSet) { createDelegate = (Func <TCollection>)_createHashSet .MakeGenericMethod(typeof(TCollection), typeof(TElement)) .CreateDelegate(typeof(Func <TCollection>)); } else if (IsObservableHashSet(concreteType)) { createDelegate = (Func <TCollection>)_createObservableHashSet .MakeGenericMethod(typeof(TCollection), typeof(TElement)) .CreateDelegate(typeof(Func <TCollection>)); } else { createDelegate = (Func <TCollection>)_create .MakeGenericMethod(typeof(TCollection), concreteType) .CreateDelegate(typeof(Func <TCollection>)); } } return(new ClrICollectionAccessor <TEntity, TCollection, TElement>( navigation.Name, getterDelegate, setterDelegate, setterDelegateForMaterialization, createAndSetDelegate, createDelegate));
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public virtual void NavigationCollectionChanged( InternalEntityEntry entry, INavigationBase navigationBase, IEnumerable <object> added, IEnumerable <object> removed) => _navigationFixer.NavigationCollectionChanged(entry, navigationBase, added, removed);
public void RecordReferencedUntrackedEntity( object referencedEntity, INavigationBase navigation, InternalEntityEntry referencedFromEntry) => throw new NotImplementedException();
public static IEnumerable <string> GetKeywords(INavigationBase that) => that.Value <IEnumerable <string> >("keywords");
protected NavigationEntry(InternalEntityEntry internalEntry, INavigationBase navigation) : base(internalEntry, navigation) { }
// *** Constructors *** public GoBackCommand(INavigationBase navigationManager) { this.navigationManager = navigationManager; }
/// <summary> /// Creates a new instance of the <see cref="MaterializeCollectionNavigationExpression" /> class. /// </summary> /// <param name="subquery">An expression reprensenting how to get value from query to create the collection.</param> /// <param name="navigation">A navigation associated with this collection.</param> public MaterializeCollectionNavigationExpression(Expression subquery, INavigationBase navigation) { Subquery = subquery; Navigation = navigation; }
// *** Constructors *** public NavigationContext(INavigationBase current) { _current = current; }
// *** Constructors *** public NavigateToCommand(INavigationBase navigationManager, string pageName, object arguments) { this.navigationManager = navigationManager; this.pageName = pageName; this.arguments = arguments; }
public NavigationView(INavigationBase navigationManager) : base(s_emptyPage) { _navigationManager = navigationManager; }
/// <summary>Static getter for Hide in Navigation</summary> public static bool GetUmbracoNavihide(INavigationBase that) { return(that.GetPropertyValue <bool>("umbracoNavihide")); }
// *** Methods *** public void NavigateTo(object page, INavigationBase navigationManager) { NavigateToCalls.Add(Tuple.Create(page, navigationManager)); }
public static string GetSeoMetaDescription(INavigationBase that) => that.Value <string>("seoMetaDescription");
// *** Constructors *** public NavigateToCommand(INavigationBase navigationManager, string pageName, object arguments) { _navigationManager = navigationManager; _pageName = pageName; _arguments = arguments; }
private CollectionShaperExpression AddCollectionProjection( ShapedQueryExpression subquery, INavigationBase navigation, Type elementType) => new CollectionShaperExpression(
// *** Constructors *** public NavigateToState(INavigationBase navigationManager, string pageName, object arguments) { this.NavigationManager = navigationManager; this.PageName = pageName; this.Arguments = arguments; }
// *** Constructors *** public GoBackCommand(INavigationBase navigationManager) { _navigationManager = navigationManager; navigationManager.NavigationStack.PropertyChanged += NavigationStack_PropertyChanged; }
protected NavigationEntry([NotNull] InternalEntityEntry internalEntry, [NotNull] INavigationBase navigation) : base(internalEntry, navigation) { }
public CollectionEntry(InternalEntityEntry internalEntry, INavigationBase navigationBase) : base(internalEntry, navigationBase) { }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public void DetectNavigationChange(InternalEntityEntry entry, INavigationBase navigationBase) { var snapshotValue = entry.GetRelationshipSnapshotValue(navigationBase); var currentValue = entry[navigationBase]; var stateManager = entry.StateManager; if (navigationBase.IsCollection) { var snapshotCollection = (IEnumerable?)snapshotValue; var currentCollection = (IEnumerable?)currentValue; var removed = new HashSet <object>(LegacyReferenceEqualityComparer.Instance); if (snapshotCollection != null) { foreach (var entity in snapshotCollection) { removed.Add(entity); } } var added = new HashSet <object>(LegacyReferenceEqualityComparer.Instance); if (currentCollection != null) { foreach (var entity in currentCollection) { if (!removed.Remove(entity)) { added.Add(entity); } } } if (added.Count > 0 || removed.Count > 0) { if (_loggingOptions.IsSensitiveDataLoggingEnabled) { if (navigationBase is INavigation navigation) { _logger.CollectionChangeDetectedSensitive(entry, navigation, added, removed); } else if (navigationBase is ISkipNavigation skipNavigation) { _logger.SkipCollectionChangeDetectedSensitive(entry, skipNavigation, added, removed); } } else { if (navigationBase is INavigation navigation) { _logger.CollectionChangeDetected(entry, navigation, added, removed); } else if (navigationBase is ISkipNavigation skipNavigation) { _logger.SkipCollectionChangeDetected(entry, skipNavigation, added, removed); } } stateManager.InternalEntityEntryNotifier.NavigationCollectionChanged(entry, navigationBase, added, removed); } } else if (!ReferenceEquals(currentValue, snapshotValue)) { Check.DebugAssert(navigationBase is INavigation, "Issue #21673. Non-collection skip navigations not supported."); var navigation = (INavigation)navigationBase; if (_loggingOptions.IsSensitiveDataLoggingEnabled) { _logger.ReferenceChangeDetectedSensitive(entry, navigation, snapshotValue, currentValue); } else { _logger.ReferenceChangeDetected(entry, navigation, snapshotValue, currentValue); } stateManager.InternalEntityEntryNotifier.NavigationReferenceChanged(entry, navigation, snapshotValue, currentValue); } }
public void NavigateTo(object page, INavigationBase navigationManager) { //Ensures the nav menu reflects reality when navigation is triggered outside of the nav menu buttons. if (AppFrame.Content != null) { var item = (from p in this.navlist where p.DestPageName == navigationManager.NavigationStack.CurrentPage.PageName select p).SingleOrDefault(); if (item == null && navigationManager.NavigationStack.CanGoBack) { // In cases where a page drills into sub-pages then we'll highlight the most recent // navigation menu item that appears in the BackStack foreach (var entry in navigationManager.NavigationStack.Reverse()) { item = (from p in this.navlist where p.DestPageName == entry.PageName select p).SingleOrDefault(); if (item != null) break; } } var container = (ListViewItem)NavMenuList.ContainerFromItem(item); // While updating the selection state of the item prevent it from taking keyboard focus. If a // user is invoking the back button via the keyboard causing the selected nav menu item to change // then focus will remain on the back button. if (container != null) container.IsTabStop = false; NavMenuList.SetSelectedItem(container); if (container != null) container.IsTabStop = true; } // Perform the navigation this.NavigationManager = navigationManager; AppFrame.Content = page; Window.Current.Content = this; // After a successful navigation set keyboard focus to the loaded page if (page is Page && page != null) { var control = (Page)page; control.Loaded += Page_Loaded; } }
/// <summary> /// Sets the navigation for given entity as loaded. /// </summary> /// <param name="entity">The entity instance.</param> /// <param name="navigation">The navigation property.</param> public virtual void SetNavigationIsLoaded(object entity, INavigationBase navigation) // InitializeStateManager will populate the field before calling here => _stateManager !.TryGetEntry(entity) !.SetIsLoaded(navigation);
// *** Constructors *** public ShareSourceManager(INavigationManager navigationManager) { this.navigationManager = navigationManager; navigationManager.NavigatedTo += NavigationManager_NavigatedTo; }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> public virtual IClrCollectionAccessor?Create(INavigationBase navigation) => !navigation.IsCollection || navigation.IsShadowProperty() ? null : Create(navigation, navigation.TargetEntityType);
public void NavigationReferenceChanged( InternalEntityEntry entry, INavigationBase navigationBase, object oldValue, object newValue) { }
/// <summary>Static getter for Description</summary> public static string GetSeoMetaDescription(INavigationBase that) { return(that.GetPropertyValue <string>("seoMetaDescription")); }
public void NavigationCollectionChanged( InternalEntityEntry entry, INavigationBase navigationBase, IEnumerable <object> added, IEnumerable <object> removed) => CollectionChanged.Add(Tuple.Create(entry, navigationBase, added, removed));
public static global::System.Collections.Generic.IEnumerable <string> GetKeywords(INavigationBase that) => that.Value <global::System.Collections.Generic.IEnumerable <string> >("keywords");
private static Expression <Func <TSourceEntity, IEnumerable <TEntity> > > BuildSelectManyLambda(INavigationBase navigation) { var entityParameter = Expression.Parameter(typeof(TSourceEntity), "e"); return(Expression.Lambda <Func <TSourceEntity, IEnumerable <TEntity> > >( Expression.MakeMemberAccess( entityParameter, navigation.PropertyInfo), entityParameter)); }
public static bool GetUmbracoNavihide(INavigationBase that) => that.Value <bool>("umbracoNavihide");
// *** Methods *** public void NavigateTo(object page, INavigationBase navigationManager) { _navigationManager = navigationManager; SetWindowContent(page); }