The asmx can be accessed at: http://myserver/_vti_bin/TaxonomyClientService.asmx

Not surprisingly, it exposes the bare minimum for clients to access the data and display them. Clients won’t be able to manipulate the data with the APIs exposed. Following are the methods exposed:

• AddTerms
• GetChildTermsInTerm
• GetChildTermsInTermSet
• GetKeywordTermsByGuids
• GetTermSets
• GetTermsByLabel

So, to get going, we’ll need to add the service reference to the asmx in the Visual Studio project. Once done, it can be accessed using its SOAP client.

Once the web reference has been added, a proxy to the service can be created:

<p>public static TaxonomywebserviceSoapClient CreateProxy(string siteUrl) <br />{ <br />        BasicHttpBinding basicHttpBinding = default(BasicHttpBinding); <br />        TaxonomywebserviceSoapClient proxy = null; <br />        try <br />        { <br />            basicHttpBinding = GetBasicHttpBinding();</p> <p>            // The endpoints are setup towards the sub website which should be searched <br />            EndpointAddress endpoint = new EndpointAddress(siteUrl +  <br />                                                              &quot;/_vti_bin/TaxonomyClientService.asmx&quot;); <br />            proxy = new TaxonomywebserviceSoapClient(basicHttpBinding, endpoint);</p> <p>            // We go under impersonation and current networkcredentials <br />            // to sharepoint services. <br />            proxy.ClientCredentials.Windows.AllowedImpersonationLevel =  <br />                                                                TokenImpersonationLevel.Impersonation; <br />            proxy.ClientCredentials.Windows.ClientCredential =  <br />                                                           CredentialCache.DefaultNetworkCredentials; <br />        } <br />        catch (Exception ex) <br />        { <br />            EventLog.WriteEntry(ex.Message + ex.StackTrace); <br />        } <br />        <br />        return proxy; <br />}</p> <p>private static BasicHttpBinding GetBasicHttpBinding() <br />{ <br />        BasicHttpBinding basicHttpBinding = new BasicHttpBinding(); <br />        try <br />        { <br />            basicHttpBinding.Security.Mode = <br />                                                     BasicHttpSecurityMode.TransportCredentialOnly; <br />            basicHttpBinding.MaxBufferSize = 2097152; <br />            basicHttpBinding.MaxBufferPoolSize = 2097152; <br />            basicHttpBinding.MaxReceivedMessageSize = 2097152; <br />            basicHttpBinding.ReaderQuotas.MaxStringContentLength = 65536; <br />            //Security can be set to Windows. Ntlm, None, Digest, Certificate or Basic <br />            basicHttpBinding.Security.Transport.ClientCredentialType = <br />                                                                              HttpClientCredentialType.Ntlm; <br />        } <br />        catch (Exception ex) <br />        { <br />            EventLog.WriteEntry(&quot;TaxonomyViewer&quot;, &quot;ex.Message + ex.StackTrace); <br />            throw; <br />        } <br />        return basicHttpBinding; <br />}</p>

Once the proxy is there for the web service, we can use the Client Object Model to fetch the SchemaXML containing all the info about the managed metadata field. The SchemaXML looks something like this:

<Field Type="TaxonomyFieldType" DisplayName="MMColumn1" List="{821fc609-d88a-4b4f-9edc-36c7054ea8b6}" WebId="7368b749-307f-40c6-b20b-406410cfe056"
       ShowField="Term1033" Required="FALSE" EnforceUniqueValues="FALSE" ID="{6e71ecab-32e8-4fe2-86ea-023aa32a3386}"
       SourceID="{78f88b4b-d2c1-4e9c-bcc9-514816471c03}" StaticName="MMColumn1" Name="MMColumn1" ColName="int1" RowOrdinal="0" Version="1">
  <Default>6;#ChildTerm111|03389ff4-33b4-4ff8-9ac1-e9621a8ee77a</Default>
  <Customization>
    <ArrayOfProperty>
      <Property>
        <Name>SspId</Name>
        <Value xmlns:q1="http://www.w3.org/2001/XMLSchema" p4:type="q1:string" xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">ba1108c5-2fae-4cda-bb89-a00953f73993</Value>
      </Property>
        <Name>TermSetId</Name>
        <Value xmlns:q2="http://www.w3.org/2001/XMLSchema" p4:type="q2:string" xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">2db8b15a-2f1d-4e67-b6c5-53d49be53726</Value>
      </Property>
      <Property>
        <Name>IsKeyword</Name>
        <Value xmlns:q8="http://www.w3.org/2001/XMLSchema" p4:type="q8:boolean" xmlns:p4="http://www.w3.org/2001/XMLSchema-instance">false</Value>
      </Property>
      …
    </ArrayOfProperty>
  </Customization>
</Field>

Important things to note above are:

1. FieldType: TaxonomyFieldType for a single value field or TaxonomyFieldTypeMulti for a multi-value field
2. SspId: TermStore Guid
3. TermSetId: Term Set Guid

So, now we use the client OM to get the above into action

public static Field GetField(string siteUrl, string strList, string strField)
{
    try
    {
        ClientContext clientContext = new ClientContext(siteUrl);
        List oList = clientContext.Web.Lists.GetByTitle(strList);

        clientContext.Load(oList, f => f.Fields);
        clientContext.ExecuteQuery();

        clientContext.Load(oList.Fields, fs => fs.Include( f => f.Title,
                                                      f => f.TypeAsString, f => f.SchemaXml));
        clientContext.ExecuteQuery();

        Field oField = null;
        foreach (Field field in oList.Fields)
        {
            if (field.Title.Equals(strField, StringComparison.InvariantCultureIgnoreCase))
            {
                oField = field;
                break;
            }
        }

        return oField;
    }
    catch (Exception ex)
    {
            EventLog.WriteEntry(ex.Message + ex.StackTrace);
    }

    return null;
}

SchemaXML obtained above can be used to get the terms in the term set.

void TestTermSets(TaxonomywebserviceSoapClient service, Guid termStoreId, Guid termSetId)
    {
        string sXmlTimeStamp;
        XNode xnSspIds = new XElement("sspIds", new XElement("sspId", termStoreId));
        XNode xnTermSetIds = new XElement("termSetIds", new XElement("termSetId", termSetId));
        XNode xnDateTimes = new XElement("dateTimes", new XElement("dateTime", (new DateTime(1900, 1, 1)).ToString("s")));
        XNode xnVersions = new XElement("versions", new XElement("version", 0));

        try
        {
            string sXml;
            Stopwatch watch = new Stopwatch();

            sXml = service.GetTermSets(xnSspIds.ToString(SaveOptions.DisableFormatting),
                    xnTermSetIds.ToString(SaveOptions.DisableFormatting),
                    CultureInfo.GetCultureInfo("en-US").LCID,
                    xnDateTimes.ToString(SaveOptions.DisableFormatting),
                    xnVersions.ToString(SaveOptions.DisableFormatting),
                    out sXmlTimeStamp);
        }
        catch (Exception ex)
        {
              EventLog.WriteEntry(ex.Message + ex.StackTrace);
        }
    }

The XML returned contains all the info one needs for the term set.

<TermStore>
  <T a9="e93dc490-6d97-42e4-8b14-8b0c63e4e693" a21="false" a61="0">
    <LS>
      <TL a32="Term1" a31="true" />
    </LS>
    <DS />
    <TMS>
      <TM a24="bb58a4cf-0b70-4c71-a319-261da6b13e5f" a12="TermSet1" a40="" a17="true" a67="" a45="e93dc490-6d97-42e4-8b14-8b0c63e4e693" a69="true" />
    </TMS>
  </T>
  <T a9="ddaac853-68a4-46ee-b91c-8182679f51b4" a21="false" a61="0">
    <LS>
      <TL a32="Term2" a31="true" />
    </LS>
    <DS />
    <TMS>
      <TM a24="bb58a4cf-0b70-4c71-a319-261da6b13e5f" a12="TermSet1" a40="" a17="true" a67="" a45="ddaac853-68a4-46ee-b91c-8182679f51b4" a69="true" />
    </TMS>
  </T>
  <T a9="9ac515de-6bfc-4d2e-9dba-d902e6d40539" a21="false" a61="0">
    <LS>
      <TL a32="Term3" a31="true" />
    </LS>
    <DS />
    <TMS>
      <TM a24="bb58a4cf-0b70-4c71-a319-261da6b13e5f" a12="TermSet1" a40="" a17="true" a67="" a45="9ac515de-6bfc-4d2e-9dba-d902e6d40539" />
    </TMS>
  </T>
</TermStore>

More info about the cryptic attributes are in the Microsoft Enterprise Managed Metadata Web Service Protocol Specification.

SOLUTION:

Algo:

1. Have start and end counter
2. First, increment end counter and keep on adding till sum exceeds target
3. Second, increment start counter and keep on decreseasing sum till sum becomes less than target
4. This way, keep on moving the counters till the required zone is narrowed down

#include "stdio.h"
#define SUMEQUALSTARGET(sum, target) \
    if ((sum) == (target))  \
    {                       \
            bFound == true; \
            break;          \
    }

int consecutiveSum(int target, int* psc, int* pec)
{
    int sum = 0, startCounter = 1, endCounter = 0;
    bool bFound = false;

    if (target <= 0)
    {
        printf("ERROR: Invalid target %d", target);
        return 0;
    }

    while (!bFound)
    {
        SUMEQUALSTARGET(sum, target);

        // increase the endCounter
        while (sum < target)
        {
            endCounter++;
            sum += endCounter;

            SUMEQUALSTARGET(sum, target);
            if (startCounter == endCounter)
            {
                break;
            }
        }

        // increase the startCounter
        while (sum > target)
        {
            sum -= startCounter;
            startCounter++;

            SUMEQUALSTARGET(sum, target);
            if (startCounter == endCounter)
            {
                break;
            }
        }
    }

    *psc = startCounter;
    *pec = endCounter;
    return sum;
}

int main()
{
    int startCounter = 0, endCounter = 0;

    for (int target = 1; target <= 50; target++)
    {
        if (!consecutiveSum(target, &startCounter, &endCounter))
        {
            printf("%s", "consecutiveSum failed for target=%d", target);
            return -1;
        }

        printf("%d\t", target);
        for (int i = startCounter; i <= endCounter; i++)
        {
            printf("%d ", i);
        }
        printf("\n");
    }

    return 0;
}

ANSWER: Algo:

1. Start from the first position. Find a random element for this position. Swap the current element at this first position with the found random element.
2. Repeat the process to the next element, swapping its contents with a randomly found element. Swapping ensures that no element is lost/overwritten.

    void ShuffleArray(int arr[], int size)
    {
        for (int i = 0; i < size; i++)
        {
            // find the random element for the ith array element
            int index = i + (rand() % (size - i));

            // now swap the two
            int temp   = arr[i];
            arr[i]     = arr[index];
            arr[index] = temp;
        }
    }

Solutions:

1. Run the XBAP application from the same URI as the host service (it can be a WCF service). So, if the WCF service is hosted at http://mydomain/myservice, then the XBAP should also run from http://mydomain/myXbapApp. Now, this basically means that both service and XBAP app are running from the same domain http://mydomain. Why this? Because, CLR identifies an object (application) through certain parameters, the site and URI being one of them. Hence, only if the XBAP app originates from the same domain, it will trust it. No wonder, when the XBAP app is run from the local machine, all works good, but the moment it is share out to a network share or copied around and then run, it fails with some security exception.

   For debugging purposes, one can also use the hack mentioned here, using the PresentationHost.exe to make it appear that the XBAP is indeed running from the same location as the service. But one cannot take this approach everytime as using another exe to launch the XBAP app is not a good idea.

2. Make the XBAP full-trust
   Ofcourse this calls for security implications, but if done with open eyes, it can be fine. It calls for making the XBAP application full-trust, either by Visual Studio->Project Settings->Security->FullTrust, or by editing the app.manifest and adding Unrestricted="true" in <PermissionSet> attribute.

   Once that is done, still the app won’t load in the browser as it won’t be granted full-trust just because it declares its self as full-trust! So, way out is to sign the application manifest with one’s own private key, then import that key to the browser as a Trusted Publisher and then run the application.

   Basically following steps are reqd:

   1. VisualStudio->ProjectProperties->Signing->SignClickOnceManifests->CreateTestCertificate->MoreDetails->CopyToFile->save the certificate to disk.
   2. VisualStudio->ProjectProperties->Signing->SignClickOnceManifests->SelectFromStore->select the test certificate
   3. Publish the app (VisualStudio->ProjectProperties->Publish) to any location like a network path.
   4. Browser (on the machine where you want to load the XBAP) –> Tools->Options->Content->Certificates->TrustedRootCertificationAuthorities->Import->add the private saved certificate
   5. Do the same for Browser->Tools->Options->Content->Certificates->TrustedPublishers also.
   6. Now running the XBAP will work! Why? Well, then the XBAP is loaded by the browser, its signature is validated the existing one in the store and it is certified as full-trust.

      A good pictorial representation of above step-by-step is shown here.

While this works, news is that in .Net 4.0, this will be available via a prompt mechanism, wherein, when the app declares itself as full-trust and tries to access a resource, a prompt will be thrown to the user to allow the action to take place. Let’s hope this comes soon!

S&y

In short, what is trust? According to Webster’s:

trust, n
Pronunciation: \ˈtrəst\
a: assured reliance on the character, ability, strength, or truth of someone or something b: one in which confidence is placed

So, simply elaborated as an example, a program running in the local disk has more trust than a program running over the network share for obvious reasons. Trust, thus, for a program can be defined at various levels: full, partial, low etc., each having its own nuances. A program developed and tested to run under full trust can fail completely when run under partial trust.

One should thus take care and look ahead when developing a program which might have to run under various scenarios: local, intranet or internet. A nice nifty article by Keith Brown explains the whole basics about trust and how to program around it. Here’s the link: Programming for Partial Trust

It paints a fair picture of this whole trust thing with various practical notes and examples. Nice read.