namespace WorkerRole1

open System.Diagnostics
open System.Net
open System.Threading
open Microsoft.WindowsAzure
open Microsoft.WindowsAzure.ServiceRuntime
open Microsoft.WindowsAzure.StorageClient

type WorkerRole() =
    inherit RoleEntryPoint()

    // This is a sample worker implementation. Replace with your logic.
    let log message kind = Trace.WriteLine(message, kind)

    override wr.Run() =

        log "WorkerRole1 entry point called" "Information"

        let connectionStringName = "MyConnectionString"
        let storageAccount =
CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting(connectionStringName))
        let queueClient = storageAccount.CreateCloudQueueClient()
        let queue = queueClient.GetQueueReference("myqueue")

        ignore <| queue.CreateIfNotExist()
        let mutable sleepTime = 1000
        while(true) do
            Thread.Sleep(sleepTime)

            let message = CloudQueueMessage("Hello, World")
            queue.AddMessage(message)
            log "add new message" "Information"
            let queueSize = queue.RetrieveApproximateMessageCount()
            sleepTime <- if queueSize > 3 then
                                sleepTime + 100
                            else
                                max (sleepTime / 2) 1

            let msg = sprintf "Current Sleep time is %A" sleepTime
            log msg "Information"

    override wr.OnStart() =

        // Set the maximum number of concurrent connections
        ServicePointManager.DefaultConnectionLimit <- 12

        // For information on handling configuration changes
        // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
        base.OnStart()

namespace ConsumerRole

open System.Diagnostics
open System.Net
open System.Threading
open Microsoft.WindowsAzure
open Microsoft.WindowsAzure.ServiceRuntime
open Microsoft.WindowsAzure.StorageClient

type WorkerRole() =
    inherit RoleEntryPoint()

    // This is a sample worker implementation. Replace with your logic.

    let log message kind = Trace.WriteLine(message, kind)

    override wr.Run() =
        log "ConsumerRole entry point called" "Information"
        let connectionStringName = "MyConnectionString"
        let storageAccount =
CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting(connectionStringName))
        let queueClient = storageAccount.CreateCloudQueueClient()
        let queue = queueClient.GetQueueReference("myqueue")
        ignore <| queue.CreateIfNotExist()

        while(true) do
            Thread.Sleep(200)
            // Peek at the next message
            let peekedMessage = queue.PeekMessage()
            if (peekedMessage <> null) then
                let msg = queue.GetMessage()
                log msg.AsString "Information"
                queue.DeleteMessage(msg)
            else
                log "no message" "Information"
                ()

    override wr.OnStart() =
        // Set the maximum number of concurrent connections
        ServicePointManager.DefaultConnectionLimit <- 12

        // For information on handling configuration changes
        // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
        base.OnStart()

Data contract interfaces for loan and payment information

/// Record for LoanInformation
[<DataContract>]
type LoanInformation =
    { [<DataMember>] mutable Amount : double
      [<DataMember>] mutable InterestRateInPercent : double
      [<DataMember>] mutable TermInMonth : int }

/// Record for PaymentInformation
[<DataContract>]
type PaymentInformation =
    { [<DataMember>] mutable MonthlyPayment : double
      [<DataMember>] mutable TotalPayment : double }

Service contract interface

[<ServiceContract>]
type public ILoanCalculator =
    /// Use Record to send and receive data
    [<OperationContract>]
    abstract Calculate : a:LoanInformation -> PaymentInformation

namespace WCFWorker

open System
open System.Collections.Generic
open System.Linq
open System.Text
open LoanCalculatorContracts
open System.ServiceModel
open System.Runtime.Serialization

[<ServiceBehavior(AddressFilterMode = AddressFilterMode.Any)>]
type public LoanCalculatorImplementation() =

    member this.Calculate(loan : LoanInformation) = (this :> ILoanCadulator).Calculate
loan

    interface ILoanCalculator with
        override this.Calculate(loan : LoanInformation) =
            let monthlyInterest = Math.Pow((1.0 + loan.InterestRateInPercent / 100.0), 1.0
/ 12.0)
 - 1.0
            let num = loan.Amount * monthlyInterest
            let den = 1.0 - (1.0 / (Math.Pow(1.0 + monthlyInterest, (double)loan.
TermInMonth)))
            let monthlyPayment = num / den

            let totalPayment = monthlyPayment * (double)loan.TermInMonth
            let paymentInformation  = {MonthlyPayment = monthlyPayment;
                                            TotalPayment = totalPayment}

            paymentInformation

namespace WCFWorker

open System
open System.Collections.Generic
open System.Diagnostics
open System.Linq
open System.Net
open System.Threading
open Microsoft.WindowsAzure
open Microsoft.WindowsAzure.Diagnostics
open Microsoft.WindowsAzure.ServiceRuntime
open Microsoft.WindowsAzure.StorageClient
open System.ServiceModel
open System.Runtime.Serialization
open LoanCalculatorContracts

type WorkerRole() as this =
    inherit RoleEntryPoint()

    [<DefaultValue>]
    val mutable serviceHost : ServiceHost

    member private this.CreateServiceHost() =

        this.serviceHost <- new ServiceHost(typeof<LoanCalculatorImplementation>)
        let binding = new NetTcpBinding(SecurityMode.None)
        let externalEndPoint =
                 RoleEnvironment.CurrentRoleInstance.InstanceEndpoints.["WCFEndpoint"]
        let endpoint = String.Format("net.tcp://{0}/LoanCalculator",
                                             externalEndPoint.IPEndpoint)
        this.serviceHost.AddServiceEndpoint(typeof<ILoanCadulator>, binding, endpoint)
        |> ignore

        this.serviceHost.Open()

    override wr.Run() =
        while (true) do
                Thread.Sleep(10000)
                Trace.WriteLine("Working", "Information")

    override wr.OnStart() =

        // Set the maximum number of concurrent connections
        ServicePointManager.DefaultConnectionLimit <- 12

        // For information on handling configuration changes
        // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
        this.CreateServiceHost()
        base.OnStart()

namespace Microsoft.Samples.ServiceHosting.Thumbnails

open System
open System.Collections.Generic
open System.Configuration
open System.Diagnostics
open System.Drawing
open System.IO
open System.Text
open System.Linq
open System.Net
open Microsoft.WindowsAzure
open Microsoft.WindowsAzure.Diagnostics
open Microsoft.WindowsAzure.ServiceRuntime
open Microsoft.WindowsAzure.StorageClient

type public WorkerRole() =
    inherit RoleEntryPoint()
    [<DefaultValue>]
    val mutable width : int

    [<DefaultValue>]
    val mutable height : int

    [<DefaultValue>]
    val mutable configSetter : string * bool -> unit

    // function to create thumbnail from a stream
    member private this.CreateThumbnail( input : Stream ) =
        let orig = new Bitmap(input)

        if (orig.Width > orig.Height) then
            this.width <- 128
            this.height <- 128 * orig.Height / orig.Width
        else
            this.height <- 128
            this.width <- 128 * orig.Width / orig.Height

        let thumb = new Bitmap(this.width,this.height)

        use graphic = Graphics.FromImage(thumb)
        graphic.InterpolationMode <-
            System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic
        graphic.SmoothingMode <- System.Drawing.Drawing2D.SmoothingMode.AntiAlias
        graphic.PixelOffsetMode <- System.Drawing.Drawing2D.PixelOffsetMode.HighQuality

        graphic.DrawImage(orig, 0, 0, this.width, this.height)

        let ms = new MemoryStream()
        thumb.Save(ms,System.Drawing.Imaging.ImageFormat.Jpeg)
        ms.Seek(0L,SeekOrigin.Begin) |> ignore
        ms
    override this.OnStart() =
        // This code sets up a handler to update CloudStorageAccount
        // instances when their corresponding
        // configuration settings change in the service configuration file.
        CloudStorageAccount.SetConfigurationSettingPublisher(
            new Action<string,Func<string,bool>>(
                fun (configName:string) (configSetter:Func<string,bool>) ->
                    // Provide the configSetter with the initial value
                    configSetter.Invoke(
                        RoleEnvironment.GetConfigurationSettingValue(configName)) |>
ignore
                    RoleEnvironment.Changed.Add(
                        fun (arg : RoleEnvironmentChangedEventArgs) ->
                            let c =
                                arg.Changes.OfType<RoleEnvironmentConfigurationSettingCha
nge>()
                            if (c.Any(fun n -> n.ConfigurationSettingName = configName))
then
                                let cN = RoleEnvironment.GetConfigurationSettingValue(con
figName)
                                if (not (configSetter.Invoke(cN))) then
                                    // In this case, the change to storage account
credentials in
                                    // service configuration is significant enough that
the role
                                    // needs to be recycled in order to use the latest
settings.
                                    // (for example, the endpoint has changed)
                                    RoleEnvironment.RequestRecycle()
                        )
        ))

        base.OnStart()

    override this.Run() =
        let storageAccount =
            CloudStorageAccount.Parse(
                RoleEnvironment.GetConfigurationSettingValue("DataConnectionString"))
        let blobStorage = storageAccount.CreateCloudBlobClient()
        let container = blobStorage.GetContainerReference("photogallery")

        let queueStorage = storageAccount.CreateCloudQueueClient()
        let queue = queueStorage.GetQueueReference("thumbnailmaker")

        Trace.TraceInformation("Creating container and queue...")

        // If the Start() method throws an exception, the role recycles.
        // If this sample is run locally and development storage tool has not been
started, this
        // can cause a number of exceptions to be thrown because roles are restarted
repeatedly.
        // Let's try to create the queue and the container and
        // check whether the storage services are running at all.
        let mutable containerAndQueueCreated = false
        while(not containerAndQueueCreated) do
            try
                container.CreateIfNotExist() |> ignore
                let mutable permissions = container.GetPermissions()
                permissions.PublicAccess <- BlobContainerPublicAccessType.Container

                container.SetPermissions(permissions)
                permissions <- container.GetPermissions()
                queue.CreateIfNotExist() |> ignore
                containerAndQueueCreated <- true

            with
            | :? StorageClientException as e ->
                    if (e.ErrorCode = StorageErrorCode.TransportError) then
                        Trace.TraceError(
                            String.Format(
                                "Connect failure! The most likely reason is that the local
"+
                                "Development Storage tool is not running or your storage
account
 configuration is incorrect. "+
                                "Message: '{0}'", e.Message))
                        System.Threading.Thread.Sleep(5000)

                    else
                        raise e

        Trace.TraceInformation("Listening for queue messages...")

        // Now that the queue and the container have been created
        // in the preceding initialization process, get messages
        // from the queue and process them individually.
        while (true) do
            try
                let msg = queue.GetMessage()
                if (box(msg) <> null) then
                    let path = msg.AsString
                    let thumbnailName = System.IO.Path.GetFileNameWithoutExtension(path) +
".jpg"
                    Trace.TraceInformation(String.Format("Dequeued '{0}'", path))
                    let content = container.GetBlockBlobReference(path)
                    let thumbnail = container.GetBlockBlobReference("thumbnails/" +
thumbnailName)
                    let image = new MemoryStream()

                    content.DownloadToStream(image)

                    image.Seek(0L, SeekOrigin.Begin) |> ignore
                    thumbnail.Properties.ContentType <- "image/jpeg"
                    thumbnail.UploadFromStream(this.CreateThumbnail(image))

                    Trace.TraceInformation(String.Format("Done with '{0}'", path))

                    queue.DeleteMessage(msg)
                else
                    System.Threading.Thread.Sleep(1000)

            // Explicitly catch all exceptions of type StorageException here
            // because we should be able to
            // recover from these exceptions next time the queue message,
            // which caused this exception,
            // becomes visible again.
            with
            | _ as e ->
                                System.Threading.Thread.Sleep(5000)
                                Trace.TraceError(
                                    String.Format(
                                        "Exception when processing queue item. Message:
'{0}'",
                                            e.Message))

create table Log (
    ID int not null primary key,
    Event varchar(50),
    Description varchar(2500))

insert into Log Values(1,'Info', 'starting...')
insert into Log Values(2,'Info', 'working...')
insert into Log Values(3,'Info', 'end')

#if INTERACTIVE
#r "System.Data"
#r "System.Data.Entity"
#r "FSharp.Data.TypeProviders"
#endif

open System.Data
open System.Data.Entity
open Microsoft.FSharp.Data.TypeProviders

[<Literal>]
let conString = """Server=tcp:<server name>.database.windows.net,1433;Database=SetupLog;User
 ID=<user id>;Password=<password>;Trusted_Connection=False;Encrypt=True;Connection
Timeout=30"""

// You can use Server Explorer to build your ConnectionString.
type internal SqlConnection =
    Microsoft.FSharp.Data.TypeProviders.SqlEntityConnection<ConnectionString = conString>
let internal db = SqlConnection.GetDataContext()
// query the log table
let internal table = query {
    for r in db.Log do
    select r
    }

// print the log information
for p in table do
    printfn "[%d] %s: %s" p.ID p.Event p.Description

Execution result

[1] Info: starting...
[2] Info: working...
[3] Info: end

/// rank selection method
let RankSelection (population:ChromosomeType list) fitnessFunction=
    let populationSize = Seq.length population
    let r() = randomF() % populationSize
    let randomSelection() =
        let c0 = population.[r()]
        let c1 = population.[r()]
        let result = if (c0.Fitness(fitnessFunction) > c1.Fitness(fitnessFunction)) then
c0 else
c1
        result.Clone()
    Seq.init populationSize (fun _ -> randomSelection())

/// shuffle crossover
let ShuffleCrossover (c0:ChromosomeType) (c1:ChromosomeType) =
    let crossover c0 c1 =
        let isEven n = n%2 = 0
        let randomSwitch (x, y) = if isEven (randomF()) then (x, y) else (y, x)
        List.zip c0 c1 |> List.map randomSwitch |> List.unzip
    let (first, second) = crossover (c0.Genos) (c1.Genos)
    c0.Genos <- first
    c1.Genos <- second

/// Evolutionary computation module
/// this module is for Genetic Algorithm (GA) only
module EvolutionaryComputation

    /// random number generator
    let random = new System.Random((int)System.DateTime.Now.Ticks)

    /// random int generator
    let randomF() = random.Next()

    /// random float (double) generator
    let randomFloatF() = random.NextDouble()

    /// Chromesome type to represent the individual involves in the GAs
    type ChromosomeType(f, size, ?converters) =
        let initialF = f
        let mutable genos = [for i in 1..size do yield f()]
        let mutable genoPhenoConverters = converters

        /// make a duplicate copy of this chromosome
        member this.Clone() =
            let newValue =
                match converters with
                    | Some(converters) -> new ChromosomeType(initialF, size, converters)
                    | None -> new ChromosomeType(initialF, size)
            newValue.Genos <- this.Genos
            newValue

        /// get fitness value with given fitness function
        member this.Fitness(fitnessFunction) = this.Pheno |> fitnessFunction

        /// gets and sets the Geno values
        member this.Genos
            with get() = genos
            and set(value) = genos <- value

        /// gets and sets the Pheno values
        member this.Pheno
            with get() =
                match genoPhenoConverters with
                | Some(genoPhenoConverters) ->
                    List.zip genoPhenoConverters genos |> List.map (fun (f,value) -> f
value)
                | None -> this.Genos

        /// mutate the chromosome with given mutation function
        member this.Mutate(?mutationF) =
            let location = random.Next(Seq.length this.Genos)
            let F =
                match mutationF with
                    | Some(mutationF) -> mutationF
                    | None -> f
            let transform i v =
                match i with
                    | _ when i=location -> F()
                    | _ -> v
            this.Genos <- List.mapi transform this.Genos

    /// generate a population for GAs
    let Population randomF populationSize chromosomeSize =
        [for i in 1..populationSize do yield (new
ChromosomeType(f = randomF, size = chromosomeSize))]

    /// find the maximum fitness value from a population
    let maxFitness population fitnessF =
        let best = Seq.maxBy (fun (c:ChromosomeType) -> c.Fitness(fitnessF)) population
        best.Fitness(fitnessF)

    /// find the most fit individual
    let bestChromosome population fitnessF =
        let best = Seq.maxBy (fun (c:ChromosomeType) -> c.Fitness(fitnessF)) population
        best

    /// rank selection method
    let RankSelection (population:ChromosomeType list) fitnessFunction=
        let populationSize = Seq.length population
        let r() = randomF() % populationSize
        let randomSelection() =
            let c0 = population.[r()]
            let c1 = population.[r()]
            let result = if (c0.Fitness(fitnessFunction) > c1.Fitness(fitnessFunction))
then c0
else c1
            result.Clone();
        Seq.init populationSize (fun _ -> randomSelection())

    /// shuffle crossover
    let ShuffleCrossover (c0:ChromosomeType) (c1:ChromosomeType) =
        let crossover c0 c1 =
            let isEven n = n%2 = 0
            let randomSwitch (x,y) = if isEven (randomF()) then (x,y) else (y,x)
            List.zip c0 c1 |> List.map randomSwitch |> List.unzip
        let (first,second) = crossover (c0.Genos) (c1.Genos)
        c0.Genos <- first
        c1.Genos <- second

    /// evolve the whole population
    let Evolve (population:ChromosomeType list) selectionF crossoverF fitnessF
crossoverRate
mutationRate elitism =
        let populationSize = Seq.length population
        let r() = randomF() % populationSize
        let elites = selectionF population fitnessF |> Seq.toList
        let seq0 = elites |> Seq.mapi (fun i element->(i,element)) |> Seq.filter (fun
(i,_)->i%2=0) |> Seq.map (fun (_,b)->b)
        let seq1 = elites |> Seq.mapi (fun i element->(i,element)) |> Seq.filter (fun
(i,_)->i%2<>0) |> Seq.map (fun (_,b)->b)
        let xoverAndMutate (a:ChromosomeType) (b:ChromosomeType) =
            if (randomFloatF() < crossoverRate) then
                crossoverF a b
            if (randomFloatF() < mutationRate) then
                a.Mutate()
            if (randomFloatF() < mutationRate) then
                b.Mutate()
            [a] @ [b]

        if elitism then
            let seq0 = seq0
            let seq1 = seq1
            let r = Seq.map2 xoverAndMutate seq0 seq1 |> List.concat
            r.Tail @ [  bestChromosome population fitnessF ]
        else
            Seq.map2 xoverAndMutate seq0 seq1 |> List.concat

    /// composite function X times
    let rec composite f x =
         match x with
            | 1 -> f
            | n -> f >> (composite f (x-1))

    /// convert a function seq to function composition
    let compositeFunctions functions =
         Seq.fold ( >> ) id functions

open EvolutionaryComputation

// define the loci function to set each building block on the chromosome
let lociFunction() = box(random.Next(10))

// define the fitness (target) function
let fitnessF (items:obj list) =
    items |> Seq.map (System.Convert.ToInt32) |> Seq.sum

// initialize the population
let myPopulation = Population lociFunction 50 10

// evolve the population with rank selection, shuffle crossover (90%)
// mutation rate = 10% and elitism = true
let myEvolve population = Evolve population RankSelection ShuffleCrossover fitnessF 0.9
0.1
true

// evolve the population 75 times
let result = composite myEvolve 75 myPopulation

// print out the best fitness value which is the solution to the target function
printfn "%A" (maxFitness result fitnessF)

<configuration>
  <system.serviceModel>
    <services>
      <service name="Microsoft.ServiceBus.Samples.EchoService">
        <endpoint contract="Microsoft.ServiceBus.Samples.IEchoContract"
binding="netTcpRelayBinding" />
      </service>
    </services>
    <extensions>
      <bindingExtensions>
        <add name="netTcpRelayBinding"
type="Microsoft.ServiceBus.Configuration.NetTcpRelayBindingCollectionElement, Microsoft.
ServiceBus,
Version=1.7.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
      </bindingExtensions>
    </extensions>
  </system.serviceModel>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0" />
  </startup>
</configuration>

// Learn more about F# at http://fsharp.net
namespace Microsoft.ServiceBus.Samples

open System

open Microsoft.ServiceBus
open System.ServiceModel
[<ServiceContract(
    Name = "IEchoContract",
    Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")>]
type IEchoContract = interface
    [<OperationContract>]
    abstract member Echo : msg:string -> string
end

type IEchoChannel = interface
    inherit IEchoContract
    inherit IClientChannel
end

[<ServiceBehavior(
    Name = "EchoService",
    Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")>]
type EchoService() = class
    interface IEchoContract with
        member this.Echo(msg) =
            printfn "%s" msg
            msg
end

module Program =

    [<EntryPoint>]
    let Main(args) =
        let serviceNamespace = "testservicebus0"
        let issuerName = "owner"
        let issuerSecret = "<your account key>";

        // create the service credential
        let sharedSecretServiceBusCredential = TransportClientEndpointBehavior()
        sharedSecretServiceBusCredential.TokenProvider <-
            TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);

        // set up the service host
        let address = ServiceBusEnvironment.CreateServiceUri("sb",
                                                                        serviceNamespace,
                                                                        "EchoService");
        let host = new ServiceHost(typeof<EchoService>, address);
        let serviceRegistrySettings = new ServiceRegistrySettings(DiscoveryType.Public);

        // setup endpoints
        for endpoint in host.Description.Endpoints do
            endpoint.Behaviors.Add(serviceRegistrySettings);
            endpoint.Behaviors.Add(sharedSecretServiceBusCredential)

        // open the service host
        host.Open();
        Console.WriteLine("Service address: " + address.ToString());
        Console.WriteLine("Press [Enter] to exit");
        Console.ReadLine() |> ignore

        // close the host service
        host.Close()

        0

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <system.serviceModel>
    <client>
      <endpoint name="RelayEndpoint" contract="Microsoft.ServiceBus.Samples.IEchoContract"
binding="netTcpRelayBinding" />
    </client>
    <extensions>
      <bindingExtensions>
        <add name="netTcpRelayBinding"
type="Microsoft.ServiceBus.Configuration.NetTcpRelayBindingCollectionElement,
Microsoft.ServiceBus, Version=1.7.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
/>
      </bindingExtensions>
    </extensions>
  </system.serviceModel>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0" />
  </startup>
</configuration>

// Learn more about F# at http://fsharp.net

namespace Microsoft.ServiceBus.Samples

open System
open Microsoft.ServiceBus;
open System.ServiceModel;

[<ServiceContract(
    Name = "IEchoContract",
    Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")>]
type IEchoContract = interface
    [<OperationContract>]
    abstract member Echo : msg:string -> string
end

type IEchoChannel = interface
    inherit IEchoContract
    inherit IClientChannel
end

module Program =

    [<EntryPoint>]
    let Main(args) =

        ServiceBusEnvironment.SystemConnectivity.Mode <- ConnectivityMode.AutoDetect;

        let serviceNamespace = "testServiceBus0"
        let issuerName = "owner"
        let issuerSecret = "<your account key>";

        let serviceUri = ServiceBusEnvironment.CreateServiceUri("sb",

serviceNamespace,
                                                                           "EchoService");
        let sharedSecretServiceBusCredential = new TransportClientEndpointBehavior();
        sharedSecretServiceBusCredential.TokenProvider <-
            TokenProvider.CreateSharedSecretTokenProvider(issuerName, issuerSecret);

        let channelFactory = new ChannelFactory<IEchoChannel>(
                                           "RelayEndpoint",
                                           new EndpointAddress(serviceUri));
        channelFactory.Endpoint.Behaviors.Add(sharedSecretServiceBusCredential);

        let channel = channelFactory.CreateChannel();
        channel.Open();

        Console.WriteLine("Enter text to echo (or [Enter] to exit):");
        let mutable input = Console.ReadLine();
        while (input <> String.Empty) do
            try
                Console.WriteLine("Server echoed: {0}", channel.Echo(input));
            with
            | _ as e->
                Console.WriteLine("Error: " + e.Message);
            input <- Console.ReadLine();

        channel.Close();
        channelFactory.Close();

        0