利用微软认知服务实现语音识别功能

　　想实现语音识别已经很久了，也尝试了许多次，终究还是失败了，原因很多，识别效果不理想，个人在技术上没有成功实现，种种原因，以至于花费了好多时间在上面。语音识别，我尝试过的有科大讯飞、百度语音，微软系。最终还是喜欢微软系的简洁高效。(勿喷，纯个人感觉)

　　最开始自己的想法是我说一句话(暂且在控制台上做Demo)，控制台程序能识别我说的是什么，然后显示出来，并且根据我说的信息，执行相应的行为.(想法很美好，现实很糟心）初入语音识别，各种错误各种来，徘徊不定的选择哪家公司的api，百度上查找各种语音识别的demo，学习参考，可是真正在.NET平台上运行成功的却是寥寥无几，或许是我查找方向有问题，经历了许多的坑，没一次成功过，心灰且意冷，打了几次退堂鼓，却终究忍受不住想玩语音识别。

　　可以看看我VS中的语音demo

　　

　　第一个是今天的主角-稍后再提。

　　第二个和第三个是微软系的系统自带的System.Speech.dll和看了微软博客里面的一篇文章而去尝试的Microsoft.Speech.dll 可惜文章写的挺好的，我尝试却是失败的，并且发现一个问题，就是英文版的微软语音识别是无效的(Microsoft.Speech.Recognition)，而中文版的语音合成是无效的(Microsoft.Speech.Synthesis).，因此，我不得不将两个dll混合使用，来达到我想要的效果，最终效果确实达到了，不过却是极其简单的，一旦识别词汇多起来，这识别率直接下降，我一直认为是采样频率的问题，可是怎么也找不到采样频率的属性或是字段，如有会的朋友可给我点信息，让我也飞起来，哈哈。

　　第四个是百度语音识别demo，代码简洁许多，实现难度不难，可是小细节很多，需要注意，然后是雷区挺多的，但是呢，指导走出雷区的说明书却是太少了，我是踩了雷，很郁闷。

 

　　首先来看看，现在市面上主流语音识别设计方式：

　　1、离线语音识别

　　离线语音识别很好理解，就是语音识别库在本地或是局域网内，无需发起远程连接。这个也是我当初的想法，自己弄一套语音识别库，然后根据里面的内容设计想要的行为请求。利用微软系的System.Speech.dll中的语音识别和语音合成功能。实现了简单的中文语音识别功能，但是一旦我将语音识别库逐渐加大，识别率就越来越低，不知是我电脑麦克风不行还是其它原因。最终受打击，放弃。当我试着学习百度语音时，也发现了离线语音识别库，但是呢官方并没有给出具体的操作流程和设计思路，我也没有去深入了解，有时间我要好好了解一番。

using System;
//using Microsoft.Speech.Synthesis;//中文版tts不能发声
using Microsoft.Speech.Recognition;
using System.Speech.Synthesis;
//using System.Speech.Recognition;

namespace SAssassin.SpeechDemo
{
    /// <summary>
    /// 微软语音识别 中文版 貌似效果还好点
    /// </summary>
    class Program
    {
        static SpeechSynthesizer sy = new SpeechSynthesizer();
        static void Main(string[] args)
        {
            //创建中文识别器  
            using (SpeechRecognitionEngine recognizer = new SpeechRecognitionEngine(new System.Globalization.CultureInfo("zh-CN")))
            {
                foreach (var config in SpeechRecognitionEngine.InstalledRecognizers())
                {
                    Console.WriteLine(config.Id);
                }
                //初始化命令词  
                Choices commonds = new Choices();
                string[] commond1 = new string[] { "一", "二", "三", "四", "五", "六", "七", "八", "九" };
                string[] commond2 = new string[] { "很高兴见到你", "识别率", "assassin", "长沙", "湖南", "实习" };
                string[] commond3 = new string[] { "开灯", "关灯", "播放音乐", "关闭音乐", "浇水", "停止浇水", "打开背景灯", "关闭背景灯" };
                //添加命令词
                commonds.Add(commond1);
                commonds.Add(commond2);
                commonds.Add(commond3);
                //初始化命令词管理  
                GrammarBuilder gBuilder = new GrammarBuilder();
                //将命令词添加到管理中  
                gBuilder.Append(commonds);
                //实例化命令词管理  
                Grammar grammar = new Grammar(gBuilder);

                //创建并加载听写语法(添加命令词汇识别的比较精准)  
                recognizer.LoadGrammarAsync(grammar);
                //为语音识别事件添加处理程序。  
                recognizer.SpeechRecognized += new EventHandler<SpeechRecognizedEventArgs>(Recognizer_SpeechRRecongized);
                //将输入配置到语音识别器。  
                recognizer.SetInputToDefaultAudioDevice();
                //启动异步，连续语音识别。  
                recognizer.RecognizeAsync(RecognizeMode.Multiple);
                //保持控制台窗口打开。
                Console.WriteLine("你好");
                sy.Speak("你好");
                Console.ReadLine();
            }
        }

        //speechrecognized事件处理  
        static void Recognizer_SpeechRRecongized(object sender, SpeechRecognizedEventArgs e)
        {
            Console.WriteLine("识别结果：" + e.Result.Text + " " + e.Result.Confidence + " " + DateTime.Now);
            sy.Speak(e.Result.Text);
        }
    }
}

　　2、在线语音识别。

　　在线语音识别是我们当前程序将语音文件发送到远程服务中心，待远程服务中心匹配解决后将匹配结果进行返回的过程。其使用的一般是Restful风格，利用Json数据往返识别结果。

　　刚开始学习科大讯飞的语音识别，刚开始什么也不懂，听朋友推荐加上自己百度学习，科大讯飞都说很不错，也抱着心态去学习学习，可是windows平台下只有C++的demo，无奈我是C#，虽说语言很大程度上不分家，可是不想过于麻烦，网上找了一个demo，据说是最全的C#版本的讯飞语音识别demo,可是当看到里面错综复杂的源代码时，内心是忧伤的，这里是直接通过一种方式引用c++的函数，运行了该demo，成功了，能简单的录音然后识别，但是有些地方存在问题，也得不到解决方案，不得已，放弃。

　　后来，百度语音吸引我了，七月份时，重新开始看百度语音的demo，官网demo比较简单，尝试着学习了一下，首先你得到百度语音开放平台去创建应用得到App key 和Secret key，然后下载着demo，在构造函数或者字段中又或是写入配置文件中，将这两个得到的key写入，程序会根据这两个key去发起请求的。就如同开头所说，这是在线语音识别，利用Restful风格，将语音文件上传至百度语音识别中心，然后识别后将回执数据返回到我们的程序中，刚开始，配置的时候自己技术不怎么样，配置各种出错，地雷开始踩了，总要炸几次，最终还是能将demo中的测试文件识别出来，算是我个人的一小步把.(如果有朋友正好碰到踩雷问题，不妨可与我一起探讨，或许我也不懂，但在我踩过的里面至少我懂了，哈哈)

　　

 　　接下来是设计思路的问题，语音识别能成功了，语音合成也能成功了，这里要注意，语音识别和语音合成要分别开通，并且这两个都有App Key和Secret Key 虽然是一样的，但是还是要注意，不然语音合成就会出问题的。接下来要考虑的问题就是，百度语音的设计思路是根据文件识别，但是我们考虑的最多的就是我直接麦克风语音输入，然后识别，这也是我的想法，接下来解决这一问题，设计思路是，我将输入的信息作为文件形式保存，等我输入完，然后就调用语音识别方法，这不就行了吗，确实也是可以的，此处，又开始进入雷区了，利用NAudio.dll文件实现录音功能，这个包可以在Nuget中下载。

using NAudio.Wave;
using System;

namespace SAssassin.VOC
{
    /// <summary>
    /// 实现录音功能
    /// </summary>
    public class RecordWaveToFile
    {
        private WaveFileWriter waveFileWriter = null;
        private WaveIn myWaveIn = null;

        public void StartRecord()
        {
            ConfigWave();
            myWaveIn.StartRecording();
        }

        private void ConfigWave()
        {
            string filePath = AppDomain.CurrentDomain.BaseDirectory + "Temp.wav";
            myWaveIn = new WaveIn()
            {
                WaveFormat = new WaveFormat(16000, 16, 1)//8k,16bit,单频
                //WaveFormat = new WaveFormat()//识别音质清晰
            };
            myWaveIn.DataAvailable += new System.EventHandler<WaveInEventArgs>(WaveIn_DataAvailable);
            myWaveIn.RecordingStopped += new System.EventHandler<StoppedEventArgs>(WaveIn_RecordingStopped);
            waveFileWriter = new WaveFileWriter(filePath, myWaveIn.WaveFormat);
        }

        private void WaveIn_DataAvailable(object sender,WaveInEventArgs e)
        {
            if(waveFileWriter != null)
            {
                waveFileWriter.Write(e.Buffer,0,e.BytesRecorded);
                waveFileWriter.Flush();
            }
        }

        private void WaveIn_RecordingStopped(object sender,StoppedEventArgs e)
        {
            myWaveIn.StopRecording();
        }
    }
}

　　此处控制器中使用WaveInEvent不会报错，可就在这之前，我用的是WaveIn类，然后直接报错了

　　“System.InvalidOperationException:“Use WaveInEvent to record on a background thread””

　　在StackOverFlow上找到了解决方案，就是将WaveIn类换成WaveInEvent类即可，进入类里面看一下，其实发现都是引用同一个接口，甚至说两个类的结构都是一模一样的，只是一个用于GUI线程，一个用于后台线程。一切就绪，录音也能实现，可是当我查看自己的录音文件时，杂音好多，音质不侵袭，甚至是直接失真了，没什么用，送百度也识别失败，当将采样频率提高到44k时效果很好，录音文件很不错，但是问题来了，百度语音识别规定的pcm文件只能是8k-16bit,糟心，想换成其它格式的文件，采取压缩形式保存，但是一旦将采样频率降下来，这个效果就很糟糕，识别也是成了问题。不得不说，这还要慢慢来解决哈。

　　进入今天重头戏，这也是我博客园第一篇随笔文章，该讲点重点了，微软认知服务，七月中旬的时候接触到了必应的语音识别api，在微软bing官网里，并且里面的识别效果，让我惊呼，这识别率太高了。然后想找它的api，发现文档全是英文资料，糟心。把资料看完，感觉使用方式很不错，也是远程调用的方式，但是api呢，官网找了老半天，只有文档，那时也没看上面的产品，试用版什么的，只能看着，却不能用，心累。也就在这几天，重新看了下必应的语音识别文档，才接触到这个词--"微软认知服务",     恕我见识太浅，这个好东西却没听过，百度一查，真是不错，微软太牛了，这个里面包含很多api，语音识别都只算小菜一只，人脸识别，语义感知，等等很牛的功能，找到Api，找到免费试用，登录获得app的secret key ，便可以用起来了。下载一个demo，将secret key输入，测试一下，哇塞，这识别效果，简直了，太强了。并且从百度中看到很多结果，使用到微软认知服务语音识别功能的很少，我也因此有写一点东西的想法。

　　我将demo中的很多地方抽出来直接形成了一个控制器程序，源码如下

public class SpeechConfig
    {
        #region Fields
        /// <summary>
        /// The isolated storage subscription key file name.
        /// </summary>
        private const string IsolatedStorageSubscriptionKeyFileName = "Subscription.txt";

        /// <summary>
        /// The default subscription key prompt message
        /// </summary>
        private const string DefaultSubscriptionKeyPromptMessage = "Secret key";

        /// <summary>
        /// You can also put the primary key in app.config, instead of using UI.
        /// string subscriptionKey = ConfigurationManager.AppSettings["primaryKey"];
        /// </summary>
        private string subscriptionKey = ConfigurationManager.AppSettings["primaryKey"];

        /// <summary>
        /// Gets or sets subscription key
        /// </summary>
        public string SubscriptionKey
        {
            get
            {
                return this.subscriptionKey;
            }

            set
            {
                this.subscriptionKey = value;
                this.OnPropertyChanged<string>();
            }
        }

        /// <summary>
        /// The data recognition client
        /// </summary>
        private DataRecognitionClient dataClient;

        /// <summary>
        /// The microphone client
        /// </summary>
        private MicrophoneRecognitionClient micClient;

        #endregion Fields

        #region event
        /// <summary>
        /// Implement INotifyPropertyChanged interface
        /// </summary>
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// Helper function for INotifyPropertyChanged interface 
        /// </summary>
        /// <typeparam name="T">Property type</typeparam>
        /// <param name="caller">Property name</param>
        private void OnPropertyChanged<T>([CallerMemberName]string caller = null)
        {
            this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(caller));
        }
        #endregion event

        #region 属性
        /// <summary>
        /// Gets the current speech recognition mode.
        /// </summary>
        /// <value>
        /// The speech recognition mode.
        /// </value>
        private SpeechRecognitionMode Mode
        {
            get
            {
                if (this.IsMicrophoneClientDictation ||
                    this.IsDataClientDictation)
                {
                    return SpeechRecognitionMode.LongDictation;
                }

                return SpeechRecognitionMode.ShortPhrase;
            }
        }

        /// <summary>
        /// Gets the default locale.
        /// </summary>
        /// <value>
        /// The default locale.
        /// </value>
        private string DefaultLocale
        {
            //get { return "en-US"; }
            get { return "zh-CN"; }

        }

        /// <summary>
        /// Gets the Cognitive Service Authentication Uri.
        /// </summary>
        /// <value>
        /// The Cognitive Service Authentication Uri.  Empty if the global default is to be used.
        /// </value>
        private string AuthenticationUri
        {
            get
            {
                return ConfigurationManager.AppSettings["AuthenticationUri"];
            }
        }

        /// <summary>
        /// Gets a value indicating whether or not to use the microphone.
        /// </summary>
        /// <value>
        ///   <c>true</c> if [use microphone]; otherwise, <c>false</c>.
        /// </value>
        private bool UseMicrophone
        {
            get
            {
                return this.IsMicrophoneClientWithIntent ||
                    this.IsMicrophoneClientDictation ||
                    this.IsMicrophoneClientShortPhrase;
            }
        }

        /// <summary>
        /// Gets the short wave file path.
        /// </summary>
        /// <value>
        /// The short wave file.
        /// </value>
        private string ShortWaveFile
        {
            get
            {
                return ConfigurationManager.AppSettings["ShortWaveFile"];
            }
        }

        /// <summary>
        /// Gets the long wave file path.
        /// </summary>
        /// <value>
        /// The long wave file.
        /// </value>
        private string LongWaveFile
        {
            get
            {
                return ConfigurationManager.AppSettings["LongWaveFile"];
            }
        }
        #endregion 属性

        #region 模式选择控制器设置
        /// <summary>
        /// Gets or sets a value indicating whether this instance is microphone client short phrase.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is microphone client short phrase; otherwise, <c>false</c>.
        /// </value>
        public bool IsMicrophoneClientShortPhrase { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether this instance is microphone client dictation.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is microphone client dictation; otherwise, <c>false</c>.
        /// </value>
        public bool IsMicrophoneClientDictation { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether this instance is microphone client with intent.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is microphone client with intent; otherwise, <c>false</c>.
        /// </value>
        public bool IsMicrophoneClientWithIntent { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether this instance is data client short phrase.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is data client short phrase; otherwise, <c>false</c>.
        /// </value>
        public bool IsDataClientShortPhrase { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether this instance is data client with intent.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is data client with intent; otherwise, <c>false</c>.
        /// </value>
        public bool IsDataClientWithIntent { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether this instance is data client dictation.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is data client dictation; otherwise, <c>false</c>.
        /// </value>
        public bool IsDataClientDictation { get; set; }

        #endregion

        #region 委托执行对象
        /// <summary>
        /// Called when the microphone status has changed.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="MicrophoneEventArgs"/> instance containing the event data.</param>
        private void OnMicrophoneStatus(object sender, MicrophoneEventArgs e)
        {
            Task task = new Task(() =>
            {
                Console.WriteLine("--- Microphone status change received by OnMicrophoneStatus() ---");
                Console.WriteLine("********* Microphone status: {0} *********", e.Recording);
                if (e.Recording)
                {
                    Console.WriteLine("Please start speaking.");
                }

                Console.WriteLine();
            });
            task.Start();
        }

        /// <summary>
        /// Called when a partial response is received.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="PartialSpeechResponseEventArgs"/> instance containing the event data.</param>
        private void OnPartialResponseReceivedHandler(object sender, PartialSpeechResponseEventArgs e)
        {
            Console.WriteLine("--- Partial result received by OnPartialResponseReceivedHandler() ---");
            Console.WriteLine("{0}", e.PartialResult);
            Console.WriteLine();
        }

        /// <summary>
        /// Called when an error is received.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="SpeechErrorEventArgs"/> instance containing the event data.</param>
        private void OnConversationErrorHandler(object sender, SpeechErrorEventArgs e)
        {
            Console.WriteLine("--- Error received by OnConversationErrorHandler() ---");
            Console.WriteLine("Error code: {0}", e.SpeechErrorCode.ToString());
            Console.WriteLine("Error text: {0}", e.SpeechErrorText);
            Console.WriteLine();
        }

        /// <summary>
        /// Called when a final response is received;
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="SpeechResponseEventArgs"/> instance containing the event data.</param>
        private void OnMicShortPhraseResponseReceivedHandler(object sender, SpeechResponseEventArgs e)
        {
            Task task = new Task(() =>
            {
                Console.WriteLine("--- OnMicShortPhraseResponseReceivedHandler ---");

                // we got the final result, so it we can end the mic reco.  No need to do this
                // for dataReco, since we already called endAudio() on it as soon as we were done
                // sending all the data.
                this.micClient.EndMicAndRecognition();

                this.WriteResponseResult(e);
            });
            task.Start();
        }

        /// <summary>
        /// Called when a final response is received;
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="SpeechResponseEventArgs"/> instance containing the event data.</param>
        private void OnDataShortPhraseResponseReceivedHandler(object sender, SpeechResponseEventArgs e)
        {
            Task task = new Task(() =>
            {
                Console.WriteLine("--- OnDataShortPhraseResponseReceivedHandler ---");

                // we got the final result, so it we can end the mic reco.  No need to do this
                // for dataReco, since we already called endAudio() on it as soon as we were done
                // sending all the data.
                this.WriteResponseResult(e);

            });
            task.Start();
        }

        /// <summary>
        /// Called when a final response is received;
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="SpeechResponseEventArgs"/> instance containing the event data.</param>
        private void OnMicDictationResponseReceivedHandler(object sender, SpeechResponseEventArgs e)
        {
            Console.WriteLine("--- OnMicDictationResponseReceivedHandler ---");
            if (e.PhraseResponse.RecognitionStatus == RecognitionStatus.EndOfDictation ||
                e.PhraseResponse.RecognitionStatus == RecognitionStatus.DictationEndSilenceTimeout)
            {
                Task task = new Task(() =>
                {
                    // we got the final result, so it we can end the mic reco.  No need to do this
                    // for dataReco, since we already called endAudio() on it as soon as we were done
                    // sending all the data.
                    this.micClient.EndMicAndRecognition();
                });
                task.Start();
            }

            this.WriteResponseResult(e);
        }

        /// <summary>
        /// Called when a final response is received;
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="SpeechResponseEventArgs"/> instance containing the event data.</param>
        private void OnDataDictationResponseReceivedHandler(object sender, SpeechResponseEventArgs e)
        {
            Console.WriteLine("--- OnDataDictationResponseReceivedHandler ---");
            if (e.PhraseResponse.RecognitionStatus == RecognitionStatus.EndOfDictation ||
                e.PhraseResponse.RecognitionStatus == RecognitionStatus.DictationEndSilenceTimeout)
            {
                Task task = new Task(() =>
                {

                    // we got the final result, so it we can end the mic reco.  No need to do this
                    // for dataReco, since we already called endAudio() on it as soon as we were done
                    // sending all the data.
                });
                task.Start();
            }

            this.WriteResponseResult(e);
        }

        /// <summary>
        /// Sends the audio helper.
        /// </summary>
        /// <param name="wavFileName">Name of the wav file.</param>
        private void SendAudioHelper(string wavFileName)
        {
            using (FileStream fileStream = new FileStream(wavFileName, FileMode.Open, FileAccess.Read))
            {
                // Note for wave files, we can just send data from the file right to the server.
                // In the case you are not an audio file in wave format, and instead you have just
                // raw data (for example audio coming over bluetooth), then before sending up any 
                // audio data, you must first send up an SpeechAudioFormat descriptor to describe 
                // the layout and format of your raw audio data via DataRecognitionClient's sendAudioFormat() method.
                int bytesRead = 0;
                byte[] buffer = new byte[1024];

                try
                {
                    do
                    {
                        // Get more Audio data to send into byte buffer.
                        bytesRead = fileStream.Read(buffer, 0, buffer.Length);

                        // Send of audio data to service. 
                        this.dataClient.SendAudio(buffer, bytesRead);
                    }
                    while (bytesRead > 0);
                }
                finally
                {
                    // We are done sending audio.  Final recognition results will arrive in OnResponseReceived event call.
                    this.dataClient.EndAudio();
                }
            }
        }
        #endregion 委托执行对象

        #region 辅助方法
        /// <summary>
        /// Gets the subscription key from isolated storage.
        /// </summary>
        /// <returns>The subscription key.</returns>
        private string GetSubscriptionKeyFromIsolatedStorage()
        {
            string subscriptionKey = null;

            using (IsolatedStorageFile isoStore = IsolatedStorageFile.GetStore(IsolatedStorageScope.User | IsolatedStorageScope.Assembly, null, null))
            {
                try
                {
                    using (var iStream = new IsolatedStorageFileStream(IsolatedStorageSubscriptionKeyFileName, FileMode.Open, isoStore))
                    {
                        using (var reader = new StreamReader(iStream))
                        {
                            subscriptionKey = reader.ReadLine();
                        }
                    }
                }
                catch (FileNotFoundException)
                {
                    subscriptionKey = null;
                }
            }

            if (string.IsNullOrEmpty(subscriptionKey))
            {
                subscriptionKey = DefaultSubscriptionKeyPromptMessage;
            }

            return subscriptionKey;
        }

        /// <summary>
        /// Creates a new microphone reco client without LUIS intent support.
        /// </summary>
        private void CreateMicrophoneRecoClient()
        {
            this.micClient = SpeechRecognitionServiceFactory.CreateMicrophoneClient(
                this.Mode,this.DefaultLocale,this.SubscriptionKey);

            this.micClient.AuthenticationUri = this.AuthenticationUri;

            // Event handlers for speech recognition results
            this.micClient.OnMicrophoneStatus += this.OnMicrophoneStatus;
            this.micClient.OnPartialResponseReceived += this.OnPartialResponseReceivedHandler;
            if (this.Mode == SpeechRecognitionMode.ShortPhrase)
            {
                this.micClient.OnResponseReceived += this.OnMicShortPhraseResponseReceivedHandler;
            }
            else if (this.Mode == SpeechRecognitionMode.LongDictation)
            {
                this.micClient.OnResponseReceived += this.OnMicDictationResponseReceivedHandler;
            }

            this.micClient.OnConversationError += this.OnConversationErrorHandler;
        }

        /// <summary>
        /// Creates a data client without LUIS intent support.
        /// Speech recognition with data (for example from a file or audio source).  
        /// The data is broken up into buffers and each buffer is sent to the Speech Recognition Service.
        /// No modification is done to the buffers, so the user can apply their
        /// own Silence Detection if desired.
        /// </summary>
        private void CreateDataRecoClient()
        {
            this.dataClient = SpeechRecognitionServiceFactory.CreateDataClient(
                this.Mode,
                this.DefaultLocale,
                this.SubscriptionKey);
            this.dataClient.AuthenticationUri = this.AuthenticationUri;

            // Event handlers for speech recognition results
            if (this.Mode == SpeechRecognitionMode.ShortPhrase)
            {
                this.dataClient.OnResponseReceived += this.OnDataShortPhraseResponseReceivedHandler;
            }
            else
            {
                this.dataClient.OnResponseReceived += this.OnDataDictationResponseReceivedHandler;
            }

            this.dataClient.OnPartialResponseReceived += this.OnPartialResponseReceivedHandler;
            this.dataClient.OnConversationError += this.OnConversationErrorHandler;
        }

        /// <summary>
        /// Writes the response result.
        /// </summary>
        /// <param name="e">The <see cref="SpeechResponseEventArgs"/> instance containing the event data.</param>
        private void WriteResponseResult(SpeechResponseEventArgs e)
        {
            if (e.PhraseResponse.Results.Length == 0)
            {
                Console.WriteLine("No phrase response is available.");
            }
            else
            {
                Console.WriteLine("********* Final n-BEST Results *********");
                for (int i = 0; i < e.PhraseResponse.Results.Length; i++)
                {
                    Console.WriteLine(
                        "[{0}] Confidence={1}, Text=\"{2}\"",
                        i,
                        e.PhraseResponse.Results[i].Confidence,
                        e.PhraseResponse.Results[i].DisplayText);
                    if (e.PhraseResponse.Results[i].DisplayText == "关闭。")
                    {
                        Console.WriteLine("收到命令，马上关闭");
                    }
                }

                Console.WriteLine();
            }
        }
        #endregion 辅助方法

        #region Init
        public SpeechConfig()
        {
            this.IsMicrophoneClientShortPhrase = true;
            this.IsMicrophoneClientWithIntent = false;
            this.IsMicrophoneClientDictation = false;
            this.IsDataClientShortPhrase = false;
            this.IsDataClientWithIntent = false;
            this.IsDataClientDictation = false;

            this.SubscriptionKey = this.GetSubscriptionKeyFromIsolatedStorage();
        }

        /// <summary>
        /// 语音识别开始执行
        /// </summary>
        public void SpeechRecognize()
        {
            if (this.UseMicrophone)
            {
                if (this.micClient == null)
                {
                    this.CreateMicrophoneRecoClient();
                }

                this.micClient.StartMicAndRecognition();
            }
            else
            {
                if (null == this.dataClient)
                {
                    this.CreateDataRecoClient();
                }

                this.SendAudioHelper((this.Mode == SpeechRecognitionMode.ShortPhrase) ? this.ShortWaveFile : this.LongWaveFile);
            }
        }
        #endregion Init
    }

 　　在这其中有几个引用文件可以通过nuget包下载，基本没什么问题。对了这里注意的一个问题就是，下载Microsoft.Speech的时候一定是两个包都需要下载，不然会报错的，版本必须是4.5+以上的。

　　只需替换默认的key就行，程序便可跑起来，效果真是很6

　　

 　　这识别率真是很好很好，很满意，可是这个微软的免费试用只有一个月，那就只能在这个月里多让它开花结果了哈哈。

 

 　　2017-08-20,望技术有成后能回来看见自己的脚步。