Come utilizzare i dati campione di Blend come dati reali?

Si spera che l'applicazione utilizzi lo schema MVVM in modo che possa produrre dati di Blend. Credo che questo sia l'approccio raccomandato. Se non lo conosci, prenditi del tempo per familiarizzare con esso.

Incluse alcuni frammenti di codice qui sotto, ma non preoccupatevi troppo del codice, seguite semplicemente lo schema.

Per unire i tuoi dati:

Configura MMVM nel progetto e nel costruttore del modello View, controlla se sei in Blend. Passa in un agente che gestirà il recupero dei dati per te.

public MainPageViewModel(IUserAgent userAgent)
        {
            //Design Mode Check, use WCF when not in design mode
            if (!base.InDesignerTool)
            {
                if (userAgent != null)
                {
                    UserAgent = userAgent;
                }
            }
            else // In Cider (CS 2010 designer) or Expression Blend, don't call WCF, so use the UserAgentDesigner instead
            {
                UserAgent = new UserAgentDesigner();
            }

            //Wire up the commands to the view model.
            this.WireUpCommands();
        }

Abbiamo un'interfaccia per popolare la vista, chiamata IUserAgent, e due implementazioni, una per una chiamata di servizio e una per la fase di progettazione (dati falsi):

namespace SilverlightApplicationChannelWCF.ServiceAgent
{
    /// <summary>
    /// The User Agent Interface
    /// 
    /// We use an interface so the the get data method is loosely coupled with the view model.
    /// 
    /// We could get the data from a WCF service, or manufacture data if in a design environment like
    /// Expression Blend.
    /// </summary>
    public interface IUserAgent
    {
        /// <summary>
        /// Gets users
        /// </summary>
        /// <param name="callback">The call back when the call completes.</param>
        void GetUsers(System.EventHandler<DataTransferObjectEventArgs> callback);

        /// <summary>
        /// Saves users
        /// </summary>
        /// <param name="users">The users to save.</param>
        /// <param name="callback">The call back when the method completes.</param>
        void SaveUsers(DataTransferObject dto, System.EventHandler<DataTransferObjectEventArgs> callback);
    }
}

Quindi abbiamo due classi di implementazione, una che riceve i dati dal servizio:

public class UserAgent : IUserAgent  

E un altro che produce dati per il progettista:

 public class UserAgentDesigner : IUserAgent

Ogni implementazione restituisce lo stesso tipo di DTO, per il designer i dati sono prodotti:

        /// <summary>
        /// Gets users.
        /// </summary>
        /// <param name="callback"></param>
        public void GetUsers(System.EventHandler<DataTransferObjectEventArgs> callback)
        {
            //Wire up the call back
            this.AgentGetUsersCompleted += callback;

            DataTransferObject dto = new DataTransferObject();
            //Return the users
            List<BaseDTO> users = new List<BaseDTO>();

            users.Add(new UserDTO() { FirstName = "Jon", LastName = "Raynor (Design Data)", IsDirty = false });
            users.Add(new UserDTO() { FirstName = "Sunil", LastName = "Munikar(Design Data)", IsDirty = false });
            users.Add(new UserDTO() { FirstName = "Aaron", LastName = "McIver(Design Data)", IsDirty = false });

            //Assign users to DTO
            dto.DataTransferObjects = users;

            //Setup and assign event args
            DataTransferObjectEventArgs e = new DataTransferObjectEventArgs();
            e.Dto = dto;

            //Raise an event for the callback
            if (!ReferenceEquals(null, AgentGetUsersCompleted))
            {
                AgentGetUsersCompleted(this, e);
            }
        }

Ora puoi distribuire la tua applicata in Blend e compila i dati senza utilizzare una chiamata di servizio WCF in modo che l'UI possa essere progettata e resa con i dati.

I dati del tempo di progettazione e i dati di runtime sono diversi.

Puoi certamente utilizzare la stessa struttura di classe che hai creato per i tuoi dati di esempio quando configuri il tuo supporto per l'origine dati dell'oggetto che potrebbe fornirti la necessità di sfruttare la struttura che hai definito per i dati di esempio.