C# Xamarin.forms滑块作为音频播放器条

我想使用xamarin.forms的滑块控件作为音频播放条。我有一个依赖服务来播放录音并获取总持续时间和当前位置。如何将其设置为我的滑块

她是我的密码：

Button btnPlay = new Button
{
    Text = "Play/Pause",
    Command = new Command(() =>
                    {
                        DependencyService.Get<IAudio>().PlayMp3File();
                    })
};
Button btnStop = new Button { Text = "Stop" };
TimeSpan timeSpan = DependencyService.Get<IAudio>().GetInfo();
Label lblDuration = new Label { Text = String.Format("{0:hh\\:mm\\:ss}", timeSpan) };

var slider = new Slider {
    Minimum = 0,
    Maximum = timeSpan.TotalHours,
};
var label = new Label {
    Text = "Slider value is 0",
    FontSize = 25,
    HorizontalOptions = LayoutOptions.Start,
};
slider.ValueChanged += 
    (sender, e) => 
    {
        label.Text = String.Format("Slider value is {0:hh\\:mm\\:ss}", TimeSpan.FromMilliseconds(e.NewValue));
        DependencyService.Get<IAudio>().SeekTo(Convert.ToInt32(e.NewValue));

    };
MainPage = new ContentPage
{
    Content = new StackLayout {
        Children = {
            btnPlay,
            btnStop,
            slider,
            lblDuration,
            label
        }
    },  
    Padding = new Thickness (10, Device.OnPlatform (20, 0, 0), 10, 5)
};

Audioservice.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Android.App;
using Android.Content;
using Android.OS;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using AudioTest.Droid;
using Xamarin.Forms;
using Android.Media;
using System.Threading.Tasks;


[assembly: Dependency(typeof(AudioService))]

namespace AudioTest.Droid
{

    public class AudioService : IAudio
    {
        public AudioService() { }

        MediaPlayer player = null;

        public async Task StartPlayerAsync()
        {
            try
            {
                if (player == null)
                {
                    player = new MediaPlayer();
                    player = MediaPlayer.Create(global::Android.App.Application.Context, Resource.Raw.test);
                    player.Start();
                }
                else
                {
                    if (player.IsPlaying == true)
                    {
                        player.Pause();
                    }
                    else
                    {
                        player.Start();
                    }
                }
            }
            catch (Exception ex)
            {
                Console.Out.WriteLine(ex.StackTrace);
            }
        }

        public void StopPlayer()
        {
            if ((player != null))
            {
                if (player.IsPlaying)
                {
                    player.Stop();
                }
                player.Release();
                player = null;
            }
        }

        public async Task PlayMp3File()
        {
            await StartPlayerAsync();
        }

        public void Stop()
        {
            this.StopPlayer();
        }

        public async Task SeekTo( int s)
        {
            await seekTo(s);
        }

        public double CurrentPosition()
        {
            if ((player != null))
            {
                return player.CurrentPosition;
            }
            else
            { return 0; }
        }

        private async Task seekTo(int mseconds)
        {
            if (player == null)
            {
                player = new MediaPlayer();
                player = MediaPlayer.Create(global::Android.App.Application.Context, Resource.Raw.test);

            }

            player.SeekTo(mseconds);
            player.Start();
        }



        public TimeSpan GetInfo()
        {
            int arr;
            if (player == null)
            {
                player = new MediaPlayer();
                player = MediaPlayer.Create(global::Android.App.Application.Context, Resource.Raw.test);

            }
            arr = player.Duration;

            return TimeSpan.FromMilliseconds(arr);
        }


       public bool Isplaying()
        {
            if (player == null)
            {
                return false;


            }
            else { 
            return player.IsPlaying;
                }

        }
    }
}

---

在我回答这个问题之前，让我问你一个我自己的问题：你真的想让滑块跟踪小时数吗？我希望媒体滑块可以跟踪秒或十分之一秒；小时是一个非常粗糙的步骤

假设您是

IAudio

接口及其实现的作者，我的建议是

IAudio

接口在播放位置更改时公开并触发包含当前位置的事件（例如：

PositionChanged

）。

IAudio

接口的实现超出了这个问题的范围，但是我希望您订阅一个事件，或者使用您正在使用的任何媒体堆栈注册一个回调，这将反过来触发

PositionChanged

事件

注意：我还假设你的意思是秒；如果你真的是指小时，将下面的位置改为小时

public class PositionChangedEventArgs : EventArgs
{
    public PositionChangedEventArgs(int seconds)
    {
        Seconds = seconds;
    }

    public int Seconds { get; set; }
}

public interface IAudio
{
    ...
    event EventHandler<PositionChangedEventArgs> PositionChanged;
}

公共类PositionChangedEventArgs:EventArgs
{
公共位置更改默认值（整数秒）
{
秒=秒；
}
公共整数秒{get；set；}
}
公共接口音频
{
...
事件处理程序位置已更改；
}

然后，在PositionChanged的事件处理程序中，您将更新滑块的位置：

// note that we're caching our reference to IAudio;
// I don't know whether it's a singleton or not
var audioService = DependencyService.Get<IAudio>(); 
TimeSpan timeSpan = audioService.GetInfo();
Label lblDuration = new Label { Text = String.Format("{0:hh\\:mm\\:ss}", timeSpan) };

var slider = new Slider {
    Minimum = 0,
    Maximum = timeSpan.TotalSeconds,
};
audioService.PositionChanged += (s, e) => {
    slider.Value = e.Position;
    label.Text = String.Format("Slider value is {0}", e.Position);
}

//注意，我们正在缓存对IAudio的引用；
//我不知道是不是单身
var audioService=DependencyService.Get（）；
TimeSpan TimeSpan=audioService.GetInfo（）；
Label lblDuration=newlabel{Text=String.Format（“{0:hh\\\：mm\\：ss}”，timeSpan）}；
变量滑块=新滑块{
最小值=0，
最大值=timeSpan.TotalSeconds，
};
audioService.PositionChanged+=（s，e）=>{
滑块值=e位置；
label.Text=String.Format（“滑块值为{0}”，e.Position）；
}

对不起，我的错。我想跟踪第二个滑块：-（我已将我的问题编辑到添加的接口类结构中。我无法在接口上添加事件位置更改，获取

错误4预期的类、委托、枚举、接口或结构如果获取该错误，则说明语法错误。是否将该事件声明添加到接口定义的主体中？顺便问一下，确保你没有包括我的椭圆（…）-我只是把它放在那里表示还有其他成员！我已经将它添加到IAudio接口类中。在将
类添加到
公共类PositionChangedEventArgs:EventArgs
后，错误现在得到修复
// note that we're caching our reference to IAudio;
// I don't know whether it's a singleton or not
var audioService = DependencyService.Get<IAudio>(); 
TimeSpan timeSpan = audioService.GetInfo();
Label lblDuration = new Label { Text = String.Format("{0:hh\\:mm\\:ss}", timeSpan) };

var slider = new Slider {
    Minimum = 0,
    Maximum = timeSpan.TotalSeconds,
};
audioService.PositionChanged += (s, e) => {
    slider.Value = e.Position;
    label.Text = String.Format("Slider value is {0}", e.Position);
}