using System;
// Define a custom attribute called "AuthorAttribute" that can be applied to classes and methods.
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class AuthorAttribute : Attribute
{
public string Name { get; }
public AuthorAttribute(string name)
{
Name = name;
}
}
// Apply the custom attribute to a class and a method.
[Author("John Doe")]
class MyClass
{
[Author("Alice Smith")]
public void MyMethod()
{
Console.WriteLine("Hello, world!");
}
}
class Program
{
static void Main()
{
// Use reflection to access and display the custom attribute values.
Type myClassType = typeof(MyClass);
object[] classAttributes = myClassType.GetCustomAttributes(typeof(AuthorAttribute), false);
if (classAttributes.Length > 0)
{
AuthorAttribute classAuthorAttribute = (AuthorAttribute)classAttributes[0];
Console.WriteLine($"Author of MyClass: {classAuthorAttribute.Name}");
}
var myMethod = typeof(MyClass).GetMethod("MyMethod");
object[] methodAttributes = myMethod.GetCustomAttributes(typeof(AuthorAttribute), false);
if (methodAttributes.Length > 0)
{
AuthorAttribute methodAuthorAttribute = (AuthorAttribute)methodAttributes[0];
Console.WriteLine($"Author of MyMethod: {methodAuthorAttribute.Name}");
}
}
}
Author of MyClass: John Doe
Author of MyMethod: Alice Smith
In C#, tasks are used to represent asynchronous operations. They are part of the Task Parallel Library (TPL) and provide a way to perform work asynchronously on a separate thread. Creating a task in C# involves using the Task class or related methods. Here are the common ways to create a task:
string path = @"C:\s\name\Documents";
string path = "C:\\s\\name\\Documents";
MyClass myObject = new MyClass(); // Creating an instance using a parameterless constructorMyClass myObject = new MyClass("parameter1", 42); // Creating an instance using a constructor with parameters
MyClass myObject = new MyClass{
Property1 = "value1",
Property2 = 42
};
public class MyClass
{
public static MyClass CreateInstance()
{
return new MyClass();
}
}
MyClass myObject = MyClass.CreateInstance();
MyClass myObject = originalObject.Clone();MyClass myObject = Activator.CreateInstance();
Type classType = Type.GetType("Namespace.MyClass");
MyClass myObject = (MyClass)Activator.CreateInstance(classType);
public record Person(string FirstName, string LastName);
public record Person(string FirstName, string LastName);
class Program
{
static void Main()
{
Person person1 = new Person("John", "Doe");
Person person2 = new Person("John", "Doe");
Console.WriteLine(person1.Equals(person2)); // Outputs: True
// Deconstruction
var (firstName, lastName) = person1;
Console.WriteLine($"First Name: {firstName}, Last Name: {lastName}");
}
}
public record Person(string FirstName, string LastName);
public record Person(string FirstName, string LastName)
{
public Person(string fullName)
{
var parts = fullName.Split(' ');
FirstName = parts.Length > 0 ? parts[0] : string.Empty;
LastName = parts.Length > 1 ? parts[1] : string.Empty;
}
}
public class MyClass
{
public event EventHandler MyEvent;
public void DoSomething()
{
// Trigger the event when something happens
MyEvent?.Invoke(this, EventArgs.Empty);
}
}
methodName(argument1, argument2);
ClassName.MethodName(argument1, argument2);
ClassName instance = new ClassName();
instance.MethodName(argument1, argument2);
instance.Method1().Method2().Method3(); delegateType delegateName = methodName;
delegateName(argument1, argument2);
delegateType delegateName = (arg1, arg2) => { /* method implementation */ };
delegateName(argument1, argument2);
delegateName.Invoke(argument1, argument2);
eventName += methodName; // Subscribe the method to the event
methodName(parameter2: value2, parameter1: value1);
A partial class in C# allows you to split the definition of a class, struct, interface, or method across multiple files. This can be useful when working on large projects or when using auto-generated code, as it allows for organizing code in a way that separates auto-generated and manually written parts of the class. The partial keyword is used to specify that a class has been divided into parts.
To define a partial class, declare it using the partial keyword in each file where the class definition is split. Each file must have the same class name and be in the same namespace.
Example of Partial Class
Suppose you have a class Person split into two files, Person1.cs and Person2.cs:
public partial class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string GetFullName()
{
return $"{FirstName} {LastName}";
}
}
public partial class Person
{
public int Age { get; set; }
public void DisplayInfo()
{
Console.WriteLine($"Name: {GetFullName()}, Age: {Age}");
}
}Both parts together make up the complete Person class, with FirstName, LastName, Age, and methods GetFullName and DisplayInfo.
Partial classes are mainly used to improve code readability and maintainability, especially in projects where auto-generated code is prevalent or when dealing with large classes.
partial void MyPartialMethod(int x);
partial void MyPartialMethod(int x)
{
// Implementation code here
}
public void SomeMethod()
{
// Call the partial method
MyPartialMethod(42);
}
partial void MyPartialMethod(int x);
partial void MyPartialMethod(int x, string message = "Default message");
partial void MyPartialMethod(int x);
partial void MyPartialMethod(int x) // Valid, matching signature
{
// Implementation code here
}
// Error: Multiple partial method declarations with the same name and signature
partial void MyPartialMethod(int x);
partial void MyPartialMethod(int x);
// Error: Multiple partial method implementations with the same name and signature
partial void MyPartialMethod(int x)
{
// Implementation 1
}
partial void MyPartialMethod(int x)
{
// Implementation 2
}
using System;
public static class StringExtensions
{
public static string Reverse(this string str)
{
char[] charArray = str.ToCharArray();
Array.Reverse(charArray);
return new string(charArray);
}
}
using System;
class Program
{
static void Main(string[] args)
{
string originalString = "hello";
string reversedString = originalString.Reverse();
Console.WriteLine("Original: " + originalString);
Console.WriteLine("Reversed: " + reversedString);
}
}
public interface IBaseInterface
{
void SomeMethod();
}
public interface IDerivedInterface : IBaseInterface
{
void AnotherMethod();
}
using System;
public class OuterClass
{
private int outerData;
public OuterClass(int data)
{
outerData = data;
}
public void DisplayOuterData()
{
Console.WriteLine("Outer data: " + outerData);
}
public class NestedClass
{
private int nestedData;
public NestedClass(int data)
{
nestedData = data;
}
public void DisplayNestedData()
{
Console.WriteLine("Nested data: " + nestedData);
}
public void AccessOuterData(OuterClass outer)
{
Console.WriteLine("Accessing outer data from nested class: " + outer.outerData);
}
}
}
public class Program
{
public static void Main()
{
// Creating an instance of the outer class
OuterClass outer = new OuterClass(10);
// Creating an instance of the nested class
OuterClass.NestedClass nested = new OuterClass.NestedClass(20);
// Accessing and displaying data from the outer and nested classes
outer.DisplayOuterData();
nested.DisplayNestedData();
// Accessing outer data from the nested class
nested.AccessOuterData(outer);
}
}
