C# PROGRAMMING

C# Programming

Date Published:
Last Modified:

Child Pages

  • Binding
  • Closing Your Application
  • Detecting Key Presses
  • Going From WinForms To WPF
  • Graph Drawing
  • How To Access Serial Ports In C#
  • Redirecting The Command-line To A Text Block
  • Threading
  • Timers
  • Using InstallSheild
  • Windows Office Application Interface
  • String Manipulation

    <string type>.IndexOf - Searchs for a particuler character within a string, and returns the position of the first instance found. Can specify where in the string to start looking, as well as how many characters to look through

    Convert.To<type> - Converts back and forth from many standard types, including integers and strings

    There is a great cheat sheet by John Sheehan which explains string manipulation in the .NET language. Unfortunately, it can no longer be found on his site, but you can still download this locally cached version.

    Removing Characters From A String

    <string type>.Remove - Removes characters from a string, starting at a specified location. Note that this creates a new string with chosen characters removed, it DOES NOT touch the original string! This is a common mistake for people to make, and results in nothing happening to the string.

    // Given string 
    delSomeChars = "Blah blah blah";
    // This won't work
    delSomeChars.Remove(5);
    // while this will
    delSomeChars = delSomeChars.Remove(5);

    Converting To Hex

    Use the Convert.ToString() class to convert to a hexadecimal string. The case of the format specifier (i.e. ‘x’ or ‘X’), determines whether the alphabetical characters in the hex output (A-F) will be in lower-case or in upper-case.

    // Will convert the value into a hexadecimal number with 4 digits,
    // (using 0 as the placeholder)
    outputString = value.ToString("X4");

    Populating A ComboBox From An Enumeration

    Populating a combo box from an enumeration can save heaps of typing and manual work to enter each item individually. It is done easily with the one line of code below:

    comboBox.DataSource = Enum.GetValues(typeof(<enumeration>));

    You can also use the actual value of an Enum rather than it’s name by casting it to an int.

    Iterating Through An Enumeration

    Use the following code:

    foreach (int i in Enum.GetValues(typeof(myEnum)))
    {
        // Uses the enum value, i, here for your own bidding
    }

    Running .NET On Non-Windows Platforms

    There is a popular “cross platform, open source, .NET development framework” called Mono. It is an open source implementation of the .NET framework which can run on a number of devices including Linus, Mac OS, Windows (of course), and even the RaspberryPi!

    Signal Processing

    The Math.Net project contains the “Neodym” library for signal processing in C#. See the Signal Processing page for more information.

    Rounding

    The Math library (Math.) supports basic rounding. However, here is a trick to round to any specified value. You basically divide the number by the precision (the number to want to round to, e.g. 0.1, 0.25, 5 e.t.c), then use standard rounding on the result, and lastly multiply the rounded number by the precision to get the answer.

    /// <summary>
    /// Rounds to a given precision, using the standard Math.Round() rules. E.g. RoundToPrecision(10.34, 0.1) will return 10.3.
    /// RoundToPrecision(1286, 10) will return 1290. Requires Math package.
    /// </summary>
    /// <param name="dataIList">Value to round.</param>
    /// <param name="precision">The precision to round too. Common values are 0.1 or 0.01.</param>
    /// <returns>Rounded dataIList</returns>
    static public double RoundToPrecision(double value, double precision)
    {
        return Math.Round(value / precision, 0) * precision;
    }

    You can also preform variable precision rounding with an offset.

    /// <summary>
    /// Rounds to a precision, with a given offset. Requires Math package. 
    /// </summary>
    /// <param name="dataIList">Value to round.</param>
    /// <param name="precision">Precision to round to</param>
    /// <param name="offset"></param>
    /// <returns></returns>
    static public double RoundToPrecision(double value, double precision, double offset)
    {
        return Math.Round((value-offset) / precision, 0) * precision + offset;
    }

    Profiling And Performance Tuning

    To programs to do this are SlimTune and EQATEC.

    Command-Line Parsers

    Command-line parsers are a good way for user-program interaction and well as computer-computer communication. There are quite a few free and opensource C# Command-Line Parsers out there. Their core functionality is similar to the C-based linux getopt() command, but incorporate the powerful functionality of the .NET language. Most use inline lambda notation to create the equivalent of call-back functions when registering the parameters.

    Command Line Parser Library

    Author: GSSCoder Author’s Link: https://github.com/gsscoder/commandline CodePlex: http://commandline.codeplex.com/ NuGet: “install-package CommandLineParser” (latest stable), “install-package CommandLineParser -pre” (latest release)

    This library has had a continuously updated API since 2005. Parses commands in the “–age 50” style. Requires the parameters to registered with a custom class at build time.

    Does not support an initial keyword that determines the nature of the following parameters (similar to calling a particular program).

    cmdline

    Author: Ron Jacobs Author’s Link: http://code.msdn.microsoft.com/Command-Line-Parser-Library-a8ba828a NuGet: “install-package cmdline”

    NDesk.Options

    Author: NDesk Author’s Link: NuGet:

    This one can support multiple commands, with the additional library ManyConsole. NDesk.Options replaced the now obsolete Mono.Options library, and it is include in the Mono 2.0 package.

    ManyConsole

    Author: https://github.com/fschwiet Author’s Link: https://github.com/fschwiet/ManyConsole NuGet: install-package ManyConsole

    This library supports multiple commands, which is useful if you want to use the command-line style for communication between two computers/microcontrollers. It uses the NDesk.Options library. In my opinion, ManyConsole is hard to use, and requires all the commands/parameters to be created at compile time as classes.

    Microsoft Office Program Manipulation With C

    You can manipulate Microsoft Office applications quite easily within the .NET framework (which includes C#). See the following page I wrote for more information.

    => Windows Office Application Interface

    Installing Third-Party Libraries

    I recommend a package manager like NuGet is used to install third-party libraries/packages whenever possible. NuGet allows you to select a pre-compiled third-part library from a large online database and then install it into a Visual Studio project at the click of a button. It also removes a library just as quickly. The image below shows the NuGet package management screen

    A screenshot of the NuGet plugin for Visual Studio.

    A screenshot of the NuGet plugin for Visual Studio.

    Other Resources

    If you have the money, you can buy the MS Word component Spire.Doc from E-IceBlue. It provides an API to easily create and manipulate Word documents in an easier manner than with Microsoft’s standard library.


    Tags:

      comments powered by Disqus