public RbECROperationType()
{
this._ECROperations = new EntitySet<ECROperation>(new Action<ECROperation>(this.attach_ECROperations), new Action<ECROperation>(this.detach_ECROperations));
this._Person_CreatePersonId = default(EntityRef<Person>);
this._Person_ModifyPersonId = default(EntityRef<Person>);
OnCreated();
}
public ClientQuoting()
{
this._ActionPropertyClientQuotings = new EntitySet<ActionPropertyClientQuoting>(new Action<ActionPropertyClientQuoting>(this.attach_ActionPropertyClientQuotings), new Action<ActionPropertyClientQuoting>(this.detach_ActionPropertyClientQuotings));
this._Person_CreatePersonId = default(EntityRef<Person>);
this._Person_ModifyPersonId = default(EntityRef<Person>);
OnCreated();
}
// Assign handlers for the add and remove operations, respectively.
public TaskSeries()
{
_tasks = new EntitySet<Task>(
new Action<Task>(this.attach_Task),
new Action<Task>(this.detach_Task)
);
}
/// <summary>Initializes a new instance of the <see cref="CountryRegion"/> class.</summary>
public CountryRegion()
{
_countryRegionCurrencies = new EntitySet<CountryRegionCurrency>(new Action<CountryRegionCurrency>(this.Attach_CountryRegionCurrencies), new Action<CountryRegionCurrency>(this.Detach_CountryRegionCurrencies) );
_salesTerritories = new EntitySet<SalesTerritory>(new Action<SalesTerritory>(this.Attach_SalesTerritories), new Action<SalesTerritory>(this.Detach_SalesTerritories) );
_stateProvinces = new EntitySet<StateProvince>(new Action<StateProvince>(this.Attach_StateProvinces), new Action<StateProvince>(this.Detach_StateProvinces) );
OnCreated();
}
public RbEmergencyPlaceReceptionCall()
{
this._EmergencyCalls = new EntitySet<EmergencyCall>(new Action<EmergencyCall>(this.attach_EmergencyCalls), new Action<EmergencyCall>(this.detach_EmergencyCalls));
this._Person_CreatePersonId = default(EntityRef<Person>);
this._Person_ModifyPersonId = default(EntityRef<Person>);
OnCreated();
}
public RbStatusObservationClientType()
{
this._ClientStatusObservations = new EntitySet<ClientStatusObservation>(new Action<ClientStatusObservation>(this.attach_ClientStatusObservations), new Action<ClientStatusObservation>(this.detach_ClientStatusObservations));
this._Person_CreatePersonId = default(EntityRef<Person>);
this._Person_ModifyPersonId = default(EntityRef<Person>);
OnCreated();
}
/// <summary>Initializes a new instance of the <see cref="ProductModel"/> class.</summary>
public ProductModel()
{
_products = new EntitySet<Product>(new Action<Product>(this.Attach_Products), new Action<Product>(this.Detach_Products) );
_productModelIllustrations = new EntitySet<ProductModelIllustration>(new Action<ProductModelIllustration>(this.Attach_ProductModelIllustrations), new Action<ProductModelIllustration>(this.Detach_ProductModelIllustrations) );
_productModelProductDescriptionCultures = new EntitySet<ProductModelProductDescriptionCulture>(new Action<ProductModelProductDescriptionCulture>(this.Attach_ProductModelProductDescriptionCultures), new Action<ProductModelProductDescriptionCulture>(this.Detach_ProductModelProductDescriptionCultures) );
OnCreated();
}
private static void SetupEntities(EntitySet set)
{
var entity1 = CreateEntity(set, "Entity1");
var entity2 = CreateEntity(set, "Entity2");
entity1.CreateReferenceTo(entity2);
}
/// <summary>Initializes a new instance of the <see cref="CurrencyRate"/> class.</summary>
public CurrencyRate()
{
_currency = default(EntityRef<Currency>);
_currency1 = default(EntityRef<Currency>);
_salesOrderHeaders = new EntitySet<SalesOrderHeader>(new Action<SalesOrderHeader>(this.Attach_SalesOrderHeaders), new Action<SalesOrderHeader>(this.Detach_SalesOrderHeaders) );
OnCreated();
}
/// <summary>Initializes a new instance of the <see cref="Order"/> class.</summary>
public Order()
{
_customer = default(EntityRef<Customer>);
_employee = default(EntityRef<Employee>);
_orderRows = new EntitySet<OrderRow>(new Action<OrderRow>(this.Attach_OrderRows), new Action<OrderRow>(this.Detach_OrderRows) );
OnCreated();
}
public RbHospitalBedType()
{
this._OrgStructureHospitalBeds = new EntitySet<OrgStructureHospitalBed>(new Action<OrgStructureHospitalBed>(this.attach_OrgStructureHospitalBeds), new Action<OrgStructureHospitalBed>(this.detach_OrgStructureHospitalBeds));
this._Person_CreatePersonId = default(EntityRef<Person>);
this._Person_ModifyPersonId = default(EntityRef<Person>);
OnCreated();
}
public LocationAddress()
{
_location = new EntitySet<Location>(
attach_Location,
detach_Location
);
}
public Nests()
{
_words = new EntitySet<Words>(
new Action<Words>(this.attach_Words),
new Action<Words>(this.detach_Words)
);
}
public OrganisationAccount()
{
this._Contracts_RecipientAccountId = new EntitySet<Contract>(new Action<Contract>(this.attach_Contracts_RecipientAccountId), new Action<Contract>(this.detach_Contracts_RecipientAccountId));
this._Contracts_PayerAccountId = new EntitySet<Contract>(new Action<Contract>(this.attach_Contracts_PayerAccountId), new Action<Contract>(this.detach_Contracts_PayerAccountId));
this._Bank = default(EntityRef<Bank>);
OnCreated();
}
/// <summary>Initializes a new instance of the <see cref="WorkOrder"/> class.</summary>
public WorkOrder()
{
_product = default(EntityRef<Product>);
_scrapReason = default(EntityRef<ScrapReason>);
_workOrderRoutings = new EntitySet<WorkOrderRouting>(new Action<WorkOrderRouting>(this.Attach_WorkOrderRoutings), new Action<WorkOrderRouting>(this.Detach_WorkOrderRoutings) );
OnCreated();
}
public RbBloodType()
{
this._Clients = new EntitySet<Client>(new Action<Client>(this.attach_Clients), new Action<Client>(this.detach_Clients));
this._Person_CreatePersonId = default(EntityRef<Person>);
this._Person_ModifyPersonId = default(EntityRef<Person>);
OnCreated();
}
public RbTempInvalidExtraReason()
{
this._TempInvalids = new EntitySet<TempInvalid>(new Action<TempInvalid>(this.attach_TempInvalids), new Action<TempInvalid>(this.detach_TempInvalids));
this._Person_CreatePersonId = default(EntityRef<Person>);
this._Person_ModifyPersonId = default(EntityRef<Person>);
OnCreated();
}
public Account()
{
_accountRoles = new EntitySet<AccountRole>(new Action<AccountRole>(this.AccountRoles_Attach), new Action<AccountRole>(this.AccountRoles_Detach));
_avatar = new EntitySet<Avatar>(new Action<Avatar>(this.Avatar_Attach), new Action<Avatar>(this.Avatar_Detach));
_accountSessions = new EntitySet<AccountSession>(new Action<AccountSession>(this.AccountSessions_Attach), new Action<AccountSession>(this.AccountSessions_Detach));
this.OnCreated();
}
public JobTicket()
{
this._ActionPropertyJobTickets = new EntitySet<ActionPropertyJobTicket>(new Action<ActionPropertyJobTicket>(this.attach_ActionPropertyJobTickets), new Action<ActionPropertyJobTicket>(this.detach_ActionPropertyJobTickets));
this._EQueueTicket = default(EntityRef<EQueueTicket>);
this._Job = default(EntityRef<Job>);
OnCreated();
}
public void Handler_ReturnsRemoteMembershipViews_WhenFound_ByUserId()
{
var userId = FakeData.Id();
var otherUserId1 = FakeData.Id(userId);
var otherUserId2 = FakeData.Id(userId, otherUserId1);
var remoteMemberships = new[]
{
new ProxiedRemoteMembership(FakeData.String(), FakeData.String())
{ UserId = otherUserId1, },
new ProxiedRemoteMembership(FakeData.String(), FakeData.String())
{ UserId = otherUserId2, },
new ProxiedRemoteMembership(FakeData.String(), FakeData.String())
{ UserId = userId, },
};
var data = remoteMemberships.AsQueryable();
var query = new RemoteMembershipViewsBy(userId);
var dbSet = new Mock<DbSet<RemoteMembership>>(MockBehavior.Strict).SetupDataAsync(data);
var entities = new Mock<IReadEntities>(MockBehavior.Strict);
var entitySet = new EntitySet<RemoteMembership>(dbSet.Object, entities.Object);
entities.Setup(x => x.Query<RemoteMembership>()).Returns(entitySet);
var handler = new HandleRemoteMembershipViewsByQuery(entities.Object);
RemoteMembershipView[] results = handler.Handle(query).Result.ToArray();
results.ShouldNotBeNull();
results.Length.ShouldEqual(1);
RemoteMembershipView result = results.Single();
var expectedEntity = data.Single(x => x.UserId == userId);
result.UserId.ShouldEqual(expectedEntity.UserId);
result.Provider.ShouldEqual(expectedEntity.LoginProvider);
result.Key.ShouldEqual(expectedEntity.ProviderKey);
entities.Verify(x => x.Query<RemoteMembership>(), Times.Once);
}
public RbNomenclatureAnalog()
{
this._RbNomenclatures = new EntitySet<RbNomenclature>(new Action<RbNomenclature>(this.attach_RbNomenclatures), new Action<RbNomenclature>(this.detach_RbNomenclatures));
this._Person_CreatePersonId = default(EntityRef<Person>);
this._Person_ModifyPersonId = default(EntityRef<Person>);
OnCreated();
}
public Department()
{
_employees = new EntitySet<Employee>(
new Action<Employee>(this.attach_Employee),
new Action<Employee>(this.detach_Employee)
);
}
public override EntitySet LoadWithId(string type, string[] id, string[] attributes)
{
EntitySet result = new EntitySet();
foreach (string itemId in id)
{
string strQuote = itemId.IndexOf("'") > 0 ? "\"" : "'"; // if id contains ' limiter is " else '
ArrayList subQueries = new ArrayList();
// Creates a query for each sub-type, and concatenates them using and OR expression
foreach (string subtype in Factory.Model.GetTreeAsArray(type))
subQueries.Add(String.Concat("id(", strQuote, _CommandProcessor.GetKey(subtype, itemId), strQuote, ")"));
if (subQueries.Count == 0)
throw new ModelElementNotFoundException("No such types in metadata: " + type);
EntitySet es = LoadWithXPath(String.Join(" | ", (string[])subQueries.ToArray(typeof(string))));
if (es.Count > 0)
result.Add(es[0]);
}
if (result.Count > 0)
LoadAttribute(result, attributes);
return result;
}
public RbReasonOfAbsence()
{
this._ActionPropertyRbReasonOfAbsences = new EntitySet<ActionPropertyRbReasonOfAbsence>(new Action<ActionPropertyRbReasonOfAbsence>(this.attach_ActionPropertyRbReasonOfAbsences), new Action<ActionPropertyRbReasonOfAbsence>(this.detach_ActionPropertyRbReasonOfAbsences));
this._Person_CreatePersonId = default(EntityRef<Person>);
this._Person_ModifyPersonId = default(EntityRef<Person>);
OnCreated();
}
public Group()
{
_activitiesGroupsRef = new EntitySet<ActivityGroup>(
new Action<ActivityGroup>(this.addActivitiesGroupsRef),
new Action<ActivityGroup>(this.removeActivitiesGroupsRef)
);
}
public void Handler_ReturnsNullLocalMembership_WhenNotFound_ByVerifiedEmail()
{
var emailAddress = FakeData.Email();
var user = new User();
user.EmailAddresses.Add(new EmailAddress
{
IsVerified = false,
Value = emailAddress,
});
var data = new[]
{
new LocalMembership { User = user, },
}.AsQueryable();
var query = new LocalMembershipByVerifiedEmail(emailAddress);
var dbSet = new Mock<DbSet<LocalMembership>>(MockBehavior.Strict).SetupDataAsync(data);
var entities = new Mock<IReadEntities>(MockBehavior.Strict);
var entitySet = new EntitySet<LocalMembership>(dbSet.Object, entities.Object);
entities.Setup(x => x.Query<LocalMembership>()).Returns(entitySet);
var handler = new HandleLocalMembershipByVerifiedEmailQuery(entities.Object);
LocalMembership result = handler.Handle(query).Result;
result.ShouldBeNull();
entities.Verify(x => x.Query<LocalMembership>(), Times.Once);
}
// Assign handlers for the add and remove operations, respectively.
public ToDoCategory()
{
_todos = new EntitySet<ToDoItem>(
new Action<ToDoItem>(this.attach_ToDo),
new Action<ToDoItem>(this.detach_ToDo)
);
}
public void Handler_ReturnsTrue_WhenFound_ByUserId()
{
var userId = FakeData.Id();
var otherUserId1 = FakeData.Id(userId);
var otherUserId2 = FakeData.Id(userId, otherUserId1);
var user = new ProxiedUser(userId);
var otherUser1 = new ProxiedUser(otherUserId1);
var otherUser2 = new ProxiedUser(otherUserId2);
var localMemberships = new[]
{
new LocalMembership { User = otherUser1, },
new LocalMembership { User = user, },
new LocalMembership { User = otherUser2, },
};
var data = localMemberships.AsQueryable();
var query = new UserHasLocalMembership(user.Id);
var dbSet = new Mock<DbSet<LocalMembership>>(MockBehavior.Strict).SetupDataAsync(data);
var entities = new Mock<IReadEntities>(MockBehavior.Strict);
var entitySet = new EntitySet<LocalMembership>(dbSet.Object, entities.Object);
entities.Setup(x => x.Query<LocalMembership>()).Returns(entitySet);
var handler = new HandleUserHasLocalMembershipQuery(entities.Object);
bool result = handler.Handle(query).Result;
result.ShouldBeTrue();
entities.Verify(x => x.Query<LocalMembership>(), Times.Once);
}
public ECROperation()
{
this._ECRCheckItems = new EntitySet<ECRCheckItem>(new Action<ECRCheckItem>(this.attach_ECRCheckItems), new Action<ECRCheckItem>(this.detach_ECRCheckItems));
this._Person = default(EntityRef<Person>);
this._RbECROperationType = default(EntityRef<RbECROperationType>);
OnCreated();
}
/// <summary>Initializes a new instance of the <see cref="SpecialOfferProduct"/> class.</summary>
public SpecialOfferProduct()
{
_product = default(EntityRef<Product>);
_salesOrderDetails = new EntitySet<SalesOrderDetail>(new Action<SalesOrderDetail>(this.Attach_SalesOrderDetails), new Action<SalesOrderDetail>(this.Detach_SalesOrderDetails) );
_specialOffer = default(EntityRef<SpecialOffer>);
OnCreated();
}
internal AssociationSetMapping(AssociationSet associationSet, EntitySet storeEntitySet)
: this(associationSet, storeEntitySet, (EntityContainerMapping)null)
{
}
public Orders()
{
this._Order_Details = new EntitySet <Order_Details>(new Action <Order_Details>(this.attach_Order_Details), new Action <Order_Details>(this.detach_Order_Details));
this._Customers = default(EntityRef <Customers>);
OnCreated();
}
public Customers()
{
this._Orders = new EntitySet <Orders>(new Action <Orders>(this.attach_Orders), new Action <Orders>(this.detach_Orders));
OnCreated();
}
public Customer()
{
this._Orders = new EntitySet <Order>();
}
public Lecture()
{
this._StudentLectures = new EntitySet <StudentLecture>(new Action <StudentLecture>(this.attach_StudentLectures), new Action <StudentLecture>(this.detach_StudentLectures));
OnCreated();
}
public Student()
{
this._StudentLectures = new EntitySet <StudentLecture>(new Action <StudentLecture>(this.attach_StudentLectures), new Action <StudentLecture>(this.detach_StudentLectures));
this._University = default(EntityRef <University>);
OnCreated();
}
public University()
{
this._Students = new EntitySet <Student>(new Action <Student>(this.attach_Students), new Action <Student>(this.detach_Students));
OnCreated();
}
public Answer()
{
this._DetailSurveys = new EntitySet <DetailSurvey>(new Action <DetailSurvey>(this.attach_DetailSurveys), new Action <DetailSurvey>(this.detach_DetailSurveys));
OnCreated();
}
public System(EntitySet set, IParallelRunner runner, int minEntityCountByRunnerIndex)
: base(set, runner, minEntityCountByRunnerIndex)
{
}
public CabinType()
{
this._Surveys = new EntitySet <Survey>(new Action <Survey>(this.attach_Surveys), new Action <Survey>(this.detach_Surveys));
OnCreated();
}
public System(EntitySet set)
: base(set)
{
}
public Airport()
{
this._Surveys = new EntitySet <Survey>(new Action <Survey>(this.attach_Surveys), new Action <Survey>(this.detach_Surveys));
this._Surveys1 = new EntitySet <Survey>(new Action <Survey>(this.attach_Surveys1), new Action <Survey>(this.detach_Surveys1));
OnCreated();
}
public Subject()
{
this._Marks = new EntitySet <Mark>(new Action <Mark>(this.attach_Marks), new Action <Mark>(this.detach_Marks));
this._Registrations = new EntitySet <Registration>(new Action <Registration>(this.attach_Registrations), new Action <Registration>(this.detach_Registrations));
OnCreated();
}
public System(EntitySet set, IParallelRunner runner)
: base(set, runner)
{
}
/// <summary>
/// don't let this be constructed publicly;
/// </summary>
/// <exception cref="EntityCommandCompilationException">Cannot prepare the command definition for execution; consult the InnerException for more information.</exception>
/// <exception cref="NotSupportedException">The ADO.NET Data Provider you are using does not support CommandTrees.</exception>
internal EntityCommandDefinition(DbProviderFactory storeProviderFactory, DbCommandTree commandTree)
{
EntityUtil.CheckArgumentNull(storeProviderFactory, "storeProviderFactory");
EntityUtil.CheckArgumentNull(commandTree, "commandTree");
DbProviderServices storeProviderServices = DbProviderServices.GetProviderServices(storeProviderFactory);
try {
if (DbCommandTreeKind.Query == commandTree.CommandTreeKind)
{
// Next compile the plan for the command tree
List <ProviderCommandInfo> mappedCommandList = new List <ProviderCommandInfo>();
ColumnMap columnMap;
int columnCount;
PlanCompiler.Compile(commandTree, out mappedCommandList, out columnMap, out columnCount, out _entitySets);
_columnMapGenerators = new IColumnMapGenerator[] { new ConstantColumnMapGenerator(columnMap, columnCount) };
// Note: we presume that the first item in the ProviderCommandInfo is the root node;
Debug.Assert(mappedCommandList.Count > 0, "empty providerCommandInfo collection and no exception?"); // this shouldn't ever happen.
// Then, generate the store commands from the resulting command tree(s)
_mappedCommandDefinitions = new List <DbCommandDefinition>(mappedCommandList.Count);
foreach (ProviderCommandInfo providerCommandInfo in mappedCommandList)
{
DbCommandDefinition providerCommandDefinition = storeProviderServices.CreateCommandDefinition(providerCommandInfo.CommandTree);
if (null == providerCommandDefinition)
{
throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.ProviderReturnedNullForCreateCommandDefinition);
}
_mappedCommandDefinitions.Add(providerCommandDefinition);
}
}
else
{
Debug.Assert(DbCommandTreeKind.Function == commandTree.CommandTreeKind, "only query and function command trees are supported");
DbFunctionCommandTree entityCommandTree = (DbFunctionCommandTree)commandTree;
// Retrieve mapping and metadata information for the function import.
FunctionImportMappingNonComposable mapping = GetTargetFunctionMapping(entityCommandTree);
IList <FunctionParameter> returnParameters = entityCommandTree.EdmFunction.ReturnParameters;
int resultSetCount = returnParameters.Count > 1 ? returnParameters.Count : 1;
_columnMapGenerators = new IColumnMapGenerator[resultSetCount];
TypeUsage storeResultType = DetermineStoreResultType(entityCommandTree.MetadataWorkspace, mapping, 0, out _columnMapGenerators[0]);
for (int i = 1; i < resultSetCount; i++)
{
DetermineStoreResultType(entityCommandTree.MetadataWorkspace, mapping, i, out _columnMapGenerators[i]);
}
// Copy over parameters (this happens through a more indirect route in the plan compiler, but
// it happens nonetheless)
List <KeyValuePair <string, TypeUsage> > providerParameters = new List <KeyValuePair <string, TypeUsage> >();
foreach (KeyValuePair <string, TypeUsage> parameter in entityCommandTree.Parameters)
{
providerParameters.Add(parameter);
}
// Construct store command tree usage.
DbFunctionCommandTree providerCommandTree = new DbFunctionCommandTree(entityCommandTree.MetadataWorkspace, DataSpace.SSpace,
mapping.TargetFunction, storeResultType, providerParameters);
DbCommandDefinition storeCommandDefinition = storeProviderServices.CreateCommandDefinition(providerCommandTree);
_mappedCommandDefinitions = new List <DbCommandDefinition>(1)
{
storeCommandDefinition
};
EntitySet firstResultEntitySet = mapping.FunctionImport.EntitySets.FirstOrDefault();
if (firstResultEntitySet != null)
{
_entitySets = new Set <EntitySet>();
_entitySets.Add(mapping.FunctionImport.EntitySets.FirstOrDefault());
_entitySets.MakeReadOnly();
}
}
// Finally, build a list of the parameters that the resulting command should have;
List <EntityParameter> parameterList = new List <EntityParameter>();
foreach (KeyValuePair <string, TypeUsage> queryParameter in commandTree.Parameters)
{
EntityParameter parameter = CreateEntityParameterFromQueryParameter(queryParameter);
parameterList.Add(parameter);
}
_parameters = new System.Collections.ObjectModel.ReadOnlyCollection <EntityParameter>(parameterList);
}
catch (EntityCommandCompilationException) {
// No need to re-wrap EntityCommandCompilationException
throw;
}
catch (Exception e) {
// we should not be wrapping all exceptions
if (EntityUtil.IsCatchableExceptionType(e))
{
// we don't wan't folks to have to know all the various types of exceptions that can
// occur, so we just rethrow a CommandDefinitionException and make whatever we caught
// the inner exception of it.
throw EntityUtil.CommandCompilation(System.Data.Entity.Strings.EntityClient_CommandDefinitionPreparationFailed, e);
}
throw;
}
}
public System(EntitySet set, bool useBuffer)
: base(set, useBuffer)
{
}
public DictionaryHeader()
{
this._Dictionaries = new EntitySet<Dictionary>(new Action<Dictionary>(this.attach_Dictionaries), new Action<Dictionary>(this.detach_Dictionaries));
OnCreated();
}
internal FunctionColumnMapGenerator(FunctionImportMappingNonComposable mapping, int resultSetIndex, EntitySet entitySet, StructuralType baseStructuralType)
{
_mapping = mapping;
_entitySet = entitySet;
_baseStructuralType = baseStructuralType;
_resultSetIndex = resultSetIndex;
}
public NHANVIEN()
{
this._LOPs = new EntitySet <LOP>(new Action <LOP>(this.attach_LOPs), new Action <LOP>(this.detach_LOPs));
OnCreated();
}
public Territory()
{
this._EmployeeTerritories = new EntitySet <EmployeeTerritory>();
}
public HOCPHAN()
{
this._BANGDIEMs = new EntitySet <BANGDIEM>(new Action <BANGDIEM>(this.attach_BANGDIEMs), new Action <BANGDIEM>(this.detach_BANGDIEMs));
OnCreated();
}
public Bird()
{
this._BirdCounts = new EntitySet <BirdCount>(new Action <BirdCount>(this.attach_BirdCounts), new Action <BirdCount>(this.detach_BirdCounts));
OnCreated();
}
public TabSystemUser()
{
_tabCredentialInFoS = new EntitySet <TabCredentialInfos>(new Action <TabCredentialInfos>(this.TabCredentialInFOs_Attach), new Action <TabCredentialInfos>(this.TabCredentialInFOs_Detach));
this.OnCreated();
}
public LOP()
{
this._SINHVIENs = new EntitySet <SINHVIEN>(new Action <SINHVIEN>(this.attach_SINHVIENs), new Action <SINHVIEN>(this.detach_SINHVIENs));
this._NHANVIEN = default(EntityRef <NHANVIEN>);
OnCreated();
}
public User()
{
this._Videos = new EntitySet <Video>(new Action <Video>(this.attach_Videos), new Action <Video>(this.detach_Videos));
OnCreated();
}
public SINHVIEN()
{
this._BANGDIEMs = new EntitySet <BANGDIEM>(new Action <BANGDIEM>(this.attach_BANGDIEMs), new Action <BANGDIEM>(this.detach_BANGDIEMs));
this._LOP = default(EntityRef <LOP>);
OnCreated();
}
public virtual T GetModel(Expression <Func <T, bool> > exp) => EntitySet.SingleOrDefault(exp);
public Product()
{
this._Order_Details = new EntitySet <Order_Detail>(new Action <Order_Detail>(this.attach_Order_Details), new Action <Order_Detail>(this.detach_Order_Details));
OnCreated();
}
public virtual IQueryable <T> GetModels(Expression <Func <T, bool> > exp) => EntitySet.Where(exp);
public virtual int GetCount(Expression <Func <T, bool> > exp) => exp == null?EntitySet.Count() : EntitySet.Where(exp).Count();