public interface IListDataStructure<T>
{
    //取得线性表的实际元素个数
    int Count();

    //清空线性表
    void Clear();

    //判断线性表是否为空
    bool IsEmpty();

    //（在末端）追加元素
    void Append(T item);

    //在位置i“前面”插入元素item
    void InsertBefore(T item, int i);

    //在位置i“后面”插入元素item
    void InsertAfter(T item, int i);

    //删除索引i处的元素
    T RemoveAt(int i);

    //获得索引位置i处的元素
    T GetItemAt(int i);

    //返回元素value的索引
    int IndexOf(T value);

    //反转线性表的所有元素
    void Reverse();
}

public class Node<T>
{
    private T data;
    private Node<T> next;

    public Node(T val, Node<T> p)
    {
        data = val;
        next = p;
    }

    public Node(Node<T> p)
    {
        next = p;
    }

    public Node(T val)
    {
        data = val;
        next = null;
    }

    public Node()
    {
        data = default(T);
        next = null;
    }

    public T Data
    {
        get { return data; }
        set { data = value; }
    }

    public Node<T> Next
    {
        get { return next; }
        set { next = value; }
    }
}

public class LinkList<T> : IListDataStructure<T>
{
    private Node<T> head;

    public Node<T> Head
    {
        get { return head; }
        set { head = value; }
    }

    public LinkList()
    {
        head = null;
    }

    /// <summary>
    /// 类索引器
    /// </summary>
    /// <param name="index"></param>
    /// <returns></returns>
    public T this[int index]
    {
        get
        {
            return this.GetItemAt(index);
        }
    }

    /// <summary>
    /// 返回单链表的长度
    /// </summary>
    /// <returns></returns>
    public int Count()
    {
        Node<T> p = head;
        int len = 0;
        while (p != null)
        {
            len++;
            p = p.Next;
        }
        return len;
    }

    /// <summary>
    /// 清空
    /// </summary>
    public void Clear()
    {
        head = null;
    }

    /// <summary>
    /// 是否为空
    /// </summary>
    /// <returns></returns>
    public bool IsEmpty()
    {
        return head == null;
    }

    /// <summary>
    /// 在最后附加元素
    /// </summary>
    /// <param name="item"></param>
    public void Append(T item)
    {
        Node<T> d = new Node<T>(item);
        Node<T> n = new Node<T>();

        if (head == null)
        {
            head = d;
            return;
        }

        n = head;
        while (n.Next != null)
        {
            n = n.Next;
        }
        n.Next = d;
    }

    //前插
    public void InsertBefore(T item, int i)
    {
        if (IsEmpty() || i < 0)
        {
            Console.WriteLine("List is empty or Position is error!");
            return;
        }

        //在最开头插入
        if (i == 0)
        {
            Node<T> q = new Node<T>(item);
            q.Next = Head;//把"头"改成第二个元素
            head = q;//把自己设置为"头"
            return;
        }

        Node<T> n = head;
        Node<T> d = new Node<T>();
        int j = 0;

        //找到位置i的前一个元素d
        while (n.Next != null && j < i)
        {
            d = n;
            n = n.Next;
            j++;
        }

        if (n.Next == null) //说明是在最后节点插入(即追加)
        {
            Node<T> q = new Node<T>(item);
            n.Next = q;
            q.Next = null;
        }
        else
        {
            if (j == i)
            {
                Node<T> q = new Node<T>(item);
                d.Next = q;
                q.Next = n;
            }
        }
    }

    /// <summary>
    /// 在位置i后插入元素item
    /// </summary>
    /// <param name="item"></param>
    /// <param name="i"></param>
    public void InsertAfter(T item, int i)
    {
        if (IsEmpty() || i < 0)
        {
            Console.WriteLine("List is empty or Position is error!");
            return;
        }

        if (i == 0)
        {
            Node<T> q = new Node<T>(item);
            q.Next = head.Next;
            head.Next = q;
            return;
        }

        Node<T> p = head;
        int j = 0;

        while (p != null && j < i)
        {
            p = p.Next;
            j++;
        }
        if (j == i)
        {
            Node<T> q = new Node<T>(item);
            q.Next = p.Next;
            p.Next = q;
        }
        else
        {
            Console.WriteLine("Position is error!");
        }
    }

    /// <summary>
    /// 删除位置i的元素
    /// </summary>
    /// <param name="i"></param>
    /// <returns></returns>
    public T RemoveAt(int i)
    {
        if (IsEmpty() || i < 0)
        {
            Console.WriteLine("Link is empty or Position is error!");
            return default(T);
        }

        Node<T> q = new Node<T>();
        if (i == 0)
        {
            q = head;
            head = head.Next;
            return q.Data;
        }

        Node<T> p = head;
        int j = 0;

        while (p.Next != null && j < i)
        {
            j++;
            q = p;
            p = p.Next;
        }

        if (j == i)
        {
            q.Next = p.Next;
            return p.Data;
        }
        else
        {
            Console.WriteLine("The node is not exist!");
            return default(T);
        }
    }

    /// <summary>
    /// 获取指定位置的元素
    /// </summary>
    /// <param name="i"></param>
    /// <returns></returns>
    public T GetItemAt(int i)
    {
        if (IsEmpty())
        {
            Console.WriteLine("List is empty!");
            return default(T);
        }

        Node<T> p = new Node<T>();
        p = head;

        if (i == 0)
        {
            return p.Data;
        }

        int j = 0;

        while (p.Next != null && j < i)
        {
            j++;
            p = p.Next;
        }

        if (j == i)
        {
            return p.Data;
        }
        else
        {
            Console.WriteLine("The node is not exist!");
            return default(T);
        }
    }

    //按元素值查找索引
    public int IndexOf(T value)
    {
        if (IsEmpty())
        {
            Console.WriteLine("List is Empty!");
            return -1;
        }
        Node<T> p = new Node<T>();
        p = head;
        int i = 0;
        while (!p.Data.Equals(value) && p.Next != null)
        {
            p = p.Next;
            i++;
        }
        return i;
    }

    /// <summary>
    /// 元素反转
    /// </summary>
    public void Reverse()
    {
        LinkList<T> result = new LinkList<T>();
        Node<T> t = this.head;
        result.Head = new Node<T>(t.Data);
        t = t.Next;

        //(把当前链接的元素从head开始遍历，逐个插入到另一个空链表中，这样得到的新链表正好元素顺序跟原链表是相反的)
        while (t != null)
        {
            result.InsertBefore(t.Data, 0);
            t = t.Next;
        }
        this.head = result.head;//将原链表直接挂到"反转后的链表"上
        result = null;//显式清空原链表的引用，以便让GC能直接回收
    }

    public override string ToString()
    {
        StringBuilder sb = new StringBuilder();
        Node<T> n = this.head;
        sb.Append(n.Data + ",");
        while (n.Next != null)
        {
            sb.Append(n.Next.Data + ",");
            n = n.Next;
        }
        return sb.ToString().TrimEnd(',');
    }
}

public static void TestLinkList()
{
    Console.WriteLine("-------------------------------------");
    Console.WriteLine("单链表测试开始...");
    LinkList<string> link = new LinkList<string>();
    link.Head = new Node<string>("x");
    link.InsertBefore("w", 0);
    link.InsertBefore("v", 0);
    link.Append("y");
    link.InsertBefore("z", link.Count());
    Console.WriteLine(link.Count());//5
    Console.WriteLine(link.ToString());//v,w,x,y,z
    Console.WriteLine(link[1]);//w
    Console.WriteLine(link[0]);//v
    Console.WriteLine(link[4]);//z
    Console.WriteLine(link.IndexOf("z"));//4
    Console.WriteLine(link.RemoveAt(2));//x
    Console.WriteLine(link.ToString());//v,w,y,z
    link.InsertBefore("x", 2);
    Console.WriteLine(link.ToString());//v,w,x,y,z
    Console.WriteLine(link.GetItemAt(2));//x
    link.Reverse();
    Console.WriteLine(link.ToString());//z,y,x,w,v
    link.InsertAfter("1", 0);
    link.InsertAfter("2", 1);
    link.InsertAfter("6", 5);
    link.InsertAfter("8", 7);
    link.InsertAfter("A", 10);//Position is error!

    Console.WriteLine(link.ToString()); //z,1,2,y,x,w,6,v,8
}

System.Boolean
System.Byte
System.SByte
System.Int16
System.UInt16
System.Int32
System.UInt32
System.Int64
System.UInt64
System.IntPtr
System.UIntPtr
System.Char
System.Double
System.Single

public void Send()
{
    var inFile1 =
        @"C:\Users\User1\source\repos\ConsoleApp1\Test.mp3";
    byte[] data = File.ReadAllBytes(inFile1);

    FileUpLoadDTO gdto = new FileUpLoadDTO();
	
	// 其它参数
    gdto.DeviceId = "1234321";
    gdto.DeviceMac = "1343212";

    var filedto = new FileDTO();
    filedto.FileData = data;
    filedto.FileName = GetFileName();
    filedto.FileSize = data.Length;
    gdto.FileDto = filedto;
	
	// 序列化文件
    var jsonData = JsonHelper.Serialize(new { dto = gdto });
    var url = "http://temp.uri/UpLoadFile";
    var response = HttpHelper.SendRequest(url, "POST", jsonData);
}

public string GetFileName()
{
    Random rd = new Random();
    StringBuilder serial = new StringBuilder();
    serial.Append(DateTime.Now.ToString("yyyyMMddHHmmssff"));
    serial.Append(rd.Next(0, 999999).ToString());
    return serial.ToString();
}

public ReturnInfoDTO ReceiveFile(FileUpLoadDTO dto)
{
    ReturnInfoDTO rdto = new ReturnInfoDTO() { StatusCode = "200", IsSuccess = true, Message = "调用成功" };

    var outputFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "NAudio");
    Directory.CreateDirectory(outputFolder);

    var filename = dto.FileDto.FileName;

    try
    {
        using (FileStream stream = File.Open(filename, FileMode.OpenOrCreate))
        {
            stream.Seek(0, SeekOrigin.End);
            stream.Write(dto.FileDto.FileData, 0, dto.FileDto.FileData.Length);
        }
    }
    catch (Exception e)
    {
        rdto.IsSuccess = false;
        rdto.StatusCode = "500";
        rdto.Message = "调用失败";
    }

    return rdto;
}

private void button9_Click(object sender, EventArgs e)
{
    var inFile1 =
        @"C:\Users\User1\Desktop\Test.mp3";
    byte[] data = File.ReadAllBytes(inFile1);

    FileUpLoadDTO gdto = new FileUpLoadDTO();

    // 其它参数
    gdto.DeviceId = "1234321";
    gdto.DeviceMac = "1343212";

    var filedto = new FileDto();
    filedto.FileData = data;
    filedto.FileName = GetFileName() + System.IO.Path.GetExtension(inFile1);
    filedto.FileSize = data.Length;
    gdto.FileDto = filedto;

    ReceiveFile(gdto);
}

public class JsonHelper
{
    public static T Deserialize<T>(string json)
    {
        return JsonConvert.DeserializeObject<T>(json, new JsonSerializerSettings()
        {
            ReferenceLoopHandling = ReferenceLoopHandling.Ignore
        });
    }

    public static string Serialize<T>(T data)
    {
        JsonSerializerSettings settings = new JsonSerializerSettings();
        ByteJsonConverter byteJsonConverter = new ByteJsonConverter();
        settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
        DateTimeConverter dateTimeConverter = new DateTimeConverter();
        settings.Converters.Add(dateTimeConverter);
        settings.Converters.Add(byteJsonConverter);
        return JsonConvert.SerializeObject((object)data, settings);
    }

    internal static string ObjectToJson<T>(T obj)
    {
        using (MemoryStream memoryStream = new MemoryStream())
        {
            new DataContractJsonSerializer(typeof(T)).WriteObject(memoryStream, obj);
            memoryStream.Position = 0L;
            using (StreamReader streamReader = new StreamReader(memoryStream, Encoding.UTF8))
                return streamReader.ReadToEnd();
        }
    }
}

internal class DateTimeConverter : JsonConverter
{
    public override bool CanRead
    {
        get { return false; }
    }

    public override bool CanWrite
    {
        get { return true; }
    }

    public override bool CanConvert(Type objectType)
    {
        return typeof(DateTime) == objectType || typeof(DateTime?) == objectType;
    }

    public override object ReadJson(
        JsonReader reader,
        Type objectType,
        object existingValue,
        JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        string json = JsonHelper.ObjectToJson<DateTime>(Convert.ToDateTime(value));
        writer.WriteRawValue(json);
    }
}

internal class ByteJsonConverter : JsonConverter
{
    public override bool CanRead
    {
        get { return false; }
    }

    public override bool CanWrite
    {
        get { return true; }
    }

    public override bool CanConvert(Type objectType)
    {
        return typeof(byte[]) == objectType;
    }

    public override object ReadJson(
        JsonReader reader,
        Type objectType,
        object existingValue,
        JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        string json = JsonHelper.ObjectToJson<byte[]>(value as byte[]);
        writer.WriteRawValue(json);
    }
}

var inFile1 =
    @"C:\Users\test\source\repos\ConsoleApp1\7794FDBE-34E9-4218-B5EC-2272ED750201.mp3";
byte[] data = File.ReadAllBytes(inFile1);

var outputFolder = Path.Combine(System.Environment.CurrentDirectory, "NAudio");
Directory.CreateDirectory(outputFolder);

var filename = GetFileName();
string g711FileName = filename + "-g711.wav";

var inFile = Path.Combine(outputFolder, filename + ".wav");
var outfile = Path.Combine(outputFolder, g711FileName);

using (MemoryStream ms = new MemoryStream(data))
using (var reader = new Mp3FileReader(ms))
{
    WaveFileWriter.CreateWaveFile(inFile, reader);
}

NAudioHelper.EnCodeG711(inFile, outfile);

/// <summary>
/// Naudio 转码
/// </summary>
public class NAudioHelper
{
    private static MuLawChatCodec _codec = new MuLawChatCodec();
    public static void EnCodeG711(string inFile, string outfile)
    {
        var format = new WaveFormat(8000, 16, 1);
        using (var reader = new WaveFileReader(inFile))
        using (WaveFileWriter waveFileWriter = new WaveFileWriter(outfile, format))
        {
            byte[] buffer = new byte[reader.WaveFormat.AverageBytesPerSecond * 4];
            while (true)
            {
                int count = reader.Read(buffer, 0, buffer.Length);

                byte[] encoded = _codec.Encode(buffer, 0, count);

                if (count != 0)
                    waveFileWriter.Write(encoded, 0, encoded.Length);
                else
                    break;
            }
        }
    }
    public static string GetFileName()
    {
        Random rd = new Random();
        StringBuilder serial = new StringBuilder();
        serial.Append(DateTime.Now.ToString("yyyyMMddHHmmssff"));
        serial.Append(rd.Next(0, 999999).ToString());
        return serial.ToString();
    }
}

internal class MuLawChatCodec
{
    public string Name => "G.711 mu-law";

    public int BitsPerSecond => RecordFormat.SampleRate * 8;

    public WaveFormat RecordFormat => new WaveFormat(8000, 16, 1);

    public byte[] Encode(byte[] data, int offset, int length)
    {
        var encoded = new byte[length / 2];
        int outIndex = 0;
        for (int n = 0; n < length; n += 2)
        {
            encoded[outIndex++] = MuLawEncoder.LinearToMuLawSample(BitConverter.ToInt16(data, offset + n));
        }

        return encoded;
    }

    public byte[] Decode(byte[] data, int offset, int length)
    {
        var decoded = new byte[length * 2];
        int outIndex = 0;
        for (int n = 0; n < length; n++)
        {
            short decodedSample = MuLawDecoder.MuLawToLinearSample(data[n + offset]);
            decoded[outIndex++] = (byte)(decodedSample & 0xFF);
            decoded[outIndex++] = (byte)(decodedSample >> 8);
        }

        return decoded;
    }

    public void Dispose()
    {
        // nothing to do
    }

    public bool IsAvailable
    {
        get { return true; }
    }
}