C# programming and Visual Studio usage tips (Part 2)

If you found this article through a search engine, I suggest you read the first article in this series. This is the second article in this series. Today I will bring you richer C# and Visual Studio programming. Let’s take a look at the techniques.

1. DataTable.HasRows

It does not belong to any framework, but it is easy to imitate such a method through extension methods. It does not eliminate the original check whether the data table object is empty or has the number of rows. code, but it can simplify the application code, here is a code snippet:

<CODE> 
public static bool HasRows(this DataTable dataTable) 
  { 
return dataTable.IsNull() ? false : (dataTable.Rows.Count > 0); 
  } 
  
 public static bool IsNull(this object o) 
  { 
   return (o == null); 
  } 
  
 To use: 
 If(dataTable.HasRows()) 
 { 
 … 
 } 
  </CODE>

Other rules are still the same as for extension methods.

2. ToTitleCase

This method can convert the first letter of each word to uppercase and the remaining letters to lowercase. For example, "look below for a sample" will be converted to "Look Below For A Sample", TextInfo is part of the System.Globalization namespace, but it has the following problems:

Current Culture

If the input string is all uppercase

The following extension method takes both of these flaws into account.

<CODE> 
public static string ToTitleCase(this string inputString) 
  { 
   return Thread.CurrentThread.CurrentCulture.TextInfo. 
ToTitleCase((inputString ?? string.Empty).ToLower()); 
 } 
  </CODE>

3. Explicit and implicit interface implementation

Is this important? Yes, very important, do you know the syntax difference between them? In fact, there are fundamental differences between them. The implicit interface implementation on a class defaults to a public method, which can be accessed on objects or interfaces of the class. The explicit interface implementation on the class is a private method by default, which can only be accessed through the interface, not through the object of the class. The following is a sample code:

<CODE> 
  
 INTERFACE 
 public interface IMyInterface 
 { 
 void MyMethod(string myString); 
 } 
  
 CLASS THAT IMPLEMENTS THE INTERFACE IMPLICITLY 
 public MyImplicitClass: IMyInterface 
 { 
 public void MyMethod(string myString) 
 { 
 /// 
 } 
 } 
  
 CLASS THAT IMPLEMENTS THE INTERFACE EXPLICITLY 
 public MyExplicitClass: IMyInterface 
 { 
 void IMyInterface.MyMethod(string myString) 
 { 
 /// 
 } 
 } 
  
 MyImplicitClass instance would work with either the class or the Interface: 
 MyImplicitClass myObject = new MyImplicitClass(); 
 myObject.MyMethod(""); 
 IMyInterface myObject = new MyImplicitClass(); 
 myObject.MyMethod(""); 
  
 MyExplicitClass would work only with the interface: 
 //The following line would not work. 
 MyExplicitClass myObject = new MyExplicitClass(); 
 myObject.MyMethod(""); 
 //This will work 
 IMyInterface myObject = new MyExplicitClass(); 
 myObject.MyMethod(""); 
  
 </CODE>

4. Auto attribute

It is the best way to replace an attribute containing one public and two private members.

Press the Tab key twice (you need to enable the code snippet function), and an Auto attribute will be created. Press the Tab key again to get a name for the Auto attribute. The following code

<CODE> 
 private double _total; 
 public double Total 
 { 
 get { return _total; } 
 set { _total = value; } 
 } 
 </CODE>

becomes

<CODE> 
public double Total { get; set; } 
 </CODE>

Note that you can still apply access specifiers according to your design, and the compiler should create private member variables for you.

5. Powerful Path.Combine

Path.Combine eliminates trailing slashes and path-related problems with its powerful functions. It is simple and easy to use, making the path string more continuous. It contains A string path parameter.

You don’t have to worry about valid delimiters or spaces in the path, and you don’t have to deal with string concatenation when merging paths.

6. A quick way to write the "Override" method in a class

Enter override in the code editor, press the space bar, and you will see a list of class-based overrides method, as shown in Figure 2.

Figure 1 List of overridable methods

7. Using extended configuration files

Thanks app.config (for applications) and web.config configuration files, allowing us to handle complex application-level settings, but we still have to deal with various issues faced by different environment settings, here refers to the settings of development, test and production environments.

We have to revert to a specific environment in order to analyze, test or debug parts of the code, and in this process, every setup and adjustment is tedious.

For example, each restore may require resetting the ConnectionStrings (connection string). Now you can use the ConfigSource property to solve this problem through an external file reference. For example, the following code references a development.config external configuration file.

<connectionStrings configSource="configs\ development.config" />

You can also use this useful property in the AppSettings settings section.

8. Overcoming the limitations of the String.Split method

String.Split is the most ideal method to separate strings, but as far as we know, it also has some limitations, such as the inability to use "|| " or "::" characters must use a unique single character on the keyboard as a separator. This shortcoming can be overcome by using the Split method provided by the RegEx library. The following code shows the use of RegEx Split to separate a "||" Separate strings.

<CODE>
string delimitedString = "String.Split || RegEx.Split");
string[] ouputString = System.Text.RegularExpressions.Regex.Split(
 delimitedString,
 , System.Text.RegularExpressions.Regex.Escape("||"));
 </CODE>

9. Quick switching between HTML code view and design view of elements (and vice versa)

When designing applications, we spend time in IDE I have a lot of time, most of which is spent on HTML content and design view. Visual Studio 2010 provides the function of quickly switching between design view and HTML code.

If you are in HTML view, locate the element you want to view in Design view, and then switch to Design view, the element you want to view should be selected. Additionally, the Properties window should now show Properties of the selected element.
Similarly, when you select an element in design view and then switch to code view, the HTML code corresponding to the element you selected should be highlighted.

10. Quickly search data in the database

Although the data table supports the Find and Select methods to select rows, they are not as easy to use as the DataView method. DataView provides a FindRows method, which can Uses an index created on the sort column, so it's faster.
I hope these tips can help you save valuable programming time, give it a try!

For more C# programming and Visual Studio usage tips (Part 2), please pay attention to the PHP Chinese website!