public static FileItem NewObject(ClientTransaction clientTransaction)
{
using (clientTransaction.EnterNonDiscardingScope())
{
return(DomainObject.NewObject <FileItem> ());
}
}
public new static Customer NewObject()
{
return(DomainObject.NewObject <Customer> ());
}
public new static Partner NewObject()
{
return(DomainObject.NewObject <Partner> ());
}
public static Address NewObject()
{
return(DomainObject.NewObject <Address> ());
}
public new static DerivedClass NewObject()
{
return(DomainObject.NewObject <DerivedClass> ());
}
public new static DevelopmentPartner NewObject()
{
return(DomainObject.NewObject <DevelopmentPartner> ());
}
public static Ceo NewObject()
{
return(DomainObject.NewObject <Ceo> ());
}
public static Company NewObject()
{
return(DomainObject.NewObject <Company>());
}
public static Client NewObject()
{
return(DomainObject.NewObject <Client>());
}
public static Employee NewObject()
{
return(DomainObject.NewObject <Employee> ());
}
public static ClassWithoutProperties NewObject()
{
return(DomainObject.NewObject <ClassWithoutProperties> ());
}
/// <summary>
/// Returns a new instance of a concrete domain object for the current<see cref="DomainObjects.ClientTransaction"/>. The instance is constructed
/// with a constructor accepting the given parameter list.
/// </summary>
/// <param name="constructorParameters">A <see cref="ParamList"/> object holding the parameters to be passed to the constructor. Instantiate this
/// by using one of the <see cref="ParamList.Create{A1,A2}"/> methods.</param>
/// <returns>A new <typeparamref name="TDomainObject"/> instance.</returns>
/// <remarks>
/// <para>
/// This method is identical to <see cref="DomainObject.NewObject{T}(ParamList)"/>, but it can be called from any other class whereas
/// <see cref="DomainObject.NewObject{T}(ParamList)"/> can only be called from classes derived from <see cref="DomainObject"/>.
/// </para>
/// </remarks>
/// <seealso cref="DomainObject.NewObject{T}(ParamList)"/>
/// <exception cref="ArgumentException">The type <typeparamref name="TDomainObject"/> cannot be extended to a proxy, for example because it is sealed
/// or abstract and non-instantiable.</exception>
/// <exception cref="MissingMethodException">The given type <typeparamref name="TDomainObject"/> does not implement the required protected
/// constructor.
/// </exception>
public static TDomainObject NewObject(ParamList constructorParameters)
{
ArgumentUtility.CheckNotNull("constructorParameters", constructorParameters);
return(DomainObject.NewObject <TDomainObject> (constructorParameters));
}
/// <summary>
/// Returns a new instance of a concrete domain object for the current<see cref="DomainObjects.ClientTransaction"/>. The instance is constructed
/// with the default constructor.
/// </summary>
/// <returns>A new <typeparamref name="TDomainObject"/> instance.</returns>
/// <remarks>
/// <para>
/// This method is identical to <see cref="DomainObject.NewObject{T}()"/>, but it can be called from any other class whereas
/// <see cref="DomainObject.NewObject{T}()"/> can only be called from classes derived from <see cref="DomainObject"/>.
/// </para>
/// </remarks>
/// <seealso cref="DomainObject.NewObject{T}()"/>
/// <exception cref="ArgumentException">The type <typeparamref name="TDomainObject"/> cannot be extended to a proxy, for example because it is sealed
/// or abstract and non-instantiable.</exception>
/// <exception cref="MissingMethodException">The given type <typeparamref name="TDomainObject"/> does not implement the required protected
/// constructor.
/// </exception>
public static TDomainObject NewObject()
{
return(DomainObject.NewObject <TDomainObject>());
}
public static ConcreteClass NewObject()
{
return(DomainObject.NewObject <ConcreteClass> ());
}
public static ClassForRelationTest NewObject()
{
return(DomainObject.NewObject <ClassForRelationTest> ());
}
public static ClassWithUndefinedEnum NewObject()
{
return(DomainObject.NewObject <ClassWithUndefinedEnum> ());
}
public static ClassWithRelations NewObject()
{
return(DomainObject.NewObject <ClassWithRelations>());
}
public static Order NewObject()
{
return(DomainObject.NewObject <Order> ());
}
public static File NewObject()
{
return(DomainObject.NewObject <File>());
}
