Develop Reference

Xamarin Forms - Changes aren't detected

I've been trying to make a Custom search field that, on the fly, should add objects to a list when typing.
But for some reason it only shows the list with an item when i hot reload.
CreateHerdPageViewModel
public class CreateHerdPageViewModel : ViewModelBase
{
private IHerdService herdService;
private string searchInput;
public string SearchInput { get => searchInput;
set {
SetProperty(ref searchInput, value);
RaisePropertyChanged(nameof(HerdSearchResults));
}
}
private List<Herd> herdSearchResults;
public List<Herd> HerdSearchResults
{
get => herdSearchResults;
set {
SetProperty(ref herdSearchResults, value);
}
}
private List<Herd> allHerds;
public List<Herd> AllHerds { get => allHerds; set => SetProperty(ref allHerds, value); }
public DelegateCommand SearchChrOrAddressCommand { get; set; }
public CreateHerdPageViewModel(INavigationService navigationService, IHerdService herdService)
: base(navigationService)
{
this.herdService = herdService;
SearchChrOrAddressCommand = new DelegateCommand(SearchChrOrAddress);
}
private void SearchChrOrAddress()
{
Herd herdMatch = new Herd();
for (int i = 0; i < AllHerds.Count; i++)
{
herdMatch = AllHerds[i];
}
if (herdMatch.ChrAddress.Area.Contains(SearchInput))
{
if (HerdSearchResults.Contains(herdMatch) == false)
{
HerdSearchResults.Add(herdMatch);
RaisePropertyChanged(nameof(HerdSearchResults));
}
}
}
public async override void OnNavigatedTo(INavigationParameters parameters)
{
base.OnNavigatedTo(parameters);
AllHerds = await herdService.GetHerds();
HerdSearchResults = new List<Herd>();
}
}
}
CreateHerdPage.Xaml
xmlns:yummy="clr-namespace:Xamarin.Forms.PancakeView;assembly=Xamarin.Forms.PancakeView"
xmlns:b="clr-namespace:Prism.Behaviors;assembly=Prism.Forms"
xmlns:CustomRenderer="clr-namespace:ChrApp.CustomRenderer">
<yummy:PancakeView
Grid.Column="0"
Grid.Row="0"
Grid.ColumnSpan="3"
CornerRadius="10">
<CustomRenderer:NoUnderlineEntry
x:Name="SearchField"
Style="{StaticResource UpdateEntry}"
Margin="0"
TextChanged="RemovceSearchIcon"
Text="{Binding SearchInput}">
<CustomRenderer:NoUnderlineEntry.Behaviors>
<b:EventToCommandBehavior
EventName="TextChanged"
Command="{Binding SearchChrOrAddressCommand}"/>
</CustomRenderer:NoUnderlineEntry.Behaviors>
</CustomRenderer:NoUnderlineEntry>
</yummy:PancakeView>
As you can see, i've tried different approaches to make it recognize changes, but without luck.
Can someone enlighten me on what i'm missing?
Thanks in advance

So the issue was that I used an ordinary List, and not an ObservableCollection. So swithcing to this solved the issue.

UWP: Images in GridView cause memory leaks

I've developed an UWP app for managing forms. Each form can contain a lot of images. These images raise memory leaks, and I don't found any solution to fix this.
Currently all the datas are stored in a SQLite database, including the images, as byte[].
The root object is a "Car_Form", which contains the "Images" in an ObservableCollection:
public class Car_Forms : BasePoco
{
// form_id
private int _form_id;
[PrimaryKey, NotNull, AutoIncrement]
public int form_id
{
get
{ return _form_id; }
set
{
if (value != _form_id)
{
_form_id = value;
RaisePropertyChanged(() => form_id);
}
}
}
//...
// images
private ObservableCollection<Images> _images;
[Ignore]
public ObservableCollection<Images> images
{
get
{ return _images; }
set
{
if (value != _images)
{
_images = value;
RaisePropertyChanged(() => images);
}
}
}
}
The "Images" object contains the reference to the "Car_Form", the byte[] that is stored in the SQLite database in the "image1" field, and the BitmapImage that is used for the display, in the "image_display" field:
public class Images : BasePoco
{
// image_id
private int _image_id;
[PrimaryKey, NotNull, AutoIncrement]
public int image_id
{
get
{ return _image_id; }
set
{
if (value != _image_id)
{
_image_id = value;
RaisePropertyChanged(() => image_id);
}
}
}
//...
// image1
private byte[] _image1;
[NotNull]
public byte[] image1
{
get
{ return _image1; }
set
{
if (value != _image1)
{
_image1 = value;
RaisePropertyChanged(() => image1);
}
}
}
// form_id
private int? _form_id;
public int? form_id
{
get
{ return _form_id; }
set
{
if (value != _form_id)
{
_form_id = value;
RaisePropertyChanged(() => form_id);
}
}
}
// bitmap_image
private BitmapImage _bitmap_image;
[Ignore]
public BitmapImage bitmap_image
{
get
{ return _bitmap_image; }
set
{
if (value != _bitmap_image)
{
_bitmap_image = value;
RaisePropertyChanged(() => bitmap_image);
}
}
}
}
In my XAML page, the "Images" are in displayed in a GridView like this:
<GridView ItemsSource="{x:Bind ViewModel.CarForm.images, Mode=OneWay}"
IsItemClickEnabled="True"
SelectionMode="Single"
Grid.Row="1">
<GridView.ItemTemplate>
<DataTemplate x:DataType="models:Images">
<Border BorderBrush="Gray" BorderThickness="2"
Background="White"
Padding="10"
Height="160" Width="225">
<Image Stretch="UniformToFill"
Source="{x:Bind image1, Mode=OneWay, Converter={StaticResource ByteArrayToBitmapImageConverter}}" />
</Border>
</DataTemplate>
</GridView.ItemTemplate>
</GridView>
The datas are loaded from the SQLite database in the ViewModel:
private Car_Forms _carForm;
public Car_Forms CarForm
{
get { return _carForm; }
//set { Set(ref _carForm, value); }
set
{
this._carForm = value;
RaisePropertyChanged(() => CarForm);
}
}
private void LoadForm(Guid id)
{
CarForm = RepositoryService.GetById<Car_Forms>(id);
var formImages = RepositoryService.Where<Images>(im => im.IsDeleted == false && im.form_id == CarForm.form_id);
CarForm.images = new ObservableCollection<Images>(formImages);
//...
}
Then, the the BitmapImage is loaded through the "ByteArrayToBitmapImageConverter":
public class ByteArrayToBitmapImageConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter, string language)
{
try
{
var bImg = (byte[])value;
if (bImg != null)
{
BitmapImage biImg = ByteArrayBitmapHelper.AsBitmapImage(bImg);
return biImg;
}
else
{
return null;
}
}
catch (Exception e)
{
return null;
}
}
public object ConvertBack(object value, Type targetType, object parameter, string language)
{
return null;
}
}
public static BitmapImage AsBitmapImage(this byte[] byteArray)
{
if (byteArray != null)
{
using (var stream = new InMemoryRandomAccessStream())
{
stream.WriteAsync(byteArray.AsBuffer()).GetResults();
var image = new BitmapImage();
stream.Seek(0);
image.SetSource(stream);
return image;
}
}
return null;
}
I have also implemented a "Cleanup()" method on the ViewModel, where I "clean" all the objects that are used:
public override void Cleanup()
{
//...
CarForm.images.Clear();
CarForm = null;
base.Cleanup();
}
But when I launch the app, I can see that all resources are not released: each time that I open the same form and that I come back to the list, there are 30 Mo that are not released.
laucnh of the app: "Home" page
display of the form
back to the "Home" page
display of the form
back to the "Home" page
display of the form
display of the form
back to the "Home" page
display of the form
=> Would you have any explanation? How could I optimize it?

This is happening because pages in UWP are not cached by default, so everytime you navigate to page, new instance of that page is created. You can set the NavigationCacheMode property of the page to NavigationCacheMode.Required so the pages will be cached and navigation will not be causing memory leaks.

Wpf ICollectionView Binding item cannot resolve property of type object

I have bound a GridView with an ICollectionView in the XAML designer the properties are not known because the entity in the CollectionView have been transformed into type Object and the entity properties can't be accessed, it runs fine no error but the designer shows it as an error, if I bind to the collection I can access the properties fine
Example the entity is a Person with a string Name property I place them in an ObservableCollection<Person> and get the view from it and bind it to the GridView.ItemsSource now when I try to set the column header DataMemberBinding.FirstName property the designer shows it as an error
Cannot Resolve property 'FirstName' in data Context of type object
Is it a bug or is it Resharper playing tricks on me
Sample code:
public class Person
{
public string FirstName{
get { return _firstName; }
set { SetPropertyValue("FirstName", ref _firstName, value); }
}
}
public class DataService
{
public IDataSource DataContext { get; set; }
public ICollectionView PersonCollection{ get; set; }
public DataService()
{
DataContext = new DataSource();
//QueryableCollectionView is from Telerik
//but if i use any other CollectionView same thing
//DataContext Persons is an ObservableCollection<Person> Persons
PersonCollection = new QueryableCollectionView(DataContext.Persons);
}
}
<telerik:RadGridView x:Name="ParentGrid"
ItemsSource="{Binding DataService.PersonCollection}"
AutoGenerateColumns="False">
<telerik:RadGridView.Columns >
<telerik:GridViewDataColumn Header="{lex:Loc Key=FirstName}"
DataMemberBinding="{Binding FirstName}"/>
</telerik:RadGridView.Columns>
</telerik:RadGridView>

The warnings that Resharper is giving you in the XAML view is because the design-time view of the control does not know what type it's data-context is. You can use a d:DesignInstance to help with your bindings.
Add the following (replacing Assembly/Namespace/Binding Target names appropriately)
<UserControl x:Class="MyNamespace.UserControl1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup‐compatibility/2006"
mc:Ignorable="d"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:lcl="clr‐namespace:MyAssembly"
d:DataContext="{d:DesignInstance Type=lcl:ViewModel}">

Your entity has not been transformed in object, it's because the interface ICollectionView is not a generic collection so ReSharper has no way to know that it holds a collection of Person.
You can create a generic version of ICollectionView and use it for your PersonCollection property as demonstrated in this post https://benoitpatra.com/2014/10/12/a-generic-version-of-icollectionview-used-in-a-mvvm-searchable-list/.
First some interfaces:
public interface ICollectionView<T> : IEnumerable<T>, ICollectionView
{
}
public interface IEditableCollectionView<T> : IEditableCollectionView
{
}
The implementation:
public class GenericCollectionView<T> : ICollectionView<T>, IEditableCollectionView<T>
{
readonly ListCollectionView collectionView;
public CultureInfo Culture
{
get => collectionView.Culture;
set => collectionView.Culture = value;
}
public IEnumerable SourceCollection => collectionView.SourceCollection;
public Predicate<object> Filter
{
get => collectionView.Filter;
set => collectionView.Filter = value;
}
public bool CanFilter => collectionView.CanFilter;
public SortDescriptionCollection SortDescriptions => collectionView.SortDescriptions;
public bool CanSort => collectionView.CanSort;
public bool CanGroup => collectionView.CanGroup;
public ObservableCollection<GroupDescription> GroupDescriptions => collectionView.GroupDescriptions;
public ReadOnlyObservableCollection<object> Groups => collectionView.Groups;
public bool IsEmpty => collectionView.IsEmpty;
public object CurrentItem => collectionView.CurrentItem;
public int CurrentPosition => collectionView.CurrentPosition;
public bool IsCurrentAfterLast => collectionView.IsCurrentAfterLast;
public bool IsCurrentBeforeFirst => collectionView.IsCurrentBeforeFirst;
public NewItemPlaceholderPosition NewItemPlaceholderPosition
{
get => collectionView.NewItemPlaceholderPosition;
set => collectionView.NewItemPlaceholderPosition = value;
}
public bool CanAddNew => collectionView.CanAddNew;
public bool IsAddingNew => collectionView.IsAddingNew;
public object CurrentAddItem => collectionView.CurrentAddItem;
public bool CanRemove => collectionView.CanRemove;
public bool CanCancelEdit => collectionView.CanCancelEdit;
public bool IsEditingItem => collectionView.IsEditingItem;
public object CurrentEditItem => collectionView.CurrentEditItem;
public event NotifyCollectionChangedEventHandler CollectionChanged
{
add => ((ICollectionView) collectionView).CollectionChanged += value;
remove => ((ICollectionView) collectionView).CollectionChanged -= value;
}
public event CurrentChangingEventHandler CurrentChanging
{
add => ((ICollectionView) collectionView).CurrentChanging += value;
remove => ((ICollectionView) collectionView).CurrentChanging -= value;
}
public event EventHandler CurrentChanged
{
add => ((ICollectionView) collectionView).CurrentChanged += value;
remove => ((ICollectionView) collectionView).CurrentChanged -= value;
}
public GenericCollectionView([NotNull] ListCollectionView collectionView)
{
this.collectionView = collectionView ?? throw new ArgumentNullException(nameof(collectionView));
}
public IEnumerator<T> GetEnumerator()
{
return (IEnumerator<T>) ((ICollectionView) collectionView).GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return ((ICollectionView) collectionView).GetEnumerator();
}
public bool Contains(object item)
{
return collectionView.Contains(item);
}
public void Refresh()
{
collectionView.Refresh();
}
public IDisposable DeferRefresh()
{
return collectionView.DeferRefresh();
}
public bool MoveCurrentToFirst()
{
return collectionView.MoveCurrentToFirst();
}
public bool MoveCurrentToLast()
{
return collectionView.MoveCurrentToLast();
}
public bool MoveCurrentToNext()
{
return collectionView.MoveCurrentToNext();
}
public bool MoveCurrentToPrevious()
{
return collectionView.MoveCurrentToPrevious();
}
public bool MoveCurrentTo(object item)
{
return collectionView.MoveCurrentTo(item);
}
public bool MoveCurrentToPosition(int position)
{
return collectionView.MoveCurrentToPosition(position);
}
public object AddNew()
{
return collectionView.AddNew();
}
public void CommitNew()
{
collectionView.CommitNew();
}
public void CancelNew()
{
collectionView.CancelNew();
}
public void RemoveAt(int index)
{
collectionView.RemoveAt(index);
}
public void Remove(object item)
{
collectionView.Remove(item);
}
public void EditItem(object item)
{
collectionView.EditItem(item);
}
public void CommitEdit()
{
collectionView.CommitEdit();
}
public void CancelEdit()
{
collectionView.CancelEdit();
}
}
And finally the usage:
ICollectionView<Person> PersonCollectionView { get; }
In the constructor:
var view = (ListCollectionView) CollectionViewSource.GetDefaultView(PersonCollection);
PersonCollectionView = new GenericCollectionView<Person>(view);

Neither
d:DataContext="{d:DesignInstance Type=lcl:ViewModel}">
nor
GenericCollectionView
works directly for a DataGrid with a CollectionViewSource.
<DataGrid AutoGenerateColumns="False"
ItemsSource="{Binding collectionViewSource.View}"
SelectedItem="{Binding SelectedRow}"
We can't set "d:DataContext"; because, we often need to bind multiple properties to our viewmodel.
The CollectionViewSource creates new ListCollectionView which is runtime instantiated each time you set the Source property. Since setting the Source property is the only reasonable way to refresh a range of rows, we can't keep a GenericCollectionView around.
My solution is perhaps perfectly obvious, but I dumped the CollectionViewSource. By making creating a property
private ObservableCollection<ListingGridRow> _rowDataStoreAsList;
public GenericCollectionView<ListingGridRow> TypedCollectionView
{
get => _typedCollectionView;
set { _typedCollectionView = value; OnPropertyChanged();}
}
public void FullRefresh()
{
var listData = _model.FetchListingGridRows(onlyListingId: -1);
_rowDataStoreAsList = new ObservableCollection<ListingGridRow>(listData);
var oldView = TypedCollectionView;
var saveSortDescriptions = oldView.SortDescriptions.ToArray();
var saveFilter = oldView.Filter;
TypedCollectionView = new GenericCollectionView<ListingGridRow>(new ListCollectionView(_rowDataStoreAsList));
var newView = TypedCollectionView;
foreach (var sortDescription in saveSortDescriptions)
{
newView.SortDescriptions.Add(new SortDescription()
{
Direction = sortDescription.Direction,
PropertyName = sortDescription.PropertyName
});
}
newView.Filter = saveFilter;
}
internal void EditItem(object arg)
{
var view = TypedCollectionView;
var saveCurrentPosition = view.CurrentPosition;
var originalRow = view.TypedCurrentItem;
if (originalRow == null)
return;
var listingId = originalRow.ListingId;
var rawListIndex = _rowDataStoreAsList.IndexOf(originalRow);
// ... ShowDialog ... DialogResult ...
var lstData = _model.FetchListingGridRows(listingId);
_rowDataStoreAsList[rawListIndex] = lstData[0];
view.MoveCurrentToPosition(saveCurrentPosition);
view.Refresh();
}
After adding
public T TypedCurrentItem => (T)collectionView.CurrentItem;
To the GenericCollectionView provided by Maxence.

adding DataItems from one page to another in Windows Store Apps?

I am creating windows store app in VS2012 c#/xaml using WindowsStore GridApp Template.
And I am using Group and Items pages that this template has.
In Group page I am displaying a list of Rooms - datasource for this are RoomObjects
public class RoomsObject : LivingDataCommon
{
public RoomsObject()
: base(String.Empty, String.Empty)
{
}
public RoomsObject(String ID, String title)
: base(ID, title)
{ }
//adds Actors to collection of a Room, will be used for Rooms pages
private ObservableCollection<ActorsObject> _actors = new ObservableCollection<ActorsObject>();
public ObservableCollection<ActorsObject> Actors
{
get { return this._actors; }
}
}
In Item page I am displaying a list of Actors that each Room has - datasource for this are ActorsObjects
public class ActorsObject : LivingDataCommon
{
public ActorsObject()
: base(String.Empty, String.Empty)
{
}
public ActorsObject(String ID, String title, Boolean homepage,String function, RoomsObject room, double currentValue, ActorsType type, AllActors allactors)
: base(ID, title)
{
this._function = function;
this._room = room;
this._currentValue = currentValue;
this._type = type;
this._homepage = homepage;
this._all = allactors;
}
//set home page appearance
private Boolean _homepage = false;
public static Boolean Homepage = false;
//sets value of an actor
private double _currentValue;
public double CurrentValue
{
get { return this._currentValue; }
set { this.SetProperty(ref this._currentValue, value); }
}
//sets and gets function code
private string _function = string.Empty;
public string Function
{
get { return this._function; }
set { this.SetProperty(ref this._function, value); }
}
//gets room properity
private RoomsObject _room;
public RoomsObject Room
{
get { return this._room; }
set { this.SetProperty(ref this._room, value); }
}
private ActorsType _type;
public ActorsType Type
{
get { return this._type; }
set { this.SetProperty(ref this._type, value); }
}
private AllActors _all;
public AllActors All
{
get { return this._all; }
set { this.SetProperty(ref this._all, value); }
}
}
When I select an Actor in Items page my appbar appears and I need on my pinButton to allow that Actor to be displayed at Home.xaml as well.
I am assuming that I should create an empty ObservableCollection an add selected items to it, and then use that collection as data source for Home.xaml, but I am new at c#, I cant get it work..
Please any suggestions, code, or some different ways to do this?

Hmm.. just to give you some input. I would probably create a "global" static class for this, which you can access from your entire app (public static class PinnedActors). Within this class you have your static ObservableCollection.

Bind a single RIA Entity in View

I can't get why this works (binds a single Car to RadDataForm):
xaml:
<tk:RadDataForm ItemsSource="{Binding Path=Cars}"
AutoGenerateFields="True" DataContext="{Binding}" />
viewmodel:
public void OnNavigatedTo(NavigationContext navigationContext)
{
carId = int.Parse(navigationContext.Parameters["IdRecord"]);
Cars= _carContext.GetCarById(carId);
}
private IEnumerable<Car> cars;
public IEnumerable<Car> Cars
{
get { return this.cars; }
set
{
if (this.cars!= value)
{
this.cars= value;
this.RaisePropertyChanged(() => this.Cars);
}
}
}
and this not:
xaml:
<tk:RadDataForm CurrentItem="{Binding Path=CurrentCar}"
AutoGenerateFields="True" DataContext="{Binding}" />
viewmodel:
public void OnNavigatedTo(NavigationContext navigationContext)
{
carId = int.Parse(navigationContext.Parameters["IdRecord"]);
CurrentCar= _carContext.GetCarById(carId).FirstOrDefault();
}
private Car currentCar;
public Car CurrentCar
{
get { return this.currentCar; }
set
{
if (this.currentCar!= value)
{
this.currentCar= value;
this.RaisePropertyChanged(() => this.CurrentCar);
}
}
}
I don't want a IEnumerable<> because I want to get a single Entity.
And, by the way, I want to understand what is going wrong...

When binding to a single entity you should use CurrentItem instead of ItemsSource.