AutoGenerate ID in aspdotnet C#
———————————————————
private void AutoGenerateID()
{
SqlConnection con=new SqlConnection("");
string qr="select 'EMP' + cast(max(cast(SUBSTRING(employeeid,4,5)as int))+1 as nvarchar)as nextkey from tblemployee";
SqlCommand cmd=new SqlCommand("qr",con);
if(con.State==ConnectionState.Closed)
{
con.Open();
}
SqlDataReader dr=new cmd.ExecuteReader();
while(dr.read())
{
if(dr[0].ToString()!="" || dr[0].ToString().trim()!=string.empty)
{
string id=dr[0].ToString();
textempid.text=id;
}
else
{
textempid.text="EMP1";
}
}
if(dr.HasRows)
{
dr.Close();
}
}
________________________________________________

💡𝗖# 𝗧𝗶𝗽
✔️ 𝗨𝘀𝗲 𝗿𝗲𝗰𝗼𝗿𝗱𝘀 𝗳𝗼𝗿 𝗗𝗧𝗢𝘀

✅ 𝗥𝗲𝗰𝗼𝗿𝗱𝘀 are a feature introduced in 𝗖# 𝟵.𝟬 that allows you to create simple, immutable data types. They are particularly useful for representing 𝗗𝗧𝗢𝘀 (Data Transfer Objects) because they provide a concise syntax for defining classes that are primarily used to transfer data between layers of an application, such as between the business logic layer and the presentation layer.

✅ 𝗥𝗲𝗰𝗼𝗿𝗱𝘀 are best suited for simple data structures, and they are not meant to replace classes for all scenarios. For more complex types with behavior, you may still want to use regular classes or other features provided by C#.

🔥 𝗥𝗲𝗰𝗼𝗿𝗱𝘀 are an excellent choice for creating 𝗗𝗧𝗢𝘀 due to their simplicity, immutability, and concise syntax, which helps in writing clean and maintainable code.


𝗧𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 📖

✔️𝗦𝘄𝗶𝘁𝗰𝗵 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 in C#

🕯 The 𝘀𝘄𝗶𝘁𝗰𝗵 𝘀𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 has been part of C# since its early versions. It allows you to evaluate an expression against a series of case values and execute code blocks based on the matched case. Each case value must be a constant value that is known at compile-time. After a case block is executed, you usually need to include a break statement to exit the switch statement.

💡 The 𝘀𝘄𝗶𝘁𝗰𝗵 𝗲𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 was introduced in C# 8 as a more concise and expressive alternative to the traditional switch statement. It allows you to assign a value to a variable based on the value of an expression. In a switch expression, you use the => syntax to specify the value to assign if the expression matches a certain case. The _ is a discard symbol and is used as the "default" case.

✅ Both the 𝘀𝘄𝗶𝘁𝗰𝗵 𝘀𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 and the 𝘀𝘄𝗶𝘁𝗰𝗵 𝗲𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 are used for similar purposes, the switch expression offers more concise syntax and greater flexibility for pattern matching and value assignment, making it a more powerful tool for modern C# development.

🤔 Which one do you prefer?


𝗧𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 📖

✔️ 𝗡𝘂𝗹𝗹 𝗮𝗿𝗴𝘂𝗺𝗲𝗻𝘁 𝗰𝗵𝗲𝗰𝗸𝘀 𝗶𝗻 𝗖# 𝟭𝟬 𝗮𝗻𝗱 .𝗡𝗘𝗧 𝟲

✅ The 𝗔𝗿𝗴𝘂𝗺𝗲𝗻𝘁𝗡𝘂𝗹𝗹𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻.𝗧𝗵𝗿𝗼𝘄𝗜𝗳𝗡𝘂𝗹𝗹 method is a static method in the System namespace that throws an 𝗔𝗿𝗴𝘂𝗺𝗲𝗻𝘁𝗡𝘂𝗹𝗹𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻 if the specified object is null. It is a convenient way to check for null parameters in your code. It can help to prevent runtime errors and make the code more concise.

🔥 𝗔𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲𝘀 𝗼𝗳 𝗔𝗿𝗴𝘂𝗺𝗲𝗻𝘁𝗡𝘂𝗹𝗹𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻.𝗧𝗵𝗿𝗼𝘄𝗜𝗳𝗡𝘂𝗹𝗹:
◾️ It is easy to use. Just pass the object you want to check for null to the method, and it will throw an exception if the object is null.
◾️ It is reduce code size and make it easy to read.

🤔 Which one do you prefer?


𝗧𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 📖

✔️𝗣𝗿𝗼𝗽𝗲𝗿𝘁𝘆 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 𝗠𝗮𝘁𝗰𝗵𝗶𝗻𝗴 in C#

✅ It is allows you to test whether an expression's properties or fields match specific values or nested patterns. It's a concise and expressive way to perform conditional logic based on object structures.

🔥 𝗔𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲𝘀:
◾️ 𝗖𝗼𝗻𝗰𝗶𝘀𝗲𝗻𝗲𝘀𝘀: Can be used to create more concise and readable code.
◾️ 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝘃𝗲𝗻𝗲𝘀𝘀: Can be used to express more complex conditions.
◾️ 𝗧𝘆𝗽𝗲 𝘀𝗮𝗳𝗲𝘁𝘆: Ensures type correctness at compile time, reducing potential runtime errors.

🤔 Which one do you prefer?


𝗧𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 📖

💡𝗖# 𝗧𝗶𝗽
✔️ 𝗣𝗮𝗿𝗮𝗹𝗹𝗲𝗹 𝗙𝗼𝗿𝗘𝗮𝗰𝗵

✔️ 𝗣𝗮𝗿𝗮𝗹𝗹𝗲𝗹 𝗙𝗼𝗿𝗘𝗮𝗰𝗵

🐌 The regular 𝗳𝗼𝗿𝗲𝗮𝗰𝗵 loop is a sequential construct. It iterates over a collection or an enumerable in a single-threaded manner, processing each element one after the other. It's a good choice when the tasks performed inside the loop are relatively simple and quick to execute, and there's no need to parallelize them.

🚀 The 𝗣𝗮𝗿𝗮𝗹𝗹𝗲𝗹.𝗙𝗼𝗿𝗘𝗮𝗰𝗵 construct is part of the System.Threading.Tasks namespace and is designed for parallel execution of tasks across multiple threads. It divides the input collection into smaller partitions and processes them concurrently on separate threads.

✅ The performance of 𝗳𝗼𝗿𝗲𝗮𝗰𝗵 and 𝗣𝗮𝗿𝗮𝗹𝗹𝗲𝗹.𝗙𝗼𝗿𝗘𝗮𝗰𝗵 depends on the specific scenario. In general, Parallel.ForEach can be faster than foreach if the collection is large and the work being done is well-suited for parallel execution. However, there are some cases where foreach may be faster than Parallel.ForEach.


𝗧𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 📖

✔️𝗨𝘀𝗲 𝘆𝗶𝗲𝗹𝗱 𝗿𝗲𝘁𝘂𝗿𝗻 𝘁𝗼 𝗺𝗶𝗻𝗶𝗺𝗶𝘇𝗲 𝗺𝗲𝗺𝗼𝗿𝘆 𝘂𝘀𝗮𝗴𝗲

💡𝗖# 𝗧𝗶𝗽
✔️𝗨𝘀𝗲 𝘆𝗶𝗲𝗹𝗱 𝗿𝗲𝘁𝘂𝗿𝗻 𝘁𝗼 𝗺𝗶𝗻𝗶𝗺𝗶𝘇𝗲 𝗺𝗲𝗺𝗼𝗿𝘆 𝘂𝘀𝗮𝗴𝗲

✅ The 𝘆𝗶𝗲𝗹𝗱 keyword is used in an iterator block to provide a value to the enumerator object or to signal the end of iteration. When used with return, it provides a value, and when used with break, it signals the end of iteration.

✅ The 𝘆𝗶𝗲𝗹𝗱 keyword is often used for custom iteration over a collection. It's a powerful tool for writing more efficient code. It's worth noting that yield can only be used in the body of methods, operators, or accessors, and those have to return either IEnumerable, IEnumerable<T>, IEnumerator, or IEnumerator<T>.

🔥 𝗔𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲𝘀 𝗼𝗳 𝘂𝘀𝗶𝗻𝗴 𝘆𝗶𝗲𝗹𝗱:
◾️𝗗𝗲𝗳𝗲𝗿𝗿𝗲𝗱 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻: The code in an iterator block (where yield return is used) is not executed until the sequence is enumerated. This can lead to performance benefits because it allows elements to be generated on demand rather than all at once.
◾️𝗦𝗶𝗺𝗽𝗹𝗲𝗿 𝗰𝗼𝗱𝗲: When creating a collection that needs to be iterated over, yield can simplify your code by abstracting away the need to create and manage your own collection.
◾️𝗠𝗲𝗺𝗼𝗿𝘆 𝗘𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝗰𝘆: When iterating over large collections or sequences, yield can be more memory efficient because it does not require the entire collection to be held in memory at once.


𝗧𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 📖

✔️𝗨𝘀𝗲 𝗻𝗮𝗺𝗲𝗼𝗳() 𝘁𝗼 𝗰𝗼𝗻𝘃𝗲𝗿𝘁 𝗮𝗻 𝗲𝗻𝘂𝗺 𝘁𝗼 𝗮 𝘀𝘁𝗿𝗶𝗻𝗴

💡𝗖# 𝗧𝗶𝗽
✔️𝗨𝘀𝗲 𝗻𝗮𝗺𝗲𝗼𝗳() 𝘁𝗼 𝗰𝗼𝗻𝘃𝗲𝗿𝘁 𝗮𝗻 𝗲𝗻𝘂𝗺 𝘁𝗼 𝗮 𝘀𝘁𝗿𝗶𝗻𝗴

✅ The 𝗧𝗼𝗦𝘁𝗿𝗶𝗻𝗴 method, inherited from the System.Object class, is used to convert a value into its string representation. It can be overridden in derived classes to provide a meaningful string representation of the object's current state.

✅ The 𝗻𝗮𝗺𝗲𝗼𝗳 keyword, introduced in C# 6.0, is used to get the name of a variable, type, or member as a string at compile-time. It's useful to avoid magic strings in your code and to keep your code refactor-friendly.

🚀 𝗻𝗮𝗺𝗲𝗼𝗳() is the preferred way to convert an enum to a string. This is because nameof() is evaluated at compile time and will inject a string literal that will never change, while ToString() is evaluated at runtime. This means that nameof() is more efficient and can help to improve the performance of your code.

💡 Using nameof() with enums can lead to mismatched enum member names if the enum changes without recompiling referencing projects, as nameof() provides names at compile-time.


𝗧𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 📖

✔️ 𝗗𝗲𝗰𝗹𝗮𝗿𝗮𝘁𝗶𝗼𝗻 𝗣𝗮𝘁𝘁𝗲𝗿𝗻

✅ You use declaration and type patterns to check if the run-time type of an expression is compatible with a given type. With a 𝗱𝗲𝗰𝗹𝗮𝗿𝗮𝘁𝗶𝗼𝗻 𝗽𝗮𝘁𝘁𝗲𝗿𝗻, you can also declare a new local variable. When a declaration pattern matches an expression, that variable is assigned a converted expression result.

🔥 𝗔𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲𝘀 𝗼𝗳 𝘂𝘀𝗶𝗻𝗴 𝗱𝗲𝗰𝗹𝗮𝗿𝗮𝘁𝗶𝗼𝗻 𝗽𝗮𝘁𝘁𝗲𝗿𝗻𝘀:
◾️ They can make your code more readable and maintainable.
◾️ They can help you to avoid errors caused by type mismatches.
◾️ They can be used to write more concise and expressive code.


𝗧𝗵𝗮𝗻𝗸 𝘆𝗼𝘂 𝗳𝗼𝗿 𝗿𝗲𝗮𝗱𝗶𝗻𝗴 📖

✔️ 𝗨𝘀𝗲 𝘀𝘁𝗿𝗶𝗻𝗴.𝗘𝗾𝘂𝗮𝗹𝘀 𝗶𝗻𝘀𝘁𝗲𝗮𝗱 𝗼𝗳 𝗧𝗼𝗨𝗽𝗽𝗲𝗿()/𝗧𝗼𝗟𝗼𝘄𝗲𝗿() 𝘄𝗵𝗲𝗻 𝗰𝗼𝗺𝗽𝗮𝗿𝗶𝗻𝗴 𝘀𝘁𝗿𝗶𝗻𝗴𝘀

🐌 Using 𝗧𝗼𝗨𝗽𝗽𝗲𝗿() and 𝗧𝗼𝗟𝗼𝘄𝗲𝗿() for case conversion in C# can impact performance due to memory allocation, string copying, and potential garbage collection, especially in situations involving large strings or frequent conversions.

🚀 𝗦𝘁𝗿𝗶𝗻𝗴.𝗘𝗾𝘂𝗮𝗹𝘀 is faster than ToUpper() or ToLower() due to direct character comparison, avoiding memory allocation, and reducing overhead for case-insensitive string comparison.

🔥 To perform string comparison , it's better to use the built-in comparison methods like 𝗦𝘁𝗿𝗶𝗻𝗴.𝗘𝗾𝘂𝗮𝗹𝘀 with appropriate StringComparison options, which handle case-insensitivity and cultural considerations correctly while maintaining better performance and accuracy.