C#高级语法 Attribute特性详解和类型，方法，变量附加特性讲解

已于 2024-01-04 22:54:58 修改
阅读量1.3k 收藏 18
点赞数 16
分类专栏： C# 文章标签： c# 数据库 ui
于 2024-01-04 17:30:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44695769/article/details/135384682
版权

文章目录

前言

Attribute特性是一种高级的语法，在C#和Java中用的比较多。如果你想要了解特性，就需要先了解反射。

相关资料

【C#进阶】C# 特性

C# 官方文档 创建自定义特性

C# 官方文档 使用反射访问特性

C#基础教程 Attribute 特性与反射案例详解，自动化识别与使用类型!

C#基础教程 Reflection应用，简单使用反射，打破常规！

Attribute特性

Attribute是一个简单的语法，一般来说都是放在类/变量/函数的前面，当然也可以放在参数里面。不过我们这里主要讨论常用的三种情况：

  • 类
  • 变量
  • 方法

个人原理理解
找到带有Attribute特性的类
Assembly程序集,存放所有的编译信息
所有的Class类名
带有Attribute特性的类
Type
Attribute特性
...等等
MethodInfo方法属性
Attribute
PropertyInfo变量属性

特性的声明与使用

【C#进阶】C# 特性

在这里插入图片描述

简单的特性声明

namespace NetCore.Models
{

    /// <summary>
    /// 特性需要以MyAttributeTestAttribute结尾，这个是约定
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    
    public class MyAttributeTestAttribute:Attribute
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public MyAttributeTestAttribute(string name) {
            Name = name;
        }

        public MyAttributeTestAttribute()
        {


        }
    }
}

在这里插入图片描述

为了方便后面的讲解，我们这里声明三个特性

namespace NetCore.Models
{
    /// <summary>
    /// 类型特性
    /// </summary>
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    public class MyClassAttribute:Attribute
    {
        public string Name { get; set; }
        public MyClassAttribute(string name) {
            Name = name;
        }
        public MyClassAttribute() { }
    }
}



namespace NetCore.Models
{
    /// <summary>
    /// 方法特性
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    public class MyMethodAttribute:Attribute
    {
        public string Name { get; set; }

        public MyMethodAttribute(string name) {
            Name = name;
        }
        public MyMethodAttribute() { }
    }
}


namespace NetCore.Models
{
    /// <summary>
    /// 参数特性
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
    public class MyPropertyAttribute:Attribute
    {
        public string Name { get; set; }
        public MyPropertyAttribute(string name) {
            Name = name;
        }
		public MyPropertyAttribute() { }
    }
}

类型特性

我们声明三个类，去获取这三个类的MyClass特性
其它两个设置差不多

在这里插入图片描述
在这里插入图片描述

  static void Main(string[] args)
 {
     var list = GetAllTypes<MyClassAttribute>();
     for (var i = 0; i < list.Count; i++)
     {
         Console.WriteLine($"ClassName:[{list[i].Name}],Attribute.Name[{GetAttribute<MyClassAttribute>(list[i]).Name}]");
     }
     Console.WriteLine("运行完成！");
     Console.ReadKey();
 }

 /// <summary>
 /// 获取所有有T特性的类型
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <returns></returns>
 public static List<Type> GetAllTypes<T>() where T : Attribute
 {
     var res = new List<Type>();
     //Assembly存放所有的程序集
     res = Assembly.GetExecutingAssembly()
         .GetTypes()
         .Where(t => t.GetCustomAttributes(typeof(T), false).Any())//我们找到所有程序集中带有T特性的Type类型
         .ToList();
     return res;
 }
 /// <summary>
 /// 获取
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="model"></param>
 /// <returns></returns>
 public static T GetAttribute<T>(Type model) where T : Attribute, new()
 {
     var res = new T();
     res = model.GetCustomAttribute<T>();
     return res;
 }

运行结果：

在这里插入图片描述

找到类的Attribute属性

如果只是找到带有Attribute的属性，那么意义就不大了，那么目前就只有一个标记的功能。这里我们将对应Attribute属性取到

 static void Main(string[] args)
 {
     var list = GetAllTypes<MyClassAttribute>();
     for (var i = 0; i < list.Count; i++)
     {
         Console.WriteLine($"ClassName:[{list[i].Name}],Attribute.Name[{GetAttribute<MyClassAttribute>(list[i]).Name}]");
     }
     Console.WriteLine("运行完成！");
     Console.ReadKey();
 }

 /// <summary>
 /// 获取所有有T特性的类型
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <returns></returns>
 public static List<Type> GetAllTypes<T>() where T : Attribute
 {
     var res = new List<Type>();
     //Assembly存放所有的程序集
     res = Assembly.GetExecutingAssembly()
         .GetTypes()
         .Where(t => t.GetCustomAttributes(typeof(T), false).Any())//我们找到所有程序集中带有T特性的Type类型
         .ToList();
     return res;
 }
 /// <summary>
 /// 获取
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="model"></param>
 /// <returns></returns>
 public static T GetAttribute<T>(Type model) where T : Attribute, new()
 {
     var res = new T();
     res = model.GetCustomAttribute<T>();
     return res;
 }

在这里插入图片描述

方法特性和变量特性

现在会了类型特性，那么方法特性和变量特性也差不多了。我们这里直接将对应的代码封装一下

代码封装

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace NetCore.Utils
{
    public static class MyAttributeHelper
    {

        /// <summary>
        /// 获取该类型下所有的带Attribute的方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <returns></returns>
        public static List<MethodInfo> GetAllMethods<T>(Type type) where T : class, new()
        {
            var res = new List<MethodInfo>();
            res = type.GetMethods().Where(t => t.GetCustomAttributes(typeof(T), false).Any()).ToList();
            return res;
        }

        /// <summary>
        /// 获取该类型下所有的带Attribute的属性
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <returns></returns>
        public static List<PropertyInfo> GetAllPropertys<T>(Type type) where T : class, new()
        {
            var res = new List<PropertyInfo>();
            res = type.GetProperties().Where(t => t.GetCustomAttributes(typeof(T), false).Any()).ToList();
            return res;
        }
        /// <summary>
        /// 获取程序集所有有T特性的类型class
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static List<Type> GetAllTypes<T>() where T : Attribute
        {
            var res = new List<Type>();
            //Assembly存放所有的程序集
            res = Assembly.GetExecutingAssembly()
                .GetTypes()
                .Where(t => t.GetCustomAttributes(typeof(T), false).Any())//我们找到所有程序集中带有T特性的Type类型
                .ToList();
            return res;
        }
        /// <summary>
        /// 获取特性
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public static T GetAttribute<T>(Type type) where T : Attribute, new()
        {
            var res = new T();
            res = type.GetCustomAttribute<T>();
            return res;
        }

        /// <summary>
        /// 获取特性
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public static T GetAttribute<T>(MethodInfo type) where T : Attribute, new()
        {
            var res = new T();
            res = type.GetCustomAttribute<T>();
            return res;
        }

        /// <summary>
        /// 获取特性
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public static T GetAttribute<T>(PropertyInfo type) where T : Attribute, new()
        {
            var res = new T();
            res = type.GetCustomAttribute<T>();
            return res;
        }
    }
}

测试类

TestService1

namespace NetCore.Services
{
    [MyClass("TestServiceAttribute1")]
    public class TestService1
    {

        [MyProperty("TestService1的Property")]
        public string Name { get; set; }

        public int Id { get; set; }

        [MyMethod("TestService1的Method")]
        public void Test()
        {

        }

        public void Send()
        {

        }
    }
}
TestService2
using NetCore.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NetCore.Services
{
    [MyClass("TestServiceAttribute2")]
    public class TestService2
    {
    }
}
TestService3
using NetCore.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace NetCore.Services
{
    [MyClass("TestServiceAttribute3")]
    public class TestService3
    {
    }
}

测试代码


        static void Main(string[] args)
        {
            //找到所有带MyClassAttribute特性的类
            var list = MyAttributeHelper.GetAllTypes<MyClassAttribute>();
            for (var i = 0; i < list.Count; i++)
            {
                Console.WriteLine($"ClassName:[{list[i].Name}],Attribute.Name[{MyAttributeHelper.GetAttribute<MyClassAttribute>(list[i]).Name}]");
                //找到所有带MyMethodAttribute的方法
                var methods = MyAttributeHelper.GetAllMethods<MyMethodAttribute>(list[i]);
                //找到所有带MyPropertyAttribute的方法
                var propertis = MyAttributeHelper.GetAllPropertys<MyPropertyAttribute>(list[i]);

                //对代码进行打印
                foreach (var item in methods)
                {
                    var att = MyAttributeHelper.GetAttribute<MyMethodAttribute>(item);
                    Console.WriteLine($"ClassName:[{list[i].Name}],Method:[{item.Name}],Attribute.Name[{att.Name}]");
                }
                foreach (var item in propertis)
                {
                    var att = MyAttributeHelper.GetAttribute<MyPropertyAttribute>(item);

                    Console.WriteLine($"ClassName:[{list[i].Name}],Property:[{item.Name}],Attribute.Name[{att.Name}]");
                }
            }
            Console.WriteLine("运行完成！");
            Console.ReadKey();
        }

运行结果

在这里插入图片描述

对封装的代码进行优化

我们获取带有Attribute的类的时候，肯定希望一个函数直接返回两个结果：

  • Type：那个带Attribute的类
  • Attribute:Attribute本身的属性

一个函数返回多个变量有许多种解决方案，我这里觉得使用ValueTuple更加的合适。

C# 元祖，最佳的临时变量。

封装代码

......其它代码
 /// <summary>
 /// 返回带有Attribute的类型元祖列表
 /// </summary>
 /// <typeparam name="Att"></typeparam>
 /// <returns></returns>
 public static List<(Type type, Att att)> GetAll_TypeAndAtt<Att>() where Att : Attribute, new()
 {
     var res = new List<(Type type, Att att)> ();
     var typeLists = GetAllTypes<Att>();
     foreach (var item in typeLists)
     {
         var att = GetAttribute<Att>(item);
         res.Add((item, att));   
     }
     return res;
 }

 /// <summary>
 /// 返回带有Attribute的变量元祖列表
 /// </summary>
 /// <typeparam name="Att"></typeparam>
 /// <param name="type"></param>
 /// <returns></returns>
 public static List<(PropertyInfo property, Att att)> GetAll_PropertyAndAtt<Att>(Type type) where Att : Attribute, new()
 {
     var res = new List<(PropertyInfo type, Att att)>();
     var typeLists = GetAllPropertys<Att>(type);
     foreach (var item in typeLists)
     {
         var att = GetAttribute<Att>(item);
         res.Add((item, att));
     }
     return res;
 }

 /// <summary>
 /// 返回带有Attribute的方法元祖列表
 /// </summary>
 /// <typeparam name="Att"></typeparam>
 /// <param name="type"></param>
 /// <returns></returns>
 public static List<(MethodInfo method, Att att)> GetAll_MethodAndAtt<Att>(Type type) where Att : Attribute, new()
 {
     var res = new List<(MethodInfo type, Att att)>();
     var typeLists = GetAllMethods<Att>(type);
     foreach (var item in typeLists)
     {
         var att = GetAttribute<Att>(item);
         res.Add((item, att));
     }
     return res;
 }

测试代码


            var lists = MyAttributeHelper.GetAll_TypeAndAtt<MyClassAttribute>();
            lists.ForEach(item1 =>
            {
                Console.WriteLine($"ClassName:[{item1.type.Name}],Attribute.Name[{item1.att.Name}]");
                var methods = MyAttributeHelper.GetAll_MethodAndAtt<MyMethodAttribute>(item1.type);
                var properties = MyAttributeHelper.GetAll_PropertyAndAtt<MyPropertyAttribute>(item1.type);
                methods.ForEach(item2 => { Console.WriteLine($"ClassName:[{item1.type.Name}],Method:[{item2.method.Name}],Attribute.Name[{item2.att.Name}]"); });
                properties.ForEach(item2 => { Console.WriteLine($"ClassName:[{item1.type.Name}],Method:[{item2.property.Name}],Attribute.Name[{item2.att.Name}]"); });

            });

运行结果（和上次的一致）

在这里插入图片描述

最后封装好的代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace NetCore.Utils
{
    public static class MyAttributeHelper
    {

        /// <summary>
        /// 获取该类型下所有的带Attribute的方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <returns></returns>
        public static List<MethodInfo> GetAllMethods<T>(Type type) where T : class, new()
        {
            var res = new List<MethodInfo>();
            res = type.GetMethods().Where(t => t.GetCustomAttributes(typeof(T), false).Any()).ToList();
            return res;
        }

        /// <summary>
        /// 获取该类型下所有的带Attribute的属性
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <returns></returns>
        public static List<PropertyInfo> GetAllPropertys<T>(Type type) where T : class, new()
        {
            var res = new List<PropertyInfo>();
            res = type.GetProperties().Where(t => t.GetCustomAttributes(typeof(T), false).Any()).ToList();
            return res;
        }
        /// <summary>
        /// 获取程序集所有有T特性的类型class
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static List<Type> GetAllTypes<T>() where T : Attribute
        {
            var res = new List<Type>();
            //Assembly存放所有的程序集
            res = Assembly.GetExecutingAssembly()
                .GetTypes()
                .Where(t => t.GetCustomAttributes(typeof(T), false).Any())//我们找到所有程序集中带有T特性的Type类型
                .ToList();
            return res;
        }
        /// <summary>
        /// 获取特性
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public static T GetAttribute<T>(Type type) where T : Attribute, new()
        {
            var res = new T();
            res = type.GetCustomAttribute<T>();
            return res;
        }

        /// <summary>
        /// 获取特性
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public static T GetAttribute<T>(MethodInfo type) where T : Attribute, new()
        {
            var res = new T();
            res = type.GetCustomAttribute<T>();
            return res;
        }

        /// <summary>
        /// 获取特性
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="model"></param>
        /// <returns></returns>
        public static T GetAttribute<T>(PropertyInfo type) where T : Attribute, new()
        {
            var res = new T();
            res = type.GetCustomAttribute<T>();
            return res;
        }

        /// <summary>
        /// 返回带有Attribute的类型元祖列表
        /// </summary>
        /// <typeparam name="Att"></typeparam>
        /// <returns></returns>
        public static List<(Type type, Att att)> GetAll_TypeAndAtt<Att>() where Att : Attribute, new()
        {
            var res = new List<(Type type, Att att)> ();
            var typeLists = GetAllTypes<Att>();
            foreach (var item in typeLists)
            {
                var att = GetAttribute<Att>(item);
                res.Add((item, att));   
            }
            return res;
        }

        /// <summary>
        /// 返回带有Attribute的变量元祖列表
        /// </summary>
        /// <typeparam name="Att"></typeparam>
        /// <param name="type"></param>
        /// <returns></returns>
        public static List<(PropertyInfo property, Att att)> GetAll_PropertyAndAtt<Att>(Type type) where Att : Attribute, new()
        {
            var res = new List<(PropertyInfo type, Att att)>();
            var typeLists = GetAllPropertys<Att>(type);
            foreach (var item in typeLists)
            {
                var att = GetAttribute<Att>(item);
                res.Add((item, att));
            }
            return res;
        }

        /// <summary>
        /// 返回带有Attribute的方法元祖列表
        /// </summary>
        /// <typeparam name="Att"></typeparam>
        /// <param name="type"></param>
        /// <returns></returns>
        public static List<(MethodInfo method, Att att)> GetAll_MethodAndAtt<Att>(Type type) where Att : Attribute, new()
        {
            var res = new List<(MethodInfo type, Att att)>();
            var typeLists = GetAllMethods<Att>(type);
            foreach (var item in typeLists)
            {
                var att = GetAttribute<Att>(item);
                res.Add((item, att));
            }
            return res;
        }
    }
}

总结

Attribute是C# 的高级语法，使用范围很广，可以极大的简化我们需要运行代码。本篇文章只是讲解了如何拿到特性属性，如果我们需要深入解决，那么就需要深入了解反射的使用方法。

龙中舞王
关注
  • 16
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c#特性（Attribute）简单示例
12-13
c#特性（Attribute）简单示例，适合初学者
C# 特性（Attribute）总结
明月清风@的博客
06-15 3623
特性的作用就是对程序中所标记元素的另加描述和限限制。就像生活中的坐火车的车票一样，对该行程进行了进一步描述（如哪个站，目的地，出发时间等），同时也对描述信息进行了限制（如你错过发车时间就不能上车），出现任何差错都会视为异常。
C# 特性（Attribute）
weixin_43055166的博客
11-27 429
特性（Attribute）是用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的。 特性（Attribute）用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。.Net 框架提供了两种类型的特性：预定义特性和自定义特性。 规定特性（Attribute） 规定特性（Attribute）的语法如下： [attribute(positional_param
C#中Property和Attribute的区别实例详解
09-03
主要介绍了C#中Property和Attribute的区别,较为详细的分析了C#中Property和Attribute的功能、定义、区别及使用时的相关注意事项,需要的朋友可以参考下
C# 特性（Attribute）.docx
02-03
预定义特性 AttributeUsage 描述了如何使用一个自定义特性类。它规定了特性可应用到的项目的类型
C#属性(Attribute)用法实例解析
09-04
主要介绍了C#属性(Attribute)用法实例解析,需要的朋友可以参考下
C# 特性（Attribute）
06-14 305
C#特性（Attribute）特性（Attribute）是用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的。特性（Attribute）用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。.Net 框架提供了两种类型的特性：预定...
C#中Attribute的用法
charlsdm的博客
06-16 551
Attribute的一些用法
C#中的Attribute详解（上）
热门推荐
xiaouncle的博客
04-17 3万+
近期正在研究AOP，本以为学会之后就又得了一个宝贝，想想心中还挺高兴的。我在学习时无意中发现了一位大牛在12年前写的一篇关于AOP博客（http://www.cnblogs.com/wayfarer/articles/241024.html），写的真是很深入很不错，这时我突然感觉自己很渺小很无知，人家12年前就了如指掌的东西，我到如今还在东拼西凑地找学习资料，觉得自己真是太差劲了。不过后来我也想通了
C#高级--特性详解
李宥的博客
08-02 1万+
C#高级–特性详解 一、什么是特性 1、特性定义 **特性（Attribute）**是用于在运行时传递程序中各种元素（比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。您可以通过使用特性向程序添加声明性信息。一个声明性标签是通过放置在它所应用的元素前面的方括号（[ ]）来描述的。 特性（Attribute）用于添加元数据，如编译器指令和注释、描述、方法、类等其他信息。.Net 框架提供了两种类型的特性：预定义特性和自定义特性。 2、特性的语法 特性（Attribute）的名称和值是在方括号内规定的，
C# XML序列化方法及常用特性总结分析
09-02
主要介绍了C# XML序列化方法及常用特性,总结分析了C# xml序列化的实现方法及序列化常用Attribute含义与功能,具有一定参考借鉴价值,需要的朋友可以参考下
C#高级教程_特性在编程中的应用_研究报告
07-09
C#特性，⼀个⾮常强⼤，但对于初学者来说⾮常难懂的功能。为什么在类的前加⼀个“[Serializable]”就可以实现对类的序列化，为什么⽅法 的前⾯加⼀个[DllImpot]就能为⾮托管动态链接库公开静态⼊⼝。今天我们来接开...
C#中的Attribute详解（下）
xiaouncle的博客
04-18 1万+
从上篇里我们可以看到，Attribute似乎总跟public、static这些关键字（Keyword）出现在一起。莫非使用了Attribute就相当于定义了新的修饰符（Modifier）吗？让我们一窥究竟吧！
11. C#高级进阶
weixin_42051619的博客
03-23 1710
高级进阶
c# .net 特性Attribute高级篇-实现特性多属性验证、多重验证、随意扩展的应用与实战，
橙-极纪元-cplvfx-JJY.Cheng
04-05 1035
在上一篇中我们讲了特性Attribute如何声明使用， 为什么我们声明的特性不像EF--MVC--WCF-WebService--UnitTest--IOC--AOP--SuperSocket里面的特性一样，具有申请的效果， 其，原因是因为我们需要在中间加一个反射控制器，来过滤Filter标记特性的类、方法、属性等； 接下来我们讲解下，特性Attribute的应用实战。 1 特性封装提供额...
C#高级特性
MeatLoveJK的博客
02-23 724
一、C# 特性（Attribute）（注解） 特性（Attribute）是用于在运行时传递程序中各种元素 （比如类、方法、结构、枚举、组件等）的行为信息的声明性标签。 （有点像java中的注解） 定义规则： [attribute(positional_parameters, name_parameter = value, ...)] element .Net 框架提供了三种预定义特性： 1.At...
C# 特性详解
sbayje的专栏
04-27 1822
1、什么是特性      1）属性与特性的区别          属性(Property)：属性是面向对象思想里所说的封装在类里面的数据字段，Get，Set方法。          特性(Attribute):  官方解释：特性是给指定的某一声明的一则附加的声明性信息。 允许类似关键字的描述声明。它对程序中的元素进行标注，如类型、字段、方法、属性等。从.net角度看，特性是一种 类，这些类继
C#高级教程
qq_50682713的博客
05-16 2101
1. StringBuilder类 高性能的字符串控制类，反复修改添加字符串时使用 // 新建一个StringBuilder类 StringBuilder sb1 = new StringBuilder("Hello World"); StringBuilder sb2 = new StringBuilder(20); StringBuilder sb3 = new StringBuilder("Hello World", 20); 方法 功能 Append(string) 在尾部追加字符
【Entity Framework】聊一聊EF如何使用数据库函数
最新发布
记录总结工作过往
04-21 1436
内置函数是数据库中预定义的，而用户定义的函数是由数据库用户显式定义的。EF Core将查询转换为使用数据库函数时，它使用内置函数来确保该函数在数据库中始终可用。在某些数据库中，需要了解内置函数的特征，才能正确生成SQL。例如SqlServer要求使用架构限定的名称调用各个用户定义的函数。但SqlServer中的内置函数没有架构。PostgreSQL使用public架构定义内置函数，但可使用架构限定的名称调用它们。除了 EF Core 提供程序提供的映射以外，用户还可以定义自定义映射。
c语言 c17标准 pdf
12-19
C语言是一种通用的编程语言，经过多年的发展，目前发布的最新版本是C17标准。C17标准为C语言的使用者提供了一些新的特性和改进，使得编程更加方便和高效。 C17标准的内容十分丰富，包括了很多新的语法规则、函数和库的新增，同时修复了之前版本的一些 bug 和问题。这些改进主要是为了让C语言更加适合于现代编程的需求，提高程序的性能和安全性。 C语言C17标准的PDF文件可以在互联网上找到并下载，其中包含了C17标准的所有内容和细节。通过阅读这份PDF文件，使用者可以了解C17标准中新增的特性和改进，以及如何在自己的项目中应用这些新特性。 对于想要深入学习C语言的程序员来说，熟悉C17标准是非常重要的。通过阅读C17标准的PDF文件，程序员可以更好地理解C语言的最新规范，同时也可以学习如何利用这些新特性来提高自己的编程水平。 总之，C语言C17标准PDF文件是学习和掌握C语言的重要工具，它为C语言的使用者提供了最新的知识和规范，帮助他们更好地应用C语言进行编程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值