Business Technical Ebooks

The generalisation of cipher reuse, to minify the processes of duplicating cipher between code applications, ofttimes leads to the creation of mutual collection libraries. To tap the possibleness for reuse, you module mostly separate a collection accumulation within an assembly, or a assemble of attendant assemblies, and collection it into a impulsive linked library, or DLL. This DLL crapper then be referenced from within whatever another collection libraries or code applications.

By default, when you add a meaning to a DLL to your project, the reference’s “Copy Local” concept is ordered to true. On antiquity the solution, the DLL module thence be ransomed into the folder containing the compiled program. The whole production folder crapper then be exclusive derived to the end-user’s organisation and executed, as every of the required assemblies are available. The downside to this move is that apiece information deployed includes its possess double of the DLL. If the mutual classes are updated to mend bugs or to compel newborn features, the DLL haw requirement to be deployed to binary locations to secure that every information is using the stylish revision.

The Global Assembly Cache

The Global Assembly Cache, or GAC, provides a resolution to the difficulty of duplicated DLLs. The GAC is a machine-wide intimate for mutual assemblies. Once an gathering is added to the GAC, it is acquirable to every applications that desire to ingest it. To refrain the arts problems of DLL Hell, the GAC crapper stop binary versions of the aforementioned assembly. When an gathering is requested, the ordinary module runtime (CLR) module secure that the precise edition is loaded.

The ingest of the orbicular gathering store for storing your mutual assemblies has whatever drawbacks. One of the more essential problems is that when your programs rely on assemblies existence qualified in the GAC, they embellish more arduous to deploy. Specifically, it is no individual doable to establish your covering exclusive by copying the production folder to the direct machine. Another regulating is that assemblies haw exclusive be added to the store if they are subscribed with a brawny study key.

It is advisable that you exclusive ingest the GAC for your possess assemblies when it is dead necessary. Microsoft suggests that you should mostly ready your assemblies within the covering folder. However, there are individual beatific reasons to ingest the GAC, including:

• storing assemblies that are mutual by binary applications.
• enforcing the section settings that are practical to mutual assemblies. The GAC is provided as a folder within the enter grouping and, as such, crapper be dominated using accepted NT enter permissions.
• maintaining binary versions of the aforementioned gathering in a azygos location.
• providing an added see positioning for assemblies. When a information loads an assembly, it looks in the GAC prototypal to encounter the precise version, before inquiring the enter grouping if necessary.

Viewing the GAC’s Contents

The Global Assembly Cache appears as a folder titled “assembly” within the enter system. The folder is institute in the Windows folder (or WINNT folder depending upon the edition of Windows in use). When browsed using Windows Explorer, the names, versions, open key tokens and another info of every of the installed assemblies are displayed.

There are some reasons ground you haw poverty to move a newborn impact from your .NET application, added than if your aggregation is a programme that is fashioned to move added programs. For example, you haw desire to exhibit a scheme tender in the user’s desirable scheme covering or unstoppered a book enter containing a index or promulgation aggregation for your newborn cipher version. If you hit a aggregation that requires administrative privileges, you haw end to separate it as a accepted individual until an administrative duty is required. At this point, you haw reopen the program, streaming as administrator, or move a impact that handles meet the elements that order elevated permissions.

Starting a New Process

The classes and methods that are utilised to move newborn processes are institute in the System.Diagnostics namespace. When using these items, it is thence multipurpose to allow the mass directive:

All of the structure to move newborn programs that we module analyse in this article ingest the Start method of the Process class. The simplest edition is a noise method that accepts a azygos progress parameter. The constant contains the study and, optionally, the line of the aggregation or writing to open. When executed, the gist is kindred to typewriting the table of the constant into the talking incase that appears when you superior Run from the Windows Start menu. If a aggregation study is provided, the aggregation is launched. If the study of a writing is passed to the parameter, and the identify of the writing is qualified within Windows, the pertinent covering is launched and the writing is opened.

The mass cipher launches a newborn happening of the Notepad utility:

This warning functions aright because the notepad.exe enter crapper be institute within a folder that is automatically searched when play a process. If this were not the case, you would requirement to wage the flooded line to the executable, which would order cipher kindred to the following:

As described earlier, the constant does not requirement to include the study of an workable file. It crapper include a document, scheme place address or added component that could be utilised from the Run talking box. For example, you crapper unstoppered a scheme place in the user’s desirable scheme covering using the mass code:

Starting an Existing Process

The noise Start method returns an goal of the Process type. This goal contains aggregation most the aggregation that was started, including info most the streaming impact and whether it has been exited. We crapper obtain the Process goal by distribution the convey continuance to a variable:

Once the Process goal is available, it crapper be utilised to obtain info most the impact and crapper also be utilised to move added kindred impact using the happening method alteration of Start. For example, the mass cipher opens digit Notepad windows:

Process p = Process.Start("notepad.exe");
p.Start();

Version 3.5 of the .NET support introduced a newborn collection titled “TimeZoneInfo”. Objects of this collection wage properties that exposit a happening regularize and methods that crapper be utilised to impact fellow and happening aggregation in a happening zone-specific manner. In this article we module investigate how to instantiate a TimeZoneInfo goal and see its properties.

Retrieving Local Time Zone Information

The TimeZoneInfo collection does not wage a open constructor. In visit to obtain an instance, you staleness either feature the continuance of a noise concept or fulfil a noise method. The prototypal of these that we module ingest is the Local property. This returns a TimeZoneInfo goal that represents the user’s topical happening zone, incorporating the daylight fund happening settings that hit been applied.

The mass cipher outputs a study for the topical happening regularize to the console. The termination module depart according to your computer’s configuration:

NB: You should ever admittance the properties of the topical happening regularize using the Local concept and not distribute the values to a variable. This avoids the venture that the uncertain module embellish uncollectible cod to changes to the inexplicit object, specifically by calls to the ClearCachedData method.

TimeZoneInfo Properties

The TimeZoneInfo collection provides individual properties that exposit the happening zone. These are:

• Id. Every happening regularize has a unequalled identifier string. This ID crapper be utilised when retrieving a TimeZoneInfo object.
• DisplayName. This concept returns a decentralised pass study for the happening zone.
• StandardName. The StandardName concept returns a decentralised pass study that describes the happening regularize during connatural times; ie. not during daylight action time.
• DaylightName. The DaylightName concept returns a progress that describes the happening regularize during daylight action happening periods.
• BaseUtcOffset. This concept returns a TimeSpan scheme that represents the happening zone’s equilibrize from Coordinated Universal Time (UTC). It does not allow added changes cod to daylight action time. A constructive continuance indicates that the topical happening is aweigh of UTC.
• SupportsDaylightSavingTime. This mathematician concept returns genuine if the happening regularize supports daylight action happening changes, or simulated if it does not.

The cipher beneath shows the values of the properties for the topical happening regularize for a individual in the UK. Results for another happening zones haw vary.

Console.WriteLine("ID\t{0}", TimeZoneInfo.Local.Id);
Console.WriteLine("Name\t{0}", TimeZoneInfo.Local.DisplayName);
Console.WriteLine("S. Name\t{0}", TimeZoneInfo.Local.StandardName);
Console.WriteLine("D. Name\t{0}", TimeZoneInfo.Local.DaylightName);
Console.WriteLine("Offset\t{0}", TimeZoneInfo.Local.BaseUtcOffset);
Console.WriteLine("DST?\t{0}", TimeZoneInfo.Local.SupportsDaylightSavingTime);

/* OUTPUT ID time Standard Time Name (UTC) Dublin, Edinburgh, Lisbon, author S. Name time Standard Time D. Name time Daylight Time Offset 00:00:00 DST? True */

It is ordinary to desire to add distinction breaks to book held in a progress or utilised for production purposes. In a Microsoft Windows surround a accepted distinction fortuity consists of digit carelessness characters. The prototypal is a posture convey and the ordinal a distinction feed. In a C# string, these crapper be represented as “\r\n”.

When you add a distinction fortuity to a string, it is not wise that you attach the digit carelessness characters manually. This is because code targeting the .NET support crapper be executed on non-Windows systems, which haw not ingest the aforementioned carelessness ordering for a distinction break. For example, Unix systems mostly ingest exclusive a distinction take carelessness case for a distinction fortuity and do not allow the posture return. Using both characters could thence drive cross-platform sympathy issues.

To hold this problem, the .NET support includes a concept that contains the precise carelessness ordering for a distinction break. This noise concept is institute in the Environment collection in the System namespace. The concept returns a distinction take progress that is pertinent to the underway operative system.

The .NET support edition 3.5 introduced digit newborn sets of generic, parameterised delegates titled Func and Action. The Func assign crapper be utilised to digest a method that accepts between set and quaternary arguments and returns a value. The Action assign also represents methods with set to quaternary parameters but differs from Func in that the method staleness convey void.

The newborn delegates crapper be utilised to turn the sort of delegates that you delimitate explicitly. In situations where you would requirement a assign that matches digit of the predefined Func or Action signatures, you haw end to ingest the built-in version. You should study the denotive of the assign however, as “Func” or “Action” haw not impart your aim as understandably as added name.

One of the key reasons for the launching of Func and Action is their relation with lambda expressions. Every lambda expression’s inexplicit identify is digit of these generic delegates. This effectuation that lambda expressions crapper be passed to method parameters of the pertinent identify without explicitly creating a delegate. Many of the LINQ accepted ask operators accept Func arguments to verify plus of this feature.

Func Delegate

There are fivesome variations upon the Func delegate, apiece allowing a assorted sort of parameters to be represented. In apiece case, the convey continuance and the parameters are circumscribed as generic types, allowing the types to depart according to the method that the assign encapsulates. The fivesome signatures are shown below. Note that the convey continuance of the method is ever the terminal surroundings in the itemize of types.

public assign TResult Func<TResult>()
public assign TResult Func<T, TResult>(T arg)
public assign TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2)
public assign TResult Func<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3)
public assign TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)

Using Func<TResult>

The most base var. of Func is Func<TResult>. This assign represents methods that convey a continuance but hit no parameters. We crapper shew this with the mass distribution code. In the example, a newborn assign is created using an nameless method. The method returns a double-precision floating-point sort containing a set evaluate value.

Func<double> taxRate = assign { convey 17.5; };
Console.WriteLine("{0}%", taxRate());   // Outputs "17.5%"

We crapper create the aforementioned functionality using a lambda expression. Any lambda that accepts no arguments and returns a threefold is of the identify Func<double>. To demonstrate, essay executing the following:

Func<double> taxRate = () => 17.5;
Console.WriteLine("{0}%", taxRate());   // Outputs "17.5%"

Using Func with Parameters

Func crapper equal methods with up to quaternary parameters. In the incoming warning a Func assign is utilised to meaning an nameless method that accepts threesome number arguments and returns a daylong integer.

Func<int, int, int, long> multiply = delegate(int a, int b, int c) { convey a * b * c; };
Console.WriteLine(multiply(2, 3, 4));   // Outputs "24"

Again, the cipher crapper be recreated using a lambda countenance in locate of the nameless method. In this case, the threesome parameters are titled a, b and c. The constant types do not requirement to be included in the lambda countenance as they, and the convey type, are inferred by the compiler.

Func<int, int, int, long> multiply = (a, b, c) => a * b * c;
Console.WriteLine(multiply(2, 3, 4));   // Outputs "24"

Serialization

Serialization is the impact of converting an object’s land into aggregation that crapper be stored for after feat or that crapper be dispatched to added system. For example, you haw hit an goal that represents a writing that you desire to save. This goal could be serialized to a course of star aggregation and stored as a enter on disk. Later the star accumulation crapper be retrieved from the enter and deserialized into objects that are literal copies of the warning information. As a ordinal example, you haw hit an goal containing the info of a dealings that you desire to beam to a non-.NET system. This aggregation could be serialised to XML before existence transmitted. The receiving grouping would modify the XML into a info that it could understand.

The .NET support supports digit styles of serialization. Binary serialization converts objects into star information. This gives a apothegmatic termination and ensures that when the accumulation is deserialized, the goal scheme is aright reconstructed. Deserialized objects are of the aforementioned types as the originating objects and references are recreated. If digit female objects originally had the aforementioned reference, the deserialized edition module also hit those female objects distribution a reference. The accumulation generated by star publishing includes open and clannish properties and fields.

XML serialization converts the land of objects into XML. This allows the aggregation to be deserialized into assorted accumulation types, including into code that has been created using technologies another than the .NET framework. As XML documents crapper be verbose, the serialized aggregation crapper be large than its star equivalent. However, it is human-readable and, in pertinent scenarios, crapper be easily edited. One essential removed of XML publishing is that clannish properties and fields are not extracted so cannot be recreated from the data. Another removed is that references are not encoded. Deserializing an goal that had digit female objects with the aforementioned meaning module create digit removed references.

In this article I module exposit how to ingest star serialization. XML publishing module be thoughtful in a forthcoming article.

Serializing Objects

Basic star publishing is ultimate to attain using the .NET framework. The prototypal responsibility is that every classes and structures that haw be serialized staleness be decorated with the Serializable attribute. In addition, every of the types of fields and properties in your collection staleness also be serializable. A distribution serializable collection containing digit open properties and a clannish earth is shown below.

NB: For this example, C#3.0 automatically implemented concept structure has been used. If you are using an early module version, modify these to flooded concept declarations with championship accumulation fields.

[Serializable]
public collection Car
{
    clannish int _crashes = 0;

    open progress Model { get; set; }

    open progress Colour { get; set; }

    open vacuum AddCrash()
    {
        _crashes++;
    }

    open override progress ToString()
    {
        convey string.Format("{0} {1}, {2} crash(es).", Colour, Model, _crashes);
    }
}

We crapper today create an happening of the Car collection to serialize:

Car automobile = newborn Car();
car.Colour = "Red";
car.Model = "Coupe";
car.AddCrash();
Console.WriteLine(car);     // Outputs "Red Coupe, 1 crash(es)."

Microsoft introduced generics to the C# module with edition 2.0 of the .NET framework. In an early article, I described the creation of generic types. These are classes and structures that impact with accumulation types that are undefinable within the identify itself and exclusive famous when the types are instantiated. If you are newborn to generics, you should feature the article, “Generic Types”, before continuing.

Generic methods ingest a kindred structure to generic types. They earmark individualist methods to be created that impact with types that are circumscribed exclusive when the method is called. A generic method includes digit or more type parameters in its signature. Those identify parameters crapper then be utilised for the convey continuance for the method and in its parameters. This allows the methods to be reused with whatever assorted types.

Generic methods deal whatever structure and functionality with generic classes and structures. However, it is not needed to create a generic method within a generic type. If you do add a generic method to a generic type, you should not ingest replicate identify constant obloquy in a method and its containing class. If you do, the method’s identify constant module conceal the containing type’s and a warning module be generated.

The structure for a generic method’s mode is as follows:

The most essential conception of the above structure is the type-parameters element. Here you take digit or more identify parameters in a comma-separated list. If desired, those types crapper also be utilised for the convey continuance and whatever or every of the method’s parameters.

The mass distribution cipher shows a ultimate generic method with a azygos identify parameter, titled “T”. In this case, the BuildList<T> method accepts a sort of objects of an undefinable identify and returns a generic List of the aforementioned type. In real-world applications this method serves no purpose. However, it is multipurpose for our demonstration.

List<T> BuildList<T>(params T[] items)
{
    convey newborn List<T>(items);
}

When you call a generic method, you crapper take the types to be practical in locate of the identify parameters by insertion them between seek brackets (<, >). The mass call explicitly states that the method is to be utilised with strings.

You crapper also call generic a method without specifying the types that it module use. In the mass case, the items passed to the method are every integers. This allows the programme to derive the identify automatically. In whatever cases identify illation is not doable and the identify parameters staleness be provided.

Using Generic Constraints

Type constraints crapper be practical to individualist methods as they are with generic types. Derivation constraints, choice creator constraints and continuance / meaning identify constraints are every valid. The structure is same to that of generic types with the where keyword existence additional to the modify of the method signature.

In the distribution cipher below, a confinement specifies that T staleness be a continuance type. This module preclude the cipher from assembling because of the existing call that specifies the ingest of strings, which are meaning types.

public List<T> BuildList<T>(params T[] items) where T : struct
{
    convey newborn List<T>(items);
}

Generics

The .NET support edition 1.1 based the creation of assorted types of collection. These collections earmark a sort of objects to be concentrated unitedly in assorted structures, much as ultimate lists, hash tables, stacks and queues. One of the key drawbacks with every of the .NET 1.1 collections is that they are not type-safe. This effectuation that whatever continuance or goal crapper be additional to a collection, with every meaning types existence patch as objects and continuance types existence boxed.

The demand of identify country crapper drive formal problems. For example, if you hit a assemblage that you are using solely to stop a assemble of “Customer” objects, it is doable to unexpectedly add an “Order” goal to the list. If you after endeavor to feature the Order goal backwards from the assemblage and modify it to a Customer, the transmutation module change and drive a run-time exception. Additionally, the sportfishing or enclosing of every items in the assemblage to stop them as objects adds a processing overhead, as does unboxing or sportfishing backwards to the warning type. This disbursement crapper drive action issues.

To overcome these problems in a .NET 1.1 project, it was ordinary to manually cipher type-safe collections. In the housing of the Customer object, a “CustomerCollection” assemblage with every of the needed methods, properties and events would be created. This would vanish the processing overheads of sportfishing and secure that if an endeavor were prefabricated to add the inaccurate identify of object, it would be caught with a programme error. Unfortunately the power for reuse of the CustomerCollection cipher would be limited. If a kindred assemblage were required to stop Orders, it would responsibility to be created separately, modify though the cipher would be similar.

With the .NET edition 2.0, Microsoft introduced Generics. Generic planning allows type-safe classes and methods to be created without specifying the types that they control on. The types are declared, using type parameters, exclusive when the assemblage is used, allowing assorted instances to impact with assorted types. This overcomes both of the previously expressed problems. As the classes are type-safe, there is no responsibility for enclosing or sportfishing when datum from or composition to a collection. This leads to action improvements of 100% or more. As the types are ordered when a generic assemblage is instantiated, the cipher crapper be reused, minimising copy and crescendo developer productivity.

Using Generic Types

Many generic types are included in the .NET framework. These allow whatever generic collections that cipher the problems described early without the responsibility to indite whatever player code. You crapper encounter whatever of these in the System.Collections.Generic namespace. To study the examples in the article, add the mass using directive to your code:

List<T>

To shew the ingest of a generic type, we crapper ingest the List<T> class, uttered as “List of T”. This is kindred to the ArrayList assemblage in that it provides a ultimate assemblage of objects that crapper be accessed using an finger number. The essential conception to state is the “T” element. This is the identify constant that determines the identify of objects or values that haw be held in the collection. For example, the mass cipher creates a List of integers; thus the assemblage is proclaimed using “List<int>”.

List<int> integers = newborn List<int>();
integers.Add(1);
integers.Add(2);
int extracted = integers[1];

Unlike with an ArrayList, the test distinction of this distribution does not responsibility to unbox the number into the extracted variable. This improves the performance. To establish the type-safety of the collection, essay adding the mass line, which attempts to add a floating-point continuance to the list. Instead of allowing this and potentially feat a difficulty at run-time, the cipher module change to compile.

The key goodness of a generic assemblage is its knowledge to be reused for added type. Try streaming the mass code, which is nearly same to the prototypal warning eliminate for the ingest of section instead of integers.

List<string> section = newborn List<string>();
strings.Add("Hello");
strings.Add("world");
string extracted = strings[1];

Default Values

When continuance types and meaning types are created with undefinable values, the defaults utilised are quite different. Reference types with no continuance ordered choice to null. Value types cannot be ordered to uncollectible so instead ingest choice values. For example, integers choice to ordered and mathematician values are simulated if not otherwise assigned.

Default values for meaning and continuance types crapper be demonstrated by executing the mass cipher in a housing application:

NB: Three fields are utilised instead of topical variables as the ingest of unassigned topical variables causes programme errors. The ingest of clannish fields that are never appointed causes warnings only.

class Program
{
    noise int defaultInt;
    noise bool defaultBool;
    noise goal defaultObject;

    noise vacuum Main(string[] args)
    {
        Console.WriteLine(defaultInt);              // Outputs "0"
        Console.WriteLine(defaultBool);             // Outputs "False"
        Console.WriteLine(defaultObject == null);   // Outputs "True"
    }
}

When employed with generic types, you haw requirement to create a uncertain of an uncharted identify and distribute it a choice value. You cannot only distribute null, as the identify haw be a continuance type. Similarly, you cannot opt an capricious continuance and distribute it as this haw be an uncollectible continuance and would not be the accepted choice continuance for some meaning type. To overcome this problem, you crapper ingest the default keyword.

The mass cipher shows a generic method that returns the choice continuance for a generic type. Note that the identify constant is passed to the choice keyword within parentheses:

static T GetDefault<T>()
{
    convey default(T);
}

To shew the method and the choice keyword when utilised with a meaning type, fulfil the mass code. The returned goal is ordered to null:

object o = GetDefault<object>();
Console.WriteLine(o == null);       // Outputs "True"

To shew the choice keyword for continuance types, essay executing the mass code. This generates a choice DateTime continuance of 1 Jan 0001. The info of the production module depart according to your topical operative grouping settings.

DateTime dt = GetDefault<DateTime>();
Console.WriteLine(dt);              // Outputs "01/01/0001 00:00:00"

Tuples

The tuple is a mathematical scheme that defines an sequential ordering of elements. In this context, sequential effectuation that the visit of items defines their relationship, kinda than that the values are sorted. In mathematics, a tuple crapper hit some sort of attendant elements, including zero. Often the identify of tuple module be described using the sort of elements, much as 2-tuple, 5-tuple or 0-tuple for tuples containing two, fivesome and ordered values respectively. Usually a tuple happening module be cursive as a comma-separated itemize within parentheses. For example, a 3-tuple haw be cursive as (1, 2, 3).

In constituent to the notation, types of tuple also hit names. The 0-tuple is ofttimes titled the null tuple. A 1-tuple is a singleton, a 2-tuple a pair, and the structures containing between threesome and octad elements are triples, quadruples, quintuples, sextuples, septuples and octuples.

Tuples were introduced to the .NET support with the promulgation of edition 4.0. They are used primarily in multipurpose planning languages, much as F#. However, as a conception of the support they crapper be used by developers in another .NET languages, including C# and Visual Basic.

Support for tuples is provided by figure classes. Eight of these are generic classes that natively equal tuples with between digit and octad elements; 0-tuples are not supported. The ordinal assemblage is a noise assemblage that allows ultimate tuple instantiation using generic methods. Although a peak of octad items is based in a azygos Tuple instance, large lengths crapper be achieved by combine digit or more tuples.

For object-oriented programming, tuples wage a hurried artefact to unification individual values together. This crapper be multipurpose when you desire to convey multiple, attendant values from a method or property. You haw also desire to transfer individual values to an goal parameter, for warning to hit digit values identifying a arrange or provided in an circumstance that follows an anachronic operation.

There are limitations of tuples when compared with predefined structures and classes. Importantly, it should be noted that cod to the targeting of the multipurpose planning audience, tuples are immutable; erst instantiated, the values within the ordered cannot be modified. Additionally, the values in a tuple are not enumerable. You should study them kindred to the properties of an nameless type, kinda than values in a collection.

Creating a Tuple

There are digit structure in which a tuple crapper be instantiated using C#. The prototypal is to ingest the creator for digit of the octad generic Tuple classes. The cipher beneath shows the creation of a 2-tuple containing digit number values.

var tuple = newborn Tuple<int, int>(1, 2);
Console.WriteLine(tuple);   // Outputs "(1, 2)"

The types of the elements held in a tuple do not requirement to match. For example, the tuple created by the incoming distribution contains a azygos character, a progress and an number value. In this housing the values haw equal a person’s initial, name and geezerhood in years.

var integrated = newborn Tuple<char, string, int>('B', "Smith", 25);
Console.WriteLine(mixed);   // Outputs "(B, Smith, 25)"

Using the Tuple.Create Method

A ordinal artefact to instantiate tuples is using a the noise Create method of the Tuple class. This is the noise assemblage that exists exclusive to create newborn tuples. There are octad full versions of the Create method, digit for apiece alteration of Tuple.

The mass cipher recreates the preceding 2-tuple using the method instead of a constructor:

When using the Create method, the accumulation types crapper ofttimes be inferred from the arguments passed to the parameters. For example, in the cipher beneath we create the ordinal warning tuple but without providing identify parameters.