Some C# / .NET techniques as I encounter them. More to follow…

Arrays and Strings

Using an array of strings in a foreach loop:

using System.IO;
using System;

class Program
{
    static void Main()
    {
        string[] values = new string[]{ "abc", "xyz", "123" };
        
        foreach( string s in values )
        {
            Console.WriteLine( s );
        }
    }
}

Console output:

Indexers

Providing array-like access to classes, using the [] array access operator.

using System.IO;
using System;

class StringIndexer
{
    private static int limit = 5;
    private string[] values = new string[limit];

    public int Limit()
    {
        return limit;
    }

    public string this[int index]
    {
        get
        {
            if (index < limit && index >= 0)
            {
                return values[index];
            }
            else
            {
                return "";
            }

        }
        set
        {
            if (index < limit && index >= 0)
            {
                values[index] = value;
            }
        }
    }
}

class MainProgram
{
    public static void Main()
    {
        StringIndexer stringIndexer = new StringIndexer();

        stringIndexer[0] = "The";
        stringIndexer[1] = "cat";
        stringIndexer[2] = "sat";
        stringIndexer[3] = "on";
        stringIndexer[4] = "the";
        stringIndexer[5] = "mat";

        for (int i = 0; i <= 10; i++)
        {
            Console.WriteLine("String Element #{0} = {1}", i, stringIndexer[i]);
        }
    }
}

Console output:

IEnumerable
An interface specifying that the underlying type implements GetEnumerator(). It allows iteration of non-generic collections, and is returned returned from query expressions

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        IEnumerable<int> result = from value in Enumerable.Range(0, 5)
                                  select value;

        // Loop.
        foreach (int value in result)
        {
            Console.WriteLine(value);
        }

        // We can use extension methods on IEnumerable<int>
        double average = result.Average();

        // Extension methods to convert IEnumerable<int> into int array
        List<int> list = result.ToList();
        int[] array = result.ToArray();
    }
}

Console output:

Properties

Example usage of instance, static and read-only properties:

using System.IO;
using System;

class Employee
{
    // static properties
    public static int numberOfEmployees;
    private static int counter;
    private static string name;
    
    // Read-write properties
    public string Name
    {
        get
        {
           return name;
        }
        set
        {
          name = value;
        }
    }
    
    // Read-only property
    public int Counter
    {
        get
        {
          return counter;
        }
    }
    
    // Constructor
    public Employee()
    {
        counter = ++counter + numberOfEmployees;
    } 
}

class MainProgram
{
    public static void Main()
    {
        Employee.numberOfEmployees = 100;
        Employee employee = new Employee();
        employee.Name = "Jones";
        Console.WriteLine( "Employee number: {0}", employee.Counter);
        Console.WriteLine( "Employee name: {0}", employee.Name);
    }
}

Console output:

Attributes

Lambda Expressions

Use the => token, called the lambda operator, to separate the input variables on the left from the lambda body on the right.

using System;
using System.Linq;

namespace LambdaExpression
{
   public delegate TResult Func<TArg0, TResult>(TArg0 arg0);

    class Program
    {
        static void Main(string[] args)
        {
            // Using Count to obtain total even numbers
            int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
            int oddNumbers = numbers.Count(n => n % 2 == 1);
            Console.WriteLine("Number of odd numbers = ", oddNumbers);

            // Using delegate to determin if number is a multiple of 5
            Func<int, bool> myFunc = x => x % 5 == 0;
            bool result = myFunc(15);
            Console.WriteLine("result = {0}", result);

            // Lambda to get the longest length string
            var strings = new string[] { "1", "02", "003", "0004", "00005" };
            string longest = strings.OrderByDescending(s => s.Length).First();
            Console.WriteLine("Longest string = {0}", longest);
        }
    }
}

Console output:

Connect to a SQL Server Database

A simple example whereby we connect to the SQL Server database on clicking the WinForms button and setting the SQL connection string:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Data.SqlClient;

namespace WinForm1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {            
            SqlConnectionStringBuilder sqlConnBuilder = new SqlConnectionStringBuilder();

            sqlConnBuilder.DataSource = "L011035\\DIRDEV";
            sqlConnBuilder.InitialCatalog = "IRDB";
            sqlConnBuilder.IntegratedSecurity = true;
            sqlConnBuilder.UserID = "webba";
            sqlConnBuilder.Password = "";

            string connectionString = sqlConnBuilder.ConnectionString;
            SqlConnection cnn = new SqlConnection(connectionString);
            
            try
            {
                cnn.Open();
                MessageBox.Show ("Connection Open ! ");
                cnn.Close();
            }
            catch (Exception ex)
            {
                MessageBox.Show("Can not open connection ! ");
            }
        }
    }
}

Read an XML attribute

For example, read the “checksum” (SHA-256) and media file name from the following XML:

<?xml version="1.0" encoding="utf-8" ?> 
<file name="ZOO.mp4" source="">
    <Request Type="AddSegmentable">
        <Key CompositeID="53_Ev_CC_10_15" />
        <Attachment Name="ZOO.mp4" Update="Y" LocalPath="C:\Symphony\File Drop" Description="MFM" Type=".Supporting File" FileSize="3526921" />
    </Request>
    <checksum>
        <type>SHA 256</type>
        <value>8584149da444979c794281007369964d89079b5263972850be05b66354a980e2</value>
    </checksum>
    <RepositoryPath>2015\03\20\53_Ev_CC_10_15</RepositoryPath>   
</file>

Use the XDocument object to obtain attributes:

using System;
using System.Linq;
using System.Text;
using System.Xml.Linq;

class Program
{
    static void Main(string[] args)
    {
        // Using Count to obtain total even numbers
        try
        {
            XDocument xmlDoc = XDocument.Load("C:\\Backup\\xml.xml");
            string SHA256 = xmlDoc.Root.Element("checksum").Element("value").Value.ToString();
            string mediaFileName = xmlDoc.Root.Attribute("name").Value.ToString();

            Console.WriteLine("SHA-256 value = {0}", SHA256);
            Console.WriteLine("Media file = {0}", mediaFileName);
        }
        catch (Exception ex)
        {
            Console.WriteLine("XML file not found");
        }
    }
}

Giving the following output:

Use linq to query lists of objects

How to return all items that match a given criteria, in this case return a list of all integers greater than 6:

using System;
using System.Collections.Generic;
using System.Linq;

namespace Search
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> items = new List<int>{ 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11  };

            Console.WriteLine("All values:");
            foreach (int item in items)
            {
                Console.Write(item + " ");
            }

            var search = items.Where(s => s > 6);

            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("Search results: all values greater than 6:");
            foreach (int value in search)
            {
                Console.Write(value + " ");
            }
        }
    }
}

Another example, this time searching on a list of objects and searching on object attribute values:

using System;
using System.Collections.Generic;
using System.Linq;

namespace Search
{
    class Data
    { 
        public Data(string title, string description)
        {
            Description = title;
            Value = description;
        }

        public string Description
        { get; set; }

        public string Value
        { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            List<Data> items = new List<Data>
            { 
                new Data("One", "1"),
                new Data("Two", "2"),
                new Data("Deux", "2"),
                new Data("Three", "3"),               
                new Data("Four", "4"),
                new Data("Five", "5")
            };

            Console.WriteLine("All values:");
            foreach (var item in items)
            {
                Console.WriteLine(item.Description + " " + item.Value);
            }

            var search = items.Where(s => s.Value == "2" || s.Description == "Five");

            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("Search results: items matching value = 2 OR description = Five");
            foreach (var value in search)
            {
                Console.WriteLine(value.Description + " " + value.Value);
            }
        }
    }
}

Giving the following search result:

Delegates

A data structure that can be used to refer to a static method or to a class instance and an instance method of that class.

Example:

using System;

namespace Delegate
{
   // Declares a delegate for a method that takes in an int and returns a String.
   public delegate string MethodDelegate(int val);

   // Defines some methods to which the delegate can point.
   public class SampleClass
   {
      // Defines an instance method.
      public static string GetPolarityString(int val)
      {
         if (val > 0)
            return "positive";

         return val < 0 ? "negative" : "zero";
      }

      // Defines a static method.
      public static string GetSignString(int val)
      {
         if (val > 0)
            return "+";

         return val < 0 ? "-" : "";
      }

      public string GetValueString(int val)
      {
         return val.ToString();
      }
   }

   internal static class Program
   {
      private static void Main()
      {
         // For the instance method, an instance (sampleClass) must be supplied.         
         var sampleClass = new SampleClass();

         // Creates one delegate for each method.
         // For the static method, use the class name.
         var delegate1 = new MethodDelegate(SampleClass.GetPolarityString);
         var delegate2 = new MethodDelegate(SampleClass.GetSignString);

         // Invokes the delegates.
         const int val = 5;
         Console.WriteLine("{0} is {1}; use the sign \"{2}\".", sampleClass.GetValueString(val), delegate1(val), delegate2(val));
      }
   }
}

Giving the following output: