It is also now clear that this technology can be used in the development of Enterprise, as it is in the main supply of the framework, but it’s such an argument against which project managers do not trample. Typically, project managers are very reluctant to use technologies and products which are not mentioned in press releases MS, even if the technology is widely and successfully used by the community. Although they can understand, this is the first point on which they will be kicking in the event of any overlap.

So, MEF easy to make the application modular, and adding new libraries can be carried out on the fly, without the use of sophisticated techniques. All the code is transparent and easy to understand.

MEF can be used starting with version. Net 3.5, taking the necessary libraries from CodePlex. As you may have guessed, from there you can take the source code and see how it all works.

Main features of MEF:

• Provides a standardized way to organize workshops for the application and its appendices. In general, supplements are not tied to a specific application and implement a common interface can be used by different programs, which generally does not cancel and tight binding to the master application. Supplements may be dependent on one another and MEF alone connect them in the correct order.
• Provides search and download of the add-ons by MEF
• Allows you to tag metadata additions for additional opportunities to connect and filter adds.

Creating a simple application

For the beginning do something in the spirit of the HelloWorld application, and then do something more useful, because I would curse myself if focused on HelloWorld example that usually does not demonstrate anything))

So, the application will be very simple that can be. Let it be a console and will display the phrase in various languages, depending on what type of library we will choose as the application. For the beginning ,that’s it! You will be able to focus only on the MEF code.

Create a console application. It will be the master application. In order to connect and find other libraries allocate additional communication interface in the assembly. So, at this stage we will have a console project HelloConsole and the assembly LangDefiniton.

To a project HelloConsole add reference to the assembly System.ComponentModel.Composition System.ComponentModel.Composition and to our library LangDefinition. At this point the solution should look like this:

In the project LangDefinition create a new interface, where we define the method SayHello, which will return the needed text.

namespace LangDefinition {
    public interface ILanguage {
        string SayHello();
    }
}

After the defined the interface, you can write code that will load use a supplement to our application. To do this, go to the project HelloConsole and there create a class AddingComposer.

The method, which is responsible for finding and downloading additions will LoadAddings. It shall indicate in which directory to look for additions and load them.

public void LoadAddings() {
    var catalog = new AggregateCatalog();
    catalog.Catalogs.Add(new DirectoryCatalog("Adding"));

    var container = new CompositionContainer(catalog);
    container.ComposeParts(this);
}

On the third line indicates exactly where to look for additions. In this case, the specified provider DirectoryCatalog, which allows you to specify the path to the directory with additions (absolute or relative path of the executable library, in this case, the executable file), including filters to specify the library search.

You can also specify an assembly where to look for additions. For this we need to create AssemblyCatalog. In addition, you can specify the types that need to be imported. Use the TypeCatalog.

On the fifth line specifies what and how to gather in the main application. You can mark additions as thread-safe .

To gain access to that found by complement, one has to interface with our field and mark it with a special attribute Import, which tells the system that is imported from the supplement type. Total class would look like this:

public class AddingComposer {
    [Import]
    public ILanguage Language { get; set; }

    public void LoadAddings() {
        var catalog = new AggregateCatalog();
        catalog.Catalogs.Add(new DirectoryCatalog("Adding"));

        var container = new CompositionContainer(catalog);
        container.ComposeParts(this);
    }
}

At the moment everything is ready to ensure that write the actual code additions.

Add a new class library project. We call it RussianHello. Refer it to the project with an interface to System.ComponentModel.Composition and implement the interface ILanguage.

namespace RussianHello {
     [Export(typeof (ILanguage))]
     public class RuHello : ILanguage {
          public string SayHello() {
              return "Привет";
          }
     }
}

To see MEF class, you have to mark the attribute Export.V this case could not specify the interface exports.

Another point to test the application. It will be useful to specify a folder directly on the formation of libraries Addings in the directory where the executable will lie.

The final step is to call the class AddingComposer in the body of Main.

private static void Main(string[] args) {
    var addingComposer = new AddingComposer();

    addingComposer.LoadAddings();
    var hello = addingComposer.Language.SayHello();
    Console.WriteLine(hello);

    Console.ReadLine();
}

After this, run the application and see:

This is the basic functionality of MEF, on which many of the articles and come to an end, but of course we go any further, consistently developing the application.

Adding another language

Create another assembly, where realise the interface ILanguage for English.

namespace EnglishHello {
     [Export(typeof (ILanguage))]
     public class EnHello : ILanguage {
         public string SayHello() {
             return "Hello";
         }
     }
}

After that we can cast the appropriate libraries in the folder Adding and watch the result that the message is changing.

But this will happen only if the folder only additions one more addition. If you cast the two additions, the runtime will throw an error on an application that can not be resolved as a complement to download and use.

To resolve this situation, we use metadata for export applications.

Metadata for export

Metadata for exports may be untyped and typed. Let’s start with untyped, as it’s more simple to use.

weak typing

Metadata is added using a special attribute ExportMetadata. We need the constructor, where you can specify a variable name and its value will be used to uniquely identify the add-on.

For a class RuHello add:

[ExportMetadata("Lang","Ru")]

Then we obtain

[Export(typeof (ILanguage))]
[ExportMetadata("Lang","Ru")]
public class RuHello : ILanguage { ... }

Similarly add class EnHello, to see

[Export(typeof (ILanguage))]
[ExportMetadata("Lang","En")]
public class EnHello : ILanguage { ...  }

After that we can choose the Build-to-field Lang. Sample itself will be carried out in the master application.

For import multiple we use attribute ImportMany which is used in type to import. This attribute is better to hang on a lazy collection of MEF namespace for posted initialization of components.

[ImportMany(typeof (ILanguage))]
private Lazy<ILanguage, IDictionary<string, object>>[] langVaults { get; set; }

Choosing the right additions can be carried out following sample:

public ILanguage GetHello(string type) {
    LoadAddings();

    return (from codeVault in langVaults
              where (string) codeVault.Metadata["Lang"] == type
              select codeVault).Single().Value;
}

After this, the main application code looks like this:

public class AddingComposer {
    [ImportMany(typeof (ILanguage))]
    private Lazy<ILanguage, IDictionary<string, object>>[] langVaults { get; set; }

    private void LoadAddings() {
        var catalog = new AggregateCatalog();
        catalog.Catalogs.Add(new DirectoryCatalog("Adding"));

        var container = new CompositionContainer(catalog);
        container.ComposeParts(this);
    }

    public ILanguage GetHello(string type) {
        LoadAddings();

        return (from codeVault in langVaults
                  where (string) codeVault.Metadata["Lang"] == type
                  select codeVault).Single().Value;
    }
}

private static void Main(string[] args) {
    var lang = Console.ReadLine();

    var addingComposer = new AddingComposer();
    var hello = addingComposer
               .GetHello(lang)
               .SayHello();

    Console.WriteLine(hello);

    Console.ReadLine();
}

You can mark try to enter values Ru and En and see how the application displays the data to us from the right supplements.

Best of all, before the application starts you can do to clean the folder Adding, copyingand there additions as you work. They will be picked up without restarting the application.

Strong Typing

Now try the same things with typed metadata.

In general, the algorithm is as follows: declare a class that will be typed attribute, inherited from his ExportAttribute. Create an interface that will follow a set of properties, but only for reading. Use the newly created attribute on the desired class.

Assume that we have changed the metadata to the point:

namespace EnglishHello {
     [Export(typeof (ILanguage)),
      ExportMetadata("Lang","En"),
      ExportMetadata("Version","2"),
      ExportMetadata("Comment","English language"),
     ]
      public class EnHello : ILanguage {
          public string SayHello() {
             return "Hello";
          }
      }
}

Logically languages are fairly limited and may be given enumerated type, version can only be an integer value, this comment line. To get all the advantages of typing, you need to create a necessary attribute types. Since then begin.

[MetadataAttribute]
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class LangMetaData : ExportAttribute {
    public Lang Language { get; set; }
    public int Version { get; set; }
    public string Comment { get; set; }
}

The class inherits from ExportAttribute, while attributes are applied to it MetadataAttribute and indicates the types it will be used and how. In this case, the attribute should apply only to classes with multiple inheritance through the use is prohibited.

Now we need to create an interface that will follow a set of properties, and they must be declared read-only.

public interface ILangMetaData {
    Lang Language { get;  }
    int Version { get;  }
    string Comment { get; }
}

The interface can be declared next to the attribute.

Then you can use attribute. It looks prettier than untyped metadata.

namespace EnglishHello {
     [Export(typeof(ILanguage)),
     LangMetaData(
         Language = Lang.En,
         Version = 2,
         Comment = "English Language"
     )]
     public class EnHello : ILanguage {
         public string SayHello() {
             return "Hello";
         }
     }
}

There is no way to make a mistake, the compiler will notice;

• Know precisely what options might be, intelliSense tell;
• It is easy to change and seek to use the project properties;
• Sane filter when searching for additions to the application.

It remains only to modify the master application to strongly typed metadata understood. The list will announce as we desired dictionary from the interface and the interface metadata.

[ImportMany]
private Lazy<ILanguage, ILangMetaData>[] langVaults { get; set; }

I draw your attention that the attribute is not specified ImportMany type that can be booted. If you leave the type, then load the add-on twice and MEF can not correctly resolve the dependency. It is necessary to specify the type or in ImportMany, or in Export, but not in two places at once.

Method GetHello now changed, and in my opinion would be more informative and accurate
Метод GetHello теперь изменится, и на мой взгляд станет более информативным и аккуратным

public ILanguage GetHello(Lang lang) {
    LoadAddings();

    return (from codeVault in langVaults
              where codeVault.Metadata.Language == lang
              select codeVault).Single().Value;
}

Hmm … I haven’t guessed any difficult examples yet, right? Well, it’s probably because I do not particularly complicated things and treated. Rest in the next section, and even so there are too many letters. Wait, it is almost ready;)

Hard’n’heavy

As already mentioned in the title, this step will be to rotate. Bat files since they are widely used in our daily activities, and constantly open Explorer or FAR is not very convenient. Much better to have effect until the pile and hang it on the key combination to achieve complete nirvana

So, given: a project that uses a batch file

Required: run a batch file from the context menu in the Project Explorer.

Create a link to an external application

In the main menu, select studio Tools -> External Tools …

After that, a window appears where you can specify which application and what parameters to run. In this environment variables are available, such as the path to the file to the project, the file name, the root of the decision, and others.

In the resulting window click on the Add button and fill in the fields according to the screenshot.

Give the name to the action, so that we ourselves can determine what will happen in the end. Prescribes the name of the application to run. In this case the command line C: \ Windows \ System32 \ cmd.exe

The command line arguments. For us, it will be the path to the file. In the variables it is listed as $(ItemPath). I think you have noticed that before this variable is still “/ C”, it says the command line, that is to close immediately after the operation.

Another important thing is to point the working directory for the command line. In my case this is solution folder.

Note in daw Use Output window , to see everything at once in the studio and on stage this customization tool is completed. Click OK and proceed to the next stage of setup.

Adding context menu

Before you add a context menu, you need to do a very important step, without which, success is not guaranteed.

So, you need to open the main menu in the studio Tools, and calculate how the order is necessary to you external tool.

Required item is the sixth. Remember this and move on to the setting in the context menu for files in the Project Explorer.

Open the Tools > Customize…, go to the tab Commands, select the item Context menu and in the dropdown list search for the line Project and Solution Context Menus | Item

After you have selected a row in the drop-down list, you will be all the possible commands that can be displayed for the item.

We need to add a new team that we are doing. Click on the appropriate menu item and look for the category Tools and you want us to command. Team we are looking at its sequence number in the list, which was in the beginning of this section. Now do you understand why it was necessary to find the serial number of the menu item?

After pressing OK, to be like the following on the previous dialog box.

Close this window and you can try to start .bat in the Project Explorer.

That’s all, hope this helps you in your work and allow more productive use of your time.

Hard’h’heavy!

Creating your own package NuGet

For example, and I think in most cases, you’ll create a package NuGet without dependencies on other packages. So we need any project, for simplicity let it be a simple library with the N- of methods.

In order to be able to set library or libraries to include in the final NuGet package, you must add the project file with the extension “.Nuspec“, where there will be described all the properties and the internal function of our package. So far, in the studio there is no setting to create the files required extensions, so that you can create any text file, and change it’s dwells.

In general, the nuspec file looks as follows:

<?xml version="1.0" encoding="utf-8"?>
<package>
  <metadata>
    <id>WBR.ArgParser</id>
    <version>1.0.0</version>
    <title>Argument Parser library</title>
    <authors>Violet Tape</authors>
    <description>Easy to use library for parsing app arguments.</description>
    <language>en-US</language>
    <projectUrl>http://violet-tape.net</projectUrl>
    <iconUrl>http://violet-tape.net/images/commandprompt.png</iconUrl>
    <requireLicenseAcceptance>false</requireLicenseAcceptance>
  </metadata>
  <files>
    <file src="bin\Release\WBR.ArgParser.dll" target="lib" />
  </files>
</package>

We can say that the comments here are irrelevant. The only thing that is necessary to specify is which tags are mandatory and which are optional.

Mandatory tags:

• id – can not specify a name with spaces or special characters. In general, here are the same rules that apply to URL
• version – package version in the format 1.2.3.
• authors – list of the authors of code separated by commas
• description – the description of what makes the package

Everything else is optional and is filled on their own. There is no particular limitation, but iconUrl – recommend 100×100 image in png format with transparent background. Such are the demands.

If you want to invest in the package a lot of files and to prescribe them by hand , as any normal programmer is too lazy, you can use a batch addition of the mask. Examples of adding and using below.

<files>
  <file src="c:\docs\bin\*.xml" target="lib" />
  <file src="bin\Debug\*.dll" target="lib" />
  <file src="bin\Debug\*.pdb" target="lib" />
  <file src="tools\**\*.*" />
</files>

After nuspec file will be created, we need NuGet.exe to pack everything into the final file nupkg. This operation is doing with the help of the command

Pack “Path.To.Nuspec.File”

It is best to put the command into PostBuild action in successful assembly and from there to pick up ready-made package

“$(SolutionDir)Tools\NuGet.exe” pack “$(SolutionDir)ArgParser\ArgParser.nuspec”

After performing such uncomplicated actions you will completely ready and the work package, which may be placed on the official hosting or on your own.

The easiest way to start posting packages from local or network folders. This is the simplest and easiest way, which does not require any significant effort on your part.

Packages in the local directory

Let’s say you have chosen as a repository package local directory C: \ NuGet. Want to copy back all the packages you want, and then configure the package manager NuGet in this directory. This is done as follows:

Call Manager Package Tools > Library Package Manager > Package Manager Settings

After that the window will appear with the settings, where you can specify the package repository.

Enter the name of the repository and the path to the folder with the packages, then click Add and you can try to add packages NuGet from a new repository.

As you can see in the picture, there’s a new resource LocalRepository when allocation of it it, downloads the NuGet , which were placed in the appropriate folder. Similarly, all will work with network folder.

As you can see, everything is more than easy!

Placing in the gallery

Place in the general gallery of packages NuGet possible after registering on the site http://nuget.org/. Registration process is very simple, and here consider it does not make sense. After the registeration, you can add your package.

Adding is possible in two ways: through a Web interface and command-line using NuGet.exe.

Adding through the web interface

Click on the GetStarted and follow the instructions.

After the package is loaded, you will be redirected to a page where you can edit the data that was listed in nuspec file.

After you are satisfied that everything is filled properly, you can press on Next at the bottom of the page and you’ll be taken to setup a logo or a screenshot of the package. This will be the final step in the publication.

After clicking Finish, about a minute you can go to the tab My Contributions and see your packadge.

In passing to the page you can edit the package some of its properties, delete it. Learn how many people have downloaded the package, find out what other people think about your product.

Adding through the command line

After registering, you can find your GUID to update and add packages using the command line utility nuget.exe. Know your GUID may be in the tab MY ACCOUNT, in the upper right corner. After clicking on the specified menu item, you will see the following picture

nuget push -source http://packages.nuget.org/v1/ MyPackage.1.0.nupkg 64f10e0c-207a-4728-95bb-1b0e0f469511

GUID is fake, so that everything is O.K)) But you shouldn’t tell anybody your own. On this page as you can see an example , as deploit your packages from the command line

Push is the first parameter which says that we download the package, followed by the parameter source, who says, where we load the package. Next comes the name of the package to download, and most recently held a secret option GUID.

In generalthere is nothing particularly complicated.

Placement on personal hosting

This method is ideal accommodation if you have a proprietary libraries or commercial software , and a project is big and the work is done by several teams. In the future community plans to make such a placement package easier and more functional.

At the moment the private gallery package only supports return packages, download them we will do by hands.

To create a distribution package of the site will need to first create a blank project Web site.

After creating the project type the command in Package Manager: install-package nuget.Server

After that, downloading and instalingl all the packages dependencies. Blank project ready to become a server for the packets. There will be new directory. The most important for us, this folder Packages, in which actually will be adding ready packages NuGet.

Add the existing packages in a folder and you can run the site. After starting ,see the following:

Comments on the site speak for themselves. Now you can add the site to available resources and see how it all works.

After this, open the package manager, select the resource and watch as shown our packages

Voila!

I hope this knowledge will help you in the future and come across to any new uses NuGet, the possibility of decomposition of your projects and upload dependent parts through NuGet.

For myself, I had already decided that, regardless, I will try to connect through NuGet. In this case the libraries loaded locally and do not need to keep track of the correct paths to link to the library. And even the newcomers will not make mistakes, if connect the link on nunit through NuGet, because all team members will receive the correct path to the library and will not be screaming on “The Right to the relative path of the project!”;)

NuGet – a manager to control the dependencies on external libraries. With this tool you can install, update and remove according to your project with great ease. This applies both for the desktop software and the web. In particular, when expanding the CMS Orchard, she drags the half assembly during installation of the library on their own packages. There are examples of NuGet for Silverlight.

Notes from the back seats

When studying materials NuGet, a plus appears availability of shared libraries to your projects. Conditional opponents NuGet, or principled opposition asks why you need NuGet for their shared libraries, if there can be external to SVN, and other such things for VCS? So you can refer to the stable branch sources.

Developers NuGet answer that

• do not control whether access to the version control system,
• source code is not displayed to other groups
• no need to monitor and switch to other audits by hand (maybe you want to jump from branch Release, to an earlier, or you are referring to an audit in trunk)

Quite good advantages. Especially now that your favorite library does not get lost among repositories and projects.

Installation

Get package manager NuGet You can either set yourself ASP.NET MVC 3.0, or download it from the site nuget.codeplex.com. Then in Visual Studio will have a new menu item for viewing and downloading packages NuGet.

Tools > Library Package Manager > Add Library Package Reference…

Usage

The package manager is out of NuGet looks if you used the add-ons manager for the studio.

All the same. A list of available packages, brief description of the allocation package. On accordion tab Online list of available places where packages are NuGet. Now there is only one official resource, but you can easily add a local directory, online directory, your own online store packages NuGet.

Installing and updating packages, up to a disgrace simple – you simply click on the Install \ Update when you select a package from the list.

Little is need to be said about the search package. I’m in the studio search periodically disappears and I use the search at the official site nuget.org. At the moment it contains 958 packages. About finding and installing with the help of the console will talk about below.

All actions can be performed from the console package manager, which appears when you install NuGet

Actions carried out in the console for a specific project that is selected as DefaultProject. The screenshot is selected WindowsFormsApplication1, and all the packages that I will show in the console will be installed for this project if the project is not specifically listed.

Searching

Displays a list of available pacts in the console is not very convenient, so you better to find him before on the site. For example add to the project StructureMap. Go to the official website and look for the name. As a result of searching you are likely to bring up a page of the form:

Installing packages

Here it is specified by a command to execute to install. Copy and paste the text into the console.

Execute the command and get all the necessary libraries added to the project. This will download and install all the dependencies needed to run the component. So most likely you will not be in a frenzy of hand-parse all dependencies. Unless of course the author of the package have all true))

In the console we can see what packages have been established and how successfully. Once it is installed, you will see that among the files of the project, a new element packages.config. This file specifies which packages are installed and which version. General view of the file is as follows:

<?xml version="1.0" encoding="utf-8"?>
<packages>
   <package id="structuremap" version="2.6.2" />
</packages>

The newly installed package appears only in that project, which exposed “by default”. If you want to add the same package in other projects that will have to choose projects from the drop-down list and then install it.

In this package will not be re-downloaded from a remote resource, NuGet smart enough to know what has already been downloaded in the current software solution, so it just adds a link to the library. In the console you will see the following:

PM> Install-Package structuremap
'structuremap 2.6.2' already installed.
Successfully added 'structuremap 2.6.2' to TestProject1.

Unfortunately, that can not be specified when adding the package several projects for the integration. The general syntax of the installation is as follows:

Install-Package [-Id] <string> [-IgnoreDependencies] [-ProjectName <string>] [-Version <string>] [-Source <string>] [<CommonParameters>]

Packages are downloaded to the root directory of software solutions to the folder packages, so be sure to add it to your version of control system.

Installed packages can be viewed as out of the package manager

As well as from the console. Operations on the update, and delete as you can make in two ways. For all the package manager is crystal clear with all the console a bit more complicated but more flexible.

Console

The basic commands for working with the console:

Package – This command lists all packages installed for the selected “default” project.

PM> package

Id                             Version              Description
—                             ——-              ———–
structuremap                   2.6.2                StructureMap is a Dependency Injection / Inversion of Control tool for .Net that can be used to improve the architectural qualities of an object ori…
UpdatePackage – с помощью этой команды осуществляется обновление установленых пакетов. Для обновления зависимостей в проекте «по умолчанию» необходимо написать
UpdatePackage – with this command by updating the installed packages. To update the dependencies in the project “default” to write

PM> Update-Package -Id structuremap

If you have the latest version, then NuGet will say:

PM> Update-Package -Id structuremap
No updates available for 'structuremap'.

The full syntax looks like this:
Update-Package [-Id] <string> [-IgnoreDependencies] [-ProjectName <string>] [-Version <string>] [-Source <string>] [<CommonParameters>]

Unfortunately you can not check for updates all the packages at once and update them. It is necessary to carry out a refresh operation for each packet NuGet. The international community and backstage hope that this opportunity will appear in an upcoming release. In the meantime, knowledgeable people have written here is a script for PowerShell

ForEach ($project in get-project -all)
{
get-package | update-package -Project $project.Name
}

The result of running:

PM> ForEach ($project in get-project -all)
>>  {
>>  get-package | update-package -Project $project.Name
>>  }
No updates available for 'structuremap'.

No updates available for 'structuremap'.

PM>

The feedback to the script, people write that the confusion about “too many requests to the resource”, so I have warned you.

Uninstall-package – remove a package ,it is not difficult to guess =)

The result:

PM> Uninstall-Package -Id structuremap
Successfully removed 'structuremap 2.6.2' from TestProject1.

General syntax:
Uninstall-Package [-Id] <string> [-RemoveDependencies] [-Force] [-Version <string>] [<CommonParameters>]

Get-help – the most important team at work!

Example

PM> Package get-help
PM> Package -?

Interesting packets

Scratch in the Internet and looking at examples, we can say that there are the following interesting packages:

nUnit – framework for testing
log4net – a rich library for logging
structureMap – IoC container
SqlServerCompact – 4th version of SQL CE
mvcMailer – a handy library for mail
jQuery – just all the family in mind when working in VS2010
moq – a lightweight library for object mocking

Most likely your favorite library from the world of OpenSource is also in the library NuGet!

The next time I’ll tell you how you can create NuGet bags and place them in libraries.

Quite often we have to use enums for a limited set of values. They are very easy to use in your code, but there are problems for bringing them to the interface of the application. Not only in Russian but in English. The values ​​in enum may consist of several words logically and embarrassing them to show in the user interface. For example:

public enum MyEnum {
    None,
    CompositeValue,
    Single
}

Naturally, it is show to the customer CompositeValue is not good. Much better to show “Composite Value”. Or, to translate it into Russian.

How it was

Now in the code you can find the following monstrous construction:

private const string LogSeverity_All = "Все";
private const string LogSeverity_Off = "Никакие";
private const string LogSeverity_Critical= "Критические";
private const string LogSeverity_Error = "Ошибки";
private const string LogSeverity_Warning = "Предупреждения";
private const string LogSeverity_Information = "Информационные";
private const string LogSeverity_Verbose = "Расширенные";
private const string LogSeverity_ActivityTracing = "Трассировочные";

To translate the text into an enumerated type using a separate code, where each potential case may be a mistake and should be tested.

private static FileSeverityFilter StringToFileSeverityFilter(string value)  {
    switch (value) {
       case LogSeverity_All:
          return FileSeverityFilter.All;
       case LogSeverity_Critical:
          return FileSeverityFilter.Critical;
       case LogSeverity_Error:
          return FileSeverityFilter.Error;
       case LogSeverity_Warning:
          return FileSeverityFilter.Warning;
       case LogSeverity_Information:
          return FileSeverityFilter.Information;
       case LogSeverity_Verbose:
          return FileSeverityFilter.Verbose;
       case LogSeverity_ActivityTracing:
          return FileSeverityFilter.ActivityTracing;
       default:
          return FileSeverityFilter.Off;
     }
}

And there is an enumerated type

enum FileSeverityFilter  {
    All = 0,
    Off,
    Critical,
    Error,
    Warning,
    Information,
    Verbose,
    ActivityTracing
}

And to generate values ​​for display property is used

public List<string> LogSeverities {
    get {
        return new List<string> {
                LogSeverity_All,
                LogSeverity_Off,
                LogSeverity_Critical,
                LogSeverity_Error,
                LogSeverity_Warning,
                LogSeverity_Information,
                LogSeverity_Verbose,
                LogSeverity_ActivityTracing
               };

     }
}

Where again it is easy to forget to specify the new type.
Total:

• A lot of code where it’s easy to make mistakes, and make out all of this will be hard enough.
• No obvious connection type values ​​and the signatures of men.
• Conversion should be done for each enumeration type.

Became

You can go the other way, getting rid of all the shortcomings, leaving only one where the error occurred, for all possible enumerations. FOr it we will deploy the attribute is Description.

public enum MyEnum {
    [Description("Не выбрано")]
    None,

    [Description("Составное значение")]
    CompositeValue,

    [Description("Значение")]
    Single
}

Immediately we see a description of what type of matches.

To get the value from the description, you should use the following code:

var type = typeof (MyEnum);
var fieldInfo = type.GetField(enumerate.ToString());
var attributes = (DescriptionAttribute[]) fieldInfo.GetCustomAttributes(typeof (DescriptionAttribute), false);
var result = (attributes.Length > 0) ? attributes[0].Description : enumerate.ToString();

Since it is inconvenient to write every time you select a class of extensions.

public static class EnumExtenders {
    public static string ToStringX(this Enum enumerate) {
        var type = enumerate.GetType();
        var fieldInfo = type.GetField(enumerate.ToString());
        var attributes = (DescriptionAttribute[]) fieldInfo.GetCustomAttributes(typeof (DescriptionAttribute), false);
        return (attributes.Length > 0) ? attributes[0].Description : enumerate.ToString();
    }
}

Now we can write

MyEnum.CompositeValue.ToStringX () // will compound the value

Already much easier and can be used for any enum.

For a list of values​​, the code is not very complicated.

public static List<string> Descriptions(this Enum enumerate) {
     var values = Enum.GetValues(enumerate.GetType());
     var descriptions = new List<string>(values.Length);

     foreach (var enumVal in values) {
          descriptions.Add(((Enum) enumVal).ToStringX());
     }

     return descriptions;
}

Uses:

var descriptions = MyEnum.Single.Descriptions();

The only disadvantage that the use by any enumeration value.

Don’t you want to write this method?

var actual = Enum.GetValues(typeof(MyEnum))
     .Cast<MyEnum>()
     .Select(i => i.ToStringX());

Use directly in your production code.

A result

In my opinion submitted by the way is more compact and versatile. In addition, the test should be only one place, everything is compact.

• Do not be afraid of tipping over on the values ​​of the user interface, since all comes.
• Visibility of use.
• The code size is reduced at times

Source code

Hard’n’heavy

As you probably noticed last time, the images I have shown are mini-icons-default applications and those applications I have several. So let us consider in more detail how to achieve this for you too.

Overlay

The easiest way, which enables you to draw an extra icon on top of existing – to use an overlay of the Win API Codec Pack. For this we need only to know the path to the object,in which will contain an icon. The way we are still taken from our class to store list elements LinkInfo

[Serializable]
public class LinkInfo {
    public string Name { get; set; }
    public string AppPath{ get; set; }
    public bool IsDefault{ get; set; }
}

So, the code for the overlay will look like:

private void SetOverlayIcon(LinkInfo linkInfo) {
    var icon = System.Drawing.Icon.ExtractAssociatedIcon(linkInfo.AppPath);
    TaskbarManager.Instance.SetOverlayIcon(this, icon, "Icon Name");
}

The first mode of action you pull out the icon from the resource. The second action is putting it on top of a working application icons.

This can be used for running the program and the overlay will look very good. I personally like. But when you quit all at once disappear = (And it’s certainly not happy, because I will not know that the default program to start.

Independent creation of icons

Yes, we’ll have some work to create icons themselves. Even more, in real time to create your new icon from the available material and make it of default for the program.

I have just showed you how to rip out icons from programs and it’s not a problem. Now we need to put them nicely to each other, and one of them reduced. Let’s start with the latter problem.

I think it is meaningful to ask here is not the absolute size and relative, that is, to be able to say, I decreased the icon-image by 50%. It turns out this is not so difficult. It is necessary to calculate how much these 50% will be in pixels, and ordered to redraw the calculated values.

public Bitmap ResizeBitmap(Bitmap b, int nWidth, int nHeight) {
    var w = (int) (b.Width*(nWidth/100M));
    var h = (int) (b.Height*(nHeight/100M));

    var result = new Bitmap(w, h);
    using (var g = Graphics.FromImage(result)) {
          g.DrawImage(b, 0, 0, w, h);
    }

    return result;
}

We’re getting icon image size. With such a repaint is likely to appear black opaque background and it can remove a single line of code:

mini.MakeTransparent();

Next you need to put the mini image on the current . For a good look I have made ​​a 2-pixel padding on the bottom and right.

public Bitmap OverlayBitmap(Bitmap background, Bitmap overlay) {
    using (var g = Graphics.FromImage(background)) {
         g.DrawImage(overlay, background.Width - overlay.Width - 2, background.Height - overlay.Height - 2);
    }
    return background;
}

Now we have the final image and you want to save as an icon. The original version was quite simple and I’m even glad that everything is so easily obtained.

var intPtr = bitmap.GetHicon();
System.Drawing.Icon.FromHandle(intPtr).Save(fileWriter);

We took a pointer to create icons, icons created and saved to disk. Yes, the icon will be created, but very poor quality, only 16 colors. This is clearly not what I wanted. It was necessary to look in the Internet on the subject of new knowledge and libraries) and a library was found – IconLib

Without going into details, the library can be applied as follows:

var sIcon = new MultiIcon().Add("Icon");
sIcon.CreateFrom(bitmap, IconOutputFormat.Vista);
sIcon.Save(iconPath);

Icon is a much better! In this it was decided to stop at will and is slightly worse than the original. Now you only have to replace the icon with the shortcut!

Creating shortcuts

.Net has no means to create and edit shortcuts.

Yes, there is an omission. I do not know why, but true. For a long time I used the library Interop.IWshRuntimeLibrary.dll and creating shortcuts in my whole suit. But the way has stopped working when used. Net 4.0, so it will not even talk about it and. Had once again to seek new ways to create shortcuts. If it was only a banal xml or some other human-readable format, but no.

In the end, I found an archive with source code, which unfortunately did not want to decompressed but luckily at the site you can view the source code. It turned out that it is necessary only two files and create a shortcut becomes to child’s play:

using (var shortcut = new ShellLink()) {
    shortcut.Target = appPath;
    shortcut.WorkingDirectory = Path.GetDirectoryName(appPath);
    shortcut.Description = name;
    shortcut.DisplayMode = ShellLink.LinkDisplayMode.edmNormal;
    shortcut.IconPath = iconPath;
    shortcut.Save(linkPath);
}

To me everything is clear without words. With Interop.IWshRuntimeLibrary.dll shortcuts created as follows:

WshShell shell = new WshShellClass();
IWshShortcut link =  (IWshShortcut)shell.CreateShortcut(shortcutFullName);

link.TargetPath = target;
link.Description = description;
link.Save();

About the program

During the development I have not managed to identify patterns in how the same to make the icons in the taskbar updated quickly. A couple of times managed to do, but to fix the result failed. Update icon is when you reboot, login, out of sleep.

When you fasten the program to the taskbar, the label is created at % USER_DIR% \ AppData \ Roaming \ Microsoft \ Internet Explorer \ Quick Launch \ User Pinned \ TaskBar, and accordingly there to look for the label and update it.

Now the program can only work with one sheet of programs and program by default, you can specify only one. The latter limitation is very easy to remove, but to an executable file has worked with several sheets and attached to the taskbar will probably more difficult. The fact that the jump list is created in relation to the window / program. And there is speculation that can create derived windows, and for them to create lists and attach them to the taskbar. So far I’ve just copypased program to another folder and rename the executable file, then set up another jump list)) the program helps me and yet do not want to bother with supplementary windows and others, as it is easier to configure everything by hand. Lazy programmer – a good programmer!

Source code, Application, Files for icons creation

Hard’n’heavy!

Thus, we’ll solve the following problem: I have a lot of icons in the taskbar is attached. 2 studios, SQL Server, Expression studio, office applications, browsers – all this would be helpful to group and to the default run basic applications.

The main functional

To get started with a Quick Jump List you need to download Windows API Code Pack. After this create any project which in the end will create the window for user, it’s no need to show. I decided to train on WPF. So we have a project that creates a window. As a result, empirically it was found that the code to create “jump list” may be placed only after fully initialize at least one window (usually main). So in my opinion, to create a suitable response to the end of the loading window.

private void Window_Loaded(object sender, RoutedEventArgs e) {
    CreateJumpList();
}

The list of actions (programs) will be based on some of the data entered by the user.You need to know:

• The Way to the program
• Name to display
• Will it be the default action

For these data, I created a small class

[Serializable]
public class LinkInfo {
    public string Name { get; set; }
    public string AppPath{ get; set; }
    public bool IsDefault{ get; set; }
}

I did not bother to check and so on, because this example, and remember that only 20% of the time spent on writing the functional. I did not want to spend more time than you need, everything else can be finished alone.

Suppose we have already a list of items LinkInfo, and we build the actual “just list.”First, add references to namespaces and Microsoft.WindowsAPICodePack.Shell and Microsoft.WindowsAPICodePack.Taskbar, then it is already possible to write real code.

Let’s start with the creation of the Jump List and categories.

var JList = JumpList.CreateJumpList();
JList.ClearAllUserTasks();

var category = new JumpListCustomCategory("Tools");

JList.AddCustomCategories(category);

Все просто и логично, вот что я люблю! =) Создание элементов списка тоже не будет rocket science.

settings.Links.ForEach(item => {
     var link = new JumpListLink(item.AppPath, item.Name) {
                     IconReference = new IconReference(item.AppPath, 0 );  };
     category.AddJumpListItems(link);
});

If an application has a few icons, you can specify it through a resource id when creating indetificator IconReference.
To separate one category from another, you can use the following code:

JList.AddUserTasks(new JumpListSeparator());

You can add links to websites, and the folder. The way is a string, and the system will calculate what meant.

JList.AddUserTasks(new JumpListLink("http://violet-tape.net", "Violet Tape"));

JList.AddUserTasks(new JumpListLink("C:\\temp", "Temp") {
            IconReference = new IconReference(setTools, 0)
});

In general, the behavior of clicking on links can be described like this: “Run this is where I show and how – puzzle out youself!”

Additional Functionality

Do not dwell in detail on how to save and load settings and stuff like that. Let’s talk about the very small nuances of the application.
Once we have assigned the default application, call our program should run the necessary program and this complete its activity (close). And at the same time we must be able to tweaking the program after the appointment of CDS programs. Yes, let’s look at the start arguments .
It is necessary to make the point in “just list” to launch the program in setup mode. Let us for this parameter will be «-s». Then the entry in jump list will be such

var setTools = Assembly.GetExecutingAssembly().Location;

var link = new JumpListLink(setTools, "Set tools") {
         IconReference = new IconReference(setTools, 0),
         Arguments = "-s"
};

As you can see, nothing does not restrict us in the construction of list items. You can pass the start arguments to the applications, the working directory, as well as the form in which to show the window – minimize, maximize, as it is (and more)
About how to work with arguments and application properties discussed earlier, so do not dwell on it.

Conclusion

This could be the starting point of the program. You can still realize a lot of things and of course to work on optimizing the code. Do not update the data as done in this program, use MVVMLight! =) The next article will continue to work on this program, to use the new features done Win 7.

Hard’n’heavy!

You can name the current compilation of the backbone for further development. Now the program can open by clicking on the file with a registered extension, the file opens in new tabs, or, if you ask, then close all other tabs and the file will open in a single tab. There will always be running only one instance at one time.

I think that I should still consider how it works in reality. Focusing only on the differences that have emerged in real life. At the same time and will be seen asdescriptive material is different from a working prototype.

Once again on the “purpose” of the program: run only one instance, opened file sare in a new tab, if the program is already running.
The program deliberately complicated in some places, as will surely be a live project. I will focus on programming in entered these places. So …

The uniqueness of the instance

The example in the article was based on WinForms and everything was quite simple, with WPF a different approach. Arguments passed to the program at startup are processed in the class App, then goes to show the main window MainWindow. When necessary to complete the second instance, we must call the completion of the application class App. This is not a problem, but we must somehow transmit knowledge about how to close the application or not. To do this, select an interface from a base class.

public interface IApp {
    bool IsOriginal { get; }
}

Now there would be a link from the main window of the application.

public MainWindow() {
    if (((IApp) Application.Current).IsOriginal) {
        ...
        InitializeComponent();
        ...
    }
    else {
        Application.Current.Shutdown();
    }
}

Thus the window of the second program and the user does not seem to notice anything, which is run a second instance.

Pending commands

In a real project, you will not use one set of commands. Yes, they will be inherited from an interface, for example ICommand, but there is only one method, so as not to contaminate all the other possible commands.

public interface ICommand {
    void Execute();
}

In this case we consider a principled approach when there is a command with parameters and commands without parameters. In this case, it does not matter how many parameters will be in the command.

public class Command : ICommand {
     public Action Action { get; set; }

     public void Execute() {
         if (Action == null) return;

         Action();
    }
}

public class Command<T> : ICommand {
     public Action<T> Action { get; set; }
     public object ParameterT { get; set; }

     public void Execute() {
         if (Action == null) return;

         Action((T)ParameterT);
     }
}

So far you could not see any problem with the use of commands. Command with parameters made in a generic style, because commands produce each type would not be rational, and simply lazy. A laziness – that’s what should be a programmer to develop!
In a simple command is invoked there is no problem because of the signature you call correctly and without problems. But we have the program starts with initial parameters, they are parsed at the beginning of work and in the form of specific types of data to be transmitted to future performance.

There can be debate, it is easier to store settings in a class or service as long as needed in a particular place, but we believe that there is no such possibility.

Since the beginning of the program no commands are not yet registered, you have to put them in a queue for execution (the order must be preserved). And here begins the most interesting.

CommandManager not parameterized types, but the command looks like

public void Execute<T>(CommandName commandName, Type type, T parameter) {
     var key = CreateKey(commandName, type);
     if (!commands.ContainsKey(key)) return;

     var command = ((Command<T>) commands[key]);
     command.ParameterT = parameter;
     command.Execute();
}

You should clearly specify the type parameter, or it is computed automatically. We select the inner class for pending commands, there must be all the values for this command, so, name, type, and, if necessary, the parameter(s).

public class CommandManager : ICommandManager {
     private class DelayedCommaind<T> {
         public Tuple<CommandName, Type> Key { get; set; }
         public T Parameter { get; set; }
     }

     ...

}

If we make the parameter type as object, there will be no match for the target commands. On the other hand you can not declare a variable of typeDelayedCommaind

public class CommandManager : ICommandManager {
     ...
     private readonly Queue< DelayedCommaind<T> > delayed = new Queue< DelayedCommaind<T> >();
     ...
}

as the class itself is not parameterized and that for T we mean the compiler is not clear. On the way out we will have a new language feature 4.0 – dynamic!

public class CommandManager : ICommandManager {
     private readonly Queue<dynamic> delayed = new Queue<dynamic>();
     private void Execute<T>(DelayedCommaind<T> delayed) {
     if (!commands.ContainsKey(delayed.Key)) return;

     if (delayed.Parameter.GetType() == typeof (NullParameter)) {
         var command = ((Command) commands[delayed.Key]);
         command.Execute();
     }
     else {
         var command = ((Command<T>) commands[delayed.Key]);
         command.ParameterT = delayed.Parameter;
         command.Execute();
    }
}

Actually it turns out that the commands works as proxies, so, for each action does not create its own command and called ready, but with different parameters. I like this approach more than one time create commands and to pass parameters to the constructor (if any).

WCF сервис

Since the server and client are working with a class assembly, it will not autogenereticproxies classes and not have to bother with the data types. Here, too, was not withoutnuance. The parameters of the secondary to the primary instance of the applicationpassed by a class StartParameter. And the interface service method looks like this:

[ServiceContract]
public interface ISingleInstanceService {
    [OperationContract]
    void PerformRemoteActions(List<StartParameter> commands);
}

Class StartParameter, as you might imagine, also must somehow transmit meta-information about the command parameter, and for this type of object is not very suitable. Dynamic type again will help.

[DataContract]
public class StartParameter {
    [DataMember] public CommandName CommandName;
    [DataMember] public dynamic Parameter;
    [DataMember] public bool HasParameter = true;
}

The main thing that a variable passed Parameter serialized data type.

Again there is scope for debate whether this method is limited, or create a bunch of methods according to needs. Or transfer all simple string, and parse the arguments run on the server side.

Commands registry

There really is nothing special, just want to mention the bonuses that get in Win7.
The main bonus – it is certainly quick access to documents is built automatically.

And from the context menu after registration of extension, you can get

public RegisterExtensions() {
    const string extension = ".ntpad";

    var location = Assembly.GetEntryAssembly().Location;
    var builder = new FileAssociateInfoBuilder("Notepad--", location)
         .AddCommand("Open", "-o", PassSelectedFile.ToApplication);
         .AddCommand("OpenExclusivelly", "-ox", PassSelectedFile.ToApplication);
         .AddExtension(extension);

    var service = new FileAssociateService();
    //service.DeleteAssociation(extension);
    if (!service.Exists(extension))
        service.CreateAssociation(builder.Result());
}

Outro

That’s all what I wanted to tell you further.
I hope it was not too messy and all turned out was similar to what I’ve described earlier.
In order to test the program, create a text file and change it the extension to the one shown in the program. Than you can just open them by double-clicking or by right-clicking and watch what happens.

Source Code

Hard’n’heavy

Let’s start with the official part, that’s what Wikipedia tells us about the purpose of this template:

Command – a design pattern used in object-oriented programming, which is for an action. The command object contains the action itself and its parameters. Provides processing commands in the form of an object that allows you to save her, to pass as a parameter of the method, and return it as a result, like any other object.

From the definition we can say that with the help of commands to make the application less connected with each other. This can be useful for writing plug-ins when there are different implementations of a single action, when to run the program, with arbitrary initial actions identified in the command line, for example.

Most, if not all, interaction with the user in Visual Studio is built on the commands. As proof, you can open Tools > Options > Environment > Keyboard and you see commands that can be binded to hotkeys. The same action can make the menu. Some acts are of plug-ins to the studio. Something makes the studio itself, as a result of remembering your actions (opening the latest working files for the project is opened) – all this is the result of a template. Otherwise would have been just a terrible linkage\references and Overobject – Oriented Programming.

In the disadvantages to this method can be written using non-obviousness in the final code and code complexity investigation without executing it.
General view of the pattern shown in the diagram below.

Do not worry, in real life it would be simplier.

Beginning

Let’s start with the simplest and elementary way.
Command will be without any parameters, just content for some action.

public class Command {
    private readonly Action action;

    public Command(Action action) {
        this.action = action;
     }

    public void Execute() {
        if (action == null) return;
        action();
    }
}

In this example, the action specified by the constructor, but you can do the same through the property, no problem in that I do not see.

In view of the fact that I prefer the interface polymorphism, for the latitude of the interface I’ve highlighted in this class, only to put the first command to complete.

public interface ICommand {
    void Execute();
}

On this backbone will be built and all the rest, the evolution in action .In order to have access to pre-established command, you need a centralized repository. This is so that you can reach of anywhere up to him and call the appropriate command in the least action. This store is said to be Command Manager.

public static class CommandManager {
    private static readonly Dictionary<string, ICommand> commands = new Dictionary<string, ICommand>();

    public static void RegisterCommand(string commandName, ICommand command) {
        commands[commandName] = command;
    }

    public static void Execute(string commandName) {
        commands[commandName].Execute();
    }
}

In its simplest form, the class is also simple. In this case, the class is made static, as in the example does not present the service locator. Heh, even though by itself it is also the manager and will have the same structure, only to give services on interfaces.

So, the command manager is used to store a dictionary key is the name of the command. Commands themselves are written on the interface. To make life more comfortable, I suggest to define a static class with the names of commands. Or you can use this enumerator.

var command = new Command(DoJob);
CommandManager.RegisterCommand("Job", command);

Using the same will be in this way

CommandManager.Execute("Job");

The first improvement

The second method extends the possibilities for recognition and usage. You will need only a little to improve Command Manager. , a unique key will be not only a command name and its associated type. This will create the same command for different data types. This will be achieved by using the type sequence.

public static class CommandManager {
    private static readonly Dictionary<Tuple<string ,Type>, ICommand> commands = new Dictionary<Tuple<string ,Type>, ICommand>();

    public static void RegisterCommand(string commandName, ICommand command, Type type) {
        commands[new Tuple<string, Type>(commandName,type)] = command;
    }

    public static void Execute(string commandName, Type type) {
        commands[new Tuple<string, Type>(commandName,type)].Execute();
    }
}

Otherwise, all the same.

Second improvement

As a further evolution of the command, it would still set conditions on action execution. To do this, extend the class of Command. The condition will be given as an option. So we finish in the Command class property

public Func<bool> CanExecute { get; set;  }

Now you can change the Execute method and make use of a new property there.

public void Execute() {
    if(CanExecute() && action != null)
    action();
}

The third improvement

The logical development of all of this will have an opportunity to pass parameters to the command.

public class Command<T> : ICommand {
    public Action<T> Action { private get; set; }
    public Func<bool> CanExecute { private get; set; }

    private T parameter;

    public void SetParameter(object parameter) {
        this.parameter = (T) parameter;
    }

    public Command() {
        CanExecute = () => { return true; };
    }

    public void Execute() {
        if (CanExecute() && Action != null)
            Action(parameter);
    }
}

The command is now a generic class that can be applied to any type of parameters.

CommandManager changes, respectively. Now, before a call is transferred to the command will be an optional parameter.

public static void Execute(string commandName, Type type,object parameters = null) {
    var command = commands[new Tuple<string, Type>(commandName, type)];
    command.SetParameter(parameters);
    command.Execute();
}

In this case I used a new feature of the fourth framework, autoinitialization parameter. With this declaration the parameter can be optional, but the parameters of this type should always go after a set of mandatory parameters.

And as the test case (though degenerate in this case)

internal class MyClass {
    public MyClass() {
        var command = new Command<string> { Action = SomeAction };

        CommandManager.RegisterCommand(CommandNames.Open, command, GetType());

        CommandManager.Execute(CommandNames.Open, GetType());
        CommandManager.Execute(CommandNames.Open, GetType(), @"c:\temp\default.txt");
    }

    public void SomeAction(string s) {
        Console.Out.WriteLine("MC: " + s);
    }
}

If it is used in another class, it will be in this way

CommandManager.Execute(CommandNames.Open, typeof(MyClass), "from main thread");

Such the manager of the command would have to be on the idea in a previous article about interprocess communication.
Source code examples

Hard’n’heavy.

The rustling in the Internet has brought to what is called Interprocess Communication (IPC) and there are many ways how to implement it, depending on the ultimate goal, whether you have only one instance, or as in Excel, or something else. Further study of the issue and gave birth to this article.

The theory

Windows OS provides opportunities for fellowship programs and use of shared data between applications. In the most general case, this results in a client-server circuit, with one application acts as a server and a client. To address the issue of what type of communication to choose, you can ask yourself the following questions to help in choosing:

• o Whether the application will interact with other applications on the network or only on your computer.
• Will the application interact with applications written for other operating systems.
• Should the application itself to determine with whom to interact, or choose to place on the user.
• Will there be cooperation on the principle of copy-paste from other applications orinteraction will be severely limited in action.
• How critical is performance.
• Will the laying of a console or user interface. Some methods require the interaction ofa graphical interface.

Windows supports the following mechanisms for data exchange:

• Clipboard
• COM
• Data Copy
• DDE
• File mapping
• Mailslots
• Pipes
• RPC
• Windows Sockets

Clipboard

Acts as a common data store. When something is copied to the clipboard, the application puts data into one or more formats. Any other application can pick them out. For example pad, and the last Word.  Clipboard.

COM

This application support model OLE – compound documents. The basis of OLE is a component object model (COM). Application that uses this technology can interact with a lot of applications, even those that are yet to be written. With this model you can run other applications, for which data do you have.

Data Copy

The application can send a message with a marker WM_COPYDATA. This requires cooperation throughout between the sending and the receiving side, based on the Windows Messaging.  Data Copy.

DDE

Dynamic Data Exchange – can be presented as an extension of the mechanism of the clipboard. It can be used for network and local communication. Dynamic Data Exchange and Dynamic Data Exchange Management Library.  Dynamic Data Exchange и Dynamic Data Exchange Management Library.

File Mapping

Through this process, you can submit the file contents as a memory in the address segment of the process. The process can use a simple pointer to a file. If two applications are looking at one and the same file, you can modify the data by one application that another then gets an update. This is a very efficient mechanism that supports security at the OS level. Works locally and to provide synchronization between processes. File Mapping и Synchronization.

Mailslot

Provides a one-sided way of communication, there is a server and client messages go only from the client. But nothing prevents to make a server on the two sides. Supported by the communication network, and broadcast messages can be done, but no more than 400 bytes.  Mailslots.

Pipes

There are two types – anonymous pipes and named pipes. Anonymous pipes can communicate related processes. For full-duplex communication is required to create two channels. Named pipes can be used for network communication between unrelated processes.  Pipes.

RPC

Remote Process Call – allows you to remotely manage the application both locally and across the network. This method is compatible with the Open Software Foundation (OSF) Distributed Computing Environment (DCE) that makes it possible to exchange messages with other operating systems. Supports automatic data conversion for different platforms. Client and server are connected very weakly, but still show the high efficiency at work. Microsoft RPC Components

Windows Sockets

This is independent of the protocol data interface. You can exchange messages withany system that supports the implementation of this protocol. Windows Sockets 2.

Yes, being a freshman, I would not rack brains with all this zoo and slapped a code to create and delete a file in the root folder of the program. And would gain application which doesn’t work after the first emergency shutdown of the program! =D

The aim

On the local computer to be able to send the arguments a second instance of the program first. That is implementing any functional program that opens a document in one of his window. For example, it can be Excell, Notepad + +, WinAmp.

Reach the goal we will with named pipes and RPC. In a specific implementation, this will make the WCF Named Pipes and Mutex for RPC. Two methods for comparing the implementation. Looking ahead to say that I like WCF is much more. Easier to code and its smaller.

In pursuit of the goal, we will have two primary objectives:

1. Determine whether there is already an instance of the program in memory;
2. If you run a second instance, his arguments to pass in the first instance.

Preparation

In both implementations will be on two projects for a better separation of functionality. One WinForms, which will check and data processing. The second project in fact with the necessary functionality.

Mutex approach

The first method is based on the use of RPC. To create the solution we need some design and visual components (WinForm, WPF) and a class library.

To solve the problem number one will use a mutex.

When two or more threads simultaneously need to access a shared resource, the system needs a synchronization mechanism to ensure the use of the resource only one thread at a time. Mutex – primitive, which provides exclusive access to a shared resource to only one stream synchronization. if thread gets the semaphore, the second thread, wishes to obtain the semaphore, suspended until such time until the first thread releases the semaphore.

A named mutex in the system can be only one, and on this name, you can find it .Accordingly, immediately comes the idea that the existence check it in the system will tell us whether there is a system already running instance of the application.

Let’s start with a basic class that will create mutexes.

public class SingleInstanceTracker : Idisposable {
    private bool disposed;
    private Mutex singleInstanceMutex;
    private bool isFirstInstance;

    public SingleInstanceTracker(string name){
        if (string.IsNullOrEmpty(name))
            throw new ArgumentNullException("name", "name cannot be null or empty.");
        try {
            singleInstanceMutex = new Mutex(true, name, out isFirstInstance);
        }
       catch (Exception ex) {
           throw new SingleInstancingException("Failed to instantiate a new SingleInstanceTracker object", ex);
       }
    }

    ~SingleInstanceTracker() {
       Dispose(false);
    }

    protected virtual void Dispose(bool disposing) {
        if (!disposed) {
          if (disposing) {
            if (singleInstanceMutex != null) {
              singleInstanceMutex.Close();
              singleInstanceMutex = null;
            }
          }
         disposed = true;
       }
    }

    public void Dispose() {
        Dispose(true);
       GC.SuppressFinalize(this);
    }

    public bool IsFirstInstance {
        get { return isFirstInstance;  }
    }
}

Creating the mutex limited to one line.

singleInstanceMutex = new Mutex(true, name, out isFirstInstance);

The same line of code and tell us this is the only instance or not. Well, the first point of the program is made super-fast. But it does not have moved the problem to transfer data from one instance to another.

For data transfer we use a special namespace System.Runtime.Remoting.Channels.Ipc. It defines a class IpcServerChannel by means of which will go to data transfer.

The data transmitted over this channel to be inheriting from the class MarshalByRefObject, so they can remotely create, and to enable them to travel outside the application domain. Data must also be serializable. Yet it would be nice to define a delegate that will perform the methods in the first application, but run from second. Thus, the proxy class

internal class SingleInstanceProxy : MarshalByRefObject {
    private readonly ISingleInstanceEnforcer enforcer;

    public SingleInstanceProxy(ISingleInstanceEnforcer enforcer) {
        if (enforcer == null)
            throw new ArgumentNullException("enforcer", "enforcer cannot be null.");

       this.enforcer = enforcer;
    }

    public override object InitializeLifetimeService() {
       return null;
    }

    public ISingleInstanceEnforcer Enforcer {
       get { return enforcer; }
    }
}

public delegate ISingleInstanceEnforcer SingleInstanceEnforcerRetriever();

public interface ISingleInstanceEnforcer {
    void OnMessageReceived(MessageEventArgs e);
    void OnNewInstanceCreated(EventArgs e);
}

Create and register a channel is as follows:

Var ipcChannel = new IpcServerChannel(name);
ChannelServices.RegisterChannel(ipcChannel, false);

Where the name - the name of the channel.

The algorithm works with the channels, after creating the mutex will be:

If this is the first instance, it is necessary

• create a channel
• register a channel
• register the proxy type as a known type
• create a proxy and make a link to it through the address icp

If we have a second instance, then

• create a channel
• register a channel
  • obtain a proxy from the first instance
  • send data through a proxy

const string proxyObjectName = "WBRSingleInstanceProxy";
var proxyUri = "ipc://" + name + "/" + proxyObjectName;

if (isFirstInstance) {
    ipcChannel = new IpcServerChannel(name);
    ChannelServices.RegisterChannel(ipcChannel, false);

    RemotingConfiguration.RegisterWellKnownServiceType(typeof (SingleInstanceProxy), proxyObjectName,WellKnownObjectMode.Singleton);

    var enforcer = enforcerRetriever();

    if (enforcer == null)
       throw new InvalidOperationException("The method must return an ISingleInstanceEnforcer object.");

    proxy = new SingleInstanceProxy(enforcer);
    RemotingServices.Marshal(proxy, proxyObjectName);
}
else {
    ipcChannel = new IpcClientChannel();
    ChannelServices.RegisterChannel(ipcChannel, false);

    proxy = (SingleInstanceProxy) Activator.GetObject(typeof (SingleInstanceProxy), proxyUri);

    proxy.Enforcer.OnNewInstanceCreated(new EventArgs());
}

Transmission and message processing

Determine the uniqueness and originality of the program in memory will run at, so in Program.cs.

private static void Main(params string[] args) {
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);

    SingleInstanceTracker tracker = null;
    try {
       tracker = new SingleInstanceTracker("SingleInstanceSample", GetSingleInstanceEnforcer);
       if (tracker.IsFirstInstance)
          Application.Run((MainForm) tracker.Enforcer);
       else
          tracker.SendMessageToFirstInstance(args);
    }
    catch (SingleInstancingException ex) {
        MessageBox.Show("Could not create a SingleInstanceTracker object:\n" + ex.Message + "\nApplication will now terminate.");
        return;
    }
   finally {
        if (tracker != null)
            tracker.Dispose();
   }
}

private static ISingleInstanceEnforcer GetSingleInstanceEnforcer() {
     return new MainForm();
}

First, try to create a tracker to determine its uniqueness. If the process is alreadyrunning previously, passing the parameters of this process using the SendMessageToFirstInstance.

Processing of this message will occur at the application form (for simplicity). The form must implement the interface ISingleInstanceEnforcer.

void ISingleInstanceEnforcer.OnMessageReceived(MessageEventArgs e) {
    OnMessageReceivedInvoker invoker = delegate(MessageEventArgs eventArgs) {
        var msg = eventArgs.Message as string[];
        if (msg == null) return;
        listBox1.Items.Clear();
        listBox1.Items.AddRange(msg);
    };

    if (InvokeRequired)
         Invoke(invoker, e);
    else
         invoker(e);
}

In the delegate defined actions that must be take when receiving a message. In life, there will need to use a template “command manager”, so you can pretty handle different messages.

WCF approach

The second way we favor the use of the WCF service. It will be an indicator of the primary instance and the method for sending messages. We again need the visual design and WCF library.

WCF service wrapper can work so many things and can be applied to almost any situation when you have to organize the interaction between parts of a program or between programs. That’s what Windows Communication Service, and to think about it.

To work within a single machine will be used Binding NetNamedPipeBinding. Ideally suited for our task, as a named pipe can be a very easy and there is.

We start from a distance of some semblance of Command Manager. For simplicity, all the same it will be a static class. And yes, in this case, start with the second problem, data.

public static class ActionManager {
    public static Action<string[]> ItemsAction;
}

We now make the registration of this action on the main form. Or in a more complicated case in ViewModel.

public partial class Form1 : Form {
    public Form1() {
       InitializeComponent();
       ActionManager.ItemsAction = array => {
                          listBox1.Items.Clear();
                          listBox1.Items.AddRange(array);
                       };
    }
}

ТNow for the actual implementation of the WCF service. The project is already the default template Service1, it can be freely renamed or leave as is, without any damage. I renamed it SingleInstanceService.

The service so far there is only one method that will accept a string array.

[ServiceContract]
public interface ISingleInstanceService {
    [OperationContract]
    void SomeArgs(params string[] args);
}

public class SingleInstanceService : ISingleInstanceService {
    public void SomeArgs(params string[] args) {
         ActionManager.ItemsAction(args);
    }
}

That’s the whole service. There will be no more than a single line of code! In fact, we all built to the acceptance and processing of data. Now we must learn to pass them. This functionality will be placed in Program.cs.

First will have to specify a unique name for the channel. Then, create a host for WCFservice. We can say that setting the WCF service is a fully manual mode. When you create a service specify which class is the main functionality..

var address = new Uri("net.pipe://localhost/WBRSingleInstanceService");

var serviceHost = new ServiceHost(typeof (SingleInstanceService), address);

Next, specify the binding. It will be named pipes. Here you can specify the behavior of the binding, the maximum waiting time, buffer size and stuff like that.

var binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None);

var localMbehave = new ServiceMetadataBehavior();

serviceHost.Description.Behaviors.Add(localMbehave);

The next step is to create the endpoints. At the beginning of the development will create two points: one service MEX, in order to be able to configure a service reference. Another would be the end point of the service. After setting up and in the final release MEX point can be removed.

serviceHost.AddServiceEndpoint(typeof (IMetadataExchange), MetadataExchangeBindings.CreateMexNamedPipeBinding(), "mex");
serviceHost.AddServiceEndpoint(typeof (ISingleInstanceService), binding, address);

serviceHost.Open();

Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());

serviceHost.Close();

After run the service and do not forget to close it after the end of the application. Now we must create a link to the service. Run the application without debug Ctrl-F5 and add a link to the service.

Trying to drive a service address, which we have indicated in the code and click “GO”. It should look something like in the picture.

Select the namespace for the service and finish the job with this dialog box. Done!

We can now solve the first problem, the uniqueness of the service. Just try to join him by creating client-side.

var client = new SingleInstanceServiceClient("NetNamedPipeBinding_ISingleInstanceService");
client.SomeArgs(args);

If this fails, then just complete the application, if not, then create a new host. If it is not carried out the operation will be an exception of type SomeArgsEndpointNotFoundException, which clearly indicates that the host is not running.

That’s all folks!

How to verify that everything works

In the first method, all checked OK by pressing a button on the form, then creates a process and there is an exchange of information.

In the second method is not a trick when you run into laminates debug. I guess the whole reason for this is correct but it is too lazy in this example. The main thing that it works, and check it out as follows. Go to the folder bin, where the application has already been collected. Do link to an executable file and the label in the properties of Target after the path to the file write anything you want.

Run the main file, then run through the same label and see that the main application to update the data.

Conclusion

In my opinion the second method is much simpler to create and operate. In an improved version of the second method can not pass a set of arguments from the command line and have formed their own team, which will handle the primary copy. It is also the service itself is richer, all typed and transparently, that comes and where sent.

For both methods is to write a good team manager, that there is no rigid bundles with fiber interface for instance

Source code of the first example, the second example.

Hard’n’heavy!