Archiv | Visual Studio 2010 RSS for this section

Anleitung zur Planung einer App

Wie jeder gute Entwickler weiss, um gute Software zuschreiben benötigt es guter Planung. Dieses ist auch bei der Entwicklung von Apps für WP7 und WP8 nötig. Aber für die Windows Phone Plattform werden sehr gute Tools angeboten. Einen Vorschlag wie eine Entwicklung vonstatten gehen kann, zeigt der Blogbeitrag Metro App Diary.

Es werden verschiedene Tool mit angesprochen, schaut einfach diesen Post mal an.

Quelle:

Metro App Diary

 

Advertisements

Windows Phone Icons Maker

Nach langer beruflicher Umstellung und Projektwechsel, habe ich es mal wieder geschafft ein wenig für meinen Blog zu schreiben. Es hat sich viel getan im WP7 Lager und ich versuche wieder auf den Stand der Zeit zu kommen. Bei der Suche nach neuen netten Tools bin ich auch wieder fündig geworden

Wer wie ich auch kein Designer ist benötigt für App Bilder und um diese einfach und schnell herzustellen kommt jetzt auf Codeplex ein Tool daher das einen die Arbeit sehr vereinfacht.

heart.png

Abb. : Der Windows Phone Icons Maker.

Dieses Tool schneidet die Bilder Marketplace konform zu.

Quelle :

Codeplex ProjectSite

HttpWebRequest und Tombstoning in WP7

Für eine aktuelle App muss ich mit Webservices arbeiten, und es ist schon echt sportlich das Handling mit mehreren Webservice Aufrufen. Aber wo es wirklich schwierig ist, Wenn mitten in der Abfrage auch noch Tombstoning und Application Switching unterstützt wird wird es echt kompliziert. Aber habe einen Lösungsansatz gefunden.

catch (WebException e) { if (e.Status == WebExceptionStatus.RequestCanceled) 
MessageBox.Show("Looks like your request was interrupted by tombstoning"); 
else { using (HttpWebResponse response = (HttpWebResponse)e.Response) 
{ MessageBox.Show("I got an http error of: " + response.StatusCode.ToString()); } } }

Abb.: try catch an wird auf WebException geprüft

Durch diese Fehlerbehandlung ist es möglich die Oberfläche zu informieren was passiert ist.Es sieht einfach aus aber Trick liegt eben im Detail.

Quelle:

HttpWebRequest (WebClient) And Tombstoning in Windows Phone 7

Die Wolke liefert Daten

Für zukünftige Aktivitäten im Business Bereich bietet Microsoft ja SQL Azure auf seiner Cloud Windows Azure an. Seit einer gewissen Zeit arbeite ich mich so ein wenig dort ein. Jetzt habe ich gestern einen Post gefunden wie man die Datenhaltung aufbaut in Verbindung mit WP7.

image

Abb.: Datenhaltung SQL Azure nach WP7

In einer Step für Step Anleitung wird vom Service Contract über den Service hin zur fertigen Anwendung alles ausführlich beschrieben. Der Transfer geht über JSON DTO Service. Es ist wirklich nicht so schwer dieses zuverstehen. Hier noch ein paar Zeilen Code:
using System.Runtime.Serialization;

namespace RESTJSONStudentsData
{
[DataContract]
public class PersonDTO
{
[DataMember]
public string StudentId { get; set; }
[DataMember]
public string FirstName { get; set; }
[DataMember]
public string LastName { get; set; }

}
}

Abb.: Data Contract

Und jetzt nich die WCF Verbindung kurz beschrieben:
using System.Collections.Generic;
using System.ServiceModel;
using System.ServiceModel.Web;

namespace RESTJSONStudentsData
{
[ServiceContract]
public interface IService1
{
[OperationContract]
[WebGet(UriTemplate=“/Persons“,
RequestFormat=WebMessageFormat.Json,
ResponseFormat=WebMessageFormat.Json]
List<PersonDTO> GetPersons();
}
}

Hier sollte hervorgehoben werden die Json Format Einstellungen. Diese können dann ganz einfach per DataContractJsonSerializer konvertiert werden. So ist es echt einfach geworden.

Quelle:

Data from Cloud on Windows Phone

 

MetroFlow ein Control der neuen Generation

Wer Apps mit vielen Bildern oder Video Anzeige hat sollte sich mal das neue MetroFlow Control vom Coding4Fun toolkit beschäftigen. Auf WindowsPhoneGeek, wir in einem ersten Beispiel beschrieben wie dieses Control funktioniert.

Alles was benötigt wird ist die neuste Version des Coding4Fun Toolkits.

Mit nur wenigen Zeilen Code ist schon eine erste Anzeige des Controls möglich,

<c4f:MetroFlow>
    <c4f:MetroFlowData Title="Sample 1" />
    <c4f:MetroFlowData
                    ImageUri="Images/bmw1.jpg"
                    Title="BMW 1" />
    <c4f:MetroFlowData ImageUri="Images/bmw1.jpg"/>
</c4f:MetroFlow>
Xaml-Code

image

Abb.: Control in Action

Viele weitere Beispiel findet ihr unter den Ouellen

Quellen:

Coding4Fun Toolkit
 
Getting Started with the Coding4Fun toolkit MetroFlow Control
 

Navigation mit Service

Der NavigationService im MVVM ist für die Steuerung zwischen Views und ViewModel. Wie man diesen Service erstellt und einsetzt, dass kann man im  Rob Garfoot’s Blog in seinem aktuellen Post lesen.

Hier das grundliegende Interface:

public interface INavigationService
{
    void Navigate(string url);
}
Danach sollte die Class erstellt werden
public class NavigationService : INavigationService
{
    private readonly System.Windows.Navigation.NavigationService _navigationService;
    public NavigationService(System.Windows.Navigation.NavigationService navigationService)
    {
        _navigationService = navigationService;
    }
    public void Navigate(string url)
    {
        _navigationService.Navigate(new Uri(url, UriKind.RelativeOrAbsolute));
    }
}
Nun noch im ViewModel integrieren
public interface INavigable
{
    INavigationService NavigationService { get; set; }
}
und ein Navigator im ViewModel
public static class Navigator
{
    public static INavigable GetSource(DependencyObject obj)
    {
        return (INavigable)obj.GetValue(SourceProperty);
    }
    public static void SetSource(DependencyObject obj, INavigable value)
    {
        obj.SetValue(SourceProperty, value);
    }
   public static readonly DependencyProperty SourceProperty =
        DependencyProperty.RegisterAttached("Source", typeof(INavigable), typeof(Navigator), new PropertyMetadata(OnSourceChanged));
    private static void OnSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        Page page = (Page) d;
        page.Loaded += PageLoaded;
    }
    private static void PageLoaded(object sender, RoutedEventArgs e)
    {
        Page page = (Page)sender;
        INavigable navSource = GetSource(page);
        if (navSource != null)
        {
            navSource.NavigationService = new NavigationService(page.NavigationService);
        }
    }
}
Hier noch ein wenig wie das im XAML eingesetzt wird:
<navigation:Page x:Class="SLNavigation.Page1"
           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
           mc:Ignorable="d"
           xmlns:navigation="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation"
           xmlns:SLNavigation="clr-namespace:SLNavigation"
           d:DesignWidth="640" d:DesignHeight="480"
           Title="Page1 Page"
           SLNavigation:Navigator.Source="{Binding}"
    >
Quelle:

Augmented Reality XAML Control für WP7 und WinRT

Ich habe ja schon über Augmented Reality Theorie berichtet, aber jetzt hat Morten Nielsen in seinem Blog einen Post erstellt, wie man ein XAML Control erstellt. Das Besondere daran ist, das es nicht nur das Windows Phone unterstützt sondern auch die kommende Windows Version 8 oder besser bekannt für Entwickler Win RT.

Mit diesem Control baue ich eine Informations App für Industrieanlagen. Nun zeige ich noch einige Codeauschnitte:

<ar:ARPanel>
    <TextBlock Text="North" ar:ARPanel.Direction="0,0" />
    <TextBlock Text="East"  ar:ARPanel.Direction="0,90" />
    <TextBlock Text="South" ar:ARPanel.Direction="0,180" />
    <TextBlock Text="West"  ar:ARPanel.Direction="0,270" />
    <TextBlock Text="Up"    ar:ARPanel.Direction="90,0" />
    <TextBlock Text="Down"  ar:ARPanel.Direction="-90,0" />
</ar:ARPanel>

Abb.: AR Control Panel in Xaml

Nachfolgend noch ein Beispiel wie man den Motion Sensor in Win RT und Windows Phone gemeinsam nutzen kann.

#if WINDOWS_PHONE
    if (Microsoft.Devices.Sensors.Motion.IsSupported)
    {
        motion = new Microsoft.Devices.Sensors.Motion();
        motion.CurrentValueChanged += motion_CurrentValueChanged;
        motion.Start();
#elif WINRT
    motion = Windows.Devices.Sensors.OrientationSensor.GetDefault();
    if (motion != null)
    {
        motion.ReadingChanged += motion_CurrentValueChanged;
#endif
    }
    else
    {
        throw new InvalidOperationException("Motion sensor not supported on this device");
    }
#endif

Quellen:

Augmented Reality on Windows Phone and Windows 8 Metro style apps

 

Splash Screen mit ProgressBar und Backroundworker

hat auf seinem Blog debug mode….. einen Post erstellt, mit einem Designvorschlag für einen Splash Screen mit ProgressBar. Diese Vorgehensweise erlaubt es dem Entwickler seine benötigten Daten für die App geschickt zu verstecken und somit den User nicht nervt mit ständigen Nachladen von Daten. Diese vorgehensweise ist meist aber nur sinnvoll wenn es sich um eine Online App handelt.

image

Abb.: Aufbau des Design Vorschlags

Der Aufbau ist als Usercontrol implementiert, und recht einfach nachvollziehbar.

<Grid x:Name=“LayoutRoot“ Height=“800″ Width=“640″>
<Image Source=“waitsymbol.jpg“
Margin=“0,0,0,0″
VerticalAlignment=“Top“
Height=“650″
HorizontalAlignment=“Left“
Width=“400″
Stretch=“Fill“/>
<TextBlock
Text=“loading….“
HorizontalAlignment=“Left“
Style=“{StaticResource PhoneTextTitle2Style}“
Margin=“185,656,0,97″
/>
<ProgressBar x:Name=“SpalshScreenProgressbar“
Width=“380″
HorizontalAlignment=“Left“
IsIndeterminate=“True“
Margin=“49,707,0,74″ />
</Grid>

Das Control wird einfach in ein PopUp als Child Objekt hinzugefügt.

image

Nun noch den Backround Service einbauen und fertig ist Splash Screen.

clip_image001

Abb.: Fertiges Control im Einsatz

Quelle:

How to create Splash Screen with Progress Bar in Windows Phone 7

Fokus Trigger in Silverlight

Über Mark Monster hatte ich ja schon öfter mal einen Beitrag, heute beschreibt er wie man einen Focus Trigger in Silverlight aufbaut. Einen klassische Trigger sieht wie folgt aus:

public class FocusOnEvent : TargetedTriggerAction<Control>
{
    protected override void Invoke(object parameter)
    {
        Target.Focus();
    }
}

Dieser ist schnell implementiert. Aber sinnvoller ist ein Default Trigger aus dem TargetTriggerAction zu implementieren, dieser könnte wie folgt aussehen:

[DefaultTrigger(typeof(FrameworkElement), typeof(EventTrigger), "Loaded")]
public class FocusOnEvent : TargetedTriggerAction<Control>
{
    protected override void Invoke(object parameter)
    {
        Target.Focus();
    }
}
Und hier der XAML Beispielcode:
<i:Interaction.Triggers>
    <i:EventTrigger>
        <Behaviors:FocusOnEvent TargetName="TitleTextBox" />
    </i:EventTrigger>
</i:Interaction.Triggers>
Quelle:
Mark Monster Blog

 

Codesnippets für MVVM RelayCommand

Wer viel mit dem Galasoft MVVM Light Framework arbeitet kann sich die Arbeit mit Commands vereinfachen. Jan Hannemann hat auf seinem Blog einen Post erstellt mit Codesnippets für eben diese Definition von RelayCommands.

<?xml version="1.0" encoding="utf-8" ?>
 2: <CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
 3: <CodeSnippet Format="1.0.0">
 4: <Header>
 5: <Title>RelayCommand</Title>
 6: <Shortcut>relaycmd</Shortcut>
 7: <Description>Define a RelayCommand</Description>
 8: <Author>Jan Hannemann</Author>
 9: <SnippetTypes>
 10: <SnippetType>Expansion</SnippetType>
 11: </SnippetTypes>
 12: </Header>
 13: <Snippet>
 14: <Declarations>
 15: <Literal>
 16: <ID>CMD</ID>
 17: <ToolTip>Command Property</ToolTip>
 18: <Default>Command</Default>
 19: </Literal>
 20: <Literal>
 21: <ID>CMDF</ID>
 22: <ToolTip>Command Field</ToolTip>
 23: <Default>command</Default>
 24: </Literal>
 25: </Declarations>
 26: <Code Language="csharp">
 27: <![CDATA[
 28: private RelayCommand _$CMDF$;
 29: public RelayCommand $CMD$
 30: {
 31: get
 32: {
 33: return _$CMDF$;
 34: }
 35: }
 36:
 37: /// <summary>
 38: /// Checks whether the $CMD$ command is executable
 39: /// </summary>
 40: private bool Can$CMD$()
 41: {
 42: return true;
 43: }
 44:
 45: /// <summary>
 46: /// Executes the $CMD$ command 
 47: /// </summary>
 48: private void Exec$CMD$()
 49: {
 50: throw new NotImplementedException();
 51: }
 52:
 53: //cut and paste this line to your ctor
 54: _$CMDF$ = new RelayCommand(Exec$CMD$, Can$CMD$);
 55: $end$]]>
 56: </Code>
 57: </Snippet>
 58: </CodeSnippet>
 59: </CodeSnippets>

Diese Codesnippets erleichtern die tägliche Arbeit doch ein wenig, und das Leben des Entwicklers wird wieder etwas schöner.

Quelle:

Bitdisaster