MARKUS

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProjectGuid>{5A357291-C483-4101-B604-DF20A2551BCB}</ProjectGuid>

    <OutputType>Library</OutputType>

    <AppDesignerFolder>Properties</AppDesignerFolder>

    <RootNamespace>DatabseModelCRUDSampleDLL</RootNamespace>

    <AssemblyName>DatabseModelCRUDSampleDLL</AssemblyName>

    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>

    <FileAlignment>512</FileAlignment>

    <Deterministic>true</Deterministic>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>bin\Debug\</OutputPath>

    <DefineConstants>DEBUG;TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <DebugType>pdbonly</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>bin\Release\</OutputPath>

    <DefineConstants>TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <ItemGroup>

    <Reference Include="EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">

      <HintPath>..\packages\EntityFramework.6.2.0\lib\net45\EntityFramework.dll</HintPath>

    </Reference>

    <Reference Include="EntityFramework.SqlServer, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">

      <HintPath>..\packages\EntityFramework.6.2.0\lib\net45\EntityFramework.SqlServer.dll</HintPath>

    </Reference>

    <Reference Include="Markus.EntityModel, Version=0.0.0.0, Culture=neutral, processorArchitecture=MSIL">

      <HintPath>..\packages\MarkusDatabase.1.7.2\lib\net45\Markus.EntityModel.dll</HintPath>

    </Reference>

    <Reference Include="System" />

    <Reference Include="System.ComponentModel.DataAnnotations" />

    <Reference Include="System.Core" />

    <Reference Include="System.Xml.Linq" />

    <Reference Include="System.Data.DataSetExtensions" />

    <Reference Include="Microsoft.CSharp" />

    <Reference Include="System.Data" />

    <Reference Include="System.Net.Http" />

    <Reference Include="System.Xml" />

  </ItemGroup>

  <ItemGroup>

    <Compile Include="TestDataBase.cs" />

    <Compile Include="Properties\AssemblyInfo.cs" />

  </ItemGroup>

  <ItemGroup>

    <None Include="App.config" />

    <None Include="packages.config" />

  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

</Project>

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

// 어셈블리에 대한 일반 정보는 다음 특성 집합을 통해 

// 제어됩니다. 어셈블리와 관련된 정보를 수정하려면

// 이러한 특성 값을 변경하세요.

[assembly: AssemblyTitle("DatabseModelCRUDSampleDLL")]

[assembly: AssemblyDescription("")]

[assembly: AssemblyConfiguration("")]

[assembly: AssemblyCompany("")]

[assembly: AssemblyProduct("DatabseModelCRUDSampleDLL")]

[assembly: AssemblyCopyright("Copyright ©  2019")]

[assembly: AssemblyTrademark("")]

[assembly: AssemblyCulture("")]

// ComVisible을 false로 설정하면 이 어셈블리의 형식이 COM 구성 요소에 

// 표시되지 않습니다. COM에서 이 어셈블리의 형식에 액세스하려면

// 해당 형식에 대해 ComVisible 특성을 true로 설정하세요.

[assembly: ComVisible(false)]

// 이 프로젝트가 COM에 노출되는 경우 다음 GUID는 typelib의 ID를 나타냅니다.

[assembly: Guid("5a357291-c483-4101-b604-df20a2551bcb")]

// 어셈블리의 버전 정보는 다음 네 가지 값으로 구성됩니다.

//

//      주 버전

//      부 버전 

//      빌드 번호

//      수정 버전

//

// 모든 값을 지정하거나 아래와 같이 '*'를 사용하여 빌드 번호 및 수정 번호를

// 기본값으로 할 수 있습니다.

// [assembly: AssemblyVersion("1.0.*")]

[assembly: AssemblyVersion("1.0.0.0")]

[assembly: AssemblyFileVersion("1.0.0.0")]

using Markus.EntityModel;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace DatabseModelCRUDSampleDLL

{

    public class TestDataBase : IDisposable

    {

        MarkusModel entities;

        public TestDataBase(string ConnectionString)

        {

            try

            {

                   //해당 프로젝트의 데이터베이스 연결

                   entities = new MarkusModel(ConnectionString);

            }

            catch (Exception ex)

            {

                throw ex;

            }

        }

        public List<CONVERTER_DOC> GetConvertDoc(int takeCount)

        {

           return  entities.CONVERTER_DOC.Take(takeCount).ToList();

        }

        public void Dispose()

        {

            if (entities != null)

            {

                entities.Dispose();

            }

        }

    }

}



Microsoft Visual Studio Solution File, Format Version 12.00

# Visual Studio 15

VisualStudioVersion = 15.0.28307.757

MinimumVisualStudioVersion = 10.0.40219.1

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WpfDataBaseTest", "WpfDataBaseTest\WpfDataBaseTest.csproj", "{B8F30C6E-9544-4DE8-A9B2-775FD30E2AC9}"

EndProject

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DatabseModelCRUDSampleDLL", "DatabseModelCRUDSampleDLL\DatabseModelCRUDSampleDLL.csproj", "{5A357291-C483-4101-B604-DF20A2551BCB}"

EndProject

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Markus.EntityModel", "EntityModel\Markus.EntityModel.csproj", "{E530645A-1B01-4060-96FC-D15B49E17D51}"

EndProject

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PakageTest", "PakageTest\PakageTest.csproj", "{DDDC91B6-CE98-4345-9BD7-74E159E0A70A}"

EndProject

Global

	GlobalSection(SolutionConfigurationPlatforms) = preSolution

		Debug|Any CPU = Debug|Any CPU

		Release|Any CPU = Release|Any CPU

	EndGlobalSection

	GlobalSection(ProjectConfigurationPlatforms) = postSolution

		{B8F30C6E-9544-4DE8-A9B2-775FD30E2AC9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{B8F30C6E-9544-4DE8-A9B2-775FD30E2AC9}.Debug|Any CPU.Build.0 = Debug|Any CPU

		{B8F30C6E-9544-4DE8-A9B2-775FD30E2AC9}.Release|Any CPU.ActiveCfg = Release|Any CPU

		{B8F30C6E-9544-4DE8-A9B2-775FD30E2AC9}.Release|Any CPU.Build.0 = Release|Any CPU

		{5A357291-C483-4101-B604-DF20A2551BCB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{5A357291-C483-4101-B604-DF20A2551BCB}.Debug|Any CPU.Build.0 = Debug|Any CPU

		{5A357291-C483-4101-B604-DF20A2551BCB}.Release|Any CPU.ActiveCfg = Release|Any CPU

		{5A357291-C483-4101-B604-DF20A2551BCB}.Release|Any CPU.Build.0 = Release|Any CPU

		{E530645A-1B01-4060-96FC-D15B49E17D51}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{E530645A-1B01-4060-96FC-D15B49E17D51}.Debug|Any CPU.Build.0 = Debug|Any CPU

		{E530645A-1B01-4060-96FC-D15B49E17D51}.Release|Any CPU.ActiveCfg = Release|Any CPU

		{E530645A-1B01-4060-96FC-D15B49E17D51}.Release|Any CPU.Build.0 = Release|Any CPU

		{DDDC91B6-CE98-4345-9BD7-74E159E0A70A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

		{DDDC91B6-CE98-4345-9BD7-74E159E0A70A}.Debug|Any CPU.Build.0 = Debug|Any CPU

		{DDDC91B6-CE98-4345-9BD7-74E159E0A70A}.Release|Any CPU.ActiveCfg = Release|Any CPU

		{DDDC91B6-CE98-4345-9BD7-74E159E0A70A}.Release|Any CPU.Build.0 = Release|Any CPU

	EndGlobalSection

	GlobalSection(SolutionProperties) = preSolution

		HideSolutionNode = FALSE

	EndGlobalSection

	GlobalSection(ExtensibilityGlobals) = postSolution

		SolutionGuid = {FBA3E879-6B25-4A8A-9096-7F1E09C5B18F}

	EndGlobalSection

EndGlobal

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class ATTACH_URL

    {

        public int ID { get; set; }

        public string GROUP_ID { get; set; }

        public string ATTACH_URL1 { get; set; }

        public string FILE_NAME { get; set; }

        public string CREATE_USER_ID { get; set; }

        public System.DateTime CREATE_DATE { get; set; }

        public virtual DOCUMENT_ITEM DOCUMENT_ITEM { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class CERTIFY_CMS_TEST

    {

        public string ID { get; set; }

        public string MEMBER_ID { get; set; }

        public string ACCESSTOKEN { get; set; }

        public string LOGIN_DATE { get; set; }

        public string EXPIRE_DATE { get; set; }

        public int DEVICE_TYPE { get; set; }

        public string DEVICE_SERIAL_NUMBER { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class CONVERTER_DOC

    {

        public string ID { get; set; }

        public string PROJECT_NO { get; set; }

        public string DOCUMENT_URL { get; set; }

        public string DOCUMENT_ID { get; set; }

        public System.DateTime CREATE_DATETIME { get; set; }

        public int STATUS { get; set; }

        public int TOTAL_PAGE { get; set; }

        public int CURRENT_PAGE { get; set; }

        public string EXCEPTION { get; set; }

        public Nullable<System.DateTime> END_DATETIME { get; set; }

        public Nullable<System.DateTime> START_DATETIME { get; set; }

        public string SERVICE_ID { get; set; }

        public int RECONVERTER { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class DOCINFO

    {

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]

        public DOCINFO()

        {

            this.DOCPAGE = new HashSet<DOCPAGE>();

            this.MARKUP_INFO = new HashSet<MARKUP_INFO>();

        }

        public string ID { get; set; }

        public string ORIGINAL_FILE { get; set; }

        public string DOCUMENT_ID { get; set; }

        public int PAGE_COUNT { get; set; }

        public string PROJECT_NO { get; set; }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]

        public virtual ICollection<DOCPAGE> DOCPAGE { get; set; }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]

        public virtual ICollection<MARKUP_INFO> MARKUP_INFO { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class DOCPAGE

    {

        public string ID { get; set; }

        public string DOCINFO_ID { get; set; }

        public int PAGE_NUMBER { get; set; }

        public string PAGE_WIDTH { get; set; }

        public string PAGE_HEIGHT { get; set; }

        public int PAGE_ANGLE { get; set; }

        public virtual DOCINFO DOCINFO { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class DOCUMENT_ITEM

    {

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]

        public DOCUMENT_ITEM()

        {

            this.ATTACH_URL = new HashSet<ATTACH_URL>();

        }

        public string ID { get; set; }

        public string REVISION { get; set; }

        public string DOCUMENT_NO { get; set; }

        public string DOCUMENT_NAME { get; set; }

        public string GROUP_NO { get; set; }

        public string ORIGINAL_FILE { get; set; }

        public string DOCUMENT_ID { get; set; }

        public string RESULT_FILE { get; set; }

        public string RESULT { get; set; }

        public string PROJECT_NO { get; set; }

        public string Link { get; set; }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]

        public virtual ICollection<ATTACH_URL> ATTACH_URL { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class ERROR_LOG

    {

        public int ID { get; set; }

        public string SERVICE_NAME { get; set; }

        public string LEVEL { get; set; }

        public string TYPE { get; set; }

        public string CONTENTS { get; set; }

        public string CREATE_DATETIME { get; set; }

        public string CODE { get; set; }

        public string DOCUMENT_ID { get; set; }

        public string PROJECT_NO { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class FAVORITE_DOC

    {

        public string ID { get; set; }

        public string PROJECT_NO { get; set; }

        public string DOCUMENT_ID { get; set; }

        public string GROUP_NO { get; set; }

        public string DOCUMENT_NO { get; set; }

        public string MEMBER_USER_ID { get; set; }

        public string DESCRIPTION { get; set; }

        public System.DateTime CREATE_TIME { get; set; }

        public int FLAG { get; set; }

        public string REVISION { get; set; }

        public int PAGE_NO { get; set; }

        public virtual MEMBER MEMBER { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class FINAL_PDF

    {

        public string ID { get; set; }

        public string PROJECT_NO { get; set; }

        public int DOCINFO_ID { get; set; }

        public int MARKUPINFO_ID { get; set; }

        public string CREATE_USER_ID { get; set; }

        public System.DateTime CREATE_DATETIME { get; set; }

        public int STATUS { get; set; }

        public int TOTAL_PAGE { get; set; }

        public int CURRENT_PAGE { get; set; }

        public string EXCEPTION { get; set; }

        public Nullable<System.DateTime> END_DATETIME { get; set; }

        public Nullable<System.DateTime> START_DATETIME { get; set; }

        public string DOCUMENT_ID { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class LOGIN_STAMP

    {

        public string ID { get; set; }

        public string USER_ID { get; set; }

        public string PROJECT_NO { get; set; }

        public string DOCUMENT_ID { get; set; }

        public System.DateTime START_DATETIME { get; set; }

        public Nullable<System.DateTime> END_DATETIME { get; set; }

        public int ISLOGIN { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class MARKUP_CHECKLIST

    {

        public int CK_NO { get; set; }

        public string CK_REV_NO { get; set; }

        public Nullable<int> CK_PAGE { get; set; }

        public string CK_COMMENT { get; set; }

        public string CK_TODO { get; set; }

        public string CK_STATUS { get; set; }

        public string CK_RESULT { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class MARKUP_DATA

    {

        public string ID { get; set; }

        public int PAGENUMBER { get; set; }

        public string DATA { get; set; }

        public string MARKUPINFO_VERSION_ID { get; set; }

        public int DATA_TYPE { get; set; }

        public virtual MARKUP_INFO_VERSION MARKUP_INFO_VERSION { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class MARKUP_INFO

    {

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]

        public MARKUP_INFO()

        {

            this.MARKUP_INFO_VERSION = new HashSet<MARKUP_INFO_VERSION>();

        }

        public string ID { get; set; }

        public string DOCINFO_ID { get; set; }

        public string USER_ID { get; set; }

        public System.DateTime CREATE_TIME { get; set; }

        public int CONSOLIDATE { get; set; }

        public string DESCRIPTION { get; set; }

        public int AVOID_CONSOLIDATE { get; set; }

        public int PART_CONSOLIDATE { get; set; }

        public Nullable<System.DateTime> UPDATE_TIME { get; set; }

        public virtual DOCINFO DOCINFO { get; set; }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]

        public virtual ICollection<MARKUP_INFO_VERSION> MARKUP_INFO_VERSION { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class MARKUP_INFO_VERSION

    {

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]

        public MARKUP_INFO_VERSION()

        {

            this.MARKUP_DATA = new HashSet<MARKUP_DATA>();

        }

        public string ID { get; set; }

        public string MARKUPINFO_ID { get; set; }

        public System.DateTime CREATE_DATE { get; set; }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]

        public virtual ICollection<MARKUP_DATA> MARKUP_DATA { get; set; }

        public virtual MARKUP_INFO MARKUP_INFO { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class MEMBER

    {

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]

        public MEMBER()

        {

            this.FAVORITE_DOC = new HashSet<FAVORITE_DOC>();

            this.SIGN_INFO = new HashSet<SIGN_INFO>();

            this.SYMBOL_PRIVATE = new HashSet<SYMBOL_PRIVATE>();

        }

        public string ID { get; set; }

        public string DEPARTMENT { get; set; }

        public string NAME { get; set; }

        public string POSITION { get; set; }

        public string EMAIL_ADDRESS { get; set; }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]

        public virtual ICollection<FAVORITE_DOC> FAVORITE_DOC { get; set; }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]

        public virtual ICollection<SIGN_INFO> SIGN_INFO { get; set; }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]

        public virtual ICollection<SYMBOL_PRIVATE> SYMBOL_PRIVATE { get; set; }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Collections.Generic;

    public partial class MEMBER_CMS_TEST

    {

        public string ID { get; set; }

        public string MEMBER_ID { get; set; }

        public string MEMBER_PASS { get; set; }

    }

}

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />

  <PropertyGroup>

    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>

    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>

    <ProjectGuid>{E530645A-1B01-4060-96FC-D15B49E17D51}</ProjectGuid>

    <OutputType>Library</OutputType>

    <RootNamespace>Markus.EntityModel</RootNamespace>

    <AssemblyName>Markus.EntityModel</AssemblyName>

    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>

    <FileAlignment>512</FileAlignment>

    <Deterministic>true</Deterministic>

    <PublishUrl>publish\</PublishUrl>

    <Install>true</Install>

    <InstallFrom>Disk</InstallFrom>

    <UpdateEnabled>false</UpdateEnabled>

    <UpdateMode>Foreground</UpdateMode>

    <UpdateInterval>7</UpdateInterval>

    <UpdateIntervalUnits>Days</UpdateIntervalUnits>

    <UpdatePeriodically>false</UpdatePeriodically>

    <UpdateRequired>false</UpdateRequired>

    <MapFileExtensions>true</MapFileExtensions>

    <ApplicationRevision>0</ApplicationRevision>

    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>

    <IsWebBootstrapper>false</IsWebBootstrapper>

    <UseApplicationTrust>false</UseApplicationTrust>

    <BootstrapperEnabled>true</BootstrapperEnabled>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

    <PlatformTarget>AnyCPU</PlatformTarget>

    <DebugSymbols>true</DebugSymbols>

    <DebugType>full</DebugType>

    <Optimize>false</Optimize>

    <OutputPath>..\Output\Debug\</OutputPath>

    <DefineConstants>DEBUG;TRACE</DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">

    <PlatformTarget>AnyCPU</PlatformTarget>

    <DebugType>pdbonly</DebugType>

    <Optimize>true</Optimize>

    <OutputPath>..\OutPut\Release\</OutputPath>

    <DefineConstants>

    </DefineConstants>

    <ErrorReport>prompt</ErrorReport>

    <WarningLevel>4</WarningLevel>

  </PropertyGroup>

  <PropertyGroup>

    <StartupObject />

  </PropertyGroup>

  <ItemGroup>

    <None Include="App.config" />

    <EntityDeploy Include="MarkusModel.edmx">

      <Generator>EntityModelCodeGenerator</Generator>

      <LastGenOutput>MarkusModel.Designer.cs</LastGenOutput>

    </EntityDeploy>

    <None Include="MarkusModel.edmx.diagram">

      <DependentUpon>MarkusModel.edmx</DependentUpon>

    </None>

    <None Include="packages.config" />

  </ItemGroup>

  <ItemGroup>

    <Content Include="MarkusDB.mdf" />

    <Content Include="MarkusDB_log.ldf">

      <DependentUpon>MarkusDB.mdf</DependentUpon>

    </Content>

    <Content Include="MarkusModel.Context.tt">

      <Generator>TextTemplatingFileGenerator</Generator>

      <DependentUpon>MarkusModel.edmx</DependentUpon>

      <LastGenOutput>MarkusModel.Context.cs</LastGenOutput>

    </Content>

    <Content Include="MarkusModel.tt">

      <Generator>TextTemplatingFileGenerator</Generator>

      <DependentUpon>MarkusModel.edmx</DependentUpon>

      <LastGenOutput>MarkusModel.cs</LastGenOutput>

    </Content>

  </ItemGroup>

  <ItemGroup>

    <Compile Include="ATTACH_URL.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="CERTIFY_CMS_TEST.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="CONVERTER_DOC.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="DOCINFO.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="DOCPAGE.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="DOCUMENT_ITEM.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="ERROR_LOG.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="FAVORITE_DOC.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="FINAL_PDF.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="LOGIN_STAMP.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="MARKUP_CHECKLIST.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="MARKUP_DATA.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="MARKUP_INFO.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="MARKUP_INFO_VERSION.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="MarkusEntities.cs" />

    <Compile Include="MarkusModel.Context.cs">

      <AutoGen>True</AutoGen>

      <DesignTime>True</DesignTime>

      <DependentUpon>MarkusModel.Context.tt</DependentUpon>

    </Compile>

    <Compile Include="MarkusModel.cs">

      <AutoGen>True</AutoGen>

      <DesignTime>True</DesignTime>

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="MarkusModel.Designer.cs">

      <AutoGen>True</AutoGen>

      <DesignTime>True</DesignTime>

      <DependentUpon>MarkusModel.edmx</DependentUpon>

    </Compile>

    <Compile Include="MEMBER.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="MEMBER_CMS_TEST.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="PRINT_DOC.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="PRINT_EXCEL.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="PROJECT_SETTING.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="PROPERTIES.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="RUN_PROJECTS.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="SERVICE_PROPERTIES.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="SIGN_INFO.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="SYMBOL_PRIVATE.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

    <Compile Include="SYMBOL_PUBLIC.cs">

      <DependentUpon>MarkusModel.tt</DependentUpon>

    </Compile>

  </ItemGroup>

  <ItemGroup>

    <Reference Include="EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">

      <HintPath>..\packages\EntityFramework.6.2.0\lib\net45\EntityFramework.dll</HintPath>

    </Reference>

    <Reference Include="EntityFramework.SqlServer, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">

      <HintPath>..\packages\EntityFramework.6.2.0\lib\net45\EntityFramework.SqlServer.dll</HintPath>

    </Reference>

    <Reference Include="System" />

    <Reference Include="System.ComponentModel.DataAnnotations" />

    <Reference Include="System.Data" />

    <Reference Include="System.Runtime.Serialization" />

    <Reference Include="System.Security" />

    <Reference Include="System.Xml" />

  </ItemGroup>

  <ItemGroup>

    <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />

  </ItemGroup>

  <ItemGroup>

    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">

      <Visible>False</Visible>

      <ProductName>.NET Framework 3.5 SP1</ProductName>

      <Install>false</Install>

    </BootstrapperPackage>

  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

</Project>



namespace Markus.EntityModel

{

    using System;

    using System.Data.Entity;

    using System.Data.Entity.Core.EntityClient;

    using System.Data.Entity.Infrastructure;

    using System.Data.SqlClient;

    public partial class MarkusModel : DbContext

    {

        private const string providerName = "System.Data.SqlClient";

        private const string MarkusMeta = @"res://*/MarkusModel.csdl|res://*/MarkusModel.ssdl|res://*/MarkusModel.msl";

        public MarkusModel(string ConnectionString)

            : base(ConnectionStringBuilder(ConnectionString).ToString())

        {

            this.Database.CommandTimeout = 60;

        }

        private static EntityConnectionStringBuilder ConnectionStringBuilder(string ConnectionString)

        {

            //SqlConnectionStringBuilder _bl = new SqlConnectionStringBuilder(string.Format(Properties.Settings.Default.ProjectCIConnectionString, "DeepView"));

            SqlConnectionStringBuilder _bl = new SqlConnectionStringBuilder(ConnectionString);

            return EntityConnectionBuilder(_bl, MarkusMeta);

        }

        private static EntityConnectionStringBuilder

          EntityConnectionBuilder(SqlConnectionStringBuilder SqlStringBuilder, string EntityMetaData)

        {

            string providerString = SqlStringBuilder.ToString();

            EntityConnectionStringBuilder entityBuilder = new EntityConnectionStringBuilder();

            entityBuilder.Provider = providerName;

            entityBuilder.ProviderConnectionString = providerString;

            entityBuilder.Metadata = EntityMetaData;

            //Console.WriteLine(entityBuilder.ToString());

            using (EntityConnection conn =

                new EntityConnection(entityBuilder.ToString()))

            {

                try

                {

                    conn.Open();

                    //Console.WriteLine("Just testing the connection.");

                    conn.Close();

                }

                catch (Exception ex)

                {

                    System.Diagnostics.Debug.WriteLine(ex.ToString());

                    throw ex;

                }

            }

            return entityBuilder;

        }

    }

}

//------------------------------------------------------------------------------

// <auto-generated>

//     이 코드는 템플릿에서 생성되었습니다.

//

//     이 파일을 수동으로 변경하면 응용 프로그램에서 예기치 않은 동작이 발생할 수 있습니다.

//     이 파일을 수동으로 변경하면 코드가 다시 생성될 때 변경 내용을 덮어씁니다.

// </auto-generated>

//------------------------------------------------------------------------------

namespace Markus.EntityModel

{

    using System;

    using System.Data.Entity;

    using System.Data.Entity.Infrastructure;

    public partial class MarkusModel : DbContext

    {

        public MarkusModel()

            : base("name=MarkusModel")

        {

        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)

        {

            throw new UnintentionalCodeFirstException();

        }

        public virtual DbSet<ATTACH_URL> ATTACH_URL { get; set; }

        public virtual DbSet<CERTIFY_CMS_TEST> CERTIFY_CMS_TEST { get; set; }

        public virtual DbSet<CONVERTER_DOC> CONVERTER_DOC { get; set; }

        public virtual DbSet<DOCINFO> DOCINFO { get; set; }

        public virtual DbSet<DOCPAGE> DOCPAGE { get; set; }

        public virtual DbSet<DOCUMENT_ITEM> DOCUMENT_ITEM { get; set; }

        public virtual DbSet<ERROR_LOG> ERROR_LOG { get; set; }

        public virtual DbSet<FAVORITE_DOC> FAVORITE_DOC { get; set; }

        public virtual DbSet<FINAL_PDF> FINAL_PDF { get; set; }

        public virtual DbSet<LOGIN_STAMP> LOGIN_STAMP { get; set; }

        public virtual DbSet<MARKUP_CHECKLIST> MARKUP_CHECKLIST { get; set; }

        public virtual DbSet<MARKUP_DATA> MARKUP_DATA { get; set; }

        public virtual DbSet<MARKUP_INFO> MARKUP_INFO { get; set; }

        public virtual DbSet<MARKUP_INFO_VERSION> MARKUP_INFO_VERSION { get; set; }

        public virtual DbSet<MEMBER> MEMBER { get; set; }

        public virtual DbSet<MEMBER_CMS_TEST> MEMBER_CMS_TEST { get; set; }

        public virtual DbSet<PRINT_DOC> PRINT_DOC { get; set; }

        public virtual DbSet<PRINT_EXCEL> PRINT_EXCEL { get; set; }

        public virtual DbSet<PROJECT_SETTING> PROJECT_SETTING { get; set; }

        public virtual DbSet<PROPERTIES> PROPERTIES { get; set; }

        public virtual DbSet<RUN_PROJECTS> RUN_PROJECTS { get; set; }

        public virtual DbSet<SERVICE_PROPERTIES> SERVICE_PROPERTIES { get; set; }

        public virtual DbSet<SIGN_INFO> SIGN_INFO { get; set; }

        public virtual DbSet<SYMBOL_PRIVATE> SYMBOL_PRIVATE { get; set; }

        public virtual DbSet<SYMBOL_PUBLIC> SYMBOL_PUBLIC { get; set; }

    }

}

<#@ template language="C#" debug="false" hostspecific="true"#>

<#@ include file="EF6.Utility.CS.ttinclude"#><#@

 output extension=".cs"#><#

const string inputFile = @"MarkusModel.edmx";

var textTransform = DynamicTextTransformation.Create(this);

var code = new CodeGenerationTools(this);

var ef = new MetadataTools(this);

var typeMapper = new TypeMapper(code, ef, textTransform.Errors);

var loader = new EdmMetadataLoader(textTransform.Host, textTransform.Errors);

var itemCollection = loader.CreateEdmItemCollection(inputFile);

var modelNamespace = loader.GetModelNamespace(inputFile);

var codeStringGenerator = new CodeStringGenerator(code, typeMapper, ef);

var container = itemCollection.OfType<EntityContainer>().FirstOrDefault();

if (container == null)

{

    return string.Empty;

}

#>

//------------------------------------------------------------------------------

// <auto-generated>

// <#=CodeGenerationTools.GetResourceString("Template_GeneratedCodeCommentLine1")#>

//

// <#=CodeGenerationTools.GetResourceString("Template_GeneratedCodeCommentLine2")#>

// <#=CodeGenerationTools.GetResourceString("Template_GeneratedCodeCommentLine3")#>

// </auto-generated>

//------------------------------------------------------------------------------

<#

var codeNamespace = code.VsNamespaceSuggestion();

if (!String.IsNullOrEmpty(codeNamespace))

{

#>

namespace <#=code.EscapeNamespace(codeNamespace)#>

{

<#

    PushIndent("    ");

}

#>

using System;

using System.Data.Entity;

using System.Data.Entity.Infrastructure;

<#

if (container.FunctionImports.Any())

{

#>

using System.Data.Entity.Core.Objects;

using System.Linq;

<#

}

#>

<#=Accessibility.ForType(container)#> partial class <#=code.Escape(container)#> : DbContext

{

    public <#=code.Escape(container)#>()

        : base("name=<#=container.Name#>")

    {

<#

if (!loader.IsLazyLoadingEnabled(container))

{

#>

        this.Configuration.LazyLoadingEnabled = false;

<#

}

foreach (var entitySet in container.BaseEntitySets.OfType<EntitySet>())

{

    // Note: the DbSet members are defined below such that the getter and

    // setter always have the same accessibility as the DbSet definition

    if (Accessibility.ForReadOnlyProperty(entitySet) != "public")

    {

#>

        <#=codeStringGenerator.DbSetInitializer(entitySet)#>

<#

    }

}

#>

    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)

    {

        throw new UnintentionalCodeFirstException();

    }

<#

    foreach (var entitySet in container.BaseEntitySets.OfType<EntitySet>())

    {

#>

    <#=codeStringGenerator.DbSet(entitySet)#>

<#

    }

    foreach (var edmFunction in container.FunctionImports)

    {

        WriteFunctionImport(typeMapper, codeStringGenerator, edmFunction, modelNamespace, includeMergeOption: false);

    }

#>

}

<#

if (!String.IsNullOrEmpty(codeNamespace))

{

    PopIndent();

#>

}

<#

}

#>

<#+

private void WriteFunctionImport(TypeMapper typeMapper, CodeStringGenerator codeStringGenerator, EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)

{

    if (typeMapper.IsComposable(edmFunction))

    {

#>

    [DbFunction("<#=edmFunction.NamespaceName#>", "<#=edmFunction.Name#>")]

    <#=codeStringGenerator.ComposableFunctionMethod(edmFunction, modelNamespace)#>

    {

<#+

        codeStringGenerator.WriteFunctionParameters(edmFunction, WriteFunctionParameter);

#>

        <#=codeStringGenerator.ComposableCreateQuery(edmFunction, modelNamespace)#>

    }

<#+

    }

    else

    {

#>

    <#=codeStringGenerator.FunctionMethod(edmFunction, modelNamespace, includeMergeOption)#>

    {

<#+

        codeStringGenerator.WriteFunctionParameters(edmFunction, WriteFunctionParameter);

#>

        <#=codeStringGenerator.ExecuteFunction(edmFunction, modelNamespace, includeMergeOption)#>

    }

<#+

        if (typeMapper.GenerateMergeOptionFunction(edmFunction, includeMergeOption))

        {

            WriteFunctionImport(typeMapper, codeStringGenerator, edmFunction, modelNamespace, includeMergeOption: true);

        }

    }

}

public void WriteFunctionParameter(string name, string isNotNull, string notNullInit, string nullInit)

{

#>

        var <#=name#> = <#=isNotNull#> ?

            <#=notNullInit#> :

            <#=nullInit#>;

<#+

}

public const string TemplateId = "CSharp_DbContext_Context_EF6";

public class CodeStringGenerator

{

    private readonly CodeGenerationTools _code;

    private readonly TypeMapper _typeMapper;

    private readonly MetadataTools _ef;

    public CodeStringGenerator(CodeGenerationTools code, TypeMapper typeMapper, MetadataTools ef)

    {

        ArgumentNotNull(code, "code");

        ArgumentNotNull(typeMapper, "typeMapper");

        ArgumentNotNull(ef, "ef");

        _code = code;

        _typeMapper = typeMapper;

        _ef = ef;

    }

    public string Property(EdmProperty edmProperty)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} {1} {2} {{ {3}get; {4}set; }}",

            Accessibility.ForProperty(edmProperty),

            _typeMapper.GetTypeName(edmProperty.TypeUsage),

            _code.Escape(edmProperty),

            _code.SpaceAfter(Accessibility.ForGetter(edmProperty)),

            _code.SpaceAfter(Accessibility.ForSetter(edmProperty)));

    }

    public string NavigationProperty(NavigationProperty navProp)

    {

        var endType = _typeMapper.GetTypeName(navProp.ToEndMember.GetEntityType());

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} {1} {2} {{ {3}get; {4}set; }}",

            AccessibilityAndVirtual(Accessibility.ForNavigationProperty(navProp)),

            navProp.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many ? ("ICollection<" + endType + ">") : endType,

            _code.Escape(navProp),

            _code.SpaceAfter(Accessibility.ForGetter(navProp)),

            _code.SpaceAfter(Accessibility.ForSetter(navProp)));

    }

    public string AccessibilityAndVirtual(string accessibility)

    {

        return accessibility + (accessibility != "private" ? " virtual" : "");

    }

    public string EntityClassOpening(EntityType entity)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} {1}partial class {2}{3}",

            Accessibility.ForType(entity),

            _code.SpaceAfter(_code.AbstractOption(entity)),

            _code.Escape(entity),

            _code.StringBefore(" : ", _typeMapper.GetTypeName(entity.BaseType)));

    }

    public string EnumOpening(SimpleType enumType)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} enum {1} : {2}",

            Accessibility.ForType(enumType),

            _code.Escape(enumType),

            _code.Escape(_typeMapper.UnderlyingClrType(enumType)));

        }

    public void WriteFunctionParameters(EdmFunction edmFunction, Action<string, string, string, string> writeParameter)

    {

        var parameters = FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef);

        foreach (var parameter in parameters.Where(p => p.NeedsLocalVariable))

        {

            var isNotNull = parameter.IsNullableOfT ? parameter.FunctionParameterName + ".HasValue" : parameter.FunctionParameterName + " != null";

            var notNullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", " + parameter.FunctionParameterName + ")";

            var nullInit = "new ObjectParameter(\"" + parameter.EsqlParameterName + "\", typeof(" + TypeMapper.FixNamespaces(parameter.RawClrTypeName) + "))";

            writeParameter(parameter.LocalVariableName, isNotNull, notNullInit, nullInit);

        }

    }

    public string ComposableFunctionMethod(EdmFunction edmFunction, string modelNamespace)

    {

        var parameters = _typeMapper.GetParameters(edmFunction);

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} IQueryable<{1}> {2}({3})",

            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),

            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),

            _code.Escape(edmFunction),

            string.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray()));

    }

    public string ComposableCreateQuery(EdmFunction edmFunction, string modelNamespace)

    {

        var parameters = _typeMapper.GetParameters(edmFunction);

        return string.Format(

            CultureInfo.InvariantCulture,

            "return ((IObjectContextAdapter)this).ObjectContext.CreateQuery<{0}>(\"[{1}].[{2}]({3})\"{4});",

            _typeMapper.GetTypeName(_typeMapper.GetReturnType(edmFunction), modelNamespace),

            edmFunction.NamespaceName,

            edmFunction.Name,

            string.Join(", ", parameters.Select(p => "@" + p.EsqlParameterName).ToArray()),

            _code.StringBefore(", ", string.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray())));

    }

    public string FunctionMethod(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)

    {

        var parameters = _typeMapper.GetParameters(edmFunction);

        var returnType = _typeMapper.GetReturnType(edmFunction);

        var paramList = String.Join(", ", parameters.Select(p => TypeMapper.FixNamespaces(p.FunctionParameterType) + " " + p.FunctionParameterName).ToArray());

        if (includeMergeOption)

        {

            paramList = _code.StringAfter(paramList, ", ") + "MergeOption mergeOption";

        }

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} {1} {2}({3})",

            AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)),

            returnType == null ? "int" : "ObjectResult<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",

            _code.Escape(edmFunction),

            paramList);

    }

    public string ExecuteFunction(EdmFunction edmFunction, string modelNamespace, bool includeMergeOption)

    {

        var parameters = _typeMapper.GetParameters(edmFunction);

        var returnType = _typeMapper.GetReturnType(edmFunction);

        var callParams = _code.StringBefore(", ", String.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray()));

        if (includeMergeOption)

        {

            callParams = ", mergeOption" + callParams;

        }

        return string.Format(

            CultureInfo.InvariantCulture,

            "return ((IObjectContextAdapter)this).ObjectContext.ExecuteFunction{0}(\"{1}\"{2});",

            returnType == null ? "" : "<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">",

            edmFunction.Name,

            callParams);

    }

    public string DbSet(EntitySet entitySet)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} virtual DbSet<{1}> {2} {{ get; set; }}",

            Accessibility.ForReadOnlyProperty(entitySet),

            _typeMapper.GetTypeName(entitySet.ElementType),

            _code.Escape(entitySet));

    }

    public string DbSetInitializer(EntitySet entitySet)

    {

        return string.Format(

            CultureInfo.InvariantCulture,

            "{0} = Set<{1}>();",

            _code.Escape(entitySet),

            _typeMapper.GetTypeName(entitySet.ElementType));

    }

    public string UsingDirectives(bool inHeader, bool includeCollections = true)

    {

        return inHeader == string.IsNullOrEmpty(_code.VsNamespaceSuggestion())

            ? string.Format(

                CultureInfo.InvariantCulture,

                "{0}using System;{1}" +

                "{2}",

                inHeader ? Environment.NewLine : "",

                includeCollections ? (Environment.NewLine + "using System.Collections.Generic;") : "",

                inHeader ? "" : Environment.NewLine)

            : "";

    }

}

public class TypeMapper

{

    private const string ExternalTypeNameAttributeName = @"http://schemas.microsoft.com/ado/2006/04/codegeneration:ExternalTypeName";

    private readonly System.Collections.IList _errors;

    private readonly CodeGenerationTools _code;

    private readonly MetadataTools _ef;

    public static string FixNamespaces(string typeName)

    {

        return typeName.Replace("System.Data.Spatial.", "System.Data.Entity.Spatial.");

    }

    public TypeMapper(CodeGenerationTools code, MetadataTools ef, System.Collections.IList errors)

    {

        ArgumentNotNull(code, "code");

        ArgumentNotNull(ef, "ef");

        ArgumentNotNull(errors, "errors");

        _code = code;

        _ef = ef;

        _errors = errors;

    }

    public string GetTypeName(TypeUsage typeUsage)

    {

        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace: null);

    }

    public string GetTypeName(EdmType edmType)

    {

        return GetTypeName(edmType, isNullable: null, modelNamespace: null);

    }

    public string GetTypeName(TypeUsage typeUsage, string modelNamespace)

    {

        return typeUsage == null ? null : GetTypeName(typeUsage.EdmType, _ef.IsNullable(typeUsage), modelNamespace);

    }

    public string GetTypeName(EdmType edmType, string modelNamespace)