Während wir uns damit befassen, was ein benutzerdefiniertes Attribut ist, müssen wir Attribute verstehen. Attribute sind Metadatenerweiterungen, die dem C#-Compiler zur Laufzeit zusätzliche Informationen über Elemente im C#-Programm liefern. Diese Attribute werden verwendet, um Bedingungen festzulegen oder die Lesbarkeit und Effizienz des Codes zu erhöhen. Es gibt so viele vordefinierte Attribute in C# (Cs), und wir haben auch die Möglichkeit, neue Benutzerattribute zu erstellen, die als „benutzerdefinierte Attribute“ bezeichnet werden. Um die benutzerdefinierte Klasse zu erstellen, müssen wir die Klassen aus dem System erstellen. Attributklasse.
Das benutzerdefinierte C#-Attribut basiert auf vordefinierten Klassen, die zum Erstellen verwendet werden. Wir werden Schritt für Schritt untersuchen, wie die benutzerdefinierten Attribute erstellt werden. Schritte zum Erstellen des benutzerdefinierten Attributs:
Durch Verwendung des AttributeUsageAttribute-Tags: Das AttributeUsageAttribute-Tag wird zum Erstellen des Attributs verwendet. Dieses Tag wird auch verwendet, um anzugeben, was die Zielattribute sind und ob diese vererbt werden können oder ob mehrere Objekte oder Instanzen des Attributs vorhanden sein können. Dieses AttributeUsageAttribute-Tag hat 3 primäre Mitglieder
1. AttributeUsageAttribute(AttributeTargets.All): AttributeTargets.All gibt an, dass das Attribut auf alle anderen Teile des Programms angewendet werden kann, während Attribute. Die Klasse gibt an, dass sie auf die Klasse und den AttributeTargets.Method-Parameter auf die benutzerdefinierte Methode angewendet werden soll.
Syntax:
AttributeUsageAttribute( AttributeTargets.All)
2. AttributeUsage(AttributeTargets.All, Inherited = false): Daher ist AttributeUsageAttribute( AttributeTargets.All) ein geerbtes Mitglied und gibt an, dass das benutzerdefinierte Attribut geerbt werden kann oder nicht. Inherited = false ist ein boolescher Wert, entweder wahr/falsch. Wenn wir Inherited = true/false nicht angegeben haben, ist der Standardwert true.
Syntax:
AttributeUsage(AttributeTargets.All, Inherited = false)
3. AttributeUsage(AttributeTargets.Method, AllowMultiple = true): Anhand dieses AllowMultiple-Parameters erfahren wir, ob mehr als ein Objekt des Attributs vorhanden ist oder nicht. Es nimmt auch den booleschen Wert an. Standardmäßig ist dieser boolesche Wert falsch.
Syntax:
AttributeUsage(AttributeTargets.Method, AllowMultiple = true)
1. Durch Definieren der Attributklasse: Dies ähnelt mehr oder ähnlich der normalen Klassendefinition. Der Klassenname endet konventionell mit Attribut. Diese Attributklasse wurde von System geerbt. Attributklasse.
Syntax:
[AttributeUsage(AttributeTargets.All, Inherited = true, AllowMultiple = false)]
public class MyAttributeDefinition: Attribute
{
//some logic or methods
}1. Definieren von Eigenschaften und Konstruktoren: Definieren eines Konstruktors ähnlich allen anderen Klassen. Konstruktoren zum Festlegen der Standardwerte und Eigenschaften werden zum Definieren von Datenbankverbindungsnameninformationen, statischen Informationen usw. verwendet.
Syntax #1
public MyAttribute(dataType dataTypeValue)
{
this.dataTypeValue= dataTypeValue;
}Syntax #2
public dataType Properties
{
get {return this.dataTypeValue;}
set {this.value = presentValue;}
}Im Folgenden finden Sie die genannten Beispiele:
Benutzerdefiniertes Attribut mit typeOf-Operator
Code:
// including packages
using System;
using System.Reflection;
using System.Collections.Generic;
// Creating a custom class from Attribute class
class CustomAttribute : Attribute {
// private variables declaration
private string name;
private string company;
//parameterized class CustomAttribute constuctor
public CustomAttribute(string name, string company)
{
this.name = name;
this.company = company;
}
// method to display the fields by using reflection class
public static void AttributeDisplay(Type classType)
{
Console.WriteLine("All the Methods of the class {0} are", classType.Name);
//methods of the class for store all the attribute values
MethodInfo[] methods = classType.GetMethods();
//looping through method attribute values by using for loop
for (int i = 0; i < methods.GetLength(0); i++) {
//create the array to recieve all the custom attribute values
object[] attributesArray = methods[i].GetCustomAttributes(true);
// foreach loop to read the values through all attributes of the method
foreach(Attribute item in attributesArray)
{
if (item is CustomAttribute) {
//display the custom attribute values
CustomAttribute attributeObject = (CustomAttribute)item;
Console.WriteLine("{0} - {1}, {2} ", methods[i].Name,
attributeObject.name, attributeObject.company);
}
}
}
}
}
//Employer class to create employer fields
class Employer {
//employer fields declaration
int employeeID;
string name;
//Parameterized Employer class constructor
public Employer(int eID, string name)
{
this.employeeID = eID;
this.name = name;
}
// Applying the custom attribute for CustomAttribute for the getId method
[CustomAttribute("Accessor Values", "Generates employee ID")] public int getEmployeeID()
{
return employeeID;
}
// Applying the custom attribute to CustomAttribute for the getName method
[CustomAttribute("Accessor Values", "Generates employee ID")] public string getName()
{
return name;
}
}
//create employee class
class Employee {
//Declaring variables of Employee
int employeeID;
string name;
//Parameterized Employee constructor
public Employee(int eID, string name)
{
this.employeeID = eID;
this.name = name;
}
// Applying the custom attribute CustomAttribute for the getEmployeeID method
[CustomAttribute("Accessor Values", "Generates employee ID")] public int getEmployeeID()
{
return employeeID;
}
// Applying the custom attribute CustomAttribute for the getName method
[CustomAttribute("Accessor Values", "Generates employee ID")] public string getName()
{
return name;
}
}
//create a class for display the output
public class Program {
// main method for the application
public static void Main(string[] args)
{
//calling static method for display typeOf employer class
CustomAttribute.AttributeDisplay(typeof(Employer));
Console.WriteLine();
//calling static method for display typeOf employee class
CustomAttribute.AttributeDisplay(typeof(Employee));
}
}Ausgabe:
Benutzerdefiniertes Attribut mit Mitarbeiterdetails
Code:
using System;
[AttributeUsage(AttributeTargets.All)]
class CustomAttribute : Attribute {
private string name;
private string designation;
// Constructor
public CustomAttribute(string name, string designation)
{
this.name = name;
this.designation = designation;
}
// setters and getters
public string Name
{
get { return name; }
}
// property to get designation
public string Action
{
get { return designation; }
}
}
class Employee {
private int empID;
private string empName;
private double salary;
[CustomAttribute("Modifier", "Assigns the Employee Details")]
public void setDetails(int id,string name, double sal)
{
empID = id;
empName = name;
salary=sal;
}
[CustomAttribute("It is an Accessor", "Displays empID")] public int getEmpID()
{
return empID;
}
[CustomAttribute("It is an Accessor", "Displays empID")] public string getEmpName()
{
return empName;
}
[CustomAttribute("It is an Accessor", "Displays empID")] public double getSalary()
{
return salary;
}
}
public class EmployeeDetailsOut {
// main method for run the application
//main method modifier must be public
public static void Main(string[] args)
{
Employee emp = new Employee();
emp.setDetails(2424, "Paramesh", 400000.00);
Console.WriteLine("Employee Details");
Console.WriteLine("Employee ID Number : " + emp.getEmpID());
Console.WriteLine("Employee Name : " + emp.getEmpName());
Console.WriteLine("Employee Salary : " + emp.getSalary());
Console.WriteLine("\n");
Employee emp1 = new Employee();
emp1.setDetails(2423, "Amardeep", 600000.00);
Console.WriteLine("Employee Details");
Console.WriteLine("Employee ID Number : " + emp1.getEmpID());
Console.WriteLine("Employee Name : " + emp1.getEmpName());
Console.WriteLine("Employee Salary : " + emp1.getSalary());
}
}Ausgabe:
Demonstration benutzerdefinierter Attribute
Code:
using System;
using System.Diagnostics;
public class DemonstrationOfCustomAttribute {
[Conditional("DEBUG")]
public static void getMyOut(string msg) {
Console.WriteLine(msg);
}
}
public class Test {
static void firstMethod() {
DemonstrationOfCustomAttribute.getMyOut("I am first method.");
secondMethod();
}
static void secondMethod() {
DemonstrationOfCustomAttribute.getMyOut("I am second method.");
}
public static void Main() {
DemonstrationOfCustomAttribute.getMyOut("I am in main method.");
firstMethod();
}
}Ausgabe:
Benutzerdefiniertes Attribut in C# wird verwendet, um die verwendete deklarierte Implementierung mit Klassen zu definieren. Wir können diese benutzerdefinierte Attributimplementierung in drei Schritten erreichen, nämlich durch die Verwendung von AttributeUsageAttribute, AttributeUsage (AttributeTargets.All, Inherited = false und AttributeUsage (AttributeTargets.Method, AllowMultiple = true).
Das obige ist der detaillierte Inhalt vonBenutzerdefiniertes C#-Attribut. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
