<serviceHostingEnvironment aspNetCompatibilityEnabled="true" />

[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

public class Calc : ICalc

<system.serviceModel>

  <client>

    <endpoint name="calcEndpoint"

              address="http://localhost/IISHost/Service1.svc"

              binding="basicHttpBinding"

              contract="Contarcts.ICalc"/>

  </client>

  <bindings>

    <basicHttpBinding>

      <binding allowCookies="true">

      </binding>

    </basicHttpBinding>

  </bindings>

</system.serviceModel>

public class Printer

{

    private PrintSystemJobInfo _systemJobinfo;

    private int _jobId;

    private const string DEFAULT_PRINT_QUEUE = "default";

    public Printer(int jobId, string printerName = DEFAULT_PRINT_QUEUE)

    {

        _jobId = jobId;

        PrintQueue queue;

        if (printerName == DEFAULT_PRINT_QUEUE)

        {

            queue = LocalPrintServer.GetDefaultPrintQueue();

        }

        else

        {

            PrintServer server = new PrintServer();

            queue = server.GetPrintQueue(printerName);

            if (queue == null)

            {

                throw new ArgumentException("printerName: " + printerName);

            }

        }

        _systemJobinfo = queue.GetJob(_jobId);

    }

    public void Pause()

    {

        _systemJobinfo.Pause();

    }

    public void Resume()

    {

        _systemJobinfo.Resume();

    }

}

static void Main(string[] args)

{

    WMI.JubSent += WMI_JubSent;

    WMI.Enable = true;

    Console.ReadLine();

}

static void WMI_JubSent(object sender, GenericEventArgs<int> e)

{

    Printer printer = new Printer(e.Data);

    printer.Pause();

}

namespace Contracts

{

    [ServiceContract(CallbackContract = typeof(IStockClient))]

    public interface IStockService

    {

        [OperationContract(IsOneWay = true)]

        void Regisetr(string stockName);

    }

}

namespace Contracts

{

    [ServiceContract]

    public interface IStockClient

    {

        [OperationContract(IsOneWay = true)]

        void GetResult(IEnumerable<StockResponce> results);

    }

}

<system.serviceModel>

  <services>

    <service name="Service.StockService">

      <endpoint address="http://localhost:1245/Stock"

                binding="wsDualHttpBinding"

                contract="Contracts.IStockService"></endpoint>

    </service>

  </services>

</system.serviceModel>

static void Main(string[] args)

{

    var factory = new DuplexChannelFactory<IStockService>(ClientCallback.Instance, "stock");

    IStockService proxy = factory.CreateChannel();

    while (true)

    {

        Console.Write("Register: ");

        string stock = Console.ReadLine();

        proxy.Regisetr(stock);

    }

}

public class ClientCallback : IStockClient

{

    #region Singelton

    #endregion

    public void GetResult(IEnumerable<StockResponce> results)

    {

        Console.WriteLine("================");

        Console.WriteLine("Result: " + DateTime.Now.ToLongTimeString());

        foreach (var item in results)

        {

            Console.WriteLine(item);

        }

        Console.WriteLine("================");

    }

}

public class StockService : IStockService

{

    private static Dictionary<IStockClient, List<string>> _list;

public void Regisetr(string stockName)

{

    var client = OperationContext.Current.GetCallbackChannel<IStockClient>();

    if (!_list.ContainsKey(client))

    {

        _list.Add(client, new List<string>());

    }

    if (!_list[client].Contains(stockName))

    {

        _list[client].Add(stockName);

    }

}

private static Timer _timer;

Rss20FeedFormatter rss20 = new Rss20FeedFormatter();

XmlReader reader = XmlReader.Create("http://blogs.microsoft.co.il/blogs/shlomo/rss.aspx");

rss20.ReadFrom(reader);

Atom10FeedFormatter atom = new Atom10FeedFormatter();

XmlReader reader = XmlReader.Create("http://blogs.microsoft.co.il/blogs/shlomo/atom.aspx");

atom.ReadFrom(reader);

[OperationContract(IsOneWay = true)]

void SaveChanges(Person person);

namespace Contarcts

{

    [ServiceContract]

    public interface IPlay

    {

        [OperationContract]

        Stream GetSong(string name);

    }

}

namespace Service

{

    public class Play : IPlay

    {

        public Stream GetSong(string name)

        {

            FileStream stream = File.OpenRead(@"C:\tmp\" + name + ".wav");

            return stream;

        }

    }

}

<system.serviceModel>

  <services>

    <service name="Service.Play">

      <endpoint address="http://localhost:3333/play"

                binding="basicHttpBinding"

                bindingConfiguration="httpStream"

                contract="Contarcts.IPlay">

      </endpoint>

    </service>

  </services>

  <bindings>

    <basicHttpBinding>

      <binding name="httpStream"

                maxReceivedMessageSize="2147483647"

                transferMode="StreamedResponse">

      </binding>

    </basicHttpBinding>

  </bindings>

</system.serviceModel>

<system.web>

  <httpRuntime maxRequestLength="2147483647"/>

</system.web>

static void Main(string[] args)

{

    ChannelFactory<IPlay> channel = new ChannelFactory<IPlay>("playEndpoint");

    IPlay proxy = channel.CreateChannel();

    using (Stream stream = proxy.GetSong(Console.ReadLine()))

    {

        SoundPlayer mp = new SoundPlayer(stream);

        mp.Play();

        Console.ReadLine();

    }

}

<system.serviceModel>

  <client>

    <endpoint name="playEndpoint"

              address=http://localhost:3333/play

              binding="basicHttpBinding"

              contract="Contarcts.IPlay"/>

  </client>

  <bindings>

    <basicHttpBinding>

      <binding transferMode="StreamedResponse"

                maxReceivedMessageSize="2147483647">

      </binding>

    </basicHttpBinding>

  </bindings>

</system.serviceModel>

receiveTimeout="00:10:00"

public Stream GetFile(string name)

{

    return File.Open(name, FileMode.Open);

}

using (Stream stream = proxy.GetFile(Console.ReadLine()))

{

    byte[] bytes = new byte[1024];

    int count = 0;

    while ((count = stream.Read(bytes, 0, 1024)) > 0)

    {

        Console.WriteLine(count);

    }

    Console.ReadLine();

}

<binding name="httpStream"

          maxReceivedMessageSize="2147483647"

          transferMode="StreamedResponse">

  <readerQuotas maxBytesPerRead="2048" />

</binding>

namespace Contarcts

{

    [ServiceContract]

    public interface IFileWorker

    {

        [OperationContract]

        [WebGet]

        Stream DownloadFile(string fileName);

        [OperationContract]

        [WebInvoke(Method = "POST", UriTemplate = "UploadFile?fileName={fileName}")]

        void UploadFile(string fileName, Stream fileContents);

    }

}

namespace Service

{

    public class FileWorker : IFileWorker

    {

        public Stream DownloadFile(string fileName)

        {

            WebOperationContext.Current.OutgoingResponse.Headers["Content-Disposition"] =

                    "attachment; filename=" + fileName;

            return File.Open(fileName, FileMode.Open);

        }

        public void UploadFile(string fileName, Stream fileContents)

        {

            using (FileStream fs = File.OpenWrite(fileName))

            {

                byte[] bytes = new byte[1024];

                int count = 0;

                while ((count = fileContents.Read(bytes, 0, 1024)) > 0)

                {

                    fs.Write(bytes, 0, count);

                }

            }

        }

    }

}

<system.serviceModel>

  <services>

    <service name="Service.FileWorker" behaviorConfiguration="filemt">

      <endpoint binding="webHttpBinding" behaviorConfiguration="webHttp"

                address="http://localhost:3333/file"

                bindingConfiguration="httpAllStream"

                contract="Contarcts.IFileWorker"></endpoint>

    </service>

  </services>

  <bindings>

    <webHttpBinding>

      <binding name="httpAllStream"

                maxReceivedMessageSize="2147483647"

                receiveTimeout="00:10:00"

                transferMode="Streamed">

      </binding>

    </webHttpBinding>

  </bindings>

  <behaviors>

    <serviceBehaviors>

      <behavior name="filemt">

        <serviceMetadata httpGetEnabled="true" httpGetUrl="http://localhost:3333/filemt" />

        <serviceDebug includeExceptionDetailInFaults="true"/>

      </behavior>

    </serviceBehaviors>

    <endpointBehaviors>

      <behavior name="webHttp">

        <webHttp faultExceptionEnabled="true" />

      </behavior>

    </endpointBehaviors>

  </behaviors>

</system.serviceModel>

public static class WMI

{

private static ManagementEventWatcher _printEventWatcher;

private static double? _queryInterval;

public static event EventHandler<GenericEventArgs<int>> JubSent;

private static double QueryInterval

{

    get

    {

        if (_queryInterval == null)

        {

            double result;

            if (double.TryParse(ConfigurationManager.AppSettings["QueryInterval"], out result))

            {

                _queryInterval = result;

            }

            else

            {

                _queryInterval = 0.001;

            }

        }

        return _queryInterval.Value;

    }

}

private static string PrintJobQuery

{

    get

    {

        return "SELECT * FROM __InstanceCreationEvent WITHIN " +

                QueryInterval +

                " WHERE TargetInstance ISA \"Win32_PrintJob\"";

    }

}

static WMI()

{

    _printEventWatcher = new ManagementEventWatcher();

    _printEventWatcher.Query = new EventQuery(PrintJobQuery);

    _printEventWatcher.Scope = new ManagementScope("\\\\" + Dns.GetHostName() + "\\root\\CIMV2");

    _printEventWatcher.EventArrived += _printEventWatcher_EventArrived;

}

private static void _printEventWatcher_EventArrived(object sender, EventArrivedEventArgs e)

{

    if (JubSent != null)

    {

        OnJobSent(e);

    }

}

private static void OnJobSent(EventArrivedEventArgs e)

{

    int jobId = int.Parse(GetValue(e, "JobId").ToString());

    var args = new GenericEventArgs<int>(jobId);

    JubSent.Invoke(null, args);

}

private static object GetValue(EventArrivedEventArgs e, string key)

{

    object val = ((ManagementBaseObject)e.NewEvent.Properties["TargetInstance"].Value).Properties[key].Value;

    return val;

}

private static bool _enable;

public static bool Enable

{

    get

    {

        return _enable;

    }

    set

    {

        if (value)

            _printEventWatcher.Start();

        else

            _printEventWatcher.Stop();

        _enable = value;

    }

}

private string GetHtml(string url)

{

    WebClient client = new WebClient();

    string str = client.DownloadString(url);

    return str;

}

private HTMLDocumentClass GetDocument(string url)

{

    var docClass = new HTMLDocumentClass();

    IHTMLDocument2 iDoc = (IHTMLDocument2)docClass;

    object html = GetHtml(url);

    iDoc.write(html);

    return docClass;

}

var doc = GetDocument(GetUrl(1));

var header = (HTMLHeaderElementClass)doc.getElementById("h1ElementId");

string hedaerText = header.innerText;