A problem occurred when Windows tried to activate. Error Code 0x8007232A “DNS Server Failure”

Activations errors are explained in the page: https://support.microsoft.com/kb/938450

It seems that the machine cannot locate a KMS server (or in my case that the server has been installed with a “wrong” product key) If you have MSDN subscription you can workaround this problem by setting the product key with this command line:

slmgr –ipk <Product-key> (e.g. slmgr -ipk J3X3X-XY3XX-XX3XX-3XXXX-XX3XX)

And then activate the key in the “Control Panel\System and Security\System”

"Server Manager encountered an unexpected error while collecting data about the status of this computer" when clicking in the detail link it said something like

"Cannot open an anonymous level security token. (Exception from HRESULT: 0x80070543)"

I have encountered this error a couple of times . I guess it is some configuration it gets changed when installing some products.

I tried many diagnostic tools and un/reinstalling some KB hotfixes that some forums recommended, I also installed the SP2 but at the end the solution was simpler (at least for my case) (extracted from https://social.technet.microsoft.com/Forums/en-US/winservermanager/thread/f80a52fc-b022-4dd4-af35-621f1e7fe67c/#page:1):

From an elevated* cmd window run:

Dcomcnfg.exe

*Or click through the UAC prompt

2. Choose ComponentServices->Computers->My Computer.

3. Choose Properties from the context menu.

4. Choose the Default Properties tab.

5. Select Connect in the Default Authentication Level drop down list if it is set to None. Choose OK, confirm selection in popup and close dcomcnfg.exe.

6. If the authentication level is not set to None, don't change it, since it may have been set by something else (such as an Admin).

Regards,

David

I've already seen the 100$ formula in other projects and I really like it.
To spend your virtual 100$ go to Grigori's blog.

Here are my 100$

20$ Make possible to have a centralized configurations for many applications. (Now you can do it but all the logs are written into the same file, the event log end up in the same source) The desired effect would be to have a central configuration file but each application have a unique event log source, each application have a log file...
30$ Make easier and document how to extend the application block. The GAT/GAX addins are great to create new AB and some providers. But if you want to Add/remove some of the functionality you need to code some not documented methods/classes and debug the code to see how EntLib works under the hood.
30$ Policy Injecton AB. Enhance the non-intrusive injection. Implement an interface or deriving from MarshalByRefObject is very restricitive.Maybe Dynamic types can help here...
20$ Make Data Access AB compatible with Entity Framework.

You can also record a video, within the game...

It is incredible all the funcionality that offers Silverlight with a plugin of 4.5 MB (WCF, Drawing, DataBinding, Linq ....) But what is even more incredible is the productivity you get right from the beggining. A .Net programmer doesn't have a deep learning curve and can accomplish many tasks within minutes.

The first Silverlight component I decided to do was a simple rotator (I know there are tons of them and very good ones) but I wanted to do my own and make it configurable so I could set the images by using the InitParameters. All of the things I needed to know where on the video tutorials.

The only glitch was finding a free hosting site to make my silverlight component public. Some hosting sites are not prepared to host Silverlight, why? Since Silverlight is just a .xap file that gets downloaded to the client and the plugins executes it. Theoretically you only need a web server to host a file and an html/php/asp.net (you name it) file to embed the SL control. Well, the problem is the xap extension, some hosting sites ban any "unkown" extension, and some doesn't have configured the MIME type for it. Therefore you end up thinking that the hosting site cannot host SL2 or that SL2 sucks. Read on ...

There is a codeplex article about writing an httphandler to bypass the hosting "type check" https://www.codeproject.com/KB/silverlight/XamlWithoutMime.aspx but of course this will only work in asp.net enabled sites.Read on ...

Well some people think a .xap file is some obscure binary file that only MS can understand, but in many places it is said that a .xap file is just a zip file that contains two files (a xaml manifest and a dll assembly) zip file??? What if I rename the xap file into zip, change the html code to tell that my SL2 control is in a zip file and then I upload it to a "Silverlight not prepared" hosting site. IT WORKS. Here is the proof!

https://www.geocities.com/dhdiez/PhotoRotatorTestPage5.html

The html code to host the app is here:

<body>

<!-- Runtime errors from Silverlight will be displayed here.

<div id='errorLocation' style="font-size: small;color: Gray;"></div>

<div id="silverlightControlHost">

<object data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="100%" height="100%">

<param name="initparams" value="imagen1=https://www.geocities.com/dhdiez/images/rw1.jpg,

imagen16=https://www.geocities.com/dhdiez/images/rw16.jpg" />

<param name="source" value="ClientBin/PhotoRotator.zip"/>

<param name="onerror" value="onSilverlightError" />

<param name="background" value="white" />

<param name="minRuntimeVersion" value="2.0.31005.0" />

<param name="autoUpgrade" value="true" />

<a href="https://go.microsoft.com/fwlink/?LinkID=124807" style="text-decoration: none;">

<img src="https://go.microsoft.com/fwlink/?LinkId=108181" alt="Get Microsoft Silverlight" style="border-style: none"/>

</a>

</object>

<iframe style='visibility:hidden;height:0;width:0;border:0px'></iframe>

</div>

</body>

https://channel9.msdn.com/pdc2008/

Here we can see the presentation of Windows Azure, Windows 7, Visual Studio 10, Team Foundation, Silverlight, C# 4.0, Office 14, Live services, Paralell Computing Platform ...

But there is not much fuss about that Windows 3.11 is going to be discontinued in embedded in 3 months (November 1st 2008) ... 16 years after its release!

John Coyne's Embedded Blog : It's the End for 3.11!!

Well if we pay a little bit of attention, by default in VS2008 there is no right button over the project -> "Add Web Reference". There is a "Add Service Reference" (without Web) that means it is using a Reference to a service no matter which protocol is using (This is something not enough stressed a Service doesn't imply to be a web service).

This Service Reference is in fact a WCF proxy (if we look to the .config file we can see that after adding a Service Reference  can see a section called system.serviceModel, bindings and so on.

If we need to create a classic "old style" web reference we still have the option to do so ... just look at this 50" video....

(In order to see a high-res video check SkyDrive: https://cid-ae1cb866e9c0b985.skydrive.live.com/self.aspx/Public/Classic-Web-Services-In-Visual-Studio-2008.wmv)

Video: Classic Web Services Reference in Visual Studio 2008

The direct link is here:

https://www.codeplex.com/entlibcontrib/SourceControl/DownloadSourceCode.aspx?changeSetId=18160 (Note that this is not a stable release)

If you are too lazy busy to download, open VS and compile you can download here the msi.

StrongNamingGuidancePackageSetup.msi

I really wanted to get to the new stuff about Linq and the .Net framework 3.5. But I got lost fiddling with the new UI, specially the new refactor functionality.

I really liked the "Organize Usings", which takes a file and removes all the unnecessary using clauses and order the rest of them. That is prety useful since some times you can see files that their using region is larger than the code inside, and most of them are just left overs of old code or some temporary test. It is really annoying to see so many usings since many times you end up analyzing the code or removing the using and compiling the project to check if it really being used. So, the fact is that you get distracted.

The only "but" to this utility is that it only does the job on a single file, instead of all the project or solution. So I decided to create an Ad-in so I could also test the extensibility of Visual Studio. I was really impressed that in less than two hours I had a working Add-in that removed and sorted all the using of the .cs files. You can find an attached RemoveAndSortAllusings.zip file with the code. Of course it is a really rough add-in and lots of things are missing, like using a custom Icon, or dealing with files in source control, but at least is a start.

using System;
using Extensibility;
using EnvDTE;
using EnvDTE80;
using Microsoft.VisualStudio.CommandBars;
using System.Resources;
using System.Reflection;
using System.Globalization;
using System.Windows.Forms;

namespace RemoveAndSortAllusings
{
    /// <summary>The object for implementing an Add-in.</summary>
    /// <seealso class='IDTExtensibility2' />
    public class Connect : IDTExtensibility2, IDTCommandTarget
    {
        /// <summary>Implements the constructor for the Add-in object. Place your initialization code within this method.</summary>
        public Connect()
        {
        }

        /// <summary>Implements the OnConnection method of the IDTExtensibility2 interface. Receives notification that the Add-in is being loaded.</summary>
        /// <param term='application'>Root object of the host application.</param>
        /// <param term='connectMode'>Describes how the Add-in is being loaded.</param>
        /// <param term='addInInst'>Object representing this Add-in.</param>
        /// <seealso class='IDTExtensibility2' />
        public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref Array custom)
        {
            _applicationObject = (DTE2)application;
            _addInInstance = (AddIn)addInInst;
            if(connectMode == ext_ConnectMode.ext_cm_UISetup)
            {
                object []contextGUIDS = new object[] { };
                Commands2 commands = (Commands2)_applicationObject.Commands;
                string toolsMenuName;

                try
                {
                    //If you would like to move the command to a different menu, change the word "Tools" to the 
                    //  English version of the menu. This code will take the culture, append on the name of the menu
                    //  then add the command to that menu. You can find a list of all the top-level menus in the file
                    //  CommandBar.resx.
                    string resourceName;
                    ResourceManager resourceManager = new ResourceManager("MyAddin2.CommandBar", Assembly.GetExecutingAssembly());
                    CultureInfo cultureInfo = new CultureInfo(_applicationObject.LocaleID);
                    
                    if(cultureInfo.TwoLetterISOLanguageName == "zh")
                    {
                        System.Globalization.CultureInfo parentCultureInfo = cultureInfo.Parent;
                        resourceName = String.Concat(parentCultureInfo.Name, "Tools");
                    }
                    else
                    {
                        resourceName = String.Concat(cultureInfo.TwoLetterISOLanguageName, "Tools");
                    }
                    toolsMenuName = resourceManager.GetString(resourceName);
                }
                catch
                {
                    //We tried to find a localized version of the word Tools, but one was not found.
                    //  Default to the en-US word, which may work for the current culture.
                    toolsMenuName = "Tools";
                }

                //Place the command on the tools menu.
                //Find the MenuBar command bar, which is the top-level command bar holding all the main menu items:
                Microsoft.VisualStudio.CommandBars.CommandBar menuBarCommandBar = ((Microsoft.VisualStudio.CommandBars.CommandBars)_applicationObject.CommandBars)["MenuBar"];

                //Find the Tools command bar on the MenuBar command bar:
                CommandBarControl toolsControl = menuBarCommandBar.Controls[toolsMenuName];
                CommandBarPopup toolsPopup = (CommandBarPopup)toolsControl;

                //This try/catch block can be duplicated if you wish to add multiple commands to be handled by your Add-in,
                //  just make sure you also update the QueryStatus/Exec method to include the new command names.
                try
                {
                    //Add a command to the Commands collection:
                    Command command = commands.AddNamedCommand2(_addInInstance, "RemoveAndSortAllUsings", "Remove and Sort ALL usings", "Executes the command to remove and sort all usings in cs files.", true, 213, ref contextGUIDS, (int)vsCommandStatus.vsCommandStatusSupported + (int)vsCommandStatus.vsCommandStatusEnabled, (int)vsCommandStyle.vsCommandStylePictAndText, vsCommandControlType.vsCommandControlTypeButton);

                    //Add a control for the command to the tools menu:
                    if((command != null) && (toolsPopup != null))
                    {
                        command.AddControl(toolsPopup.CommandBar, 1);
                    }
                }
                catch(System.ArgumentException)
                {
                    //If we are here, then the exception is probably because a command with that name
                    //  already exists. If so there is no need to recreate the command and we can 
                    //  safely ignore the exception.
                }
            }
        }

        /// <summary>Implements the OnDisconnection method of the IDTExtensibility2 interface. Receives notification that the Add-in is being unloaded.</summary>
        /// <param term='disconnectMode'>Describes how the Add-in is being unloaded.</param>
        /// <param term='custom'>Array of parameters that are host application specific.</param>
        /// <seealso class='IDTExtensibility2' />
        public void OnDisconnection(ext_DisconnectMode disconnectMode, ref Array custom)
        {
        }

        /// <summary>Implements the OnAddInsUpdate method of the IDTExtensibility2 interface. Receives notification when the collection of Add-ins has changed.</summary>
        /// <param term='custom'>Array of parameters that are host application specific.</param>
        /// <seealso class='IDTExtensibility2' />        
        public void OnAddInsUpdate(ref Array custom)
        {
        }

        /// <summary>Implements the OnStartupComplete method of the IDTExtensibility2 interface. Receives notification that the host application has completed loading.</summary>
        /// <param term='custom'>Array of parameters that are host application specific.</param>
        /// <seealso class='IDTExtensibility2' />
        public void OnStartupComplete(ref Array custom)
        {
        }

        /// <summary>Implements the OnBeginShutdown method of the IDTExtensibility2 interface. Receives notification that the host application is being unloaded.</summary>
        /// <param term='custom'>Array of parameters that are host application specific.</param>
        /// <seealso class='IDTExtensibility2' />
        public void OnBeginShutdown(ref Array custom)
        {
        }
        
        /// <summary>Implements the QueryStatus method of the IDTCommandTarget interface. This is called when the command's availability is updated</summary>
        /// <param term='commandName'>The name of the command to determine state for.</param>
        /// <param term='neededText'>Text that is needed for the command.</param>
        /// <param term='status'>The state of the command in the user interface.</param>
        /// <param term='commandText'>Text requested by the neededText parameter.</param>
        /// <seealso class='Exec' />
        public void QueryStatus(string commandName, vsCommandStatusTextWanted neededText, ref vsCommandStatus status, ref object commandText)
        {
            if(neededText == vsCommandStatusTextWanted.vsCommandStatusTextWantedNone)
            {
                if (commandName == "RemoveAndSortAllusings.Connect.RemoveAndSortAllUsings")
                {
                    status = (vsCommandStatus)vsCommandStatus.vsCommandStatusSupported|vsCommandStatus.vsCommandStatusEnabled;
                    return;
                }
            }
        }

        /// <summary>Implements the Exec method of the IDTCommandTarget interface. This is called when the command is invoked.</summary>
        /// <param term='commandName'>The name of the command to execute.</param>
        /// <param term='executeOption'>Describes how the command should be run.</param>
        /// <param term='varIn'>Parameters passed from the caller to the command handler.</param>
        /// <param term='varOut'>Parameters passed from the command handler to the caller.</param>
        /// <param term='handled'>Informs the caller if the command was handled or not.</param>
        /// <seealso class='Exec' />
        public void Exec(string commandName, vsCommandExecOption executeOption, ref object varIn, ref object varOut, ref bool handled)
        {
            handled = false;
            if(executeOption == vsCommandExecOption.vsCommandExecOptionDoDefault)
            {
                if (commandName == "RemoveAndSortAllusings.Connect.RemoveAndSortAllUsings")
                {
                    handled = true;

                    if (!_applicationObject.Solution.IsOpen)
                    {
                        MessageBox.Show("There is no solution to eliminate usings.");
                    }
                    else 
                    {
                        foreach (Project p in _applicationObject.Solution.Projects)
                        {
                            SearchInProject(p);
                        }
                    }

                    return;
                }
            }
        }

        private void SearchInProject(Project project)
        {
            SearchInProjectItem(project.ProjectItems);
        }

        private void SearchInProjectItem(ProjectItems projectItems)
        {
            if (projectItems == null)
            {
                return;
            }


            foreach (ProjectItem projectItem in projectItems)
            {
                //Eliminate the unnecessary using in cs files.
                if(projectItem.Name.EndsWith(".cs"))
                {
                    bool wasOpened = false;
                    if (projectItem.get_IsOpen(Constants.vsViewKindCode))
                    {
                        wasOpened = true;
                    }

                    Window w = projectItem.Open(Constants.vsViewKindCode);
                    w.Activate();
                    _applicationObject.ExecuteCommand("Edit.RemoveAndSort", "");

                    if (!wasOpened)
                    {
                        w.Close(vsSaveChanges.vsSaveChangesYes);
                    }
                    
                }
                
                
                if (projectItem.SubProject != null)
                {
                    SearchInProject(projectItem.SubProject);
                }
                else
                {
                    SearchInProjectItem(projectItem.ProjectItems);
                }
            }
        }


        private DTE2 _applicationObject;
        private AddIn _addInInstance;
    }
}

RemoveAndSortAllusings.zip