[C#]
＜%@ WebService Language=\"C#\" Class=\"PrimeFactorizer\" %＞

using System;
using System.Collections;
using System.Web.Services;

class PrimeFactorizer {

　[WebMethod]
　public long[] Factorize(long factorizableNum){
　　ArrayList outList = new ArrayList();
　　long i = 0;
　　int j;
　　try{
　　　long Check = factorizableNum;

　　　//Go through every possible integer
　　　//factor between 2 and factorizableNum / 2.
　　　//Thus, for 21, check between 2 and 10.
　　　for (i = 2; i ＜ (factorizableNum / 2); i++){
　　　　while(Check % i == 0){
　　　　　outList.Add(i);
　　　　　Check = (Check/i);
　　　　}
　　　}
　　　//Double-check to see how many prime factors have been added.
　　　//If none, add 1 and the number.
　　　j = outList.Count;
　　　if (j == 0) {
　　　　outList.Add(1);
　　　　outList.Add(factorizableNum);
　　　}
　　　j = outList.Count;

　　　//Return the results and
　　　//create an array to hold them.
　　　long[] primeFactor = new long[j];
　　　for (j = 0; j ＜ outList.Count; j++){
　　　　//Pass the values one by one, making sure
　　　　//to convert them to type ulong.
　　　　primeFactor[j] = Convert.ToInt64(outList[j]);
　　　}
　　　return primeFactor;
　　}
　　catch (Exception) {
　　　return null;
　　}
　}
}

[Visual Basic]
＜%@ WebService Class=\"PrimeFactorizer\" Language=\"VB\" %＞
Imports System
Imports System.Collections
Imports System.Web.Services

Public Class PrimeFactorizer
＜WebMethod＞ _
Public Function Factorize(factorizableNum As Long) As Long()
　Dim outList As New ArrayList()
　Dim i As Long = 0
　Dim j As Integer
　Try
　　Dim Check As Long = factorizableNum

　　\\\'Go through every possible integer
　　\\\'factor between 2 and factorizableNum / 2.
　　\\\'Thus, for 21, check between 2 and 10.
　　For i = 2 To CLng(factorizableNum / 2) - 1
　　　While Check Mod i = 0
　　　　outList.Add(i)
　　　　Check = CLng(Check / i)
　　　End While
　　Next i
　　\\\'Double-check to see how many prime factors have been added.
　　\\\'If none, add 1 and the number.
　　j = outList.Count
　　If j = 0 Then
　　　outList.Add(1)
　　　outList.Add(factorizableNum)
　　End If
　　j = outList.Count

　　\\\'Return the results and
　　\\\'create an array to hold them.
　　Dim primeFactor(j - 1) As Long
　　For j = 0 To outList.Count - 1
　　　\\\'Pass the values one by one, making sure
　　　\\\'to convert them to type ulong.
　　　primeFactor(j) = CLng(outList(j))
　　Next j
　　Return primeFactor
　Catch
　　Return Nothing
　End Try
End Function
End Class

public class PrimeFactorizer : System.Web.Services.Protocols.SoapHttpClientProtocol {

　public long[] Factorize(long factorizableNum) {
　　object[] results = this.Invoke(\"Factorize\", new object[] { factorizableNum});
　　　return ((long[])(results[0]));
　}

　public System.IAsyncResult BeginFactorize(long factorizableNum, System.AsyncCallback callback, object 　asyncState) {
　　return this.BeginInvoke(\"Factorize\", new object[] {
　　factorizableNum}, callback, asyncState);
　}

　public long[] EndFactorize(System.IAsyncResult asyncResult) {
　　object[] results = this.EndInvoke(asyncResult);
　　return ((long[])(results[0]));
　}
}

[C#]
using System;
using System.Runtime.Remoting.Messaging;
using MyFactorize;

class TestCallback
{
　public static void Main(){
　　long factorizableNum = 12345;
　　PrimeFactorizer pf = new PrimeFactorizer();

　　//Instantiate an AsyncCallback delegate to use as a parameter
　　//in the BeginFactorize method.
　　AsyncCallback cb = new AsyncCallback(TestCallback.FactorizeCallback);

　　// Begin the Async call to Factorize, passing in our
　　// AsyncCalback delegate and a reference
　　// to our instance of PrimeFactorizer.
　　IAsyncResult ar = pf.BeginFactorize(factorizableNum, cb, pf);

　　// Keep track of the time it takes to complete the async call
　　// as the call proceeds.
　　int start = DateTime.Now.Second;
　　int currentSecond = start;
　　while (ar.IsCompleted == false){
　　　if (currentSecond ＜ DateTime.Now.Second) {
　　　　currentSecond = DateTime.Now.Second;
　　　　Console.WriteLine(\"Seconds Elapsed...\" + (currentSecond - start).ToString() );
　　　}
　　}
　　// Once the call has completed, you need a method to ensure the
　　// thread executing this Main function
　　// doesn\\\'t complete prior to the call-back function completing.
　　Console.Write(\"Press Enter to quit\");
　　int quitchar = Console.Read();
　}
　// Set up a call-back function that is invoked by the proxy class
　// when the asynchronous operation completes.
　public static void FactorizeCallback(IAsyncResult ar)
　{
　　// You passed in our instance of PrimeFactorizer in the third
　　// parameter to BeginFactorize, which is accessible in the
　　// AsyncState property.
　　PrimeFactorizer pf = (PrimeFactorizer) ar.AsyncState;
　　long[] results;

　　// Get the completed results.
　　results = pf.EndFactorize(ar);

　　//Output the results.
　　Console.Write(\"12345 factors into: \");
　　int j;
　　for (j = 0; j＜results.Length;j++){
　　　if (j == results.Length - 1)
　　　　Console.WriteLine(results[j]);
　　　else
　　　　Console.Write(results[j] + \", \");
　　}
　}
}

[Visual Basic]
Imports System
Imports System.Runtime.Remoting.Messaging
Imports MyFactorize

Public Class TestCallback
Public Shared Sub Main()
Dim factorizableNum As Long = 12345
Dim pf As PrimeFactorizer = new PrimeFactorizer()

\\\'Instantiate an AsyncCallback delegate to use as a parameter
\\\' in the BeginFactorize method.
Dim cb as AsyncCallback
cb = new AsyncCallback(AddressOf TestCallback.FactorizeCallback)

\\\' Begin the Async call to Factorize, passing in the
\\\' AsyncCallback delegate and a reference to our instance
\\\' of PrimeFactorizer.
Dim ar As IAsyncResult = pf.BeginFactorize(factorizableNum, cb, pf)

\\\' Keep track of the time it takes to complete the async call as
\\\' the call proceeds.
Dim start As Integer = DateTime.Now.Second
Dim currentSecond As Integer = start
Do while (ar.IsCompleted = false)
If (currentSecond ＜ DateTime.Now.Second) Then
　currentSecond = DateTime.Now.Second
　Console.WriteLine(\"Seconds Elapsed...\" + (currentSecond - start).ToString() )
End If
Loop

\\\' Once the call has completed, you need a method to ensure the
\\\' thread executing this Main function
\\\' doesn\\\'t complete prior to the callback function completing.
Console.Write(\"Press Enter to quit\")
Dim quitchar As Integer = Console.Read()
End Sub

\\\' Set up the call-back function that is invoked by the proxy
\\\' class when the asynchronous operation completes.
Public Shared Sub FactorizeCallback(ar As IAsyncResult)

\\\' You passed in the instance of PrimeFactorizer in the third
\\\' parameter to BeginFactorize, which is accessible in the
\\\' AsyncState property.

Dim pf As PrimeFactorizer = ar.AsyncState
Dim results() as Long

\\\' Get the completed results.
results = pf.EndFactorize(ar)

\\\'Output the results.
Console.Write(\"12345 factors into: \")
Dim j as Integer
For j = 0 To results.Length - 1
　If j = (results.Length - 1) Then
　　Console.WriteLine(results(j) )
　Else
　　Console.Write(results(j).ToString + \", \")
　End If
Next j
End Sub
End Class

[C#]
// -----------------------------------------------------------------------// Async Variation 2.
// Asynchronously invoke the Factorize method,
//without specifying a call back.
using System;
using System.Runtime.Remoting.Messaging;
// MyFactorize, is the name of the namespace in which the proxy class is
// a member of for this sample.
using MyFactorize;

class TestCallback
{
　public static void Main(){
　　long factorizableNum = 12345;
　　PrimeFactorizer pf = new PrimeFactorizer();

　　// Begin the Async call to Factorize.
　　IAsyncResult ar = pf.BeginFactorize(factorizableNum, null, null);

　　// Wait for the asynchronous operation to complete.
　　ar.AsyncWaitHandle.WaitOne();

　　// Get the completed results.
　　long[] results;
　　results = pf.EndFactorize(ar);

　　//Output the results.
　　Console.Write(\"12345 factors into: \");
　　int j;
　　for (j = 0; j＜results.Length;j++){
　　　if (j == results.Length - 1)
　　　　Console.WriteLine(results[j]);
　　　else
　　　　Console.Write(results[j] + \", \");
　　}
　}
}

[Visual Basic]
Imports System
Imports System.Runtime.Remoting.Messaging
Imports MyFactorize \\\' Proxy class namespace

Public Class TestCallback
Public Shared Sub Main()
Dim factorizableNum As Long = 12345
Dim pf As PrimeFactorizer = new PrimeFactorizer()

\\\' Begin the Async call to Factorize.
Dim ar As IAsyncResult = pf.BeginFactorize(factorizableNum, Nothing, Nothing)

\\\' Wait for the asynchronous operation to complete.
ar.AsyncWaitHandle.WaitOne()

\\\' Get the completed results.
Dim results() as Long
results = pf.EndFactorize(ar)

\\\'Output the results.
Console.Write(\"12345 factors into: \")
Dim j as Integer
For j = 0 To results.Length - 1
　If j = (results.Length - 1) Then
　　Console.WriteLine(results(j) )
　Else
　　Console.Write(results(j).ToString + \", \")
　End If
Next j
End Sub
End Class