C# Pragma, The Inline warning control In C# | Compiler Directives C#

Pragma is a compiler directive in C#. This article explains on #pragma directives in C# and the various ways you can control the code analysis warnings that we get during the compilation of your .NET code.

When we develop C# code, the compiler occasionally issues warnings. Warnings are generally ignored by programmers because they do not prohibit the application from running. If our software contains any warnings, however, the warnings have no effect on the code. The #pragma directive is a feature of C# to remove the warnings.

When we declare a variable but do not use it elsewhere in the program, the compiler issues a warning “Variable is declared, it is never used”. We can eliminate all these kinds of warnings by using the #pragma.

Compiler directive #Pragma

Compiler directives are there for almost all languages. Pragma directives are the special instruction to the compiler when it compiles a file. For instance, if you want to your function does not react to some of the warnings that compiler produces, you can use Pragma pre-processor directives.

C# Pragma

There are two types of Pragma support in .NET, Pragma Warning and Pragma Checksum

Pragma Warning

Pragma warning enables you to disable/enable certain compiler warnings that the compiler generates when certain code appears in your code.

The #pragma keyword tells your compiler to display or not to display certain warnings. Meaning, you can enable or disable specified warnings using #pragma keyword.

You need to know warning number to enable/disable that specific warning or warnings.

For example, if you want to disable the XML comments warning(1591) then the code syntax goes as below

#pragma warning disable 1591

Similarly, you can enable warnings

#pragma warning enable 3021

Pragma Checksum

Checksum is a special number that identifies a file.

The .NET debugger generates a checksum of a file and puts in Program Database(PDB file) when it compiles. Hence even though your file is modified when you run, the checksum will always point to right source.

In case of ASP.NET, the computed checksum that is produced in the PDF file is actually points to the one that is generated rather than the actual source. You can use Pragma statement in your asp.net file to generate new checksum for your file.

#pragma checksum "yourfile.cs" "{3673e4ca-6098-4ec1-890f-8fceb2a794a2}" "{012345678AB}"

This generates a new Checksum for the file yourfile.cs and the new checksum will be written to the PDB it generates.

Remember, the hexadecimal value you pass as last argument in #pragma checksum directive should be even, any odd checksum byte will be ignored by the compiler.

Frequently Asked Questions on #Pragma

What is #pragma in C#?
Warning can be disabled or enabled by using the #pragma directive in C# code.
Example,
#pragma warning disable warning-list
ie, (#pragma warning disable CS3021)
#pragma warning restore warning-list
ie, (#pragma warning restore CS3021)
What is #pragma comment ?
A compiler directive that informs to leave a comment in the generated object file follows the #pragma comment. When the linker processes object files, the comment can be read.
Pragma comment syntax is ,
#pragma comment( comment-type [,”stringcomment”] )
What is a directive in C#?
In C#, the preprocessor directives are the compiler commands that have an effect on the compilation process. These code commands instruct how to compile various sections of the code, and how to deal with errors and warnings. The preprocessor directives starts with a # symbol and are limited to one line in length.
It is used for conditional compilations also.
How can we suppress code analysis warning in C#?
To suppress a compiler warning, use Disable directive in Visual Basic & #pragma warning directive in C#.
SuppressMessage attribute is used to suppress a warning at a project level or source file level

Summary

Hope this article on C# Pragma helped in understanding #Pragma C# in detail.Please leave your comments and feedback below.

Properties With Multiple Access Modifiers in C# 2.0 | Asymmetric Accessor Accessibility

In C# the member variables will be exposed by means of Properties. The get and set portions of a property are called accessors.

A normal property definition in C# is as below
privateintproperty1; publicintProperty1 { get { returnproperty1; } set { property1 = value; } }
Here the property is public and by default, the accessors have the same visibility that of the property to which they belong. So in the above sample both get and set accessors are public by default and hence it is possible to get and set the property value from outside the class publicly.

Asymmetric Property Accessor C#

It is sometimes needed to restrict access to one of these accessors. In this case, the possibility to make a property read-only is by removing the setter from property definition as below.

public int Property1 { get { return property1; } }
But in C# 2.0 it is possible to provide separate access specifier for get and set. For example, if you only want to make a property read-only from outside then you can simply make the setter as private (or internal to restrict setting of property value from outside the project)
privateintproperty1; publicintProperty1 { get { returnproperty1; } private set { property1 = value; ; } }
All available access modifiers (private, internal, protected and protected internal)can be applied as desired inside the property definition for set and get.

FAQ on C# Asymmetric Property

What are property accessors in C#?

In C#, to expose private fields from a class there introduced certain special kinds of methods called Property. Property Accessors are C# properties’ internal methods. It is possible to make properties read-only, read-write, or write-only. Reading and writing are supported by the read-write property.

What are the different types of properties supported by C#?

In C# we have the following 4 types of Properties- Read-Only Property, Read-Write Property
Indexer Property & Static Property

Summary

This post covered the asymmetric property in c#. Hope you found this article useful. Please provide your feedback in the comments section.

What is the use of Application.EnableVisualStyles()?

The Entry point method of C# Winform application looks as below,

[STAThread]
static void Main()
{
   Application.EnableVisualStyles();
   Application.SetCompatibleTextRenderingDefault(false);
   Application.Run(new Form1());
}

Here [STAThread] attribute decoration is essential to mark your application state as single-threaded apartment style.For details of STAThread attribute read What STAThread Attribute does?

Why Application.EnableVisualStyle Method Required?

In this article today I explain about the need of Application.EnableVisualStyles() method.If you comment this line Application.EnableVisualStyles() and run the application you will see all the controls in your form are rendered with the classic Windows look only.

If you uncomment Application.EnableVisualStyles() and run the application you can see all your controls rendered with current operating system theme settings. Means, If your operating system is Windows it will use the built-in Windows theaming to style controls and classic Windows look and feel if EnableVisualStyle() is commented.

So it is not a method which if commented will cause the application to crash or stop working. It is essential to apply the visual styles like colors, fonts, and other visual elements to your form controls from the current operating system theme. If the control and the operating system support this controls will draw with visual styles if this method is used.

Also Application.EnableVisualStyles() method must be called as the first line in the Main method before calling any controls in the application to have the effect.

Summary

This post covered the relevance of Application.EnableVisualStyles() method. Application.EnableVisualStyles() must be called as the first line in Main() before invoking any controls.Your comments and feedback are valuable for us. So please provide your suggestions in the comments section below.

What is Application.SetCompatibleTextRenderingDefault(false)?

XPATH With Default Namespace In C# – XPathNavigator

This article explains the sample C# code with XPathNavigator to select an XML element from an XML file which is having a default namespace.
Consider the sample XML file with namespace(xmlns) defined ,


   
       
          Mumbai
          Pune
       
       
          Bangalore
          Mangalore

See the console application sample given below which selects all the City Elements of the State which is having Name attribute value ‘Karnataka’.XPathNavigator is used for parsing.

class Program
{
     static void Main(string[] args)
     {

        //Replace the hardcoded XML  file path with your XML file path.
        XPathDocument xpathDocument = new XPathDocument(@"E:\XmlSamples\Country.xml");
        XPathNavigator navigator = xpathDocument.CreateNavigator();

        //Define the Namespace manager
        XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());
        nsmgr.AddNamespace("ns", "http://www.countrys.org/2013/13/CountrySchema");

        //Set the Xpath expression
        string xPathQuery = "//ns:State[@Name='Karnataka']/ns:City";
        XPathNodeIterator nodes = navigator.Select(xPathQuery, nsmgr);
        foreach (XPathNavigator item in nodes)
        {
             Console.WriteLine(item.InnerXML);
        }
        Console.Read();
    }
}

Since the XML is having a namespace defined in it, your XPath expression need namespace manager which is defined with the 2 lines below.This namespace manager is used in XpathNavigator select.

XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable());
nsmgr.AddNamespace("ns", "http://www.countrys.org/2013/13/CountrySchema");

Notice the XPath expression //ns:State[@Name=’Karnataka’]/ns:City, here the text ns:(instead of ns, use any variable name as you like) before every element name is needed since the XML file is having a default namespace.Every node name in the expression needs this namespace text.

String Value Enum with Space in between – Description Attribute

Enum with spaces C#: If you give a space in string value of Enum, it would generate a compilation error. Single-word enum string value is a normal scenario and straightforward handle. But, how to have an enum string value with multiple words

Enum values with spaces in C#

Normally, the name of an enum in c# can’t contain any special characters or spaces. There can be situations where we need to use friendly names for enums which have spaces in between.

For example, if you have a string value enum as below

public enum Country
{
  India,
  United Arab Emirates,
  United Kingdom
}

You will get syntax error since this is not the correct way of enum declaration. If you remove spaces in between string value, it will become a valid enum.

But there may be cases still wherein you want string value enums with space between words. In that case, How to have enum values with spaces in C#?

You need to use Description attribute in this case. See the corrected enum snippet as below.

Associating Strings with enums in C#

In order to have a more friendly enum ,we can use System.ComponentModel.DescriptionAttribute. see the sample below,

public enum Country
{
    India,

    [Description("United Arab Emirates")]
    UAE,

    [Description("United Kingdom")]
    UK
}

As above, by decorating with [Description] attribute you can have a valid enum for your case.

How to Get the Description Attribute Values from Enum?

Now, how to fetch the Description attribute values instead of enum values. Means, you need United Arab Emirates instead of UAE.

You can use any of the method below for getting the Description attribute value from the corresponding enum value by using reflection.

public static string GetDescriptionFromEnum(Enum value)
{
     DescriptionAttribute attribute = value.GetType()
     .GetField(value.ToString())
     .GetCustomAttributes(typeof(DescriptionAttribute), false)
     .SingleOrDefault() as DescriptionAttribute;
     return attribute == null ? value.ToString() : attribute.Description;
}

public static string GetDescriptionFromEnum(Enum value)
{
      FieldInfo fieldInfo = value.GetType().GetField(value.ToString());
      DescriptionAttribute[] attributes =
        (DescriptionAttribute[])fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);
      return attributes == null && attributes.Length == 0 ? value.ToString() : attributes[0].Description;
}

Summary

This article covered Enum with spaces C#. You need to use C# Enum Attribute, named Description to have an enum string value with multiple words. If you find this article useful share your feedback in the comments section.

What Is SetCompatibleTextRenderingDefault (false)

This article is to just to give you a brief idea about SetCompatibleTextRenderingDefault and what happens if we pass true instead of false.

So read further on about What Is SetCompatibleTextRenderingDefault?

Application.SetCompatibleTextRenderingDefault Method

SetCompatibleTextRenderingDefault (false) is an automatic method generated by visual studio in the Main method of Program.cs file.
Since it is automatically generated we normally don’t give any attention to this method.

Certain controls in Windows Forms have a property called UseCompatibleTextRendering property.These Controls in Windows Forms can render their text using either the TextRenderer class or the Graphics class.

TextRenderer class is GDI graphics library based and Graphics class is based on the GDI+ graphics library.

The method SetCompatibleTextRenderingDefault is used to set the default for the UseCompatibleTextRendering property of that controls across the application.

If the parameter value of the SetCompatibleTextRenderingDefault method is true, new controls that support UseCompatibleTextRendering use the GDI+ based Graphics class for text rendering.If the parameter value is false, new controls use the GDI based TextRenderer class.

SetCompatibleTextRenderingDefault is in System.Windows.Forms namespace from assembly System.Windows.Forms.dll

static class Program
{
   /// <summary>
   /// The main entry point for the C# application.
   /// </summary>
   [STAThread]
   static void Main()
   {
       Application.EnableVisualStyles();
       Application.SetCompatibleTextRenderingDefault(false);
       Application.Run(new Form1());
   }
}

In .NET Framework version 1.0 and .NET Framework version 1.1 applications Windows Forms controls render their text using Graphics class which is based on GDI+ graphics.

GDI+ based graphics was having some performance and localization issues.

From .NET Framework version 2.0 onwards TextRenderer class got introduced which is based on GDI graphics library to overcome the performance and localization issues of GDI+ based text rendering.

Also, the text looks better in GDI based rendering and has improved support for international fonts.
Calculation of character spacing, word wrapping etc. are different in GDI based rendering and GDI+ based rendering.

Summary

By default, UseCompatibleTextRendering property takes the value false. But In a Windows Forms application which uses the Graphics class to render text and having certain controls that use TextRenderer class to render text to appear different from the other text in the application, then to overcome this incompatibility issue we can set the UseCompatibleTextRendering property to true.Otherwise, you don’t need to change the method call at all.

Hope this post helped you in understanding what is the relevance of UseCompatibleTextRendering property? Provide your queries and feedback about this UseCompatibleTextRendering property in the comments section below.