Weiteres Bild

Da einige CSharp-ler und .NET-ler noch auf Windows Phone setzen möchte ich gerne hier meine neue App Datei-Explorer X zum Beta Test bereitstellen.
Im Gegensatz zu den vielen anderen Datei Manager habe ich hier etwas neues Entwickelt um den Umgang mit den Dateien möglichst einfach und schnell zu bewerkstelligen.
Die App hat zwei größenveränderbare Fenster die sowohl hochkant wie auch quer funktionieren. Die Dateien können per Drag and Drop verschoben oder kopiert werden.
Die aktuelle Version hat eine volle One Drive und Dropbox Integration.

Ihr könnt die App mit diesem Token Link herunterladen.
https://account.microsoft.com/billing/redeem?mstoken=D9KRJ-7DQ79-2DMJ7-7GFTC-79DRZ

Zieht sie euch runter und schreibt mir eure Meinungen, Vorschläge usw.
Danke!

Ein aktuelles Video findet ihr hier
http://www.xtrose.de/index.php?s=app&i=44&pa=vi

Ich habe jetzt kurzerhand eine blank App erstellt und habe als Netzwerkpfad MyCloud eingegeben, welche offen ist und wollte testen ob dies unter Windows auch der Fall. Hier lässt sich der Ordner öffnen. Unter Windows 10 Mobil allerdings nicht.
Denke das dies hier einfach nicht möglich ist 😦

Danke für die schnelle Antwort.
Die Berechtigungen in der Manisfest habe ich alle hinzugefügt.
Die Rechte für die Freigabe habe ich auf alle bzw. jeden gestellt....?

Hatte eigentlich vor in meinem Datei-Explorer X Verbindungen zum Netzwerk mit einzubinden.

Dies sei nach dieser Vorlage hier auch möglich
Berechtigungen für den Dateizugriff

Unter Windows 10 Mobile bekomme ich aber nur eine Exception> Fehlermeldung:

"The system cannot find the file specified"

Kennt sich jemand damit aus, oder kennt jemand einen anderen Weg um über uwp aufs Netzwerk zuzugreifen?

StorageFolder folderTest;
try
{
    folderTest = await StorageFolder.GetFolderFromPathAsync(@"\\XTROSE-DESKTOP\Test");
}
    catch (Exception e)
{

}

Mehrere meiner Apps und Spiele rufen Daten über PHP ab.
Ich habe dafür extra mal eine Klasse geschrieben mit der man POST Variblen an die Seite schicken kann und die auch einen Timeout ausgibt, wenn die Verbindung fehlschlägt.

In PHP gibst du einfach das was abgerufen werden soll aus

<?PHP
echo "AUSGABE";
?>

// Namespace
namespace MyApp
{

    // Abfrage von url
    class ClassQuery
    {

        // Abfrage Url
        public static string url = "";
        // Abfrage Post Variablen
        public static string post_data = "";
        // Ergebnis der Abfrage
        public static string result = "";
        // Strings zum prüfen der Abfrage
        public static string source = "";
        public static string checksum = "";
        // Timer zur Abfrage vom Server
        public static DispatcherTimer timer_query = new DispatcherTimer();
        // Startzeit der Abfrage
        public static DateTime start_time = new DateTime();




        // Button Abfrage starten
        private void btn_Abfrage_Click(object sender, RoutedEventArgs e)
        {
            // Post Script Variablen erstellen um an die Seite zu senden
            Dictionary<string, string> post_parameters = new Dictionary<string, string>();
            post_parameters.Add("Variable1", "Var1");
            post_parameters.Add("Variable2", "Var2");

            // Seite abfragen
            query("http://www.deineSeite.php", post_parameters);
        }


        // Dein Ergebnis
        public static process_result()
        {
            // Timer stoppen
            timer_query.Stop();

            // DEIN ERGEBNIS
            result = source.Trim();
        }





        // Abfrage erstellen
        public void query(string query_url, Dictionary<string, string> query_post_parameters)
        {
            // Aktuelle Abfrage stoppen
            timer_query.Stop();
            timer_query.Interval = new TimeSpan(0, 0, 0, 0, 200);
            timer_query.Tick += timer_query_tick;

            // Abfrage Daten zurücksetzen
            source = "";
            checksum = "";
            result = "";

            // Neue Aabfrage erstellen
            start_time = DateTime.Now;
            url = query_url;
            post_data = "";
            foreach (string key in query_post_parameters.Keys)
            {
                post_data += HttpUtility.UrlEncode(key) + "="
                      + HttpUtility.UrlEncode(query_post_parameters[key]) + "&";
            }

            // Abfragen
            query_api();

            // Timer starten
            timer_query.Start();
        }


        // Timer Abfrage
        public void timer_query_tick(object sender, object e)
        {
            // Auf Time out prüfen
            DateTime now = DateTime.Now;
            if ((start_time.AddSeconds(10)) > now)
            {
                // Ladevorgang kontrollieren
                if (source != "")
                {
                    // wenn geladene Quelle = Zu ladende Quelle // Quelltext komplett geladen
                    if (source == checksum)
                    {
                        // Prüfsumme löschen
                        checksum = "";
                        // Ergebnis verarbeiten
                        process_result();
                    }
                    //wenn geladene Quelle != Zu ladende Quelle //Quelltext noch nicht komplett geladen
                    else
                    {
                        //feedtemp zu aktuellem Feed machen
                        checksum = source;
                    }
                }
            }
            // Bei Time out
            else
            {
                //HIER TIMEOUT NACHRICHT ERSTELLEN
                timer_query.Stop();
            }
        }


        // Webseite versuchen zu erreichen
        public void query_api()
        {
            try
            {
                // Abfrage erstellen
                HttpWebRequest request = HttpWebRequest.CreateHttp(url);
                request.Method = "POST";
                request.ContentType = "application/x-www-form-urlencoded";
                // POST Method Abfrage starten
                request.BeginGetRequestStream(new AsyncCallback(GetRequestStreamCallback),request);
            }
            catch
            {
                // HIER NACHRICHT BEI VERBINDUNGSFEHLER
                timer_query.Stop();
            }
        }


        // POST Method Abfrage
        public static void GetRequestStreamCallback(IAsyncResult callbackResult)
        {
            HttpWebRequest request = (HttpWebRequest)callbackResult.AsyncState;
            // End the stream request operation
            Stream postStream = request.EndGetRequestStream(callbackResult);

            // Create the post data
            byte[] byteArray = Encoding.UTF8.GetBytes(post_data);

            // Add the post data to the web request
            postStream.Write(byteArray, 0, byteArray.Length);
            postStream.Close();

            // Start the web request
            request.BeginGetResponse(new AsyncCallback(handle_response), request);
        }


        //Quelltext in String speichern
        public static void handle_response(IAsyncResult hr_result)
        {
            HttpWebRequest request = hr_result.AsyncState as HttpWebRequest;

            try
            {
                if (request != null)
                {
                    using (WebResponse response = request.EndGetResponse(hr_result))
                    {
                        using (StreamReader reader = new StreamReader(response.GetResponseStream()))
                        {
                            //Quelltext laden
                            source = reader.ReadToEnd();
                        }
                    }
                }
            }
            catch
            {
            }
        }
    }
}

Hey, super!
Funktioniert 😃

Vielen lieben Dank

Hi,
Ich hoffe das ich hier richtig bin.
In meinem Datei-Explorer X Projekt für Windows 10 Mobile auf uwp Basis verwende ich die Dropbox API um auf Dropbox zuzugreifen. Beim Download von Dateien als Stream bekomme ich kein vernünftiges Ergebnis. Er lädt mir zwar eine Datei herunter und erstellt diese, allerdings ist die minimal größer als die Quelldatei und nicht zu gebrauchen.
Dafür bin ich schon mehrere Möglichkeiten durchgegangen.

Methode 1.

// Datei herunterladen
DropboxClient dropboxClient = new DropboxClient(token);

// Datei erstellen
StorageFile file = await folderTemp.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName);

var response = await dropboxClient.Files.DownloadAsync(path);

ulong fileSize = response.Response.Size;
const int bufferSize = 1024 * 1024;
var buffer = new byte[bufferSize];

using (var stream = await response.GetContentAsStreamAsync())
{
    using (var streamFile = await file.OpenAsync(FileAccessMode.ReadWrite))
    {
        var length = stream.Read(buffer, 0, bufferSize);
        while (length > 0)
        {
            await streamFile.WriteAsync(buffer.AsBuffer());
            length = stream.Read(buffer, 0, bufferSize);
         }
    }
}

Methode 2

// Datei herunterladen
DropboxClient dropboxClient = new DropboxClient(token);

// Datei erstellen
StorageFile file = await folderTemp.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName);

var streamFile = await file.OpenAsync(FileAccessMode.ReadWrite);

var response = await dropboxClient.Files.DownloadAsync(path);

using (Stream fileStream = await response.GetContentAsStreamAsync())
{
    // BinaryReader erstellen
    using (BinaryReader binaryReader = new BinaryReader(fileStream))
    {
        // Puffer erstellen
        byte[] buffer = new byte[256];
        int count;
        int totalBytes = 0;

        // Schleife Download
        while ((count = binaryReader.Read(buffer, 0, 256)) > 0)
        {
            // Wenn Abbruch durch Benutzer
            if (dWaitAbort.GetAnswer() == resource.GetString("001_Abbrechen"))
            {
                abort = true;
                break;
            }

            // Datei als Stream herunterladen
            await streamFile.WriteAsync(buffer.AsBuffer());
            totalBytes += count;
            dWaitAbort.SetProgressBarValueByIndex(0, totalBytes);
        }
    }
}