1. 首頁
  2. 問答
  3. 從存儲過程獲取返回值

從存儲過程獲取返回值

2013-02-06 186 views
37

我使用實體框架5與代碼優先的方法。我需要從存儲過程讀取返回值;我已經在閱讀輸出參數併發送輸入參數，但我不知道如何讀取返回值。從存儲過程獲取返回值

可能嗎？

這裏是我用來調用存儲過程的代碼：

var outParam = new SqlParameter(); 
outParam.ParameterName = "@StatusLog"; 
outParam.SqlDbType = SqlDbType.NVarChar; 
outParam.Size = 4000; 
outParam.Direction = ParameterDirection.Output; 

var code = new SqlParameter(); 
code.ParameterName = "@Code"; 
code.Direction = ParameterDirection.Input; 
code.SqlDbType = SqlDbType.VarChar; 
code.Size = 20; 
code.Value = "123"; 

var data = _context.Database.SqlQuery<Item>("exec spItemData @Code, @StatusLog OUT", code, outParam); 

var result = data.FirstOrDefault();

來源

2013-02-06 Daniele Armanasco

+0

類似【答案】（http://stackoverflow.com/a/25820352/1161370）爲我工作。 – Mahesh

回答

37

我找到了！ 我可以與具有以這種方式使用的輸出參數讀取的返回值：

// define a new output parameter 
var returnCode = new SqlParameter(); 
returnCode.ParameterName = "@ReturnCode"; 
returnCode.SqlDbType = SqlDbType.Int; 
returnCode.Direction = ParameterDirection.Output; 

// assign the return code to the new output parameter and pass it to the sp 
var data = _context.Database.SqlQuery<Item>("exec @ReturnCode = spItemData @Code, @StatusLog OUT", returnCode, code, outParam);

來源

2013-02-06 17:45:42

+0

我添加了OUT參數後，我有同樣的問題它的工作 – Mahesh

+2

它真的沒有任何意義，因爲有一個ParameterDirection.ReturnValue。但是你的解決方案適用於我。謝謝！ –

18

由丹尼爾是不是爲我工作，直到我發現這個blog post從Diego Vega，其解釋說，提供的解決方案：

您需要在您可以訪問輸出參數的值之前讀取整個結果（...）這只是存儲過程的工作方式，並非特定於此EF功能。

而且，在我的情況，我並沒有返回一個實體，我只需要執行存儲過程，所以我在_context.Database.SqlQuery<object>與object取代Item。

下面是示例代碼：

var code = new SqlParameter("@Code", 1); 

var returnCode = new SqlParameter("@ReturnCode", SqlDbType.Int); 
returnCode.Direction = ParameterDirection.Output; 

var outParam = new SqlParameter("@StatusLog", SqlDbType.Int); 
outParam.Direction = ParameterDirection.Output; 

var sql = "exec @ReturnCode = spSomeRoutine @Code, @StatusLog OUT"; 
var data = _context.Database.SqlQuery<object>(sql, returnCode, code, outParam); 

// Read the results so that the output variables are accessible 
var item = data.FirstOrDefault(); 

var returnCodeValue = (int)returnCode.Value; 
var outParamValue = (int)outParam.Value;

下面是一個示例存儲過程：

CREATE PROCEDURE [dbo].[spSomeRoutine] 
    @Code Int, 
    @StatusLog INT OUTPUT 
AS 
BEGIN 
    SET @StatusLog = 5 
    RETURN 10 
END

來源

2015-10-21 15:50:58

+0

我得到錯誤'必須聲明標量變量「@RetrunCode」這個變量是否也需要在存儲過程中聲明？ –

+1

我能夠複製你的錯誤，所以是的，變量名稱確實很重要，但是在這種情況下，問題不在存儲過程中，而是在SQL調用中，所以確保''exec @ ReturnCode = ...'匹配'var returnCode = new SqlParameter（「@ ReturnCode」，SqlDbType.Int）;' –

+0

好吧，所以我的代碼問題是我試圖將返回類型轉換爲var data = _context .Database.SqlQuery （sql，returnCode，code，outParam）這似乎不工作，但改變爲對象似乎已經完成了工作，我只是試圖結束智能:) –

7

的情況下存儲的過程沒有輸出參數我做以下，有效地使一些返回select語句的Sql;

var data = context.Database.SqlQuery<int>(@"declare @num int 
exec @num = myStoredProcThatReturnsInt 
select @num"); 

var result = data.First();

來源

2017-03-01 06:50:16

+0

如果有輸入參數，然後通過 exec @num = myStoredProcThatReturnsInt param1，param2 –

0

對於任何與EDMX工作文件，你可以添加代碼生成項目，然後用下面的T4代碼替換.Context.tt。這將創建所有的代碼使用方法映射存儲過程：

var returnCode = new SqlParameter("@ReturnCode", SqlDbType.Int); 
returnCode.Direction = ParameterDirection.Output; 
var sql = "exec @ReturnCode = spSomeRoutine @Code, @StatusLog OUT"; 
var data = _context.Database.SqlQuery<object>(sql, returnCode, code, outParam);

它將使用SqlQuery類<>時，有一個結果集和ExecuteSqlCommand當沒有，但在這兩種情況下進行的SqlParameter localSqlExecReturnValue會包含來自存儲過程調用的int返回碼。這可以與其他生成器一起使用，它僅爲存儲過程調用生成額外的代碼。

StoredProcedure.Context.tt：

<#@ template language="C#" debug="false" hostspecific="true"#> 
<#@ include file="EF6.Utility.CS.ttinclude"#><#@ 
output extension=".cs"#><# 

const string inputFile = @"CDMSAccountingModel.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 
{ 

<# 
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)#> 
<# 
    } 
} 
#> 



<# 
    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); 
#> 
     localSqlExecReturnValue = new System.Data.SqlClient.SqlParameter("@localExecReturnValue",System.Data.SqlDbType.Int); 
     localSqlExecReturnValue.Direction = System.Data.ParameterDirection.Output; 

     <#=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 System.Data.SqlClient.SqlParameter(\"@" + parameter.EsqlParameterName + "\", " + parameter.FunctionParameterName + ")"; 
      var nullInit = "new System.Data.SqlClient.SqlParameter(\"@" + parameter.EsqlParameterName + "\", SqlHelper.GetDbType(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()); 
     paramList = String.Join(",", paramList, " out System.Data.SqlClient.SqlParameter localSqlExecReturnValue").Trim().TrimStart(','); 
     paramList = paramList.Replace("ObjectParameter", "System.Data.SqlClient.SqlParameter"); 
     if (includeMergeOption) 
     { 
      paramList = _code.StringAfter(paramList, ", ") + "MergeOption mergeOption"; 
     } 

     return string.Format(
      CultureInfo.InvariantCulture, 
      "{0} {1} {2}({3})", 
      AccessibilityAndVirtual(Accessibility.ForMethod(edmFunction)), 
      returnType == null ? "int" : "System.Collections.Generic.List<" + _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 = String.Join(", ", parameters.Select(p => p.ExecuteParameterName).ToArray()); 
     callParams = _code.StringBefore(", ", String.Join(",", "localSqlExecReturnValue", callParams)).TrimEnd(',').Trim(); 

     var inSqlParams = String.Join(", ", parameters.Where(p => p.NeedsLocalVariable).Select(p => "@" + p.Source.Name).ToArray()); 
     var outSqlParams = String.Join(", ", parameters.Where(p => !p.NeedsLocalVariable).Select(p => "@" + p.Source.Name + " OUTPUT").ToArray()); 
     var sqlParams = ""; 
     if (inSqlParams.Count() > 0) 
     { 
      sqlParams = String.Join(", ", sqlParams, inSqlParams); 
     } 
     if (outSqlParams.Count() > 0) 
     { 
      sqlParams = String.Join(", ", sqlParams, outSqlParams); 
     } 
     sqlParams = sqlParams.Trim().Trim(',').Trim(); 
     if (includeMergeOption) 
     { 
      callParams = ", mergeOption" + callParams; 
     } 
     var retstring = string.Format(
      CultureInfo.InvariantCulture, 
      "var results = {3}{0}(\"EXEC @localExecReturnValue = {1} {4}\"{2});", 
      returnType == null ? "" : "<" + _typeMapper.GetTypeName(returnType, modelNamespace) + ">", 
      edmFunction.Name, 
      callParams,returnType != null ? "this.Database.SqlQuery" : "this.Database.ExecuteSqlCommand", sqlParams); 
     retstring += Environment.NewLine; 
     retstring += returnType != null ? "\t\treturn results.ToList();" : "\t\treturn results;"; 
     //retstring += Environment.NewLine + "\t\tlocalExecReturnValue = (int)localSqlExecReturnValue.Value;" ; 
     //retstring += Environment.NewLine + "\t\treturn results;"; 
     return retstring; 
    } 

    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) 
    { 
     return GetTypeName(edmType, isNullable: null, modelNamespace: modelNamespace); 
    } 

    public string GetTypeName(EdmType edmType, bool? isNullable, string modelNamespace) 
    { 
     if (edmType == null) 
     { 
      return null; 
     } 

     var collectionType = edmType as CollectionType; 
     if (collectionType != null) 
     { 
      return String.Format(CultureInfo.InvariantCulture, "ICollection<{0}>", GetTypeName(collectionType.TypeUsage, modelNamespace)); 
     } 

     var typeName = _code.Escape(edmType.MetadataProperties 
           .Where(p => p.Name == ExternalTypeNameAttributeName) 
           .Select(p => (string)p.Value) 
           .FirstOrDefault()) 
      ?? (modelNamespace != null && edmType.NamespaceName != modelNamespace ? 
       _code.CreateFullName(_code.EscapeNamespace(edmType.NamespaceName), _code.Escape(edmType)) : 
       _code.Escape(edmType)); 

     if (edmType is StructuralType) 
     { 
      return typeName; 
     } 

     if (edmType is SimpleType) 
     { 
      var clrType = UnderlyingClrType(edmType); 
      if (!IsEnumType(edmType)) 
      { 
       typeName = _code.Escape(clrType); 
      } 

      typeName = FixNamespaces(typeName); 

      return clrType.IsValueType && isNullable == true ? 
       String.Format(CultureInfo.InvariantCulture, "Nullable<{0}>", typeName) : 
       typeName; 
     } 

     throw new ArgumentException("edmType"); 
    } 

    public Type UnderlyingClrType(EdmType edmType) 
    { 
     ArgumentNotNull(edmType, "edmType"); 

     var primitiveType = edmType as PrimitiveType; 
     if (primitiveType != null) 
     { 
      return primitiveType.ClrEquivalentType; 
     } 

     if (IsEnumType(edmType)) 
     { 
      return GetEnumUnderlyingType(edmType).ClrEquivalentType; 
     } 

     return typeof(object); 
    } 

    public object GetEnumMemberValue(MetadataItem enumMember) 
    { 
     ArgumentNotNull(enumMember, "enumMember"); 

     var valueProperty = enumMember.GetType().GetProperty("Value"); 
     return valueProperty == null ? null : valueProperty.GetValue(enumMember, null); 
    } 

    public string GetEnumMemberName(MetadataItem enumMember) 
    { 
     ArgumentNotNull(enumMember, "enumMember"); 

     var nameProperty = enumMember.GetType().GetProperty("Name"); 
     return nameProperty == null ? null : (string)nameProperty.GetValue(enumMember, null); 
    } 

    public System.Collections.IEnumerable GetEnumMembers(EdmType enumType) 
    { 
     ArgumentNotNull(enumType, "enumType"); 

     var membersProperty = enumType.GetType().GetProperty("Members"); 
     return membersProperty != null 
      ? (System.Collections.IEnumerable)membersProperty.GetValue(enumType, null) 
      : Enumerable.Empty<MetadataItem>(); 
    } 

    public bool EnumIsFlags(EdmType enumType) 
    { 
     ArgumentNotNull(enumType, "enumType"); 

     var isFlagsProperty = enumType.GetType().GetProperty("IsFlags"); 
     return isFlagsProperty != null && (bool)isFlagsProperty.GetValue(enumType, null); 
    } 

    public bool IsEnumType(GlobalItem edmType) 
    { 
     ArgumentNotNull(edmType, "edmType"); 

     return edmType.GetType().Name == "EnumType"; 
    } 

    public PrimitiveType GetEnumUnderlyingType(EdmType enumType) 
    { 
     ArgumentNotNull(enumType, "enumType"); 

     return (PrimitiveType)enumType.GetType().GetProperty("UnderlyingType").GetValue(enumType, null); 
    } 

    public string CreateLiteral(object value) 
    { 
     if (value == null || value.GetType() != typeof(TimeSpan)) 
     { 
      return _code.CreateLiteral(value); 
     } 

     return string.Format(CultureInfo.InvariantCulture, "new TimeSpan({0})", ((TimeSpan)value).Ticks); 
    } 

    public bool VerifyCaseInsensitiveTypeUniqueness(IEnumerable<string> types, string sourceFile) 
    { 
     ArgumentNotNull(types, "types"); 
     ArgumentNotNull(sourceFile, "sourceFile"); 

     var hash = new HashSet<string>(StringComparer.InvariantCultureIgnoreCase); 
     if (types.Any(item => !hash.Add(item))) 
     { 
      _errors.Add(
       new CompilerError(sourceFile, -1, -1, "6023", 
        String.Format(CultureInfo.CurrentCulture, CodeGenerationTools.GetResourceString("Template_CaseInsensitiveTypeConflict")))); 
      return false; 
     } 
     return true; 
    } 

    public IEnumerable<SimpleType> GetEnumItemsToGenerate(IEnumerable<GlobalItem> itemCollection) 
    { 
     return GetItemsToGenerate<SimpleType>(itemCollection) 
      .Where(e => IsEnumType(e)); 
    } 

    public IEnumerable<T> GetItemsToGenerate<T>(IEnumerable<GlobalItem> itemCollection) where T: EdmType 
    { 
     return itemCollection 
      .OfType<T>() 
      .Where(i => !i.MetadataProperties.Any(p => p.Name == ExternalTypeNameAttributeName)) 
      .OrderBy(i => i.Name); 
    } 

    public IEnumerable<string> GetAllGlobalItems(IEnumerable<GlobalItem> itemCollection) 
    { 
     return itemCollection 
      .Where(i => i is EntityType || i is ComplexType || i is EntityContainer || IsEnumType(i)) 
      .Select(g => GetGlobalItemName(g)); 
    } 

    public string GetGlobalItemName(GlobalItem item) 
    { 
     if (item is EdmType) 
     { 
      return ((EdmType)item).Name; 
     } 
     else 
     { 
      return ((EntityContainer)item).Name; 
     } 
    } 

    public IEnumerable<EdmProperty> GetSimpleProperties(EntityType type) 
    { 
     return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type); 
    } 

    public IEnumerable<EdmProperty> GetSimpleProperties(ComplexType type) 
    { 
     return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type); 
    } 

    public IEnumerable<EdmProperty> GetComplexProperties(EntityType type) 
    { 
     return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type); 
    } 

    public IEnumerable<EdmProperty> GetComplexProperties(ComplexType type) 
    { 
     return type.Properties.Where(p => p.TypeUsage.EdmType is ComplexType && p.DeclaringType == type); 
    } 

    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(EntityType type) 
    { 
     return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null); 
    } 

    public IEnumerable<EdmProperty> GetPropertiesWithDefaultValues(ComplexType type) 
    { 
     return type.Properties.Where(p => p.TypeUsage.EdmType is SimpleType && p.DeclaringType == type && p.DefaultValue != null); 
    } 

    public IEnumerable<NavigationProperty> GetNavigationProperties(EntityType type) 
    { 
     return type.NavigationProperties.Where(np => np.DeclaringType == type); 
    } 

    public IEnumerable<NavigationProperty> GetCollectionNavigationProperties(EntityType type) 
    { 
     return type.NavigationProperties.Where(np => np.DeclaringType == type && np.ToEndMember.RelationshipMultiplicity == RelationshipMultiplicity.Many); 
    } 

    public FunctionParameter GetReturnParameter(EdmFunction edmFunction) 
    { 
     ArgumentNotNull(edmFunction, "edmFunction"); 

     var returnParamsProperty = edmFunction.GetType().GetProperty("ReturnParameters"); 
     return returnParamsProperty == null 
      ? edmFunction.ReturnParameter 
      : ((IEnumerable<FunctionParameter>)returnParamsProperty.GetValue(edmFunction, null)).FirstOrDefault(); 
    } 

    public bool IsComposable(EdmFunction edmFunction) 
    { 
     ArgumentNotNull(edmFunction, "edmFunction"); 

     var isComposableProperty = edmFunction.GetType().GetProperty("IsComposableAttribute"); 
     return isComposableProperty != null && (bool)isComposableProperty.GetValue(edmFunction, null); 
    } 

    public IEnumerable<FunctionImportParameter> GetParameters(EdmFunction edmFunction) 
    { 
     return FunctionImportParameter.Create(edmFunction.Parameters, _code, _ef); 
    } 

    public TypeUsage GetReturnType(EdmFunction edmFunction) 
    { 
     var returnParam = GetReturnParameter(edmFunction); 
     return returnParam == null ? null : _ef.GetElementType(returnParam.TypeUsage); 
    } 

    public bool GenerateMergeOptionFunction(EdmFunction edmFunction, bool includeMergeOption) 
    { 
     var returnType = GetReturnType(edmFunction); 
     return !includeMergeOption && returnType != null && returnType.EdmType.BuiltInTypeKind == BuiltInTypeKind.EntityType; 
    } 
} 

public static void ArgumentNotNull<T>(T arg, string name) where T : class 
{ 
    if (arg == null) 
    { 
     throw new ArgumentNullException(name); 
    } 
} 
#>

來源

2017-12-20 18:14:14 curlyhairedgenius

相關問題

 相關問題