/Bowling/Bowling.Domain/XmlDocument.xml

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Bowling.Domain</name>
    </assembly>
    <members>
        <member name="T:Bowling.Domain.Abstract.IRepository`1">
            <summary>
            Interface for all repository iplementations
            </summary>
            <typeparam name="T">Type of the entities in the repository</typeparam>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.GetAll">
            <summary>
            Get all items from the repository  
            </summary>
            <returns>Queryable containing all items in the repository</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.GetAsync(System.Func{System.Linq.IQueryable{`0},System.Linq.IQueryable{`0}},System.Threading.CancellationToken)">
            <summary>
            Retrieves all items in the repository satisfied by the specified query asynchronously.
            </summary>
            <param name="queryShaper">The <see cref="T:System.Func`2">function</see> that shapes the <see cref="T:System.Linq.IQueryable`1">query</see> to execute.</param>
            <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken">cancellation token</see> that can be used to cancel the operation.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the retrieved <see cref="T:System.Collections.Generic.IEnumerable`1">sequence</see>
            of <typeparamref name="T">items</typeparamref>.</returns>
            <example>The following example demonstrates how to paginate the items in a repository using an example query.
            <code><![CDATA[
            using Microsoft.DesignPatterns.Examples;
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading;
            using System.Threading.Tasks;
            
            public async static void Main()
            {
                var index = 0;
                var repository = new MyRepository();
                var cancellationToken = new CancellationToken();
                
                foreach ( var item in await repository.GetAsync( q => q.Where( i => i.FirstName.StartsWith( "Jo" ) ).OrderBy( i => i.LastName ), cancellationToken );
                    Console.WriteLine( i => i.ToString() );
            }
            ]]>
            </code></example>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.GetAsync``1(System.Func{System.Linq.IQueryable{`0},``0},System.Threading.CancellationToken)">
            <summary>
            Retrieves a query result asynchronously.
            </summary>
            <typeparam name="TResult">The <see cref="T:System.Type">type</see> of result to retrieve.</typeparam>
            <param name="queryShaper">The <see cref="T:System.Func`2">function</see> that shapes the <see cref="T:System.Linq.IQueryable`1">query</see> to execute.</param>
            <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken">cancellation token</see> that can be used to cancel the operation.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the <typeparamref name="TResult">result</typeparamref> of the operation.</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.Search(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
            <summary>
            Basic search method that allows filtering on the repository based on
            a boolean predicate.
            </summary>
            <param name="where">Where clause for the search</param>
            <returns>Queryable of the search results</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.Single(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
            <summary>
            Search and return a single entity using a where clause
            </summary>
            <param name="where">Where clause</param>
            <returns>Result entity</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.Single(System.Func{System.Linq.IQueryable{`0},System.Linq.IQueryable{`0}})">
            <summary>
            Search and return a single entity using a query function
            </summary>
            <param name="query">Query function</param>
            <returns>Result entity</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.GetById(System.Int32)">
            <summary>
            Get entity by the id
            </summary>
            <param name="id">Guid of the entity</param>
            <returns>Result entity</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.First(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
            <summary>
            Search and return the first entity that matches the given where clause
            </summary>
            <param name="where">Where clause</param>
            <returns>Result entity</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.First(System.Func{System.Linq.IQueryable{`0},System.Linq.IQueryable{`0}})">
            <summary>
            Search and return the first entity matching the given query
            </summary>
            <param name="query">Query</param>
            <returns>Result entity</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.Delete(`0)">
            <summary>
            Delete the given entity from the repository
            </summary>
            <param name="entity">Entity to delete</param>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.Add(`0)">
            <summary>
            Add the given entity to the repository
            </summary>
            <param name="entity">Entity to add</param>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.AddRange(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Add a collection of new entities to the repository. This can be more efficient
            than adding the entities one by one.
            </summary>
            <param name="entities">Range of entities to add</param>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.Attach(`0)">
            <summary>
            Attach the gievn entity
            </summary>
            <param name="entity">Entity to attach</param>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.Lock(`0)">
            <summary>
            Obtain a lock on a specific entity where possible.
            Also refreshes the entity after obtaining the lock
            </summary>
            <param name="entity">Entity to lock</param>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.Lock(System.Int32,System.String,System.Type)">
            <summary>
            Lock the specific entity where possible.  Find the entity via the given id,
            table and type
            </summary>
            <param name="id">Id of the entity being locked</param>
            <param name="table">Table that the entity being locked belongs to</param>
            <param name="entType">Type of the entity being locked</param>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepository`1.Refresh(`0)">
            <summary>
            Refresh the given entity
            </summary>
            <param name="entity">Entity to refresh</param>
        </member>
        <member name="T:Bowling.Domain.Abstract.IUnitOfWork">
            <summary>
            Interface for the unit of work.  A group of database changes to be committed at once.
            </summary>
        </member>
        <member name="M:Bowling.Domain.Abstract.IUnitOfWork.Commit">
            <summary>
            Commit the unit of work
            </summary>
        </member>
        <member name="M:Bowling.Domain.Abstract.IUnitOfWork.CommitAsync">
            <summary>
            Commit the unit of work
            </summary>
        </member>
        <member name="M:Bowling.Domain.Abstract.IUnitOfWork.ContainsLockKey(System.Type,System.Int32)">
            <summary>
            Check of the required entity is locked and has an entry in the lock table
            </summary>
            <param name="entity">Type of the entity being checked</param>
            <param name="i">Id of the entity being checked</param>
            <returns>Whether the lock table contains the lock key for the given entity</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IUnitOfWork.AddToLockTable(System.Type,System.Int32)">
            <summary>
            Add the given entity to the lock table
            </summary>
            <param name="entity">Entity to add to the lock table</param>
            <param name="i">Id of entity to add to the lock table</param>
        </member>
        <member name="M:Bowling.Domain.Abstract.UnitOfWork.Dispose">
            <summary>
            This clears up everything associated with the transaction.
            </summary>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.BaseContext">
            <summary>
            Base database context from which all other database contexts will be extended
            </summary>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.IDbContext">
            <summary>
            Interface for database contexts
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.IDbContext.SaveChanges">
            <summary>
            Save the changes to all entities within the current context
            </summary>
            <returns>Error code</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.IDbContext.SaveChangesAsync">
            <summary>
            Save the changes to all entities within the current context
            </summary>
            <returns>Error code</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.IDbContext.Set``1">
            <summary>
            Returns a DbSet for the current entity type
            </summary>
            <typeparam name="TEntity">The entity type</typeparam>
            <returns>DbSet</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.IDbContext.Lock(System.Int32,System.String,System.Type)">
            <summary>
            This obtains an update lock on a given row by ID, or waits until it can get one (or times out).
            </summary>
            <param name="id">Id of entity to lock</param>
            <param name="table">Table to get the lock on</param>
            <param name="entType">Type of the entity being locked</param>
            <returns></returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.IDbContext.Refresh(System.Object)">
            <summary>
            This refreshes the contents of a given object from the database.
            </summary>
            <param name="entity">Object to be refreshed</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.IDbContext.Entry(System.Object)">
            <summary>
            Gets a System.Data.Entity.Infrastructure.DbEntityEntry object for the given entity
            </summary>
            <param name="entity">Entity to use</param>
            <returns>DbEntityEntry</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.BaseContext.#cctor">
            <summary>
            Static constructor to create an empty context
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.BaseContext.#ctor(System.String)">
            <summary>
            Constructor creating a database context from a given connection string
            </summary>
            <param name="nameOrConnectionString">Connection string</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.BaseContext.#ctor(System.Data.Common.DbConnection)">
            <summary>
            Constructor creating a database context from a given database connection
            </summary>
            <param name="dbConnection">Database connection</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.BaseContext.OnModelCreating(System.Data.Entity.DbModelBuilder)">
            <summary>
            Model creating event
            </summary>
            <param name="modelBuilder">Model builder object being used</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.BaseContext.Lock(System.Int32,System.String,System.Type)">
            <summary>
            This obtains an update lock on a given row by ID, or waits until it can get one (or times out).
            </summary>
            <param name="id">Row id to lock</param>
            <param name="table">Table to update the lock on</param>
            <param name="entType">Type of the entity being locked</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.BaseContext.Refresh(System.Object)">
            <summary>
            This refreshes the contents of a given object from the database.
            </summary>
            <param name="entity">Entity to refresh</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.BaseContext.SaveChanges">
            <summary>
            Calls the DbContext SaveChanges. If it fails validation, it will be handled with our own exception
            </summary>
            <returns>Error code</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.BaseContext.SaveChangesAsync">
            <summary>
            Calls the DbContext SaveChanges. If it fails validation, it will be handled with our own exception
            </summary>
            <returns>Error code</returns>
        </member>
        <member name="P:Bowling.Domain.Concrete.EntityFramework.BaseContext.NamespaceDataContext">
            <summary>
            Name space for context
            </summary>
            <returns>Name space</returns>
        </member>
        <member name="P:Bowling.Domain.Concrete.EntityFramework.BaseContext.Schema">
            <summary>
            Schema for the context
            </summary>
            <returns>Schema</returns>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.BaseEntityMap`1">
            <summary>
            Base Entity Framework mapping class for Insight domain entities. This class
            configures the attributes on the base entity and also properties on the specified
            domain entity type by looking at settings provided via the SymEntity attribute
            and properties specified by the Field Definitions for the class.
            </summary>
            <typeparam name="T">The type of the entity being mapped</typeparam>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.BaseEntityMap`1.#ctor">
            <summary>
            Constructor creating the default mappings on all entities
            </summary>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.DataContext">
            <summary>
            Context for the main database
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.DataContext.#cctor">
            <summary>
            Static constructor to create an empty data context.  If we are building the database instruct 
            the system to create a database if it doesn't exst.  This cannot be used for normal usage as
            it is incompatible with caching
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.DataContext.#ctor(System.String)">
            <summary>
            Constructor to create a data context from the given connection string,
            setting whether it is a management database
            </summary>
            <param name="connectionString">Connection string</param>
            <param name="managementModelOnly">Management model only</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.DataContext.#ctor">
            <summary>
            Constructor to create a data context from the stored connection string,
            setting whether it is a management database
            </summary>
            <param name="managementContext">Management model only</param>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.EFRepository`1">
            <summary>
            Base generic repository implementation
            </summary>
            <typeparam name="T">Type of the repository</typeparam>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.#ctor">
            <summary>
            Costructor
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.GetCurrentUnitOfWork``1">
            <summary>
            Get the current Unit of Work
            </summary>
            <typeparam name="TUnitOfWork">The type of the unit of work</typeparam>
            <returns>Current unit of work</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.GetAll">
            <summary>
            Get all data from the dbSet.  This takes into account the valid partitions for the user
            </summary>
            <returns>IQueriable containing all data</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.GetAllLocal">
            <summary>
            Get all data from the dbSet.  This takes into account the valid partitions for the user
            </summary>
            <returns>IQueriable containing all data</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.GetAsync(System.Func{System.Linq.IQueryable{`0},System.Linq.IQueryable{`0}},System.Threading.CancellationToken)">
            <summary>
            Retrieves all items in the repository satisfied by the specified query asynchronously.
            </summary>
            <param name="queryShaper">The <see cref="T:System.Func`2">function</see> that shapes the <see cref="T:System.Linq.IQueryable`1">query</see> to execute.</param>
            <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken">cancellation token</see> that can be used to cancel the operation.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the retrieved <see cref="T:System.Collections.Generic.IEnumerable`1">sequence</see> of <typeparamref name="T">items</typeparamref>.</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.GetAsync``1(System.Func{System.Linq.IQueryable{`0},``0},System.Threading.CancellationToken)">
            <summary>
            Retrieves a query result asynchronously.
            </summary>
            <typeparam name="TResult">The <see cref="T:System.Type">type</see> of result to retrieve.</typeparam>
            <param name="queryShaper">The <see cref="T:System.Func`2">function</see> that shapes the <see cref="T:System.Linq.IQueryable`1">query</see> to execute.</param>
            <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken">cancellation token</see> that can be used to cancel the operation.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the <typeparamref name="TResult">result</typeparamref> of the operation.</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Search(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
            <summary>
            Search the dbSet with the given expression.  This takes into account valid partitions
            for the user
            </summary>
            <param name="where">Expression used to search the data</param>
            <returns>IQueryable containing result data</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Single(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
            <summary>
            Get a single entity from the dbSet defined by the given where clause.  This takes
            into account valid partitions for the user
            </summary>
            <param name="where">Expression used to search the data</param>
            <returns>IQueryable containing result data</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Single(System.Func{System.Linq.IQueryable{`0},System.Linq.IQueryable{`0}})">
            <summary>
            Get a single entity from the dbSet defined by the given query.  This takes
            into account valid partitions for the user
            </summary>
            <param name="query">Query used to search the data</param>
            <returns>IQueryable containing result data</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.GetById(System.Int32)">
            <summary>
            Get entity by the id
            </summary>
            <param name="id">Guid of the entity</param>
            <returns>Result entity</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.First(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
            <summary>
            Get the first entity from the dbSet defined by the given where clause.  This takes
            into account valid partitions for the user
            </summary>
            <param name="where">Expression used to search the data</param>
            <returns>IQueryable containing result data</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.First(System.Func{System.Linq.IQueryable{`0},System.Linq.IQueryable{`0}})">
            <summary>
            Get the first entity from the dbSet defined by the given query.  This takes
            into account valid partitions for the user
            </summary>
            <param name="query">Query used to search the data</param>
            <returns>IQueryable containing result data</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Delete(`0)">
            <summary>
            Delete the given entity from the data set
            </summary>
            <param name="entity">Entity to be deleted</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Add(`0)">
            <summary>
            Add the given entity to the data set
            </summary>
            <param name="entity">Entity to be added</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.AddRange(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            Add a range of entities to the data set
            </summary>
            <param name="entities">Range of entities to be added</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Attach(`0)">
            <summary>
            Attaches the given entity to the context underlying the set. That is, the entity 
            is placed into the context in the Unchanged state, just as if it had been read from the database. 
            </summary>
            <param name="entity">The entity to be attached</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Lock(`0)">
            <summary>
            Lock the given entity in the data set
            </summary>
            <param name="entity">The entity to be locked</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Lock(System.Int32,System.String,System.Type)">
            <summary>
            This obtains an update lock on a given row by ID, or waits until it can get one (or times out).
            </summary>
            <param name="id">Id of the entity to be locked</param>
            <param name="table">Table in which the entity is stored</param>
            <param name="entType">Type of the entity</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Refresh(`0)">
            <summary>
            This refreshes the contents of a given object from the database.
            </summary>
            <param name="entity">The entity to be refreshed</param>
        </member>
        <member name="P:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.Context">
            <summary>
            The context on wich the repository is based.
            </summary>
            <returns>Context</returns>
        </member>
        <member name="P:Bowling.Domain.Concrete.EntityFramework.EFRepository`1.DbSet">
            <summary>
            The dbSet object retrieved from the context
            </summary>
            <returns>DbSet</returns>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork">
            <summary>
            Entity framework unit of work.  A set of changes to be committed at one time
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork.#ctor(System.Func{Bowling.Domain.Concrete.EntityFramework.IDbContext})">
            <summary>
            Constructor creating the unit of work from functions defining the
            various contexts
            </summary>
            <param name="dataContextFunc">Function returning the data context</param>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork.ContextFor``1">
            <summary>
            Return the correct context for the given type parameter
            </summary>
            <typeparam name="T">Type</typeparam>
            <returns>Context</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork.Commit">
            <summary>
            Commit the unit of work to the database
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork.CommitAsync">
            <summary>
            Commit the unit of work to the database
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork.Dispose">
            <summary>
            Dispose the unit of work and associated contexts
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork.ContainsLockKey(System.Type,System.Int32)">
            <summary>
            Check if there is a lock inthe lock table for the Type, id pair
            </summary>
            <param name="entity">Type</param>
            <param name="i">Id</param>
            <returns>Lock found?</returns>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork.AddToLockTable(System.Type,System.Int32)">
            <summary>
            Add the given type id pair to the lock table
            </summary>
            <param name="entity">Type</param>
            <param name="i">Id</param>
        </member>
        <member name="P:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork.Context">
            <summary>
            The context being used
            </summary>
            <returns>context</returns>
        </member>
        <member name="P:Bowling.Domain.Concrete.EntityFramework.EFUnitOfWork.DataContext">
            <summary>
            The database context being used
            </summary>
            <returns>Data context</returns>
        </member>
        <member name="T:Bowling.Domain.Abstract.IRepositoryExtensions">
            <summary>
            Provides extension methods for the <see cref="T:Bowling.Domain.Abstract.IRepository`1"/> and <see cref="T:Bowling.Domain.Abstract.IRepository`1"/> interfaces.
            </summary>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepositoryExtensions.GetAsync``1(Bowling.Domain.Abstract.IRepository{``0},System.Func{System.Linq.IQueryable{``0},System.Linq.IQueryable{``0}})">
            <summary>
            Retrieves all items in the repository satisfied by the specified query asynchronously.
            </summary>
            <typeparam name="T">The <see cref="T:System.Type">type</see> of item in the repository.</typeparam>
            <param name="repository">The extended <see cref="T:Bowling.Domain.Abstract.IRepository`1">repository</see>.</param>
            <param name="queryShaper">The <see cref="T:System.Func`2">function</see> that shapes the <see cref="T:System.Linq.IQueryable`1">query</see> to execute.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the retrieved <see cref="T:System.Collections.Generic.IEnumerable`1">sequence</see>
            of <typeparamref name="T">items</typeparamref>.</returns>
            <example>The following example demonstrates how to paginate the items in a repository using an example query.
            <code><![CDATA[
            using Microsoft.DesignPatterns.Examples;
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading;
            using System.Threading.Tasks;
            
            public async static void Main()
            {
                var index = 0;
                var repository = new MyRepository();
                
                foreach ( var item in await repository.GetAsync( q => q.Where( i => i.FirstName.StartsWith( "Jo" ) ).OrderBy( i => i.LastName ) );
                    Console.WriteLine( i => i.ToString() );
            }
            ]]>
            </code></example>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepositoryExtensions.GetAsync``2(Bowling.Domain.Abstract.IRepository{``0},System.Func{System.Linq.IQueryable{``0},``1})">
            <summary>
            Retrieves a query result asynchronously.
            </summary>
            <typeparam name="T">The <see cref="T:System.Type">type</see> of item in the repository.</typeparam>
            <typeparam name="TResult">The <see cref="T:System.Type">type</see> of result to retrieve.</typeparam>
            <param name="repository">The extended <see cref="T:Bowling.Domain.Abstract.IRepository`1">repository</see>.</param>
            <param name="queryShaper">The <see cref="T:System.Func`2">function</see> that shapes the <see cref="T:System.Linq.IQueryable`1">query</see> to execute.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the <typeparamref name="TResult">result</typeparamref> of the operation.</returns>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepositoryExtensions.GetAllAsync``1(Bowling.Domain.Abstract.IRepository{``0})">
            <summary>
            Retrieves all items in the repository asynchronously.
            </summary>
            <typeparam name="T">The <see cref="T:System.Type">type</see> of item in the repository.</typeparam>
            <param name="repository">The extended <see cref="T:Bowling.Domain.Abstract.IRepository`1">repository</see>.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the <see cref="T:System.Collections.Generic.IEnumerable`1">sequence</see>
            of all <typeparamref name="T">items</typeparamref> in the repository.</returns>
            <example>The following example demonstrates how to retrieve all items in a repository.
            <code><![CDATA[
            using Microsoft.DesignPatterns.Examples;
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading;
            using System.Threading.Tasks;
            
            public async static void Main()
            {
                var repository = new MyRepository();
                
                foreach ( var item in await repository.GetAllAsync( i => i.LastName == "Doe" ) )
                    Console.WriteLine( item.ToString() );
            }
            ]]>
            </code></example>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepositoryExtensions.GetAllAsync``1(Bowling.Domain.Abstract.IRepository{``0},System.Threading.CancellationToken)">
            <summary>
            Retrieves all items in the repository asynchronously.
            </summary>
            <typeparam name="T">The <see cref="T:System.Type">type</see> of item in the repository.</typeparam>
            <param name="repository">The extended <see cref="T:Bowling.Domain.Abstract.IRepository`1">repository</see>.</param>
            <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken">cancellation token</see> that can be used to cancel the operation.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the <see cref="T:System.Collections.Generic.IEnumerable`1">sequence</see>
            of all <typeparamref name="T">items</typeparamref> in the repository.</returns>
            <example>The following example demonstrates how to retrieve all items in a repository.
            <code><![CDATA[
            using Microsoft.DesignPatterns.Examples;
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading;
            using System.Threading.Tasks;
            
            public async static void Main()
            {
                var repository = new MyRepository();
                var cancellationToken = new CancellationToken();
                
                foreach ( var item in await repository.GetAllAsync( i => i.LastName == "Doe", cancellationToken ) )
                    Console.WriteLine( item.ToString() );
            }
            ]]>
            </code></example>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepositoryExtensions.FindByAsync``1(Bowling.Domain.Abstract.IRepository{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">
            <summary>
            Searches for items in the repository that match the specified predicate asynchronously.
            </summary>
            <typeparam name="T">The <see cref="T:System.Type">type</see> of item in the repository.</typeparam>
            <param name="repository">The extended <see cref="T:Bowling.Domain.Abstract.IRepository`1">repository</see>.</param>
            <param name="predicate">The <see cref="T:System.Linq.Expressions.Expression`1">expression</see> representing the predicate used to
            match the requested <typeparamref name="T">items</typeparamref>.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the matched <see cref="T:System.Collections.Generic.IEnumerable`1">sequence</see>
            of <typeparamref name="T">items</typeparamref>.</returns>
            <example>The following example demonstrates how to find items in a repository.
            <code><![CDATA[
            using Microsoft.DesignPatterns.Examples;
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading;
            using System.Threading.Tasks;
            
            public async static void Main()
            {
                var repository = new MyRepository();
                var items = await repository.FindByAsync( i => i.LastName == "Doe" );
                items.ForEach( i => Console.WriteLine( i.ToString() ) );
            }
            ]]>
            </code></example>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepositoryExtensions.FindByAsync``1(Bowling.Domain.Abstract.IRepository{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Threading.CancellationToken)">
            <summary>
            Searches for items in the repository that match the specified predicate asynchronously.
            </summary>
            <typeparam name="T">The <see cref="T:System.Type">type</see> of item in the repository.</typeparam>
            <param name="repository">The extended <see cref="T:Bowling.Domain.Abstract.IRepository`1">repository</see>.</param>
            <param name="predicate">The <see cref="T:System.Linq.Expressions.Expression`1">expression</see> representing the predicate used to
            match the requested <typeparamref name="T">items</typeparamref>.</param>
            <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken">cancellation token</see> that can be used to cancel the operation.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the matched <see cref="T:System.Collections.Generic.IEnumerable`1">sequence</see>
            of <typeparamref name="T">items</typeparamref>.</returns>
            <example>The following example demonstrates how to find items in a repository.
            <code><![CDATA[
            using Microsoft.DesignPatterns.Examples;
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading;
            using System.Threading.Tasks;
            
            public async static void Main()
            {
                var repository = new MyRepository();
                var cancellationToken = new CancellationToken();
                var items = await repository.FindByAsync( i => i.LastName == "Doe", cancellationToken );
                items.ForEach( i => Console.WriteLine( i.ToString() ) );
            }
            ]]>
            </code></example>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepositoryExtensions.GetSingleAsync``1(Bowling.Domain.Abstract.IRepository{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">
            <summary>
            Retrieves a single item in the repository matching the specified predicate asynchronously.
            </summary>
            <typeparam name="T">The <see cref="T:System.Type">type</see> of item in the repository.</typeparam>
            <param name="repository">The extended <see cref="T:Bowling.Domain.Abstract.IRepository`1">repository</see>.</param>
            <param name="predicate">The <see cref="T:System.Linq.Expressions.Expression`1">expression</see> representing the predicate used to
            match the requested <typeparamref name="T">item</typeparamref>.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the matched <typeparamref name="T">item</typeparamref>
            or null if no match was found.</returns>
            <example>The following example demonstrates how to retrieve a single item from a repository.
            <code><![CDATA[
            using Microsoft.DesignPatterns.Examples;
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading;
            using System.Threading.Tasks;
            
            public async static void Main()
            {
                var repository = new MyRepository();
                var item = await repository.GetSingleAsync( i => i.Id == 1 );
                Console.WriteLine( item.ToString() );
            }
            ]]>
            </code></example>
        </member>
        <member name="M:Bowling.Domain.Abstract.IRepositoryExtensions.GetSingleAsync``1(Bowling.Domain.Abstract.IRepository{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}},System.Threading.CancellationToken)">
            <summary>
            Retrieves a single item in the repository matching the specified predicate asynchronously.
            </summary>
            <typeparam name="T">The <see cref="T:System.Type">type</see> of item in the repository.</typeparam>
            <param name="repository">The extended <see cref="T:Bowling.Domain.Abstract.IRepository`1">repository</see>.</param>
            <param name="predicate">The <see cref="T:System.Linq.Expressions.Expression`1">expression</see> representing the predicate used to
            match the requested <typeparamref name="T">item</typeparamref>.</param>
            <param name="cancellationToken">The <see cref="T:System.Threading.CancellationToken">cancellation token</see> that can be used to cancel the operation.</param>
            <returns>A <see cref="T:System.Threading.Tasks.Task`1">task</see> containing the matched <typeparamref name="T">item</typeparamref>
            or null if no match was found.</returns>
            <example>The following example demonstrates how to retrieve a single item from a repository.
            <code><![CDATA[
            using Microsoft.DesignPatterns.Examples;
            using System;
            using System.Collections.Generic;
            using System.Linq;
            using System.Threading;
            using System.Threading.Tasks;
            
            public async static void Main()
            {
                var repository = new MyRepository();
                var item = await repository.GetSingleAsync( i => i.Id == 1 );
                Console.WriteLine( item.ToString() );
            }
            ]]>
            </code></example>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.Mapping.AttendeeMap">
            <summary>
            Contact database field definition
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.Mapping.AttendeeMap.#ctor">
            <summary>
            Define the table fields
            </summary>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.Mapping.BowlerMap">
            <summary>
            Contact database field definition
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.Mapping.BowlerMap.#ctor">
            <summary>
            Define the table fields
            </summary>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.Mapping.EventMap">
            <summary>
            Contact database field definition
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.Mapping.EventMap.#ctor">
            <summary>
            Define the table fields
            </summary>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.Mapping.FoodOptionMap">
            <summary>
            Contact database field definition
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.Mapping.FoodOptionMap.#ctor">
            <summary>
            Define the table fields
            </summary>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.Mapping.ResultMap">
            <summary>
            Contact database field definition
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.Mapping.ResultMap.#ctor">
            <summary>
            Define the table fields
            </summary>
        </member>
        <member name="T:Bowling.Domain.Concrete.EntityFramework.Mapping.RoundMap">
            <summary>
            Contact database field definition
            </summary>
        </member>
        <member name="M:Bowling.Domain.Concrete.EntityFramework.Mapping.RoundMap.#ctor">
            <summary>
            Define the table fields
            </summary>
        </member>
        <member name="T:Bowling.Domain.Entities.Attendee">
            <summary>
            Record of which bowlers attended each event, along with their food option and score
            </summary>
        </member>
        <member name="T:Bowling.Domain.Entities.BaseEntity">
            <summary>
            Base entity used by all entities
            </summary>
        </member>
        <member name="M:Bowling.Domain.Entities.BaseEntity.OnPropertyChanged(System.String)">
            <summary>
            On property changed event
            </summary>
            <param name="propertyName">Property being changed</param>
        </member>
        <member name="M:Bowling.Domain.Entities.BaseEntity.OnPropertyChanging(System.String)">
            <summary>
            Property changing event
            </summary>
            <param name="propertyName">Property being changed</param>
        </member>
        <member name="P:Bowling.Domain.Entities.BaseEntity.Id">
            <summary>
            Key
            </summary>
        </member>
        <member name="E:Bowling.Domain.Entities.BaseEntity.PropertyChanged">
            <summary>
            Property changed event handler
            </summary>
        </member>
        <member name="E:Bowling.Domain.Entities.BaseEntity.PropertyChanging">
            <summary>
            Property changing event handler
            </summary>
        </member>
        <member name="M:Bowling.Domain.Entities.Attendee.#ctor(Bowling.Domain.Entities.Bowler,Bowling.Domain.Entities.Event,Bowling.Domain.Entities.FoodOption)">
            <summary>
            only constructor
            </summary>
            <param name="bowler"></param>
            <param name="bowlingEvent"></param>
            <param name="foodOption"></param>
        </member>
        <member name="P:Bowling.Domain.Entities.Attendee.Bowler">
            <summary>
            Bowler who attended event
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Attendee.Event">
            <summary>
            Event Attended
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Attendee.FoodOption">
            <summary>
            Choice of food
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Attendee.Paid">
            <summary>
            Has the bowler paid for the event
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Attendee.PaidDateTime">
            <summary>
            Date and Time bowler paid for the event
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Attendee.SignUpDateTime">
            <summary>
            Date and Time Bowler signed up for the event
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Attendee.Results">
            <summary>
            Bowling scores
            </summary>
        </member>
        <member name="T:Bowling.Domain.Entities.Bowler">
            <summary>
            A Bowler
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Bowler.Name">
            <summary>
            Display name of bowler
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Bowler.Attendees">
            <summary>
            List of all the times the bowler was an attendee of an event
            </summary>
        </member>
        <member name="T:Bowling.Domain.Entities.Event">
            <summary>
            Bowling event night
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Event.Name">
            <summary>
            Name of event
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Event.Description">
            <summary>
            Event description
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Event.Price">
            <summary>
            Price
            </summary>
        </member>
        <member name="P:Bowling.Domain.Entities.Event.Attendees">
            <summary>
            List of Bowlers attending event
            </summary>
        </member>
    </members>
</doc>