mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
397 lines
17 KiB
C#
397 lines
17 KiB
C#
//---------------------------------------------------------------------
|
|
// <copyright file="EntityClassGenerator.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//
|
|
// @owner [....]
|
|
// @backupOwner [....]
|
|
//---------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Data;
|
|
using System.Data.EntityModel.SchemaObjectModel;
|
|
using System.Data.Metadata.Edm;
|
|
using System.Data.EntityModel;
|
|
using System.Data.Entity.Design.Common;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Data.Entity.Design.SsdlGenerator;
|
|
using Microsoft.Build.Utilities;
|
|
using System.Runtime.Versioning;
|
|
|
|
namespace System.Data.Entity.Design
|
|
{
|
|
/// <summary>
|
|
/// Event handler for the OnTypeGenerated event
|
|
/// </summary>
|
|
/// <param name="sender">The source of the event</param>
|
|
/// <param name="e">The event args</param>
|
|
public delegate void TypeGeneratedEventHandler(object sender, TypeGeneratedEventArgs e);
|
|
|
|
/// <summary>
|
|
/// Event handler for the OnPropertyGenerated event
|
|
/// </summary>
|
|
/// <param name="sender">The source of the event</param>
|
|
/// <param name="e">The event args</param>
|
|
public delegate void PropertyGeneratedEventHandler(object sender, PropertyGeneratedEventArgs e);
|
|
|
|
/// <summary>
|
|
/// Summary description for CodeGenerator.
|
|
/// </summary>
|
|
public sealed class EntityClassGenerator
|
|
{
|
|
#region Instance Fields
|
|
LanguageOption _languageOption = LanguageOption.GenerateCSharpCode;
|
|
EdmToObjectNamespaceMap _edmToObjectNamespaceMap = new EdmToObjectNamespaceMap();
|
|
#endregion
|
|
|
|
#region Events
|
|
|
|
/// <summary>
|
|
/// The event that is raised when a type is generated
|
|
/// </summary>
|
|
public event TypeGeneratedEventHandler OnTypeGenerated;
|
|
|
|
/// <summary>
|
|
/// The event that is raised when a property is generated
|
|
/// </summary>
|
|
public event PropertyGeneratedEventHandler OnPropertyGenerated;
|
|
|
|
#endregion
|
|
|
|
#region Public Methods
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public EntityClassGenerator()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public EntityClassGenerator(LanguageOption languageOption)
|
|
{
|
|
_languageOption = EDesignUtil.CheckLanguageOptionArgument(languageOption, "languageOption");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets and Sets the Language to use for code generation.
|
|
/// </summary>
|
|
public LanguageOption LanguageOption
|
|
{
|
|
get { return _languageOption; }
|
|
set { _languageOption = EDesignUtil.CheckLanguageOptionArgument(value, "value"); }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the map entries use to customize the namespace of .net types that are generated
|
|
/// and referenced by the generated code
|
|
/// </summary>
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Edm")]
|
|
public EdmToObjectNamespaceMap EdmToObjectNamespaceMap
|
|
{
|
|
get { return _edmToObjectNamespaceMap; }
|
|
}
|
|
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Edm")]
|
|
public IList<EdmSchemaError> GenerateCode(XmlReader sourceEdmSchema, TextWriter target)
|
|
{
|
|
EDesignUtil.CheckArgumentNull(sourceEdmSchema, "sourceEdmSchema");
|
|
EDesignUtil.CheckArgumentNull(target, "target");
|
|
return GenerateCode(sourceEdmSchema, target, new XmlReader[] { });
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Edm")]
|
|
[ResourceExposure(ResourceScope.None)] //No resource is exposed since we pass in null as the target paath.
|
|
[ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] //For GenerateCodeCommon method call. Since we use null as the path, we have not changed the scope of the resource.
|
|
public IList<EdmSchemaError> GenerateCode(XmlReader sourceEdmSchema, TextWriter target, IEnumerable<XmlReader> additionalEdmSchemas)
|
|
{
|
|
EDesignUtil.CheckArgumentNull(sourceEdmSchema, "sourceEdmSchema");
|
|
EDesignUtil.CheckArgumentNull(additionalEdmSchemas, "additionalEdmSchemas");
|
|
EDesignUtil.CheckArgumentNull(target, "target");
|
|
|
|
List<EdmSchemaError> errors = new List<EdmSchemaError>();
|
|
try
|
|
{
|
|
MetadataArtifactLoader sourceLoader = new MetadataArtifactLoaderXmlReaderWrapper(sourceEdmSchema);
|
|
List<MetadataArtifactLoader> loaders = new List<MetadataArtifactLoader>();
|
|
loaders.Add(sourceLoader);
|
|
|
|
int index = 0;
|
|
foreach (XmlReader additionalEdmSchema in additionalEdmSchemas)
|
|
{
|
|
if (additionalEdmSchema == null)
|
|
{
|
|
throw EDesignUtil.Argument(Strings.NullAdditionalSchema("additionalEdmSchema", index));
|
|
}
|
|
|
|
try
|
|
{
|
|
MetadataArtifactLoader loader = new MetadataArtifactLoaderXmlReaderWrapper(additionalEdmSchema);
|
|
Debug.Assert(loader != null, "when is the loader ever null?");
|
|
loaders.Add(loader);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (MetadataUtil.IsCatchableExceptionType(e))
|
|
{
|
|
errors.Add(new EdmSchemaError(e.Message,
|
|
(int)ModelBuilderErrorCode.CodeGenAdditionalEdmSchemaIsInvalid,
|
|
EdmSchemaErrorSeverity.Error));
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
index++;
|
|
}
|
|
ThrowOnAnyNonWarningErrors(errors);
|
|
|
|
GenerateCodeCommon(sourceLoader,
|
|
loaders,
|
|
new LazyTextWriterCreator(target),
|
|
null, // source path
|
|
null, // target file path
|
|
false, // dispose readers?
|
|
errors);
|
|
}
|
|
catch (TerminalErrorException)
|
|
{
|
|
// do nothing
|
|
// just a place to jump when errors are detected
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Edm")]
|
|
[ResourceExposure(ResourceScope.Machine)] //Exposes the sourceEdmSchemaFilePath which is a Machine resource
|
|
[ResourceConsumption(ResourceScope.Machine)] //For GenerateCode method call. But the path is not created in this method.
|
|
public IList<EdmSchemaError> GenerateCode(string sourceEdmSchemaFilePath, string targetFilePath)
|
|
{
|
|
return GenerateCode(sourceEdmSchemaFilePath, targetFilePath, new string[] { });
|
|
}
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly"), System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Edm")]
|
|
[ResourceExposure(ResourceScope.Machine)] //Exposes the sourceEdmSchemaFilePath which is a Machine resource
|
|
[ResourceConsumption(ResourceScope.Machine)] //For MetadataArtifactLoader.Create method call. But the path is not created in this method.
|
|
public IList<EdmSchemaError> GenerateCode(string sourceEdmSchemaFilePath, string targetPath, IEnumerable<string> additionalEdmSchemaFilePaths)
|
|
{
|
|
EDesignUtil.CheckStringArgument(sourceEdmSchemaFilePath, "sourceEdmSchemaFilePath");
|
|
EDesignUtil.CheckArgumentNull(additionalEdmSchemaFilePaths, "additionalEdmSchemaFilePaths");
|
|
EDesignUtil.CheckStringArgument(targetPath, "targetPath");
|
|
|
|
List<EdmSchemaError> errors = new List<EdmSchemaError>();
|
|
try
|
|
{
|
|
// create a loader for the source
|
|
HashSet<string> uriRegistry = new HashSet<string>();
|
|
MetadataArtifactLoader sourceLoader;
|
|
try
|
|
{
|
|
sourceLoader = MetadataArtifactLoader.Create(sourceEdmSchemaFilePath, MetadataArtifactLoader.ExtensionCheck.Specific,
|
|
XmlConstants.CSpaceSchemaExtension, uriRegistry);
|
|
}
|
|
catch (MetadataException e)
|
|
{
|
|
errors.Add(CreateErrorForException(ModelBuilderErrorCode.CodeGenSourceFilePathIsInvalid, e, sourceEdmSchemaFilePath));
|
|
return errors;
|
|
}
|
|
|
|
if (sourceLoader.IsComposite)
|
|
{
|
|
throw new ArgumentException(Strings.CodeGenSourceFilePathIsNotAFile, "sourceEdmSchemaPath");
|
|
}
|
|
|
|
// create loaders for all the additional schemas
|
|
List<MetadataArtifactLoader> loaders = new List<MetadataArtifactLoader>();
|
|
loaders.Add(sourceLoader);
|
|
int index = 0;
|
|
foreach (string additionalSchemaFilePath in additionalEdmSchemaFilePaths)
|
|
{
|
|
if (additionalSchemaFilePath == null)
|
|
{
|
|
throw EDesignUtil.Argument(Strings.NullAdditionalSchema("additionalEdmSchemaFilePaths", index));
|
|
}
|
|
|
|
try
|
|
{
|
|
MetadataArtifactLoader loader = MetadataArtifactLoader.Create(additionalSchemaFilePath,
|
|
MetadataArtifactLoader.ExtensionCheck.Specific,
|
|
XmlConstants.CSpaceSchemaExtension, uriRegistry);
|
|
Debug.Assert(loader != null, "when is the loader ever null?");
|
|
loaders.Add(loader);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if(MetadataUtil.IsCatchableExceptionType(e))
|
|
{
|
|
errors.Add(CreateErrorForException(ModelBuilderErrorCode.CodeGenAdditionalEdmSchemaIsInvalid, e, additionalSchemaFilePath));
|
|
}
|
|
else
|
|
{
|
|
throw;
|
|
}
|
|
}
|
|
index++;
|
|
}
|
|
|
|
ThrowOnAnyNonWarningErrors(errors);
|
|
try
|
|
{
|
|
using (LazyTextWriterCreator target = new LazyTextWriterCreator(targetPath))
|
|
{
|
|
GenerateCodeCommon(sourceLoader, loaders, target, sourceEdmSchemaFilePath, targetPath,
|
|
true, // dispose readers
|
|
errors);
|
|
}
|
|
}
|
|
catch (System.IO.IOException ex)
|
|
{
|
|
errors.Add(CreateErrorForException(System.Data.EntityModel.SchemaObjectModel.ErrorCode.IOException, ex, targetPath));
|
|
return errors;
|
|
}
|
|
}
|
|
catch (TerminalErrorException)
|
|
{
|
|
// do nothing
|
|
// just a place to jump when errors are detected
|
|
}
|
|
return errors;
|
|
}
|
|
|
|
private void GenerateCodeCommon(MetadataArtifactLoader sourceLoader,
|
|
List<MetadataArtifactLoader> loaders,
|
|
LazyTextWriterCreator target,
|
|
string sourceEdmSchemaFilePath,
|
|
string targetFilePath,
|
|
bool closeReaders,
|
|
List<EdmSchemaError> errors)
|
|
{
|
|
MetadataArtifactLoaderComposite composite = new MetadataArtifactLoaderComposite(loaders);
|
|
|
|
// create the schema manager from the xml readers
|
|
Dictionary<MetadataArtifactLoader, XmlReader> readerSourceMap = new Dictionary<MetadataArtifactLoader, XmlReader>();
|
|
IList<Schema> schemas;
|
|
List<XmlReader> readers = composite.GetReaders(readerSourceMap);
|
|
|
|
try
|
|
{
|
|
IList<EdmSchemaError> schemaManagerErrors =
|
|
SchemaManager.ParseAndValidate(readers,
|
|
composite.GetPaths(),
|
|
SchemaDataModelOption.EntityDataModel,
|
|
EdmProviderManifest.Instance,
|
|
out schemas);
|
|
errors.AddRange(schemaManagerErrors);
|
|
}
|
|
finally
|
|
{
|
|
if (closeReaders)
|
|
{
|
|
MetadataUtil.DisposeXmlReaders(readers);
|
|
}
|
|
}
|
|
ThrowOnAnyNonWarningErrors(errors);
|
|
Debug.Assert(readerSourceMap.ContainsKey(sourceLoader), "the source loader didn't produce any of the xml readers...");
|
|
XmlReader sourceReader = readerSourceMap[sourceLoader];
|
|
|
|
|
|
// use the index of the "source" xml reader as the index of the "source" schema
|
|
Debug.Assert(readers.Contains(sourceReader), "the source reader is not in the list of readers");
|
|
int index = readers.IndexOf(sourceReader);
|
|
Debug.Assert(index >= 0, "couldn't find the source reader in the list of readers");
|
|
|
|
Debug.Assert(readers.Count == schemas.Count, "We have a different number of readers than schemas");
|
|
Schema sourceSchema = schemas[index];
|
|
Debug.Assert(sourceSchema != null, "sourceSchema is null");
|
|
|
|
// create the EdmItemCollection from the schemas
|
|
EdmItemCollection itemCollection = new EdmItemCollection(schemas);
|
|
if (EntityFrameworkVersionsUtil.ConvertToVersion(itemCollection.EdmVersion) >= EntityFrameworkVersions.Version2)
|
|
{
|
|
throw EDesignUtil.InvalidOperation(Strings.TargetEntityFrameworkVersionToNewForEntityClassGenerator);
|
|
}
|
|
|
|
// generate code
|
|
ClientApiGenerator generator = new ClientApiGenerator(sourceSchema, itemCollection, this, errors);
|
|
generator.GenerateCode(target, targetFilePath);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region Private Methods
|
|
private static EdmSchemaError CreateErrorForException(System.Data.EntityModel.SchemaObjectModel.ErrorCode errorCode, System.Exception exception, string sourceLocation)
|
|
{
|
|
Debug.Assert(exception != null);
|
|
Debug.Assert(sourceLocation != null);
|
|
|
|
return new EdmSchemaError(exception.Message, (int)errorCode, EdmSchemaErrorSeverity.Error, sourceLocation, 0, 0, exception);
|
|
}
|
|
|
|
internal static EdmSchemaError CreateErrorForException(ModelBuilderErrorCode errorCode, System.Exception exception, string sourceLocation)
|
|
{
|
|
Debug.Assert(exception != null);
|
|
Debug.Assert(sourceLocation != null);
|
|
|
|
return new EdmSchemaError(exception.Message, (int)errorCode, EdmSchemaErrorSeverity.Error, sourceLocation, 0, 0, exception);
|
|
}
|
|
|
|
internal static EdmSchemaError CreateErrorForException(ModelBuilderErrorCode errorCode, System.Exception exception)
|
|
{
|
|
Debug.Assert(exception != null);
|
|
|
|
return new EdmSchemaError(exception.Message, (int)errorCode, EdmSchemaErrorSeverity.Error, null, 0, 0, exception);
|
|
}
|
|
|
|
private void ThrowOnAnyNonWarningErrors(List<EdmSchemaError> errors)
|
|
{
|
|
foreach (EdmSchemaError error in errors)
|
|
{
|
|
if (error.Severity != EdmSchemaErrorSeverity.Warning)
|
|
{
|
|
throw new TerminalErrorException();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Event Helpers
|
|
|
|
/// <summary>
|
|
/// Helper method that raises the TypeGenerated event
|
|
/// </summary>
|
|
/// <param name="eventArgs">The event arguments passed to the subscriber</param>
|
|
internal void RaiseTypeGeneratedEvent(TypeGeneratedEventArgs eventArgs)
|
|
{
|
|
if (this.OnTypeGenerated != null)
|
|
{
|
|
this.OnTypeGenerated(this, eventArgs);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper method that raises the PropertyGenerated event
|
|
/// </summary>
|
|
/// <param name="eventArgs">The event arguments passed to the subscriber</param>
|
|
internal void RaisePropertyGeneratedEvent(PropertyGeneratedEventArgs eventArgs)
|
|
{
|
|
if (this.OnPropertyGenerated != null)
|
|
{
|
|
this.OnPropertyGenerated(this, eventArgs);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|