If you want to know if your device works with your new Surface RT, check Windows Hardware Compatibility List for Windows RT.

https://www.microsoft.com/en-us/windows/compatibility/winrt/CompatCenter/Home

https://sorokoletov.com/ztop/

https://wp7reviews.tomverhoeff.com/

If you want to see the metrics for ranking and download reports, https://www.distimo.com is a good resource.

If you have not used it, download it here. https://visualstudiogallery.msdn.microsoft.com/d0d33361-18e2-46c0-8ff2-4adea1e34fef/

https://blogs.msdn.com/b/microsoft_press/archive/2010/10/28/free-ebook-programming-windows-phone-7-by-charles-petzold.aspx

https://www.guidingtech.com/4535/windows-7-keyboard-shortcut/

I think I have a good grasp of the concept, this is how I can explain how dependency property and Attached Property works.

Dependency Property

This is WPF property system, even though this is a property, it is not the same as regular property. The properties are not stored in an internal field, but it is stored in an internal storage system that stores per-instance value of the property.

The dependency property is a public static read-only field that must be registered first. After it has been registered, this static property is used to get and set the value in the internal storage system.

Attached Property

This is also dependency property. The internal storage system takes a DependencyProperty as key to get and set value. Attached property allows an object to to store a value using key that belongs to another class.

Imagine WPF property system is a property bag, and the property bag can take any kind of values. In most cases, the key for this property bag is defined in the class itself, but for attached property, the key is defined in other class.

To illustrate:

Imagine a person represents a class with dependency property. Let says his name is John. Whenever a dependency property is set, John writes this property in his notebook. When the property value is requested, he reads the note and return the value. John can only writes value for the property that he knows.

Now, imagine there is another person, Jane. She has her notebook, and she has a note, that one property in her notebook is also an attached property. The meaning of this property is relevant only for Jane, but everyone can keep it in their notebook. Everyone in the office knows about the attached properties.

John is assigned a property value, and he notices that this is value is for a property belongs to Jane and it is an attached property. He does not know what to do, but because this is an attached property, he writes it down in his notebook.

Jane asked John, if he has a value for a property which she understands, John reads his notebook, and give Jane the value. Based on that, Jane can do something.

Now replace John with Button class, Jane with Grid class, and the attached property with Grid.Row and Grid.Column.

This post shows a quick tutorial on how to expose a WCF service as a REST service, using IIS. This post assumes that there is already a working service called Foo, with one method that returns FooData. Just add a WCF service within Visual Studio.

[ServiceContract]
public interface IFoo
{
    [OperationContract]
    FooData GetFooData();
}

[DataContract]
public class FooData
{
    [DataMember]
    public string Data { get; set; }
}

public class Foo : IFoo
{
    public FooData GetFooData()
    {
        return new FooData() { Data = "You Had Me at Hello World." };
    }
}
<configuration>
  <system.serviceModel>
    <services>
      <service behaviorConfiguration="FooBehavior" name="Foo">
        <endpoint address="" binding="wsHttpBinding" contract="IFoo">
          <identity>
            <dns value="localhost" />
          </identity>
        </endpoint>
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="FooBehavior">
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="false" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

To expose a REST interface of that service, these are the steps:

1. Decorate the method with WebGet or WebInvoke attribute (in System.ServiceModel.Web.

   [ServiceContract]
   public interface IFoo
   {
       [OperationContract]
       [WebGet(UriTemplate="GetFooData")]
       FooData GetFooData();
   }

2. Update the configuration
   1. Add endpointBehaviors.

      <endpointBehaviors>
        <behavior name="web">
          <webHttp />
        </behavior>
      </endpointBehaviors>

   2. Update the endPoint by changing the binding to webHttpBinding, and add behaviorConfiguration to the endPoint node to point to the endpointBehavior from step 1.

      <endpoint address="" binding="webHttpBinding" behaviorConfiguration="web" contract="IFoo">

At the end, this is the final configuration looks like.

</configuration>
  <system.serviceModel>
    <services>
      <service behaviorConfiguration="FooBehavior" name="Foo">
        <endpoint address="" binding="webHttpBinding" behaviorConfiguration="web" contract="IFoo">
          <identity>
            <dns value="localhost" />
          </identity>
        </endpoint>
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
      </service>
    </services>
    <behaviors>
      <endpointBehaviors>
        <behavior name="web">
          <webHttp />
        </behavior>
      </endpointBehaviors>
      <serviceBehaviors>
        <behavior name="FooBehavior">
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="false" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

It is done. Now open your browser and point it to your REST url (the .svc uri + the method name as specified in UriTemplate attribute (GetFooData in this example). https://localhost:8081/Foo.svc/GetFooData, and you will get:

That’s it. Two simple steps, and you have a REST interface for your WCF service.

For complex events (more than 3 lines of code), I create a separate method. If the method is short, I use anonymous method. But if the event is just one line, I use lambda expression.

private void button1_Click(object sender, EventArgs e)
{
    MessageBox.Show("Hello World!");
}

private void Form1_Load(object sender, EventArgs e)
{
    //This is good for complex events.
    button1.Click += button1_Click;
    //Anonymous method, suitable for short event.
    button2.Click += delegate(object obj, EventArgs arg)
    {
        MessageBox.Show("Hello World!");
    };
    //Lambda expression, great for one line event.
    button3.Click += ((x, y) => MessageBox.Show("Hello World!"));
}

That is an interesting question, since ‘Everyone’ can be replaced with ‘Authenticated Users’, ‘Network Service’, etc.

First, if you need only to give Everyone read-only access permission, the easiest thing is to set the DACL property of Win32_SecurityDescriptor to null. This is not equal with an array of null. An array of null will lock everyone out from this share.

ManagementObject secDescriptor = new ManagementClass(new ManagementPath("Win32_SecurityDescriptor"), null);
secDescriptor["ControlFlags"] = 4; //SE_DACL_PRESENT 
secDescriptor["DACL"] = null; 

If you need to be more explicit, or you need to assign other security principal different access, that method above will not work. As soon as you assign someone access to the share, ‘Everyone’ will lose its read access.

To assign the permission explicitly, the key is to form the correct Win32_Trustee to represent that special account (Network Service, Everyone, Authenticated Users, etc.). Take a look at System.Security.Principal.WellKnownSidType enum. It has a number of well known sid that you might be interested with.

What needs to be done is to assign the SID property of the Win32_Trustee object with the security identifier derived from the well known sid.

Let assume you have this method:

private byte[] GetWellKnwonSid(WellKnownSidType SidType)
{
    SecurityIdentifier Result = new SecurityIdentifier(SidType, null);
    byte[] sidArray = new byte[Result.BinaryLength];
    Result.GetBinaryForm(sidArray, 0);

    return sidArray;
}

Then when Win32_Trustee object is created, assign the SID property as follow:

ManagementObject Trustee = new ManagementClass(new ManagementPath("Win32_Trustee"), null);
Trustee["SID"] = GetWellKnwonSid(WellKnownSidType.WorldSid); 

That code above will create Win32_Trustee for ‘Everyone’. Use this Win32_Trustee to form the Win32_Ace, and you now explicitly assign ‘Everyone’ access to your share.