经过几天的努力Biwen.AutoClassGen终于实现了DTO复杂属性的生成

于 2025-04-26 08:23:31 发布
阅读量31 收藏
点赞数
合集 - SG(6)
1.使用.NET源生成器(SG)实现一个自动注入的生成器 2.使用.NET源生成器(SG)生成项目的版本号信息 3.使用 `Roslyn` 分析器和修复器对.cs源代码添加头部注释 4.使用Roslyn分析器和修复器 对异步方法规范化返回Async结尾 5.使用Roslyn的源生成器生成DTO
6. 经过几天的努力Biwen.AutoClassGen终于实现了DTO复杂属性的生成
收起

前言

距写上一篇 https://www.cnblogs.com/vipwan/p/18535459 生成DTO已经有一段时间了,

最初没有考虑复杂二级属性嵌套的实现,而是直接使用排除使用自定义的方式解决这个问题,

但是这个有些违背简约到底的初衷,并且也有好几个网友提出希望支持复杂嵌套属性DTO的功能,最近自己凑了几天时间打磨了一下,算是大致实现了这个功能

使用方式

支持特性继承

比如我们的DTO对象也需要[Require],[Range(1,10)]等校验型特征,我们只需要目标类的属性标注即可,生成的DTO也将传递这些重要的特性,对于OpenApi文档以及一些验证场景会相当有帮助:
image

public class Person
{
    [Required]
    public string Name { get; set; } = string.Empty;
    [Required, Range(0, 200)]
    public int Age { get; set; }
}

生成的DTO:

/// <inheritdoc cref = "Person.Name"/>
[Required]
public string Name { get; set; }
/// <inheritdoc cref = "Person.Age"/>
[Required]
[Range(0, 200)]
public int Age { get; set; }
支持复杂属性嵌套生成

实体定义示例:

// 主实体
public class Person
{
    [Required]
    public string Name { get; set; } = string.Empty;
    [Required, Range(0, 200)]
    public int Age { get; set; }
    // 嵌套对象
    public Address Address { get; set; } = new();
    // 集合属性
    public List<Hobby> Hobbies { get; set; } = [];
    // 使用特性标记忽略的属性
    [AutoDtoIgroned]
    public string Igrone2 { get; set; } = null!;
}

// 嵌套实体
public class Address
{
    [Required]
    public string Street { get; set; } = string.Empty;
    [Required]
    public string City { get; set; } = string.Empty;
    [Required]
    public string State { get; set; } = string.Empty;
    [Required]
    public string ZipCode { get; set; } = string.Empty;
}

// 集合项实体
public class Hobby
{
    [Required]
    public string Name { get; set; } = string.Empty;
    [Required]
    public string Description { get; set; } = string.Empty;
    // 多层嵌套
    public HobbyExtend Extend { get; set; } = new();
}

public class HobbyExtend
{
    public string Extend1 { get; set; } = string.Empty;
    public string Extend2 { get; set; } = string.Empty;
    public InnerExtend Extend3 { get; set; } = new();
}

public class InnerExtend
{
    public string InnerExtendMsg { get; set; } = string.Empty;
}
  1. 普通 DTO（单层映射）
/// <summary>
/// 没有复杂属性嵌套的 DTO
/// </summary>
[AutoDto<Person>(nameof(Person.Igrone))]//忽略掉Igrone属性
public partial record PersonDto;
  1. 复杂 DTO（多层嵌套）
/// <summary>
/// 模拟的复杂 DTO
/// </summary>
[AutoDto<Person>(nameof(Person.Igrone))]
[AutoDtoComplex(5)]//≥2即表示多层嵌套生成
public partial record PersonComplexDto;

生成的代码样例:

生成DTO,并对象生成映射扩展:MapperToXXX,以及IQuerylable扩展ProjectToXXX:
并且生成了预留partial扩展,如果存在FirstName + LastName -> FullName这种情况,你可以自己实现partial部分!


// <auto-generated />
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

#pragma warning disable

//generate Person-PersonComplexDto
namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;

    public partial record class PersonComplexDto
    {
        /// <inheritdoc cref = "Person.Name"/>
        [Required]
        public string Name { get; set; }

        /// <inheritdoc cref = "Person.Age"/>
        [Required]
        [Range(0, 200)]
        public int Age { get; set; }
        /// <inheritdoc cref = "Person.Address"/>
        public AddressDto Address { get; set; }
        /// <inheritdoc cref = "Person.Hobbies"/>
        public System.Collections.Generic.List<HobbyDto> Hobbies { get; set; }
    }
}

namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.Linq;

    public static partial class PersonToPersonComplexDtoExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(Person from, PersonComplexDto to);
        /// <summary>
        /// mapper to PersonComplexDto
        /// </summary>
        /// <returns></returns>
        public static PersonComplexDto MapperToPersonComplexDto(this Person model)
        {
            if (model == null)
                return null;
            var retn = new PersonComplexDto()
            {
                Name = model.Name,
                Age = model.Age,
                Address = model.Address?.MapperToAddressDto(),
                Hobbies = model.Hobbies != null ? model.Hobbies.Select(x => x?.MapperToHobbyDto()).ToList() : null,
            };
            MapperToPartial(model, retn);
            return retn;
        }

        /// <summary>
        /// ProjectTo PersonComplexDto
        /// </summary>
        public static IQueryable<PersonComplexDto> ProjectToPersonComplexDto(this IQueryable<Person> query)
        {
            return query.Select(model => model.MapperToPersonComplexDto());
        }
    }

    public static partial class PersonComplexDtoToPersonExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(PersonComplexDto from, Person to);
        /// <summary>
        /// mapper to Person
        /// </summary>
        /// <returns></returns>
        public static Person MapperToPerson(this PersonComplexDto model)
        {
            if (model == null)
                return null;
            var retn = new Person()
            {
                Name = model.Name,
                Age = model.Age,
                Address = model.Address?.MapperToAddress(),
                Hobbies = model.Hobbies != null ? model.Hobbies.Select(x => x?.MapperToHobby()).ToList() : null,
            };
            MapperToPartial(model, retn);
            return retn;
        }
    }
}

//generate Person-PersonDto
namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;

    public partial record class PersonDto
    {
        /// <inheritdoc cref = "Person.Name"/>
        [Required]
        public string Name { get; set; }

        /// <inheritdoc cref = "Person.Age"/>
        [Required]
        [Range(0, 200)]
        public int Age { get; set; }
        /// <inheritdoc cref = "Person.Address"/>
        public Biwen.AutoClassGen.TestConsole.Dtos.Address Address { get; set; }
        /// <inheritdoc cref = "Person.Hobbies"/>
        public System.Collections.Generic.List<Biwen.AutoClassGen.TestConsole.Dtos.Hobby> Hobbies { get; set; }
    }
}

namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.Linq;

    public static partial class PersonToPersonDtoExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(Person from, PersonDto to);
        /// <summary>
        /// mapper to PersonDto
        /// </summary>
        /// <returns></returns>
        public static PersonDto MapperToPersonDto(this Person model)
        {
            if (model == null)
                return null;
            var retn = new PersonDto()
            {
                Name = model.Name,
                Age = model.Age,
                Address = model.Address,
                Hobbies = model.Hobbies,
            };
            MapperToPartial(model, retn);
            return retn;
        }

        /// <summary>
        /// ProjectTo PersonDto
        /// </summary>
        public static IQueryable<PersonDto> ProjectToPersonDto(this IQueryable<Person> query)
        {
            return query.Select(model => model.MapperToPersonDto());
        }
    }

    public static partial class PersonDtoToPersonExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(PersonDto from, Person to);
        /// <summary>
        /// mapper to Person
        /// </summary>
        /// <returns></returns>
        public static Person MapperToPerson(this PersonDto model)
        {
            if (model == null)
                return null;
            var retn = new Person()
            {
                Name = model.Name,
                Age = model.Age,
                Address = model.Address,
                Hobbies = model.Hobbies,
            };
            MapperToPartial(model, retn);
            return retn;
        }
    }
}

//generate Address-AddressDto
namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;

    public partial class AddressDto
    {
        /// <inheritdoc cref = "Address.Street"/>
        [Required]
        public string Street { get; set; }

        /// <inheritdoc cref = "Address.City"/>
        [Required]
        public string City { get; set; }

        /// <inheritdoc cref = "Address.State"/>
        [Required]
        public string State { get; set; }

        /// <inheritdoc cref = "Address.ZipCode"/>
        [Required]
        public string ZipCode { get; set; }
    }
}

namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.Linq;
    using System.Net;

    public static partial class AddressToAddressDtoExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(Address from, AddressDto to);
        /// <summary>
        /// mapper to AddressDto
        /// </summary>
        /// <returns></returns>
        public static AddressDto MapperToAddressDto(this Address model)
        {
            if (model == null)
                return null;
            var retn = new AddressDto()
            {
                Street = model.Street,
                City = model.City,
                State = model.State,
                ZipCode = model.ZipCode,
            };
            MapperToPartial(model, retn);
            return retn;
        }

        /// <summary>
        /// ProjectTo AddressDto
        /// </summary>
        public static IQueryable<AddressDto> ProjectToAddressDto(this IQueryable<Address> query)
        {
            return query.Select(model => model.MapperToAddressDto());
        }
    }

    public static partial class AddressDtoToAddressExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(AddressDto from, Address to);
        /// <summary>
        /// mapper to Address
        /// </summary>
        /// <returns></returns>
        public static Address MapperToAddress(this AddressDto model)
        {
            if (model == null)
                return null;
            var retn = new Address()
            {
                Street = model.Street,
                City = model.City,
                State = model.State,
                ZipCode = model.ZipCode,
            };
            MapperToPartial(model, retn);
            return retn;
        }
    }
}

//generate Hobby-HobbyDto
namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;

    public partial class HobbyDto
    {
        /// <inheritdoc cref = "Hobby.Name"/>
        [Required]
        public string Name { get; set; }

        /// <inheritdoc cref = "Hobby.Description"/>
        [Required]
        public string Description { get; set; }
        /// <inheritdoc cref = "Hobby.Extend"/>
        public HobbyExtendDto Extend { get; set; }
    }
}

namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.Linq;

    public static partial class HobbyToHobbyDtoExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(Hobby from, HobbyDto to);
        /// <summary>
        /// mapper to HobbyDto
        /// </summary>
        /// <returns></returns>
        public static HobbyDto MapperToHobbyDto(this Hobby model)
        {
            if (model == null)
                return null;
            var retn = new HobbyDto()
            {
                Name = model.Name,
                Description = model.Description,
                Extend = model.Extend?.MapperToHobbyExtendDto(),
            };
            MapperToPartial(model, retn);
            return retn;
        }

        /// <summary>
        /// ProjectTo HobbyDto
        /// </summary>
        public static IQueryable<HobbyDto> ProjectToHobbyDto(this IQueryable<Hobby> query)
        {
            return query.Select(model => model.MapperToHobbyDto());
        }
    }

    public static partial class HobbyDtoToHobbyExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(HobbyDto from, Hobby to);
        /// <summary>
        /// mapper to Hobby
        /// </summary>
        /// <returns></returns>
        public static Hobby MapperToHobby(this HobbyDto model)
        {
            if (model == null)
                return null;
            var retn = new Hobby()
            {
                Name = model.Name,
                Description = model.Description,
                Extend = model.Extend?.MapperToHobbyExtend(),
            };
            MapperToPartial(model, retn);
            return retn;
        }
    }
}

//generate HobbyExtend-HobbyExtendDto
namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;

    public partial class HobbyExtendDto
    {
        /// <inheritdoc cref = "HobbyExtend.Extend1"/>
        public string Extend1 { get; set; }
        /// <inheritdoc cref = "HobbyExtend.Extend2"/>
        public string Extend2 { get; set; }
        /// <inheritdoc cref = "HobbyExtend.Extend3"/>
        public InnerExtendDto Extend3 { get; set; }
    }
}

namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.Linq;

    public static partial class HobbyExtendToHobbyExtendDtoExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(HobbyExtend from, HobbyExtendDto to);
        /// <summary>
        /// mapper to HobbyExtendDto
        /// </summary>
        /// <returns></returns>
        public static HobbyExtendDto MapperToHobbyExtendDto(this HobbyExtend model)
        {
            if (model == null)
                return null;
            var retn = new HobbyExtendDto()
            {
                Extend1 = model.Extend1,
                Extend2 = model.Extend2,
                Extend3 = model.Extend3?.MapperToInnerExtendDto(),
            };
            MapperToPartial(model, retn);
            return retn;
        }

        /// <summary>
        /// ProjectTo HobbyExtendDto
        /// </summary>
        public static IQueryable<HobbyExtendDto> ProjectToHobbyExtendDto(this IQueryable<HobbyExtend> query)
        {
            return query.Select(model => model.MapperToHobbyExtendDto());
        }
    }

    public static partial class HobbyExtendDtoToHobbyExtendExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(HobbyExtendDto from, HobbyExtend to);
        /// <summary>
        /// mapper to HobbyExtend
        /// </summary>
        /// <returns></returns>
        public static HobbyExtend MapperToHobbyExtend(this HobbyExtendDto model)
        {
            if (model == null)
                return null;
            var retn = new HobbyExtend()
            {
                Extend1 = model.Extend1,
                Extend2 = model.Extend2,
                Extend3 = model.Extend3?.MapperToInnerExtend(),
            };
            MapperToPartial(model, retn);
            return retn;
        }
    }
}

//generate InnerExtend-InnerExtendDto
namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;

    public partial class InnerExtendDto
    {
        /// <inheritdoc cref = "InnerExtend.InnerExtendMsg"/>
        public string InnerExtendMsg { get; set; }
    }
}

namespace Biwen.AutoClassGen.TestConsole.Dtos
{
    using Biwen.AutoClassGen.TestConsole.Dtos;
    using System.Linq;

    public static partial class InnerExtendToInnerExtendDtoExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(InnerExtend from, InnerExtendDto to);
        /// <summary>
        /// mapper to InnerExtendDto
        /// </summary>
        /// <returns></returns>
        public static InnerExtendDto MapperToInnerExtendDto(this InnerExtend model)
        {
            if (model == null)
                return null;
            var retn = new InnerExtendDto()
            {
                InnerExtendMsg = model.InnerExtendMsg,
            };
            MapperToPartial(model, retn);
            return retn;
        }

        /// <summary>
        /// ProjectTo InnerExtendDto
        /// </summary>
        public static IQueryable<InnerExtendDto> ProjectToInnerExtendDto(this IQueryable<InnerExtend> query)
        {
            return query.Select(model => model.MapperToInnerExtendDto());
        }
    }

    public static partial class InnerExtendDtoToInnerExtendExtentions
    {
        /// <summary>
        /// custom mapper
        /// </summary>
        static partial void MapperToPartial(InnerExtendDto from, InnerExtend to);
        /// <summary>
        /// mapper to InnerExtend
        /// </summary>
        /// <returns></returns>
        public static InnerExtend MapperToInnerExtend(this InnerExtendDto model)
        {
            if (model == null)
                return null;
            var retn = new InnerExtend()
            {
                InnerExtendMsg = model.InnerExtendMsg,
            };
            MapperToPartial(model, retn);
            return retn;
        }
    }
}
#pragma warning restore
最后

以上代码完整的介绍了最近实现的功能,最后你可以使用我最新发布的nuget包体验:

<ItemGroup>
   <PackageReference Include="Biwen.AutoClassGen.Attributes" Version="1.7.0" />
   <PackageReference Include="Biwen.AutoClassGen" Version="1.7.0" PrivateAssets="all" />
</ItemGroup>

如果你对完整的实现感兴趣可以移步我的GitHub仓储,欢迎star https://github.com/vipwan/Biwen.AutoClassGen

本文版权归作者所有,转载请注明出处!

原创作者: vipwan 转载于: https://www.cnblogs.com/vipwan/p/18815596
吴德承
关注
Android蓝牙BLE低功耗相关简单总结
fanfan
04-13 1万+
在看Android4.42的源码时看到有添加对BLE设备的处理，看的一头雾水，多方百度，终于有种柳暗花明的感觉。 本文总结来源于百度多篇文章，欢迎转载，分享交流 BLE蓝牙概念 BLE：Bluetooth low Energy  低能耗蓝牙，实现低成本，短距离的无线传输，传输速率于传统蓝牙相同位2.4GHZ，采用非常快速的连接方式，适用于发送数据量少而且发送次数较少的蓝牙通信 相比于传
关于Android 5.x的低功耗蓝牙BLE开发简介
Dijkstra的专栏
04-01 1327
转自：http://www.cnblogs.com/witchiman/p/5320671.html 蓝牙4.0分为标准蓝牙和低功耗蓝牙（BLE），标准蓝牙就是手机上用的那种，低功能耗蓝牙由于其具有最大化的待机时间、快速连接和低峰值的发送和接收特性，被广泛用于智能手表、智能手环等可穿戴设备上。在安卓4.3之前，安卓平台上的BLE开发相当难搞，好在谷歌在4.3之后发布了官方的API。在安卓
beele:BeeLe是一个用于低功耗蓝牙通信的Android库项目。
05-18
甲壳虫 BeeLe是一个用于低功耗蓝牙通信的Android库项目。我们已解决了同时写入特性失败的问题，并为此进行了改进。 在库中的示例演示中使用了德州仪器（TI）的CC2540 BLE开发套件。 请参考以下链接 注意：在使用此库之前，请阅读以下对Android的BluetoothGattCallback类Key方法的描述，以便更好地理解。 onDescriptorRead和onDescriptorWrite 这用于写入/读取BLE设备的配置设置，某些制造商可能需要先将一些数据发送到BLE设备并通过读取进行确认，然后才能连接到BLE设备。 onCharacteristicWrite 通常用于BLE设备的数据模式下，用于将数据发送到BLE设备。 键入时将调用此回调 gatt.writeCharacteristic（characteristics）; onCharacteristic
android 低功率蓝牙,Android 低功耗蓝牙（BLE）
weixin_28895791的博客
05-30 468
BLE分为三部分Service、Characteristic、Descriptor，这三部分都由UUID作为唯一标示符。一个蓝牙4.0的终端可以包含多个Service，一个Service可以包含多个Characteristic，一个Characteristic包含一个Value和多个Descriptor，一个Descriptor包含一个Value。一般来说，Characteristic是手机与BL...
Android 蓝牙实例【转】
03-17 186
本文转自：http://www.yiibai.com/android/android_bluetooth.html 在很多方面，蓝牙是一种能够发送或接受两个不同的设备之间传输的数据。 Android平台包含了蓝牙框架，使设备以无线方式与其他蓝牙设备进行数据交换的支持。 Android提供蓝牙API来执行这些不同的操作。 扫描其他蓝牙设备 获取配对设备列表 ...
BLE低功耗蓝牙调试助手(QT)Android源码.zip
05-25
这是使用QT编写，在Android手机上使用的BLE低功耗蓝牙调试助手。用于调试低功耗蓝牙的数据通信。 本软件是一款BLE蓝牙串口调试助手，支持常规的发送和接收调试，BLE是低功耗类型蓝牙，在智能家居、物联网领域使用较...
android蓝牙4.0 BLE低功耗应用的感受
08-26
"Android 蓝牙 4.0 BLE 低功耗应用开发经验总结" Android 蓝牙 4.0 BLE 低功耗应用开发是一件非常复杂的事情，需要开发者具备丰富的经验和知识。通过这篇文章，我们可以看到开发者在开发 Android 蓝牙 4.0 BLE 低...
经典蓝牙+ble蓝牙（低功耗蓝牙）客户端\服务端开发
07-13
在IT行业中，蓝牙技术是一种广泛应用于无线通信的短距离传输技术，主要分为经典蓝牙和BLE（低功耗蓝牙）两种类型。本主题聚焦于这两种蓝牙技术的客户端和服务端开发，特别是针对Android平台。 经典蓝牙是一种早期的...
Android蓝牙4.0 BLE低功耗开发的挑战与体验
"Android蓝牙4.0 BLE低功耗应用开发经验分享" 在Android平台上开发蓝牙4.0（Bluetooth Low Energy, 简称BLE）低功耗应用是一项充满挑战的任务，尤其是在早期阶段。2012年时，Android 2.3版本尚未支持BLE API，而...
Android实现的简单蓝牙程序示例
01-05
本文实例讲述了Android实现的简单蓝牙程序。分享给大家供大家参考，具体如下： 我将在这篇文章中介绍了的Android蓝牙程序。这个程序就是将实现把手机变做电脑PPT播放的遥控器：用音量加和音量减键来控制PPT页面的切换。 遥控器服务器端 首先，我们需要编写一个遥控器的服务器端（支持蓝牙的电脑）来接收手机端发出的信号。为了实现这个服务器端，我用到了一个叫做Bluecove（专门用来为蓝牙服务的！）的Java库。 以下是我的RemoteBluetoothServer类： public class RemoteBluetoothServer{ public static void main
Android低功耗蓝牙数据透传发送接受Ble.zip
12-15
Android低功耗蓝牙数据透传发送和接受demo，通过扫描连接自动 监听接受数据，通过连接获取到UUID
Android 蓝牙通信简单实例
09-19
这是一个Android蓝牙开发的小程序，代码简单，实现了蓝牙打开、搜索、配对、连接、通信等功能。两个Android项目，一个服务器一个客户端
Android 之路60---低功耗蓝牙4.0
hala22的博客
05-06 235
导读1.uses-feature和uses-permission基本知识 2.蓝牙4.0开启，扫描与连接 3.蓝牙4.0通信
Android BLE低功耗蓝牙学习总结
zhifanxu的专栏
12-31 163
1、服务器端相关原理：https://blog.csdn.net/weixin_38032755/article/details/78357035 2、客户端相关原理：https://www.jianshu.com/p/d991f0fdec63 3、综合讲解：https://blog.csdn.net/qq_32115439/article/details/80643906 4、官方文章：https://developer.android.google.cn/guide/topics/connecti
Android蓝牙低功耗发送数据的方法
到此一游
06-22 3947
有关蓝牙低功耗的开发指南网上示例很多，除了谷歌官方的DEMO（见此），很多大神也都分享过自己的代码，但是看了很多都是和官方Demo一样，只有接收数据，没有发送数据的方法，而有些低功耗设备是需要手机端先发送数据，才能接收设备返回的数据，在此就简单记录下。     如同读取（接收）数据一样，写入（发送）数据也要用到蓝牙低功耗开发的关键对象：BluetoothGatt 。     调用它的write
Android 蓝牙在不同系统版本中使用的不同的蓝牙版本
luo4566的博客
12-01 3435
我要查看兼容性文档最初是想看看，Android 系统不同版本中使用的蓝牙版本是哪一个，在网上百度了一下有些连接还被墙了，后来发现在Android开发者里面也有，记录一下 链接：https://source.android.google.cn/compatibility/cdd Android 兼容性定义文档 ...
Android Bluetooth Low Energy（Android低功耗蓝牙）
热门推荐
琴弦第七
11-03 2万+
Android 4.3（API Level 18）开始引入Bluetooth Low Energy（BLE，低功耗蓝牙）的核心功能并提供了相应的API，应用程序通过这些api可以扫描设备、查询services，读写设备的characteristics（属性特征）。对比传统的蓝牙，BLE的设计能够显著减低功耗。这让Android应用程序与BLE设备之间的低功耗通讯成为可能，例如距离传感器、心率监视器
蓝牙4.0 BLE对手机操作系统和微信版本的要求
u013131716的博客
08-16 291
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值