DavEngineAsync Class

IT Hit WebDAV Classes Reference

Represents WebDAV engine. Processes WebDAV request and generates WebDAV response.

Inheritance Hierarchy

SystemObject
ITHit.ServerEngineAsyncIHierarchyItem
ITHit.WebDAV.ServerDavEngineAsync

Namespace: ITHit.WebDAV.Server
Assembly: ITHit.WebDAV.Server (in ITHit.WebDAV.Server.dll) Version: 13.3.13068

Syntax

C++

Copy

public class DavEngineAsync : EngineAsync<IHierarchyItem>

Public Class DavEngineAsync
	Inherits EngineAsync(Of IHierarchyItem)

public ref class DavEngineAsync : public EngineAsync<IHierarchyItem^>

type DavEngineAsync =  
    class
        inherit EngineAsync<IHierarchyItem>
    end

The DavEngineAsync type exposes the following members.

Constructors

	Name	Description
	DavEngineAsync	Initializes a new instance of this class.

Top

Properties

	Name	Description
	AutoPutUnderVersionControl	Determines if placing file under version control is automatic.
	CalculateContentLength	Indicates if response content length is calculated. Default is true. (Inherited from EngineAsyncTHierarchyItemAsync.)
	ContentEncoding	Gets or sets the HTTP character set of the output stream. Default is UTF-8. (Inherited from EngineAsyncTHierarchyItemAsync.)
	CorsAllowedFor	Enables or disables CORS. (Inherited from EngineAsyncTHierarchyItemAsync.)
	License	Gets or sets the license text. (Inherited from EngineAsyncTHierarchyItemAsync.)
	Logger	ILogger instance which engine will use for logging. (Inherited from EngineAsyncTHierarchyItemAsync.)
	OutputXmlFormatting	Specifies whether XML written to the output will be formatted. Default is false. (Inherited from EngineAsyncTHierarchyItemAsync.)
	UseFullUris	Specifies whether engine shall use full or relative urls. Default is true. (Inherited from EngineAsyncTHierarchyItemAsync.)

Top

Methods

	Name	Description
	Equals	Determines whether the specified object is equal to the current object. (Inherited from Object.)
	Finalize	Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)
	GetHashCode	Serves as the default hash function. (Inherited from Object.)
	GetType	Gets the Type of the current instance. (Inherited from Object.)
	MemberwiseClone	Creates a shallow copy of the current Object. (Inherited from Object.)
	RegisterMethodHandler	Registers custom method handler. (Overrides EngineAsyncTHierarchyItemAsyncRegisterMethodHandler(String, IMethodHandlerTHierarchyItemAsync).)
	RegisterOptionsHandler	Registers custom options handler.
	RegisterPropertyHandler	Registers custom property handler.
	RegisterReportHandler	Registers custom report handler.
	RunAsync	Processes WebDAV request and generates WebDAV response. (Overrides EngineAsyncTHierarchyItemAsyncRunAsync(ContextAsyncTHierarchyItemAsync).)
	ToString	Returns a string that represents the current object. (Inherited from Object.)

Top

Remarks

The engine parses XML send by WebDAV client, processes requests making calls to your implementations of WebDAV interfaces (IHierarchyItem, IFolder, IFile, etc and generates XML response.

In each HTTP request, you will create a separate instance of your class derived from ContextAsyncTHierarchyItem class and pass it to the RunAsync(ContextAsyncIHierarchyItem) method. Via the context, the engine receives all necessary information about the hosting environment.

You must set License property before you can use the engine.

All updates invoked within one request execution shall be inside a single transaction. Transaction can be committed or rollbacked in BeforeResponseAsync method, which is called right before starting sending a response to the client. After this method is called, no methods of interfaces which update state will be called by the engine. However, methods which read state can be called.

Examples

The code below is part of 'WebDAVServer.FileSystemStorage.AspNet' C# & VB samples provided with the SDK.

C++

Copy

public class DavHandler : HttpTaskAsyncHandler
{
    private readonly string license = File.ReadAllText(HttpContext.Current.Request.PhysicalApplicationPath + "License.lic");
    private static readonly string googleServiceAccountID = ConfigurationManager.AppSettings["GoogleServiceAccountID"];

    private static readonly string googleServicePrivateKey = ConfigurationManager.AppSettings["GoogleServicePrivateKey"];

    private static readonly string googleNotificationsRelativeUrl = ConfigurationManager.AppSettings["GoogleNotificationsRelativeUrl"];

    private readonly string gSuiteLicense = File.Exists(HttpContext.Current.Request.PhysicalApplicationPath + "GSuiteLicense.lic") ? File.ReadAllText(HttpContext.Current.Request.PhysicalApplicationPath + "GSuiteLicense.lic") : string.Empty;

    private static readonly bool debugLoggingEnabled =
        "true".Equals(
            ConfigurationManager.AppSettings["DebugLoggingEnabled"],
            StringComparison.InvariantCultureIgnoreCase);

    public override bool IsReusable
    {
        get { return true; }
    }


    public override async Task ProcessRequestAsync(HttpContext context)
    {
        DavEngineAsync webDavEngine = getOrInitializeWebDavEngine(context);

        context.Response.BufferOutput = false;
        DavContext ntfsDavContext = new DavContext(context);
        GSuiteEngineAsync gSuiteEngine = getOrInitializeGSuiteEngine(context);
        await webDavEngine.RunAsync(ntfsDavContext);
        if (gSuiteEngine != null)
        {
            await gSuiteEngine.RunAsync(ContextConverter.ConvertToGSuiteContext(ntfsDavContext));
        }
    }

    private DavEngineAsync initializeWebDavEngine(HttpContext context)
    {

        ILogger logger = WebDAVServer.FileSystemStorage.AspNet.Logger.Instance;
        DavEngineAsync webDavEngine = new DavEngineAsync
        {
            Logger = logger

            // Use idented responses if debug logging is enabled.
            , OutputXmlFormatting = true
        };

        webDavEngine.License = license;
        string contentRootPath = HttpContext.Current.Request.MapPath("/");

        // Set custom handler to process GET and HEAD requests to folders and display 
        // info about how to connect to server. We are using the same custom handler 
        // class (but different instances) here to process both GET and HEAD because 
        // these requests are very similar. Some WebDAV clients may fail to connect if HEAD 
        // request is not processed.
        MyCustomGetHandler handlerGet  = new MyCustomGetHandler(contentRootPath);
        MyCustomGetHandler handlerHead = new MyCustomGetHandler(contentRootPath);
        handlerGet.OriginalHandler  = webDavEngine.RegisterMethodHandler("GET",  handlerGet);
        handlerHead.OriginalHandler = webDavEngine.RegisterMethodHandler("HEAD", handlerHead);

        return webDavEngine;
    }

    private DavEngineAsync getOrInitializeWebDavEngine(HttpContext context)
    {
        //we don't use any double check lock pattern here because nothing wrong
        //is going to happen if we created occasionally several engines.
        const string ENGINE_KEY = "$DavEngine$";
        if (context.Application[ENGINE_KEY] == null)
        {
            context.Application[ENGINE_KEY] = initializeWebDavEngine(context);
        }

        return (DavEngineAsync)context.Application[ENGINE_KEY];
    }
    private GSuiteEngineAsync getOrInitializeGSuiteEngine(HttpContext context)
    {
        //we don't use any double check lock pattern here because nothing wrong
        //is going to happen if we created occasionally several engines.
        const string ENGINE_KEY = "$GSuiteEngine$";
        if (string.IsNullOrEmpty(googleServiceAccountID) || string.IsNullOrEmpty(googleServicePrivateKey))
        {
            return null;
        }

        if (context.Application[ENGINE_KEY] == null)
        {
            var gSuiteEngine = new GSuiteEngineAsync(googleServiceAccountID, googleServicePrivateKey, googleNotificationsRelativeUrl)
            {
                License = gSuiteLicense, 
                Logger = WebDAVServer.FileSystemStorage.AspNet.Logger.Instance
            };

            context.Application[ENGINE_KEY] = gSuiteEngine;
        }

        return (GSuiteEngineAsync)context.Application[ENGINE_KEY];
    }
}

Public Class DavHandler
    Inherits HttpTaskAsyncHandler

    Private ReadOnly license As String = File.ReadAllText(HttpContext.Current.Request.PhysicalApplicationPath & "License.lic")

    Private Shared ReadOnly googleServiceAccountID As String = ConfigurationManager.AppSettings("GoogleServiceAccountID")

    Private Shared ReadOnly googleServicePrivateKey As String = ConfigurationManager.AppSettings("GoogleServicePrivateKey")

    Private Shared ReadOnly googleNotificationsRelativeUrl As String = ConfigurationManager.AppSettings("GoogleNotificationsRelativeUrl")

    Private ReadOnly gSuiteLicense As String = If(File.Exists(HttpContext.Current.Request.PhysicalApplicationPath & "GSuiteLicense.lic"), File.ReadAllText(HttpContext.Current.Request.PhysicalApplicationPath & "GSuiteLicense.lic"), String.Empty)

    Private Shared ReadOnly debugLoggingEnabled As Boolean = "true".Equals(ConfigurationManager.AppSettings("DebugLoggingEnabled"),
                                                                          StringComparison.InvariantCultureIgnoreCase)

    Public Overrides ReadOnly Property IsReusable As Boolean
        Get
            Return True
        End Get
    End Property

    Public Overrides Async Function ProcessRequestAsync(context As HttpContext) As Task
        Dim webDavEngine As DavEngineAsync = getOrInitializeWebDavEngine(context)
        context.Response.BufferOutput = False
        Dim ntfsDavContext As DavContext = New DavContext(context)
        Dim gSuiteEngine As GSuiteEngineAsync = getOrInitializeGSuiteEngine(context)
        Await webDavEngine.RunAsync(ntfsDavContext)
        If gSuiteEngine IsNot Nothing Then
            Await gSuiteEngine.RunAsync(ContextConverter.ConvertToGSuiteContext(ntfsDavContext))
        End If
    End Function

    Private Function initializeWebDavEngine(context As HttpContext) As DavEngineAsync
        Dim logger As ILogger = WebDAVServer.FileSystemStorage.AspNet.Logger.Instance
        Dim webDavEngine As DavEngineAsync = New DavEngineAsync With {.Logger = logger,
                                                                .OutputXmlFormatting = True}
        webDavEngine.License = license
        Dim contentRootPath As String = HttpContext.Current.Request.MapPath("/")
        ' Set custom handler to process GET and HEAD requests to folders and display 
        ' info about how to connect to server. We are using the same custom handler 
        ' class (but different instances) here to process both GET and HEAD because 
        ' these requests are very similar. Some WebDAV clients may fail to connect if HEAD 
        ' request is not processed.
        Dim handlerGet As MyCustomGetHandler = New MyCustomGetHandler(contentRootPath)
        Dim handlerHead As MyCustomGetHandler = New MyCustomGetHandler(contentRootPath)
        handlerGet.OriginalHandler = webDavEngine.RegisterMethodHandler("GET", handlerGet)
        handlerHead.OriginalHandler = webDavEngine.RegisterMethodHandler("HEAD", handlerHead)
        Return webDavEngine
    End Function

    Private Function getOrInitializeWebDavEngine(context As HttpContext) As DavEngineAsync
        'we don't use any double check lock pattern here because nothing wrong
        'is going to happen if we created occasionally several engines.
        Const ENGINE_KEY As String = "$DavEngine$"
        If context.Application(ENGINE_KEY) Is Nothing Then
            context.Application(ENGINE_KEY) = initializeWebDavEngine(context)
        End If

        Return CType(context.Application(ENGINE_KEY), DavEngineAsync)
    End Function

    Private Function getOrInitializeGSuiteEngine(context As HttpContext) As GSuiteEngineAsync
        'we don't use any double check lock pattern here because nothing wrong
        'is going to happen if we created occasionally several engines.
        Const ENGINE_KEY As String = "$GSuiteEngine$"
        If String.IsNullOrEmpty(googleServiceAccountID) OrElse String.IsNullOrEmpty(googleServicePrivateKey) Then
            Return Nothing
        End If

        If context.Application(ENGINE_KEY) Is Nothing Then
            Dim gSuiteEngine = New GSuiteEngineAsync(googleServiceAccountID, googleServicePrivateKey, googleNotificationsRelativeUrl) With {.License = gSuiteLicense, 
                                                                                                                                      .Logger = WebDAVServer.FileSystemStorage.AspNet.Logger.Instance
                                                                                                                                      }
            context.Application(ENGINE_KEY) = gSuiteEngine
        End If

        Return CType(context.Application(ENGINE_KEY), GSuiteEngineAsync)
    End Function
End Class

Examples

The code below is part of 'CalDAVServer.SqlStorage.AspNet' C# & VB samples provided with the SDK.

C++

Copy

public class DavHandler : HttpTaskAsyncHandler
{
    private readonly string license = File.ReadAllText(HttpContext.Current.Request.PhysicalApplicationPath + "License.lic");

    private static readonly bool debugLoggingEnabled =
        "true".Equals(
            ConfigurationManager.AppSettings["DebugLoggingEnabled"],
            StringComparison.InvariantCultureIgnoreCase);

    public override bool IsReusable
    {
        get { return true; }
    }


    public override async Task ProcessRequestAsync(HttpContext context)
    {
        DavEngineAsync webDavEngine = getOrInitializeWebDavEngine(context);

        context.Response.BufferOutput = false;

        using (var sqlDavContext = new DavContext(context))
        {
            await webDavEngine.RunAsync(sqlDavContext);
        }
    }

    private DavEngineAsync initializeWebDavEngine(HttpContext context)
    {

        ILogger logger = CalDAVServer.SqlStorage.AspNet.Logger.Instance;
        logger.LogFlags = LogFlagsEnum.LogGetResponseBody | LogFlagsEnum.LogPutRequestBody;
        DavEngineAsync webDavEngine = new DavEngineAsync
        {
            Logger = logger

            // Use idented responses if debug logging is enabled.
            , OutputXmlFormatting = true

            // Do not emit CORS headers, typically not required in case of CalDAV/CardDAV server.
            , CorsAllowedFor = null

            // Use full URIs only in case of a regular WebDAV server. Microsoft Mini-redirector does not support URIs without domain.
            , UseFullUris = false
        };

        webDavEngine.License = license;
        string contentRootPath = HttpContext.Current.Request.MapPath("/");

        // Set custom handler to process GET and HEAD requests to folders and display 
        // info about how to connect to server. We are using the same custom handler 
        // class (but different instances) here to process both GET and HEAD because 
        // these requests are very similar. Some WebDAV clients may fail to connect if HEAD 
        // request is not processed.
        MyCustomGetHandler handlerGet  = new MyCustomGetHandler(contentRootPath);
        MyCustomGetHandler handlerHead = new MyCustomGetHandler(contentRootPath);
        handlerGet.OriginalHandler  = webDavEngine.RegisterMethodHandler("GET",  handlerGet);
        handlerHead.OriginalHandler = webDavEngine.RegisterMethodHandler("HEAD", handlerHead);

        // Set your iCalendar & vCard library license before calling any members.
        // iCalendar & vCard library accepts:
        // - WebDAV Server Engine license with iCalendar & vCard modules. Verify your license file to see if these modules are specified.
        // - or iCalendar and vCard Library license.
        ITHit.Collab.LicenseValidator.SetLicense(license);

        return webDavEngine;
    }

    private DavEngineAsync getOrInitializeWebDavEngine(HttpContext context)
    {
        //we don't use any double check lock pattern here because nothing wrong
        //is going to happen if we created occasionally several engines.
        const string ENGINE_KEY = "$DavEngine$";
        if (context.Application[ENGINE_KEY] == null)
        {
            context.Application[ENGINE_KEY] = initializeWebDavEngine(context);
        }

        return (DavEngineAsync)context.Application[ENGINE_KEY];
    }
}

Public Class DavHandler
    Inherits HttpTaskAsyncHandler

    Private ReadOnly license As String = File.ReadAllText(HttpContext.Current.Request.PhysicalApplicationPath & "License.lic")

    Private Shared ReadOnly debugLoggingEnabled As Boolean = "true".Equals(ConfigurationManager.AppSettings("DebugLoggingEnabled"),
                                                                          StringComparison.InvariantCultureIgnoreCase)

    Public Overrides ReadOnly Property IsReusable As Boolean
        Get
            Return True
        End Get
    End Property

    Public Overrides Async Function ProcessRequestAsync(context As HttpContext) As Task
        Dim webDavEngine As DavEngineAsync = getOrInitializeWebDavEngine(context)
        context.Response.BufferOutput = False
        Using sqlDavContext = New DavContext(context)
            Await webDavEngine.RunAsync(sqlDavContext)
        End Using
    End Function

    Private Function initializeWebDavEngine(context As HttpContext) As DavEngineAsync
        Dim logger As ILogger = CalDAVServer.SqlStorage.AspNet.Logger.Instance
        logger.LogFlags = LogFlagsEnum.LogGetResponseBody Or LogFlagsEnum.LogPutRequestBody
        Dim webDavEngine As DavEngineAsync = New DavEngineAsync With {.Logger = logger,
                                                                .OutputXmlFormatting = True, .CorsAllowedFor = Nothing, .UseFullUris = False}
        webDavEngine.License = license
        Dim contentRootPath As String = HttpContext.Current.Request.MapPath("/")
        ' Set custom handler to process GET and HEAD requests to folders and display 
        ' info about how to connect to server. We are using the same custom handler 
        ' class (but different instances) here to process both GET and HEAD because 
        ' these requests are very similar. Some WebDAV clients may fail to connect if HEAD 
        ' request is not processed.
        Dim handlerGet As MyCustomGetHandler = New MyCustomGetHandler(contentRootPath)
        Dim handlerHead As MyCustomGetHandler = New MyCustomGetHandler(contentRootPath)
        handlerGet.OriginalHandler = webDavEngine.RegisterMethodHandler("GET", handlerGet)
        handlerHead.OriginalHandler = webDavEngine.RegisterMethodHandler("HEAD", handlerHead)
        ' Set your iCalendar & vCard library license before calling any members.
        ' iCalendar & vCard library accepts:
        ' - WebDAV Server Engine license with iCalendar & vCard modules. Verify your license file to see if these modules are specified.
        ' - or iCalendar and vCard Library license.
        ITHit.Collab.LicenseValidator.SetLicense(license)
        Return webDavEngine
    End Function

    Private Function getOrInitializeWebDavEngine(context As HttpContext) As DavEngineAsync
        'we don't use any double check lock pattern here because nothing wrong
        'is going to happen if we created occasionally several engines.
        Const ENGINE_KEY As String = "$DavEngine$"
        If context.Application(ENGINE_KEY) Is Nothing Then
            context.Application(ENGINE_KEY) = initializeWebDavEngine(context)
        End If

        Return CType(context.Application(ENGINE_KEY), DavEngineAsync)
    End Function
End Class

Examples

The code below is part of 'CardDAVServer.SqlStorage.AspNet' C# & VB samples provided with the SDK.

C++

Copy

public class DavHandler : HttpTaskAsyncHandler
{
    private readonly string license = File.ReadAllText(HttpContext.Current.Request.PhysicalApplicationPath + "License.lic");

    private static readonly bool debugLoggingEnabled =
        "true".Equals(
            ConfigurationManager.AppSettings["DebugLoggingEnabled"],
            StringComparison.InvariantCultureIgnoreCase);

    public override bool IsReusable
    {
        get { return true; }
    }


    public override async Task ProcessRequestAsync(HttpContext context)
    {
        DavEngineAsync webDavEngine = getOrInitializeWebDavEngine(context);

        context.Response.BufferOutput = false;

        using (var sqlDavContext = new DavContext(context))
        {
            await webDavEngine.RunAsync(sqlDavContext);
        }
    }

    private DavEngineAsync initializeWebDavEngine(HttpContext context)
    {

        ILogger logger = CardDAVServer.SqlStorage.AspNet.Logger.Instance;
        logger.LogFlags = LogFlagsEnum.LogGetResponseBody | LogFlagsEnum.LogPutRequestBody;
        DavEngineAsync webDavEngine = new DavEngineAsync
        {
            Logger = logger

            // Use idented responses if debug logging is enabled.
            , OutputXmlFormatting = true

            // Do not emit CORS headers, typically not required in case of CalDAV/CardDAV server.
            , CorsAllowedFor = null

            // Use full URIs only in case of a regular WebDAV server. Microsoft Mini-redirector does not support URIs without domain.
            , UseFullUris = false
        };

        webDavEngine.License = license;
        string contentRootPath = HttpContext.Current.Request.MapPath("/");

        // Set custom handler to process GET and HEAD requests to folders and display 
        // info about how to connect to server. We are using the same custom handler 
        // class (but different instances) here to process both GET and HEAD because 
        // these requests are very similar. Some WebDAV clients may fail to connect if HEAD 
        // request is not processed.
        MyCustomGetHandler handlerGet  = new MyCustomGetHandler(contentRootPath);
        MyCustomGetHandler handlerHead = new MyCustomGetHandler(contentRootPath);
        handlerGet.OriginalHandler  = webDavEngine.RegisterMethodHandler("GET",  handlerGet);
        handlerHead.OriginalHandler = webDavEngine.RegisterMethodHandler("HEAD", handlerHead);

        // Set your iCalendar & vCard library license before calling any members.
        // iCalendar & vCard library accepts:
        // - WebDAV Server Engine license with iCalendar & vCard modules. Verify your license file to see if these modules are specified.
        // - or iCalendar and vCard Library license.
        ITHit.Collab.LicenseValidator.SetLicense(license);

        return webDavEngine;
    }

    private DavEngineAsync getOrInitializeWebDavEngine(HttpContext context)
    {
        //we don't use any double check lock pattern here because nothing wrong
        //is going to happen if we created occasionally several engines.
        const string ENGINE_KEY = "$DavEngine$";
        if (context.Application[ENGINE_KEY] == null)
        {
            context.Application[ENGINE_KEY] = initializeWebDavEngine(context);
        }

        return (DavEngineAsync)context.Application[ENGINE_KEY];
    }
}

Public Class DavHandler
    Inherits HttpTaskAsyncHandler

    Private ReadOnly license As String = File.ReadAllText(HttpContext.Current.Request.PhysicalApplicationPath & "License.lic")

    Private Shared ReadOnly debugLoggingEnabled As Boolean = "true".Equals(ConfigurationManager.AppSettings("DebugLoggingEnabled"),
                                                                          StringComparison.InvariantCultureIgnoreCase)

    Public Overrides ReadOnly Property IsReusable As Boolean
        Get
            Return True
        End Get
    End Property

    Public Overrides Async Function ProcessRequestAsync(context As HttpContext) As Task
        Dim webDavEngine As DavEngineAsync = getOrInitializeWebDavEngine(context)
        context.Response.BufferOutput = False
        Using sqlDavContext = New DavContext(context)
            Await webDavEngine.RunAsync(sqlDavContext)
        End Using
    End Function

    Private Function initializeWebDavEngine(context As HttpContext) As DavEngineAsync
        Dim logger As ILogger = CardDAVServer.SqlStorage.AspNet.Logger.Instance
        logger.LogFlags = LogFlagsEnum.LogGetResponseBody Or LogFlagsEnum.LogPutRequestBody
        Dim webDavEngine As DavEngineAsync = New DavEngineAsync With {.Logger = logger,
                                                                .OutputXmlFormatting = True, .CorsAllowedFor = Nothing, .UseFullUris = False}
        webDavEngine.License = license
        Dim contentRootPath As String = HttpContext.Current.Request.MapPath("/")
        ' Set custom handler to process GET and HEAD requests to folders and display 
        ' info about how to connect to server. We are using the same custom handler 
        ' class (but different instances) here to process both GET and HEAD because 
        ' these requests are very similar. Some WebDAV clients may fail to connect if HEAD 
        ' request is not processed.
        Dim handlerGet As MyCustomGetHandler = New MyCustomGetHandler(contentRootPath)
        Dim handlerHead As MyCustomGetHandler = New MyCustomGetHandler(contentRootPath)
        handlerGet.OriginalHandler = webDavEngine.RegisterMethodHandler("GET", handlerGet)
        handlerHead.OriginalHandler = webDavEngine.RegisterMethodHandler("HEAD", handlerHead)
        ' Set your iCalendar & vCard library license before calling any members.
        ' iCalendar & vCard library accepts:
        ' - WebDAV Server Engine license with iCalendar & vCard modules. Verify your license file to see if these modules are specified.
        ' - or iCalendar and vCard Library license.
        ITHit.Collab.LicenseValidator.SetLicense(license)
        Return webDavEngine
    End Function

    Private Function getOrInitializeWebDavEngine(context As HttpContext) As DavEngineAsync
        'we don't use any double check lock pattern here because nothing wrong
        'is going to happen if we created occasionally several engines.
        Const ENGINE_KEY As String = "$DavEngine$"
        If context.Application(ENGINE_KEY) Is Nothing Then
            context.Application(ENGINE_KEY) = initializeWebDavEngine(context)
        End If

        Return CType(context.Application(ENGINE_KEY), DavEngineAsync)
    End Function
End Class

Thread Safety

Method RunAsync(ContextAsyncTHierarchyItemAsync) is threadsafe. All other members are NOT threadsafe. You can create a single instance of this class, initialize it once and use to serve all requests from different threads.

Reference

ITHit.WebDAV.Server Namespace