C Sharp (programming language)

C# (pronounced see-sharp) is an object-oriented programming language developed by Microsoft as part of their .NET initiative. Microsoft based C# on C++ and the Java programming language. C# was designed to balance power (the C++ influence) with rapid development (the Visual Basic and Java influences).

Code libraries

The .NET Framework is a class library which can be used from a .NET language to perform tasks from simple data representation and string manipulation to generating dynamic web pages (ASP .NET), XML parsing and reflection. The code is organised into a set of namespaces which group together classes with a similar function, e.g. System.Drawing for graphics, System.Collections for data structures and System.Windows.Forms for the Windows Forms system.

A further level of organisation is provided by the concept of an assembly. An assembly can be a single file or multiple files linked together (through al.exe) which may contain many namespaces and objects. Programs needing classes to perform a particular function might reference assemblies such as System.Drawing.dll and System.Windows.Forms.dll as well as the core library (known as mscorlib.dll in Microsoft's implementation).

Random String Example

The following code generates a random string.

using System;
using System.Security.Cryptography;

namespace RandomString
{
   public class RndStr
   {
      private static int DEFAULT_MIN_PASSWORD_LENGTH  = 8;
      private static int DEFAULT_MAX_PASSWORD_LENGTH  = 10;
      private static string PASSWORD_CHARS_LCASE  = "abcdefgijkmnopqrstwxyz";
      private static string PASSWORD_CHARS_UCASE  = "ABCDEFGHJKLMNPQRSTWXYZ";
      private static string PASSWORD_CHARS_NUMERIC= "23456789";
      public static string Generate()
      {
         return Generate(DEFAULT_MIN_PASSWORD_LENGTH, 
                         DEFAULT_MAX_PASSWORD_LENGTH);
      }
      public static string Generate(int length)
      {
         return Generate(length, length);
      }
      public static string Generate(int minLength,
                                    int maxLength)
      {
         // Make sure that input parameters are valid.
         if (minLength <= 0 || maxLength <= 0 || minLength > maxLength)
            return null;
         char[][] charGroups = new char[][] 
         {
            PASSWORD_CHARS_LCASE.ToCharArray(),
            PASSWORD_CHARS_UCASE.ToCharArray(),
            PASSWORD_CHARS_NUMERIC.ToCharArray()
         }

         // Use this array to track the number of unused characters in each
         // character group.
         int[] charsLeftInGroup = new int[charGroups.Length];

         // Initially, all characters in each group are not used.
         for (int i=0; i<charsLeftInGroup.Length; i++)
            charsLeftInGroup[i] = charGroups[i].Length;
        
         // Use this array to track (iterate through) unused character groups.
         int[] leftGroupsOrder = new int[charGroups.Length];

         // Initially, all character groups are not used.
         for (int i=0; i<leftGroupsOrder.Length; i++)
            leftGroupsOrder[i] = i;

         // Because we cannot use the default randomizer, which is based on the
         // current time (it will produce the same "random" number within a
         // second), we will use a random number generator to seed the
         // randomizer.
        
         // Use a 4-byte array to fill it with random bytes and convert it then
         // to an integer value.
         byte[] randomBytes = new byte[4];

         // Generate 4 random bytes.
         RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
         rng.GetBytes(randomBytes);

         // Convert 4 bytes into a 32-bit integer value.
         int seed = (randomBytes[0] & 0x7f) << 24 |
                     randomBytes[1]         << 16 |
                     randomBytes[2]         <<  8 |
                     randomBytes[3];

         // Now, this is real randomization.
         Random  random  = new Random(seed);

         // This array will hold password characters.
         char[] password = null;

         // Allocate appropriate memory for the password.
         if (minLength < maxLength)
            password = new char[random.Next(minLength, maxLength+1)];
         else
            password = new char[minLength];

         // Index of the next character to be added to password.
         int nextCharIdx;
        
         // Index of the next character group to be processed.
         int nextGroupIdx;

         // Index which will be used to track not processed character groups.
         int nextLeftGroupsOrderIdx;
        
         // Index of the last non-processed character in a group.
         int lastCharIdx;

         // Index of the last non-processed group. Initially, we will skip
         // special characters.
         int lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;
        
         // Generate password characters one at a time.
         for (int i=0; i<password.Length; i++)
         {
            // If only one character group remained unprocessed, process it;
            // otherwise, pick a random character group from the unprocessed
            // group list.
            if (lastLeftGroupsOrderIdx == 0)
               nextLeftGroupsOrderIdx = 0;
            else
               nextLeftGroupsOrderIdx = random.Next(0, 
						    lastLeftGroupsOrderIdx);

            // Get the actual index of the character group, from which we will
            // pick the next character.
            nextGroupIdx = leftGroupsOrder[nextLeftGroupsOrderIdx];

            // Get the index of the last unprocessed characters in this group.
            lastCharIdx = charsLeftInGroup[nextGroupIdx] - 1;
            
            // If only one unprocessed character is left, pick it; otherwise,
            // get a random character from the unused character list.
            if (lastCharIdx == 0)
               nextCharIdx = 0;
            else
               nextCharIdx = random.Next(0, lastCharIdx+1);

            // Add this character to the password.
            password[i] = charGroups[nextGroupIdx][nextCharIdx];
            
            // If we processed the last character in this group, start over.
            if (lastCharIdx == 0)
               charsLeftInGroup[nextGroupIdx] = charGroups[nextGroupIdx].Length;
            // There are more unprocessed characters left.
            else
            {
               // Swap processed character with the last unprocessed character
               // so that we don't pick it until we process all characters in
               // this group.
               if (lastCharIdx != nextCharIdx)
               {
                  char temp = charGroups[nextGroupIdx][lastCharIdx];
                  charGroups[nextGroupIdx][lastCharIdx] = 
                        charGroups[nextGroupIdx][nextCharIdx];
                  charGroups[nextGroupIdx][nextCharIdx] = temp;
               }
               // Decrement the number of unprocessed characters in
               // this group.
               charsLeftInGroup[nextGroupIdx]--;
            }

            // If we processed the last group, start all over.
            if (lastLeftGroupsOrderIdx == 0)
               lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;
            // There are more unprocessed groups left.
            else
            {
               // Swap processed group with the last unprocessed group
               // so that we don't pick it until we process all groups.
               if (lastLeftGroupsOrderIdx != nextLeftGroupsOrderIdx)
               {
                  int temp = leftGroupsOrder[lastLeftGroupsOrderIdx];
                  leftGroupsOrder[lastLeftGroupsOrderIdx] = 
                        leftGroupsOrder[nextLeftGroupsOrderIdx];
                  leftGroupsOrder[nextLeftGroupsOrderIdx] = temp;
               }
               // Decrement the number of unprocessed groups.
               lastLeftGroupsOrderIdx--;
            }
         }

         // Convert password characters into a string and return the result.
         return new string(password);
      }
   }
}

This is used like this: string myRandomString = RndStr.Generate();.

Standardization

Microsoft has submitted C# to the ECMA for formal standardization. In December 2001, ECMA released ECMA-334 C# Language Specification. C# became an ISO standard in 2003 (ISO/IEC 23270). There are independent implementations being worked on, including:

Mono, Ximian's open source .NET implementation
dotGNU & Portable.NET from the Free Software Foundation

More recently, Microsoft has announced plans to add support for generics (similar to C++ templates), partial types and some other new features. Those additions were already proposed for ECMA/ISO standardization.

Politics

Many of Microsoft’s products and initiatives generate political attention, and C# is no exception. Due to C#’s close relationship with a commercial institution, political discussions continue regarding the legitimacy of C# standardization, its Java similarities, its future as a general-purpose language, and other various debates. Some security experts express skepticism as to the efficacy of the CLR's security mechanisms, and criticise their complexity.

Unlike proprietary languages such as Visual Basic or Java, Microsoft chose to open C# up to the standardization process. However, Microsoft is still a primary force driving changes and innovation in the language. Additionally, Microsoft has made it clear that C#, as well as the other .NET languages, is an important part of its software strategy for both internal use and external consumption. Microsoft takes an active role in marketing the language as part of its overall business strategy.

External links

Template:Major programming languages small

Code libraries

Random String Example

Standardization

Politics

See also

External links