<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
  <env:Header>
    <!-- the mustUnderstand attribute's value indicates
         that this header is mandatory -->
    <ns:Foo xmlns:ns="http://msdn.microsoft.com/hows"
            env:mustUnderstand="1">
      <ns:Baz>Some info...</ns:Baz>
    </ns:Foo>
  </env:Header>
  <env:Body>
    •••
  </env:Body>
</env:Envelope>

// This class represents a SOAP header
[XmlRoot("Foo", Namespace="http://msdn.microsoft.com/hows")]
public class Foo : SoapHeader
{
  public string Baz;
}

public class SampleService : WebService
{
  // If a SOAP message's Header element includes a {http://
  // msdn.microsoft.com/hows}Foo element, it will be deserialized into 
  // this field before the target message runs
  Foo foo;

  // The [SoapHeader] attribute tells the message dispatcher to use the 
  // field foo to deserialize the appropriate header if it appears; the 
  // dispatcher uses reflection to determine which header (if any) to map 
  // to foo
  [WebMethod]
  [SoapHeader("foo")]
  public string Bar()
  {
    StringBuilder sb = new StringBuilder("Bar method ran, ");

    // The Bar method can access the foo field when it runs; if the 
    // request message did not include
    // a {http://msdn.microsoft.com/hows}Foo header, foo will be null
    if (this.foo != null)
      sb.Append("foo is null");
    else
      sb.Append(string.Format("foo.Baz is {0}", foo.Baz));
    return sb.ToString();
  }
}

[WebMethod]
[SoapHeader("foo")]
public string Bar()
{
  StringBuilder sb = new StringBuilder("Bar method ran, ");

  if (this.foo != null)
    sb.Append("foo is null");
  else
  {
    // Note that the generated string now includes
    // information about whether header was mandatory or optional
    sb.Append(string.Format("foo.Baz is {0} and {1}",
                            foo.Baz, foo.MustUnderstand ?
                            "mandatory" : "optional"));
  }

  return sb.ToString();
}

[WebMethod]
[SoapHeader("foo")]
public string Bar()
{
  StringBuilder sb = new StringBuilder("Bar method ran, ");

  if (this.foo != null)
    sb.Append("foo is null");
  else
  {
    sb.Append(string.Format("foo.Baz is {0} and {1}",
                            foo.Baz, foo.MustUnderstand ?
                            "mandatory" : "optional"));

    // tell dispatcher that mandatory header
    // was understood so plumbing doesn't generate a fault
    if (foo.MustUnderstand)
      foo.DidUnderstand = true;
  }

  return sb.ToString();
}

public class SampleService : WebService
{
  Foo foo;

  // array to hold unknown headers
  SoapUnknownHeader unknownHeaders[];

  // second SoapHeader attribute tells the message dispatcher to map all 
  // headers except Foo to unknown headers array
  [WebMethod]
  [SoapHeader("foo")]
  [SoapHeader("unknownHeaders")]
  public string Bar()
  {
    // check all expected headers and mark as understood
    if (foo != null && foo.MustUnderstand)
      foo.DidUnderstand = true;

    // check all unexpected headers and fail if any are mandatory
    foreach(SoapUnknownHeader header in unknownHeaders)
    {
      // if a header is mandatory...
      if (header.MustUnderstand)
      {
        // build string describing problem
        string err = string.Format(
          "Mandatory header: {{{0}}}{1}",
          header.Element.NamespaceURI,
          header.Element.LocalName);

        // throw mustUnderstand fault, as required by SOAP specification
        throw new SoapException(err,
          new XmlQualifiedName("mustUnderstand",
          "http://schemas.xmlsoap.org/soap/envelope/"));
      }
    }

    // do actual work after header processing is done

    StringBuilder sb = new StringBuilder("Bar method ran, ");

    if (this.foo != null)
      sb.Append("foo is null");
    else
      sb.Append(string.Format("foo.Baz is {0} and {1}",
                              foo.Baz, foo.MustUnderstand ?
                              "mandatory" : "optional"));

    return sb.ToString();
  }
}

// MustUnderstandExtension checks for unknown mandatory
// headers and generates a fault if any are found
public class MustUnderstandExtension : SoapExtension
{
  public override object GetInitializer(Type serviceType)
  { return null; }

  public override object GetInitializer(
                      LogicalMethodInfo methodInfo,
                      SoapExtensionAttribute attribute)
  { return null; }

  public override void Initialize(object initializer) {}

  // ProcessMessage looks for message headers and
  // and handles unknown mandatory headers correctly
  public override void ProcessMessage(SoapMessage message)
  {
    switch(message.Stage)
    {
      // process headers after they've been deserialized
      // into data members   
      case SoapMessageStage.AfterDeserialize:
      {
        foreach(SoapHeader header in message.Headers)
        {
          if (header.GetType() != typeof(SoapUnknownHeader))
          {
            // if header is *known* (e.g., Foo), mark it as understood
            header.DidUnderstand = true;
          }
          else if (header.MustUnderstand)
          {
            // if header is of *unknown* AND mandatory, generate a fault
            SoapUnknownHeader unknownHeader = (SoapUnknownHeader) header;
            string err = string.Format(
              "Mandatory header: {{{0}}}{1}",
              unknownHeader.Element.NamespaceURI, 
              unknownHeader.Element.LocalName);
            throw new SoapException(err,
              new XmlQualifiedName("mustUnderstand",
              "http://schemas.xmlsoap.org/soap/envelope/"
              ));
          }
        }
      }
      break;
    }
  }
}

[WebMethod]
[SoapHeader("foo")]
public string Bar()
{
  StringBuilder sb = new StringBuilder("Bar method ran, ");

  if (this.foo != null)
    sb.Append("foo is null");
  else
  {
    // Note that the generated string now includes information about 
    // whether header was mandatory or optional
    sb.Append(string.Format("foo.Baz is {0} and {1}",
                            foo.Baz, foo.MustUnderstand ?
                            "mandatory" : "optional"));
  }

  return sb.ToString();
}

public class MustUnderstandInputFilter : SoapInputFilter
{
  public override void ProcessMessage(SoapEnvelope msg)
  {
    // create and initialize namespace manager for XPath engine
    XmlNamespaceManager namespaces = new XmlNamespaceManager(msg.NameTable);
    namespaces.AddNamespace("soap", 
        "http://schemas.xmlsoap.org/soap/envelope/");

    // look in message for any mandatory header element
    XmlNode node = msg.SelectSingleNode(
      "/soap:Envelope/soap:Header/*[@soap:mustUnderstand
       [. = '1' or . = 'true']]", namespaces);

    // if any mandatory headers are found, generate a fault
    if (node != null)
    {
      string err = string.Format("Mandatory header: {{{0}}}{1}",
        node.NamespaceURI, node.LocalName);
      throw new SoapException(err, new XmlQualifiedName("mustUnderstand",
        "http://schemas.xmlsoap.org/soap/envelope/"));
    }
  }
}