Páginas dinâmicas usando o controle de tabela Dinâmica

Question

Ser novo para o Windows 7/8 telefone desenvolvimento arena...Eu estou gostando de trabalhar com o windows phone tremendamente...no entanto, tem havido uma curva de aprendizado e tanto para conhecer.

Com o que disse, o que eu estou tentando fazer é criar uma página que é dinamicamente vinculado a uma estrutura de dados que vai apresentar um número n de dinâmica de páginas, e cada página dinâmica terão diferentes XAML para exibir o conteúdo.

Eu olhei sobre este projeto de código artigohttp://www.codeproject.com/Articles/113152/Applying-Data-Templates-Dynamically-by-Type-in-WP7) e ele usa uma caixa de listagem para controlar a exibição...mas o que me interessa é fazer a mesma coisa, mas com uma dinâmica de página.

Eu aprendem melhor pelo exemplo...aqui estão as classes de enlace de dados para os controles, que eu GOSTARIA DE USAR ...

  public class ParkingLot : List<Car>
  {
    public ParkingLot() { }

    // this will be the pivot page title
    public string Lot { get; set; }

    // the list of cars will be displayed on the page
  }
  public class Car
  {
    public Car() { }

    // this will be the data that is displayed in the pivot page for each car
    public string Width { get; set; }
    public string Length { get; set; }
  }


  public class Library : List<Book>
  {
    public Library() { }

    // this will be the pivot page title
    public string Location { get; set; }

    // the list of books will be displayed on the page
  }
  public class Book
  {
    public Book() { }

    // this is the data that will be displayed for each book
    public string ISBN { get; set; }
    public string Title { get; set; }
  }

Eu não sei se seria melhor postar o código aqui...ou apenas para ter você todos os olhada no artigo sobre o projeto de Código, vou postar o código que modificado a partir do artigo...na esperança de que alguém pode me ajudar a descobrir isso:

xaml :

    <phone:PhoneApplicationPage x:Class="dynDataTemplateTest.MainPage"
                        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                        xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"
                        xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
                        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
                        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
                        xmlns:loc="clr-namespace:dynDataTemplateTest.View"

                        xmlns:controls="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls"

                        FontFamily="{StaticResource PhoneFontFamilyNormal}"
                        FontSize="{StaticResource PhoneFontSizeNormal}"
                        Foreground="{StaticResource PhoneForegroundBrush}"
                        SupportedOrientations="Portrait"
                        Orientation="Portrait"
                        mc:Ignorable="d"
                        d:DesignWidth="480"
                        d:DesignHeight="768"
                        shell:SystemTray.IsVisible="True"
                        DataContext="{Binding Main, Source={StaticResource Locator}}">

<!--LayoutRoot contains the root grid where all other page content is placed-->
<Grid x:Name="LayoutRoot"
      Background="Transparent">
    <Grid.RowDefinitions>
        <RowDefinition Height="Auto" />
        <RowDefinition Height="*" />
    </Grid.RowDefinitions>

    <!--TitlePanel contains the name of the application and page title-->
    <StackPanel x:Name="TitlePanel"
                Grid.Row="0"
                Margin="24,24,0,12">
        <TextBlock x:Name="ApplicationTitle"
                   Text="{Binding ApplicationTitle}"
                   Style="{StaticResource PhoneTextNormalStyle}" />
        <TextBlock x:Name="PageTitle"
                   Text="{Binding PageName}"
                   Margin="-3,-8,0,0"
                   Style="{StaticResource PhoneTextTitle1Style}" />
    </StackPanel>

    <!--ContentPanel - place additional content here-->
    <Grid x:Name="ContentGrid"
          Grid.Row="1">
        <Grid.RowDefinitions>
            <RowDefinition Height="*" />
            <RowDefinition Height="Auto" />
        </Grid.RowDefinitions>

        <loc:DynamicContentControl Content="{Binding SelectedItem}"
                            HorizontalContentAlignment="Stretch"
                            VerticalContentAlignment="Stretch" />

        <controls:Pivot ItemsSource="{Binding Path=Items}" SelectedItem="{Binding Path=SelectedItem}" >

            <controls:Pivot.HeaderTemplate>
                <DataTemplate>
                    <TextBlock Text="{Binding Path=DisplayName}" FontSize="30" FontWeight="Bold" Margin="5"/>
                </DataTemplate>
            </controls:Pivot.HeaderTemplate>


            <controls:Pivot.ItemsPanel>
                <ItemsPanelTemplate>
                    <StackPanel Orientation="Horizontal" HorizontalAlignment="Center"></StackPanel>
                </ItemsPanelTemplate>
            </controls:Pivot.ItemsPanel>

        </controls:Pivot>

    </Grid>
</Grid>

Aqui é o DataTemplateSelector classe

public static class DataTemplateSelector
{

    public static DataTemplate GetTemplate(ViewModelBase param)
    {
        Type t = param.GetType();
        return App.Current.Resources[t.Name] as DataTemplate;
    }
}

Aqui é a dinâmica de controle de Conteúdo:classe pública DynamicContentControl:ContentControl { protected override void OnContentChanged(objeto oldContent, objeto newContent) { da base de dados.OnContentChanged(oldContent, newContent);isso.ContentTemplate = mSator.Modelo.DataTemplateSelector.GetTemplate(newContent como ViewModelBase);}
}

Aqui está a primeira vista xaml:

<Grid x:Name="LayoutRoot" Background="{StaticResource PhoneChromeBrush}">
    <TextBlock Margin="20" Foreground="Green" FontSize="32"
           FontWeight="Bold" Text="{Binding Path=FirstProperty}"
           ></TextBlock>
</Grid>

( a segunda vista xaml pode ser a primeira vista, apenas mudar a cor )

Aqui é o FirstViewModel classe (do artigo)

    public class FirstViewModel : SelectableViewModel
{
    public FirstViewModel()
    {
        DisplayName = "First";
        FirstProperty = "this is the first property";
    }


    private string firstProp;
    public string FirstProperty
    {
        get { return firstProp; }
        set
        {
            if (firstProp != value)
            {
                firstProp = value;
                RaisePropertyChanged("FirstProperty");
            }
        }
    }

}

Aqui é o SelectableView Modelo de classe

 public class SelectableViewModel : ViewModelBase
 {
    public SelectableViewModel()
    {
    }

    string dispName;
    public string DisplayName
    {
        get { return dispName; }

        set
        {
            if (dispName != value)
            {
                dispName = value;
                RaisePropertyChanged("DisplayName");
            }
        }
    }
}

Aqui é o principal modelo de modo de exibição de classe:

    public class MainViewModel : ViewModelBase
{
    public string ApplicationTitle
    {
        get
        {
            return "Dynamic Data Templates";
        }
    }

    public string PageName
    {
        get
        {
            return "Main page";
        }
    }

    private List<SelectableViewModel> viewModels;
    public MainViewModel()
    {
        viewModels = new List<SelectableViewModel>();

        viewModels.Add(new FirstViewModel());
        viewModels.Add(new SecondViewModel());

        SelectedItem = viewModels[0];
    }

    public List<SelectableViewModel> Items
    {
        get
        {
            return viewModels;
        }
    }

    SelectableViewModel selItem;
    public SelectableViewModel SelectedItem
    {
        get { return selItem; }
        set 
        {
            if (selItem != value)
            {
                selItem = value;
                RaisePropertyChanged("SelectedItem");
            }
        }
    }
}

Mais uma vez obrigado por ajudar !

Answer 1

Como você diz que você ainda está aprendendo, deixe-me explicar por que ter um número n de Pivô itens é uma má idéia:

1. Você provavelmente vai executar em problemas de performance devido a quantidade de conteúdo em uma única página.Com uma lista de itens que podem ser virtualizados.O controle de tabela Dinâmica não suporta virtualização do adicionados dinamicamente PivotItems.

2. É difícil para as pessoas para navegar até um item desejado, quando há muitas PivotItems como não existe uma maneira de obter rapidamente para o que é desejado.Digamos que você tenha 30 itens na dinâmica, mas queria chegar ao 15 um.Isso exigiria um monte de dedo e se a fazê-lo rapidamente seria fácil ir além do que foi procurado.

A Dinâmica de Controle destina-se a ser usado para um dos dois propósitos:

1. Para mostrar os diferentes pontos de vista de um conjunto de dados.i.e.O aplicativo de e-mail mostra diferentes visões de uma caixa de correio em cada PivotItem, filtrados por "todos", "não lidas", "marcada" e "urgente".

2. Para mostrar os diferentes pedaços de dados relacionados.i.e.Quando a exibição de um contato individual/pessoa que você vê diferentes acções relacionadas com a informação e agrupadas em diferentes PivotItems:"perfis", "o que há de novo", "fotos" e "história".

A intenção não é que o Pivô de controle deve ser usado como um recipiente para grandes quantidades de conteúdo, como n coleções de modelo de listas.
Sugere-se que o número máximo de itens em um pivô deve ser 7 para evitar problemas com o desempenho e a usabilidade.

Tudo em tudo, não usando o controle de tabela Dinâmica em uma das formas que ela foi intencionada pode causar problemas de desempenho para você como um desenvolvedor e questões de usabilidade para as pessoas que utilizam o aplicativo.
Ambas são situações que devem ser evitadas.

Desculpe, isso não é uma resposta direta à sua pergunta, mas espero que isso irá ajudá-lo a desenvolver uma melhor aplicação (ou apps).;)